public static async Task SerializeAsync(ContentType contentType, Stream stream, object obj)
{
switch (contentType)
{
case ContentType.Bytes:
{
var serializer = new ByteSerializer(true, false, true);
await serializer.SerializeAsync(stream, obj);
return;
}
case ContentType.Json:
{
await System.Text.Json.JsonSerializer.SerializeAsync(stream, obj);
return;
}
case ContentType.JsonNameless:
{
var bytes = JsonSerializer.SerializeNamelessBytes(obj);
#if NETSTANDARD2_0
await stream.WriteAsync(bytes, 0, bytes.Length);
#else
await stream.WriteAsync(bytes.AsMemory());
#endif
return;
}
default:
throw new NotImplementedException();
}
}
private static async Task SaveState()
{
await stateLock.WaitAsync();
try
{
var path = $"{GetAssemblyLocation()}\\relaystate.dat";
var infos = new List <ServiceInfo>();
foreach (var service in servicesByUrl.Values)
{
var providerTypes = servicesByProviderType.Where(x => x.Value.Any(y => y.Key == service.Url)).Select(x => x.Key).ToArray();
var info = new ServiceInfo()
{
Url = service.Url,
ProviderTypes = providerTypes
};
infos.Add(info);
}
var infoArray = infos.ToArray();
try
{
using (var file = File.Create(path))
{
var serializer = new ByteSerializer();
await serializer.SerializeAsync(file, infoArray);
}
}
catch { }
}
finally
{
stateLock.Release();
}
}
public void StreamTypes()
{
var serializer = new ByteSerializer();
var model1 = Factory.GetAllTypesModel();
using (var ms = new MemoryStream())
{
serializer.SerializeAsync(ms, model1).GetAwaiter().GetResult();
ms.Position = 0;
var model2 = serializer.DeserializeAsync <AllTypesModel>(ms).GetAwaiter().GetResult();
Factory.AssertAreEqual(model1, model2);
}
}
public void StreamSerializeArray()
{
var serializer = new ByteSerializer();
var model1 = Factory.GetArrayModel();
byte[] bytes;
using (var ms = new MemoryStream())
{
serializer.SerializeAsync(ms, model1).GetAwaiter().GetResult();
bytes = ms.ToArray();
}
var model2 = serializer.Deserialize <BasicModel[]>(bytes);
Factory.AssertAreEqual(model1, model2);
}
public void StreamSerializeArrayByPropertyName()
{
var serializer = new ByteSerializer(true);
var model1 = Factory.GetAllTypesModel();
byte[] bytes;
using (var ms = new MemoryStream())
{
serializer.SerializeAsync(ms, model1).GetAwaiter().GetResult();
bytes = ms.ToArray();
}
var model2 = serializer.Deserialize <AllTypesReversedModel>(bytes);
Factory.AssertAreEqual(model1, model2);
}
public void WithSerializer()
{
var key = SymmetricEncryptor.GenerateKey(SymmetricAlgorithmType.AESwithShift);
var serializer = new ByteSerializer();
var model1 = Factory.GetAllTypesModel();
using (var ms = new MemoryStream())
using (var cryptoStreamWriter = SymmetricEncryptor.Encrypt(SymmetricAlgorithmType.AESwithShift, key, ms, true, false))
using (var cryptoStreamReader = SymmetricEncryptor.Decrypt(SymmetricAlgorithmType.AESwithShift, key, ms, false, false))
{
var expected = serializer.Serialize(model1);
serializer.SerializeAsync(cryptoStreamWriter, model1).GetAwaiter().GetResult();
cryptoStreamWriter.FlushFinalBlock();
ms.Position = 0;
var bytes = ms.ToArray();
var model2 = serializer.DeserializeAsync <AllTypesModel>(cryptoStreamReader).GetAwaiter().GetResult();
Factory.AssertAreEqual(model1, model2);
}
}
public static async Task SerializeExceptionAsync(ContentType contentType, Stream stream, Exception ex)
{
var model = new ExceptionModel()
{
Message = ex.Message
};
switch (contentType)
{
case ContentType.Bytes:
{
var serializer = new ByteSerializer();
await serializer.SerializeAsync(stream, model);
return;
}
case ContentType.Json:
{
await System.Text.Json.JsonSerializer.SerializeAsync(stream, model);
return;
}
case ContentType.JsonNameless:
{
var bytes = JsonSerializer.SerializeNamelessBytes(model);
#if NETSTANDARD2_0
stream.Write(bytes, 0, bytes.Length);
#else
stream.Write(bytes.AsSpan());
#endif
return;
}
default:
throw new NotImplementedException();
}
}
