public static void RunDeserializationPerformanceTest(int numberOfRuns, TestType testType, int testSize, ISerializerFactory serializerFactory)
{
var obj = GetSerializationObject(testType, testSize);
var serializer = serializerFactory.GetSerializer();
serializer.Init(obj);
using (var stream = new MemoryStream())
{
serializer.Serialize(obj, stream);
stream.Position = 0;
foreach (var iteration in Benchmark.Iterations)
{
using (iteration.StartMeasurement())
{
for (int i = 0; i < numberOfRuns; i++)
{
serializer.Deserialize(stream);
stream.Position = 0;
}
}
}
}
}
/// <summary>
/// Saves the specified <paramref name="tailCount"/> number of stack elements from the top of the stack (in default stack enumeration order, i.e. moving towards the bottom of the stack) to the streams yielded by the <paramref name="streams"/> sequence.
/// </summary>
/// <param name="serializerFactory">The factory to use to obtain a statically typed serializer.</param>
/// <param name="tailCount">The number of stack elements to save starting from the top of the queue.</param>
/// <param name="streams">The streams to save the stack elements to. This sequence has a length equal to <paramref name="tailCount"/>.</param>
void IStackPersistence.Save(ISerializerFactory serializerFactory, int tailCount, IEnumerable <Stream> streams)
{
//
// Get the serializer once to reduce overheads.
//
var serializer = serializerFactory.GetSerializer <T>();
//
// Zip the stack elements (most recent first) with the corresponding streams to persist to.
//
// PERF: While the enumeration below is O(tailCount), it results in a reverse order for persistence operations. Should we consider a custom Stack<T> implementation for fast in-order random access?
//
using var stackEnumerator = _stack.GetEnumerator();
using var streamEnumerator = streams.GetEnumerator();
for (var i = 0; i < tailCount; i++)
{
Invariant.Assert(stackEnumerator.MoveNext(), "No more elements in stack.");
Invariant.Assert(streamEnumerator.MoveNext(), "No more streams to write to.");
var element = stackEnumerator.Current;
using var stream = streamEnumerator.Current;
serializer.Serialize(element, stream);
}
Invariant.Assert(!streamEnumerator.MoveNext(), "Should have consumed all streams.");
}
/// <summary>
/// Saves the set element stored at the specified <paramref name="key"/> to the specified <paramref name="stream"/>.
/// </summary>
/// <param name="serializerFactory">The factory to use to obtain a statically typed serializer.</param>
/// <param name="stream">The stream to save the set element to.</param>
/// <param name="key">The key of the set element to save.</param>
void IHeapPersistence.Save(ISerializerFactory serializerFactory, Stream stream, string key)
{
var keyValue = GetIndexForKey(key);
var value = _storageKeys.GetByValue(keyValue);
serializerFactory.GetSerializer <T>().Serialize(value, stream);
}
public T DeepClone(T source)
{
var binarySerializer = serializerFactory.GetSerializer(_defaultCloneOptions.SerializerType);
var serialized = binarySerializer.Serialize(source);
return(binarySerializer.Deserialize <T>(serialized));
}
private static async Task <HttpMessageSendChangesResponse> DeserializeAsync(ISerializerFactory serializerFactory, string fileName, string directoryFullPath, BaseOrchestrator orchestrator = null)
{
var fullPath = Path.Combine(directoryFullPath, fileName);
using var fileStream = new FileStream(fullPath, FileMode.Open, FileAccess.Read);
var httpMessageContent = await serializerFactory.GetSerializer <HttpMessageSendChangesResponse>().DeserializeAsync(fileStream);
return(httpMessageContent);
}
/// <summary>
/// Saves the specified <paramref name="tailCount"/> number of queue elements from the tail of the queue (in default queue enumeration order, i.e. moving towards the tail) to the streams yielded by the <paramref name="streams"/> sequence.
/// </summary>
/// <param name="serializerFactory">The factory to use to obtain a statically typed serializer.</param>
/// <param name="tailCount">The number of queue elements to save starting from the tail of the queue.</param>
/// <param name="streams">The streams to save the queue elements to. This sequence has a length equal to <paramref name="tailCount"/>.</param>
void IQueuePersistence.Save(ISerializerFactory serializerFactory, long tailCount, IEnumerable <Stream> streams)
{
//
// The obtain the specified number of elements from the tail in dequeue order, we have to enumerate over the whole queue and skip from the front.
//
// PERF: Is this O(queueCount) traversal in lieu of an O(tailCount) lookup cost tolerable? If not, we should re-implement Queue<T> to enable fast random access.
//
var skip = _queue.Count - tailCount;
Invariant.Assert(skip >= 0, "Requested tail count greater than available queue size.");
using var queueEnumerator = _queue.GetEnumerator();
//
// Skip the elements we don't care about.
//
for (var i = 0; i < skip; i++)
{
Invariant.Assert(queueEnumerator.MoveNext(), "Failed to skip.");
}
//
// Get the serializer once to reduce overheads.
//
var serializer = serializerFactory.GetSerializer <T>();
//
// Save the remaining tailCount elements to the streams provided.
//
using var streamEnumerator = streams.GetEnumerator();
for (var i = 0L; i < tailCount; i++)
{
Invariant.Assert(queueEnumerator.MoveNext(), "No more elements in queue.");
Invariant.Assert(streamEnumerator.MoveNext(), "No more streams to write to.");
var element = queueEnumerator.Current;
using var stream = streamEnumerator.Current;
serializer.Serialize(element, stream);
}
Invariant.Assert(!queueEnumerator.MoveNext(), "Should have reached last element of the queue.");
Invariant.Assert(!streamEnumerator.MoveNext(), "Should have consumed all streams.");
}
/// <summary>
/// Возвращает строчное представление объекта в указанном формате
/// </summary>
/// <param name="value">сериализуемый объект</param>
/// <param name="format">формат</param>
/// <param name="objectname">имя для сериализуемого объекта</param>
/// <param name="options">Опции сериализации</param>
public static string SerializeAsFormat(this object value, SerializationFormat format, string objectname = DefaultObjectName, object options = null)
{
var serializer =
#if EMBEDQPT
sfactory.GetSerializer(format);
#else
Applications.Application.Current.Serialization.GetSerializer(format);
#endif
if (string.IsNullOrWhiteSpace(objectname))
{
objectname = DefaultObjectName;
}
return(serializer.Serialize(value, objectname));
}
/// <summary>
/// Serialize a container set instance
/// </summary>
private static async Task SerializeAsync(ContainerSet set, string fileName, string directoryFullPath, ISerializerFactory serializerFactory = default, BaseOrchestrator orchestrator = null)
{
if (set == null)
{
return;
}
var fullPath = Path.Combine(directoryFullPath, fileName);
var fi = new FileInfo(fullPath);
if (!Directory.Exists(fi.Directory.FullName))
{
Directory.CreateDirectory(fi.Directory.FullName);
}
if (serializerFactory == default)
{
serializerFactory = SerializersCollection.JsonSerializer;
}
var serializer = serializerFactory.GetSerializer <ContainerSet>();
using var f = new FileStream(fullPath, FileMode.CreateNew, FileAccess.ReadWrite);
byte[] serializedBytes = null;
if (orchestrator != null)
{
var interceptorArgs = new SerializingSetArgs(orchestrator.GetContext(), set, serializerFactory, fileName, directoryFullPath);
await orchestrator.InterceptAsync(interceptorArgs, default);
serializedBytes = interceptorArgs.Result;
}
if (serializedBytes == null)
{
serializedBytes = await serializer.SerializeAsync(set);
}
f.Write(serializedBytes, 0, serializedBytes.Length);
//await f.FlushAsync();
}
/// <summary>Deserializes the response stream.</summary>
/// <param name="response">The response.</param>
/// <param name="serializerFactory">The serializer factory.</param>
/// <param name="gzipInflator">The GZIP inflator.</param>
/// <typeparam name="TResult">The type of the response content.</typeparam>
/// <returns>An instance of the specified type.</returns>
private TResult DeserializeResponse <TResult>(HttpWebResponse response, ISerializerFactory serializerFactory, IConverter <Stream, Stream> gzipInflator)
{
Debug.Assert(response != null, "response != null");
Debug.Assert(serializerFactory != null, "serializerFactory != null");
Debug.Assert(gzipInflator != null, "gzipInflator != null");
// Get the response content
var stream = response.GetResponseStream();
// Ensure that there is response content
if (stream == null)
{
return(default(TResult));
}
Debug.Assert(response != null, "response != null");
Debug.Assert(response.Headers != null, "response.Headers != null");
// Ensure that we are operating on decompressed data
var contentEncoding = response.Headers["Content-Encoding"];
if (contentEncoding != null)
{
var compressed = contentEncoding.Equals("gzip", StringComparison.OrdinalIgnoreCase);
if (compressed)
{
var uncompressed = gzipInflator.Convert(stream, null);
if (uncompressed != null)
{
stream = uncompressed;
}
}
}
Debug.Assert(stream.CanRead, "stream.CanRead");
// Create a serializer
var serializer = serializerFactory.GetSerializer <TResult>();
// Deserialize the response content
return(serializer.Deserialize(stream));
}
private void ShowOutput(ClassInfo classInfo, string menuItemName)
{
IClassInfoSerializer serializer;
try
{
serializer = _serializerFactory.GetSerializer(menuItemName);
}
catch (ArgumentException ex)
{
ShowMessageBox(ServiceProvider, $"Error retrieving '{menuItemName}' serializer:" + Environment.NewLine + Environment.NewLine + ex.Message);
return;
}
foreach (var handler in _outputHandlers)
{
if (handler.Handle(serializer, classInfo))
{
break;
}
}
}
private void ShowOutput(ClassInfo classInfo, string menuItemName)
{
IClassInfoSerializer serializer;
try
{
serializer = _serializerFactory.GetSerializer(menuItemName);
}
catch (ArgumentException ex)
{
ShowMessageBox(ServiceProvider, $"Error retrieving '{menuItemName}' serializer:" + Environment.NewLine + Environment.NewLine + ex.Message);
return;
}
if (!serializer.CanSerialize(classInfo))
{
ShowMessageBox(ServiceProvider, $"Could not serialize {classInfo.Name} to {serializer.DisplayName}");
return;
}
foreach (var handler in _outputHandlers)
{
try
{
if (handler.Handle(serializer, classInfo))
{
return;
}
}
catch (Exception e)
{
ShowMessageBox(ServiceProvider, $"Error serializing {classInfo.Name}: {e}");
return;
}
}
ShowMessageBox(ServiceProvider, $"Could not find a handler for {classInfo.Name}");
}
public static void RunDeserializationPerformanceTest(int numberOfRuns, TestType testType, int testSize, ISerializerFactory serializerFactory)
{
var obj = GetSerializationObject(testType, testSize);
var serializer = serializerFactory.GetSerializer();
serializer.Init(obj);
using (var stream = new MemoryStream())
{
serializer.Serialize(obj, stream);
stream.Position = 0;
foreach (var iteration in Benchmark.Iterations)
{
using (iteration.StartMeasurement())
{
for (int i = 0; i < numberOfRuns; i++)
{
serializer.Deserialize(stream);
stream.Position = 0;
}
}
}
}
}
public string SerializeSomeData(MyData data)
{
ISerializer serializer = serializerFactory.GetSerializer("Json");
return(serializer.Serialize(data));
}
/// <summary>
/// Process a request message with HttpClient object.
/// </summary>
public async Task <U> ProcessRequestAsync <U>(HttpClient client, string baseUri, byte[] data, HttpStep step, Guid sessionId,
ISerializerFactory serializerFactory, IConverter converter, int batchSize, CancellationToken cancellationToken)
{
if (client is null)
{
throw new ArgumentNullException(nameof(client));
}
if (baseUri == null)
{
throw new ArgumentException("BaseUri is not defined");
}
HttpResponseMessage response = null;
var responseMessage = default(U);
try
{
if (cancellationToken.IsCancellationRequested)
{
cancellationToken.ThrowIfCancellationRequested();
}
// Get response serializer
var responseSerializer = serializerFactory.GetSerializer <U>();
var requestUri = new StringBuilder();
requestUri.Append(baseUri);
requestUri.Append(baseUri.EndsWith("/", StringComparison.CurrentCultureIgnoreCase) ? string.Empty : "/");
// Add params if any
if (ScopeParameters != null && ScopeParameters.Count > 0)
{
string prefix = "?";
foreach (var kvp in ScopeParameters)
{
requestUri.AppendFormat("{0}{1}={2}", prefix, Uri.EscapeUriString(kvp.Key),
Uri.EscapeUriString(kvp.Value));
if (prefix.Equals("?"))
{
prefix = "&";
}
}
}
// get byte array content
var arrayContent = data == null ? new ByteArrayContent(new byte[] { }) : new ByteArrayContent(data);
// reinit client
client.DefaultRequestHeaders.Clear();
// add it to the default header
//if (this.Cookie != null)
// client.DefaultRequestHeaders.Add("Cookie", this.Cookie.ToString());
// Create the request message
var requestMessage = new HttpRequestMessage(HttpMethod.Post, requestUri.ToString())
{
Content = arrayContent
};
// Adding the serialization format used and session id
requestMessage.Headers.Add("dotmim-sync-session-id", sessionId.ToString());
requestMessage.Headers.Add("dotmim-sync-step", ((int)step).ToString());
// serialize the serialization format and the batchsize we want.
var ser = JsonConvert.SerializeObject(new { f = serializerFactory.Key, s = batchSize });
requestMessage.Headers.Add("dotmim-sync-serialization-format", ser);
// if client specifies a converter, add it as header
if (converter != null)
{
requestMessage.Headers.Add("dotmim-sync-converter", converter.Key);
}
// Adding others headers
if (this.CustomHeaders != null && this.CustomHeaders.Count > 0)
{
foreach (var kvp in this.CustomHeaders)
{
if (!requestMessage.Headers.Contains(kvp.Key))
{
requestMessage.Headers.Add(kvp.Key, kvp.Value);
}
}
}
// If Json, specify header
if (serializerFactory.Key == SerializersCollection.JsonSerializer.Key && !requestMessage.Content.Headers.Contains("content-type"))
{
requestMessage.Content.Headers.Add("content-type", "application/json");
}
// Eventually, send the request
response = await client.SendAsync(requestMessage, cancellationToken).ConfigureAwait(false);
if (cancellationToken.IsCancellationRequested)
{
cancellationToken.ThrowIfCancellationRequested();
}
// throw exception if response is not successfull
// get response from server
if (!response.IsSuccessStatusCode && response.Content != null)
{
await HandleSyncError(response, serializerFactory);
}
// try to set the cookie for http session
var headers = response?.Headers;
if (headers != null)
{
if (headers.TryGetValues("Set-Cookie", out var tmpList))
{
var cookieList = tmpList.ToList();
// var cookieList = response.Headers.GetValues("Set-Cookie").ToList();
if (cookieList != null && cookieList.Count > 0)
{
#if NETSTANDARD
// Get the first cookie
this.Cookie = CookieHeaderValue.ParseList(cookieList).FirstOrDefault();
#else
//try to parse the very first cookie
if (CookieHeaderValue.TryParse(cookieList[0], out var cookie))
{
this.Cookie = cookie;
}
#endif
}
}
}
if (response.Content == null)
{
throw new HttpEmptyResponseContentException();
}
using (var streamResponse = await response.Content.ReadAsStreamAsync().ConfigureAwait(false))
if (streamResponse.CanRead && streamResponse.Length > 0)
{
responseMessage = responseSerializer.Deserialize(streamResponse);
}
return(responseMessage);
}
catch (SyncException)
{
throw;
}
catch (Exception e)
{
if (response == null || response.Content == null)
{
throw new HttpResponseContentException(e.Message);
}
var exrror = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
throw new HttpResponseContentException(exrror);
}
}
private async Task <ContainerSet> DeserializeAsync(string fileName, string directoryFullPath, ISerializerFactory serializerFactory = default, BaseOrchestrator orchestrator = null)
{
if (string.IsNullOrEmpty(fileName))
{
throw new ArgumentNullException(fileName);
}
if (string.IsNullOrEmpty(directoryFullPath))
{
throw new ArgumentNullException(directoryFullPath);
}
var fullPath = Path.Combine(directoryFullPath, fileName);
if (!File.Exists(fullPath))
{
throw new MissingFileException(fullPath);
}
// backward compatibility
if (serializerFactory == default)
{
serializerFactory = SerializersCollection.JsonSerializer;
}
// backward compatibility
if (this.SerializedType == default)
{
this.SerializedType = typeof(ContainerSet);
}
Debug.WriteLine($"Deserialize file {fileName}");
using var fs = new FileStream(fullPath, FileMode.Open, FileAccess.Read);
ContainerSet set = null;
if (orchestrator != null)
{
var interceptorArgs = new DeserializingSetArgs(orchestrator.GetContext(), fs, serializerFactory, fileName, directoryFullPath);
await orchestrator.InterceptAsync(interceptorArgs, default);
set = interceptorArgs.Result;
}
if (set == null)
{
if (this.SerializedType == typeof(ContainerSet))
{
var serializer = serializerFactory.GetSerializer <ContainerSet>();
set = await serializer.DeserializeAsync(fs);
}
else
{
var serializer = serializerFactory.GetSerializer <ContainerSetBoilerPlate>();
var jobject = await serializer.DeserializeAsync(fs);
set = jobject.Changes;
}
}
return(set);
}
/// <summary>
/// Process a request message with HttpClient object.
/// </summary>
public async Task <U> ProcessRequestAsync <U>(HttpClient client, string baseUri, byte[] data, HttpStep step, Guid sessionId, string scopeName,
ISerializerFactory serializerFactory, IConverter converter, int batchSize, CancellationToken cancellationToken)
{
if (client is null)
{
throw new ArgumentNullException(nameof(client));
}
if (baseUri == null)
{
throw new ArgumentException("BaseUri is not defined");
}
HttpResponseMessage response = null;
var responseMessage = default(U);
try
{
if (cancellationToken.IsCancellationRequested)
{
cancellationToken.ThrowIfCancellationRequested();
}
// Get response serializer
var responseSerializer = serializerFactory.GetSerializer <U>();
var requestUri = new StringBuilder();
requestUri.Append(baseUri);
requestUri.Append(baseUri.EndsWith("/", StringComparison.CurrentCultureIgnoreCase) ? string.Empty : "/");
// Add params if any
if (ScopeParameters != null && ScopeParameters.Count > 0)
{
string prefix = "?";
foreach (var kvp in ScopeParameters)
{
requestUri.AppendFormat("{0}{1}={2}", prefix, Uri.EscapeUriString(kvp.Key),
Uri.EscapeUriString(kvp.Value));
if (prefix.Equals("?"))
{
prefix = "&";
}
}
}
// Check if data is null
data = data == null ? new byte[] { } : data;
// get byte array content
var arrayContent = new ByteArrayContent(data);
// reinit client
client.DefaultRequestHeaders.Clear();
// Create the request message
var requestMessage = new HttpRequestMessage(HttpMethod.Post, requestUri.ToString())
{
Content = arrayContent
};
// Adding the serialization format used and session id and scope name
requestMessage.Headers.Add("dotmim-sync-session-id", sessionId.ToString());
requestMessage.Headers.Add("dotmim-sync-scope-name", scopeName);
requestMessage.Headers.Add("dotmim-sync-step", ((int)step).ToString());
// serialize the serialization format and the batchsize we want.
var ser = JsonConvert.SerializeObject(new { f = serializerFactory.Key, s = batchSize });
requestMessage.Headers.Add("dotmim-sync-serialization-format", ser);
// if client specifies a converter, add it as header
if (converter != null)
{
requestMessage.Headers.Add("dotmim-sync-converter", converter.Key);
}
// calculate hash
var hash = HashAlgorithm.SHA256.Create(data);
var hashString = Convert.ToBase64String(hash);
requestMessage.Headers.Add("dotmim-sync-hash", hashString);
// Adding others headers
if (this.CustomHeaders != null && this.CustomHeaders.Count > 0)
{
foreach (var kvp in this.CustomHeaders)
{
if (!requestMessage.Headers.Contains(kvp.Key))
{
requestMessage.Headers.Add(kvp.Key, kvp.Value);
}
}
}
// If Json, specify header
if (serializerFactory.Key == SerializersCollection.JsonSerializer.Key && !requestMessage.Content.Headers.Contains("content-type"))
{
requestMessage.Content.Headers.Add("content-type", "application/json");
}
// Eventually, send the request
response = await client.SendAsync(requestMessage, cancellationToken).ConfigureAwait(false);
if (cancellationToken.IsCancellationRequested)
{
cancellationToken.ThrowIfCancellationRequested();
}
// throw exception if response is not successfull
// get response from server
if (!response.IsSuccessStatusCode && response.Content != null)
{
await HandleSyncError(response, serializerFactory);
}
// try to set the cookie for http session
var headers = response?.Headers;
// Ensure we have a cookie
this.EnsureCookie(headers);
if (response.Content == null)
{
throw new HttpEmptyResponseContentException();
}
using (var streamResponse = await response.Content.ReadAsStreamAsync().ConfigureAwait(false))
{
if (streamResponse.CanRead && streamResponse.Length > 0)
{
// if Hash is present in header, check hash
if (TryGetHeaderValue(headers, "dotmim-sync-hash", out string hashStringRequest))
{
HashAlgorithm.SHA256.EnsureHash(streamResponse, hashStringRequest);
}
responseMessage = await responseSerializer.DeserializeAsync(streamResponse);
}
}
return(responseMessage);
}
catch (SyncException)
{
throw;
}
catch (Exception e)
{
if (response == null || response.Content == null)
{
throw new HttpResponseContentException(e.Message);
}
var exrror = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
throw new HttpResponseContentException(exrror);
}
}