/// <inheritdoc/> public virtual Response <T> Execute <T, TBody>(Uri url, HttpMethod method, TBody body, Dictionary <string, string> headers, Dictionary <string, string> queryStringParameters, RequestSettings settings) { if (url == null) { throw new ArgumentNullException("url"); } var rawBody = _stringSerializer.Serialize(body); return(Execute <T>(url, method, rawBody, headers, queryStringParameters, settings)); }
public static byte[] GetSerializedBytes(this IStringSerializer serializer, object obj, Encoding encoding = null) { var encoder = encoding ?? Encoding.UTF8; var str = serializer.Serialize(obj); return(encoder.GetBytes(str)); }
protected virtual void Dispose(bool disposing) { if (!disposing) { return; } if (_store == null) { return; } if (_dirty) { string json = _serializer.Serialize(this); using (FileLock fileLock = New <FileLocker>().Acquire(_store)) { using (StreamWriter writer = new StreamWriter(_store.OpenWrite(), Encoding.UTF8)) { writer.Write(json); } } } _dirty = false; _store = null; }
public void Save(IUserSettings userSettings) { userSettings.SaveLayout(); var xmlContent = _stringSerializer.Serialize(userSettings); XmlHelper.SaveXmlContentToFile(xmlContent, _configuration.UserApplicationSettingsFilePath); }
public static bool CanSerializeString <T>(this IStringSerializer serializer, T item) { var text = serializer.Serialize(item); var obj = serializer.Deserialize <T>(text); return(obj.Equals(item)); }
public async Task <StorageOperationResponse> Update(string key, T value) { var properties = this.app.Properties; await AddKeyIfItDoesntExist(properties, key); properties[key] = serializer.Serialize(value); return(StorageOperationResponse.CreateSucceeded()); }
/// <inheritdoc cref="ISyncCacheStore{TCacheEntryOptions}.SetEntry{T}"/> public void SetEntry <T>(string key, CacheEntry <T> item, DistributedCacheEntryOptions cacheEntryOptions) { if (key == null) { throw new ArgumentNullException(nameof(key)); } if (item == null) { throw new ArgumentNullException(nameof(item)); } if (cacheEntryOptions == null) { throw new ArgumentNullException(nameof(cacheEntryOptions)); } var value = _stringSerializer.Serialize(item); _distributedCache.SetString(key, value, cacheEntryOptions); }
public Task ExportSimulationToXmlAsync(Simulation simulation) { return(exportSimulationToFileAsync(PKSimConstants.UI.SaveSimulationToXmlFile, Constants.Filter.XML_FILE_FILTER, simulation, async fileName => { using (var writer = new StreamWriter(fileName)) { await writer.WriteAsync(_stringSerializer.Serialize(simulation)); } }, Constants.DirectoryKey.MODEL_PART)); }
public virtual async Task CreateAsync( string projectId, string key, T obj, CancellationToken cancellationToken = default(CancellationToken) ) { if (obj == null) { throw new ArgumentException("TObject obj must be provided"); } if (string.IsNullOrWhiteSpace(projectId)) { throw new ArgumentException("projectId must be provided"); } if (string.IsNullOrWhiteSpace(key)) { throw new ArgumentException("key must be provided"); } cancellationToken.ThrowIfCancellationRequested(); ThrowIfDisposed(); var pathToFile = await pathResolver.ResolvePath( projectId, key, obj, serializer.ExpectedFileExtension, true ).ConfigureAwait(false); if (File.Exists(pathToFile)) { throw new InvalidOperationException("can't create file that already exists: " + pathToFile); } var serialized = serializer.Serialize(obj); using (StreamWriter s = File.CreateText(pathToFile)) { await s.WriteAsync(serialized); } }
/// <summary> /// Serializes to stream. /// </summary> /// <param name="obj">Object to serialize.</param> /// <param name="stream">Stream to serialize to.</param> public static void SerializeToStream(this IStringSerializer serializer, object obj, Stream stream) { var streamWriter = new StreamWriter(stream) { AutoFlush = true }; var str = serializer.Serialize(obj); streamWriter.Write(str); }
protected override void Context() { _userSettings = A.Fake <IUserSettings>(); _defaultUserSettings = A.Fake <IUserSettings>(); _serializationManager = A.Fake <IStringSerializer>(); _pkSimConfiguration = A.Fake <IPKSimConfiguration>(); A.CallTo(() => _pkSimConfiguration.UserSettingsFilePath).Returns("blah"); _validUserConfigXml = "<UserConfig/>"; A.CallTo(() => _serializationManager.Serialize(_userSettings)).Returns(_validUserConfigXml); sut = new UserSettingsPersistor(_serializationManager, _defaultUserSettings, _pkSimConfiguration); }
public void TestCrossFrameworkPclCultureInfoSerialization() { IStringSerializer serializer = New <IStringSerializer>(); CustomMessageParameters parameters; string json; parameters = new CustomMessageParameters(CultureInfo.CreateSpecificCulture("en-US"), "A message"); json = serializer.Serialize(parameters.MessageCulture); Assert.That(json, Is.EqualTo("\"en-US\"")); }
public void TestSerializeWithEnglishUsCulture() { IStringSerializer serializer = New <IStringSerializer>(); CustomMessageParameters parameters; string json; parameters = new CustomMessageParameters(CultureInfo.CreateSpecificCulture("en-US"), "A message"); json = serializer.Serialize(parameters); Assert.That(json, Is.EqualTo("{\r\n \"messageCulture\": \"en-US\",\r\n \"customMessage\": \"A message\"\r\n}".Replace("\r\n", Environment.NewLine))); }
public void TestSerializeWithNullCulture() { IStringSerializer serializer = New <IStringSerializer>(); CustomMessageParameters parameters; string json; parameters = new CustomMessageParameters(null, "A message"); json = serializer.Serialize(parameters); Assert.That(json, Is.EqualTo("{\r\n \"messageCulture\": null,\r\n \"customMessage\": \"A message\"\r\n}".Replace("\r\n", Environment.NewLine))); }
/// <summary> /// Calls the js function. /// </summary> /// <param name="funcName">Name of the function.</param> /// <param name="parameters">The parameters.</param> public void CallJsFunction(string funcName, params object[] parameters) { var builder = new StringBuilder(); builder.Append(funcName); builder.Append("("); for (var n = 0; n < parameters.Length; n++) { builder.Append(_jsonSerializer.Serialize(parameters[n])); if (n < parameters.Length - 1) { builder.Append(", "); } } builder.Append(");"); InjectJavaScript(builder.ToString()); }
public async Task <TResponse> PostAsync <TBody, TResponse>(string url, TBody body) { var httpClient = new HttpClient(); var authorization = configurationProvider.GetConfigurationValue("authorization"); httpClient.DefaultRequestHeaders.Add("Authorization", $"bearer {authorization}"); string bodyAsString = body as string; if (bodyAsString == null) { bodyAsString = stringSerializer.Serialize(body); } var response = await httpClient.PostAsync(url, new StringContent(bodyAsString)); var responseBody = await response.Content.ReadAsStringAsync(); var responseContent = stringDeserializer.Deserialize <TResponse>(responseBody); return(responseContent); }
public void Save(IApplicationSettings applicationSettings) { var xmlContent = _stringSerializer.Serialize(applicationSettings); XmlHelper.SaveXmlContentToFile(xmlContent, _configuration.ApplicationSettingsFilePath); }
public Task <Guid> Binary <M>(EventInfo info, BinaryMessage <M> message, IStringSerializer dataSerializer) where M : new() { return(Connection.InvokeAsync(EventNames.SendBinaryTo, info.EventName, info.To, dataSerializer.Serialize(message.MetaData), message.Data)); }
/// <summary> /// Serializes to writer. /// </summary> /// <param name="obj">Object to serialize.</param> /// <param name="writer">Writer.</param> public static void SerializeToWriter(this IStringSerializer serializer, object obj, TextWriter writer) { writer.Write(serializer.Serialize(obj)); }
public void SaveModelPart <T>(T objectToSerialize, string filename) { var xmlContent = _stringSerializer.Serialize(objectToSerialize); XmlHelper.SaveXmlContentToFile(xmlContent, filename); }
public void SaveApplicationSettings(ApplicationSettings applicationSettings) { string serializedSettings = _stringSerializer.Serialize(applicationSettings); File.WriteAllText(_filePath, serializedSettings); }
public Task <Guid> Serialized <D, M>(EventInfo info, StringSerializedMessage <D, M> message, IStringSerializer dataSerializer, IStringSerializer metaSerializer) where D : new() where M : new() { return(Connection.InvokeAsync(EventNames.SendStringTo, info.EventName, info.To, metaSerializer.Serialize(message.MetaData), dataSerializer.Serialize(message.Data))); }
public string Serialize <TObject>(TObject objectToSerialize) { return(_compression.Compress(_underlyingSerializationManager.Serialize(objectToSerialize))); }
public virtual void Save(TSettings userSettings) { var xmlContent = _stringSerializer.Serialize(userSettings); XmlHelper.SaveXmlContentToFile(xmlContent, SettingsFilePath); }
=> _serializer.Deserialize(reader.Value.ToString()); //.Dump()); public override void WriteJson(JsonWriter writer, T value, JsonSerializer serializer) { writer.WriteRawValue(_serializer.Serialize(value)); }