/// <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));
}
