public void Setup()
{
List <byte[]> bytesList = new List <byte[]>(Size);
List <byte[]> bytesList2 = new List <byte[]>(Size);
List <byte[]> bytesList3 = new List <byte[]>(Size);
List <MyTestClass> testClasses = new List <MyTestClass>(Size);
var bogus = new Bogus.Randomizer();
for (int i = 0; i < Size; i++)
{
MyTestClass myTestClass = new MyTestClass();
myTestClass.BoolProp = bogus.Bool();
myTestClass.IntList = new List <int>(100);
for (int j = 0; j < 100; j++)
{
myTestClass.IntList.Add(bogus.Int());
}
myTestClass.StringProp = bogus.String(10, 100);
myTestClass.StringProp2 = bogus.String(10, 100);
bytesList.Add(JsonSerializer.Serialize(myTestClass));
bytesList3.Add(System.Text.Json.JsonSerializer.SerializeToUtf8Bytes(myTestClass));
bytesList2.Add(MessagePack.MessagePackSerializer.Typeless.Serialize(myTestClass, ContractlessStandardResolver.Options));
testClasses.Add(myTestClass);
}
_serializedObjectsUtf8Json = bytesList.ToArray();
_serializedObjectsMessagePack = bytesList2.ToArray();
_serializedObjectsTextJson = bytesList3.ToArray();
_testClasses = testClasses.ToArray();
}
public static async Task <List <dynamic> > GetAdAnalytics(string[] analysticsUrl, int id)
{
using (var client = new HttpClient()) {
List <dynamic> results = new List <dynamic>();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var postData = "?input_parameters=" +
Encoding.UTF8.GetString(JsonSerializer.Serialize(new { ad_campaign_id = id }));
for (int i = 0; i < analysticsUrl.Length; i++)
{
var request = new HttpRequestMessage {
Method = HttpMethod.Get,
RequestUri = new Uri(analysticsUrl[i] + postData),
Headers =
{
{ "x-token", "4950fc7e-55be-44ea-8832-58ebbd0cd436" }
},
};
using (var massage = await client.SendAsync(request)) {
results.Add(JsonSerializer.Deserialize <dynamic>(await massage.Content.ReadAsStringAsync()));
}
}
return(results);
}
}
public void JsonSerializer_Dictionary_DateTimeOffset()
{
var dict = new Dictionary <string, object>();
dict["Timestamp"] = DateTimeOffset.UtcNow;
var bts = Utf8JsonSerializer.Serialize(dict, Utf8Json.Resolvers.StandardResolver.AllowPrivateExcludeNullSnakeCase);
var newdt = Utf8JsonSerializer.Deserialize <Dictionary <string, object> >(bts, Utf8Json.Resolvers.StandardResolver.AllowPrivateExcludeNullSnakeCase);
var newdt2 = JsonObjectTypeDeserializer.Deserialize <DateTimeOffset>(newdt, "Timestamp");
Assert.Equal(dict["Timestamp"], newdt2);
}
public void JsonSerializer_DateTimeOffset()
{
var timestamp = DateTimeOffset.UtcNow;
var bts = Utf8JsonSerializer.Serialize(timestamp, Utf8Json.Resolvers.StandardResolver.AllowPrivateExcludeNullSnakeCase);
var newdt = Utf8JsonSerializer.Deserialize <DateTimeOffset>(bts, Utf8Json.Resolvers.StandardResolver.AllowPrivateExcludeNullSnakeCase);
Assert.Equal(timestamp, newdt);
var newdt1 = JsonConvert.DeserializeObject <DateTimeOffset>(System.Text.Encoding.UTF8.GetString(bts));
Assert.Equal(timestamp, newdt1);
var newdt2 = JsonObjectTypeDeserializer.Deserialize <DateTimeOffset>(System.Text.Encoding.UTF8.GetString(bts));
Assert.Equal(timestamp, newdt2);
}
private byte[] Serialize(object data)
{
switch (data)
{
case Block block: return(JsonSerializer.Serialize(_mapper.MapBlock(block)));
case FullTransaction transaction:
return(JsonSerializer.Serialize(_mapper.MapTransaction(transaction.Transaction)));
case TxReceipt receipt:
return(JsonSerializer.Serialize(_mapper.MapTransactionReceipt(receipt)));
}
return(null);
}
public void Utf8Json1()
{
using Stream stream = new MemoryStream();
Utf8JsonSerializer.Serialize(stream, Model);
}
public void Setup()
{
Model.Initialize();
T deserializedModel;
// Newtonsoft
using (MemoryStream stream = new MemoryStream())
{
using StreamWriter textWriter = new StreamWriter(stream);
using JsonTextWriter jsonWriter = new JsonTextWriter(textWriter);
var serializer = new Newtonsoft.Json.JsonSerializer();
serializer.Serialize(jsonWriter, Model);
jsonWriter.Flush();
NewtonsoftJsonData = stream.GetBuffer();
stream.Seek(0, SeekOrigin.Begin);
using StreamReader textReader = new StreamReader(stream);
using JsonTextReader jsonReader = new JsonTextReader(textReader);
deserializedModel = serializer.Deserialize <T>(jsonReader);
if (!Model.Equals(deserializedModel))
{
throw new InvalidOperationException("Failed comparison with Newtonsoft.Json");
}
}
// Binary formatter
using (MemoryStream stream = new MemoryStream())
{
var formatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
formatter.Serialize(stream, Model);
BinaryFormatterData = stream.GetBuffer();
stream.Seek(0, SeekOrigin.Begin);
deserializedModel = (T)formatter.Deserialize(stream);
if (!Model.Equals(deserializedModel))
{
throw new InvalidOperationException("Failed comparison with BinaryFormatter");
}
}
// .NETCore JSON
using (MemoryStream stream = new MemoryStream())
{
using Utf8JsonWriter jsonWriter = new Utf8JsonWriter(stream);
System.Text.Json.JsonSerializer.Serialize(jsonWriter, Model);
DotNetCoreJsonData = stream.GetBuffer();
stream.Seek(0, SeekOrigin.Begin);
deserializedModel = System.Text.Json.JsonSerializer.DeserializeAsync <T>(stream).Result;
if (!Model.Equals(deserializedModel))
{
throw new InvalidOperationException("Failed comparison with System.Text.Json");
}
}
// DataContractJson
using (MemoryStream stream = new MemoryStream())
{
var serializer = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(T));
serializer.WriteObject(stream, Model);
DataContractJsonData = stream.GetBuffer();
stream.Seek(0, SeekOrigin.Begin);
deserializedModel = (T)serializer.ReadObject(stream);
if (!Model.Equals(deserializedModel))
{
throw new InvalidOperationException("Failed comparison with DataContractJson");
}
}
// XML serializer
using (MemoryStream stream = new MemoryStream())
{
var serializer = new System.Xml.Serialization.XmlSerializer(typeof(T));
serializer.Serialize(stream, Model);
XmlSerializerData = stream.GetBuffer();
stream.Seek(0, SeekOrigin.Begin);
deserializedModel = (T)serializer.Deserialize(stream);
if (!Model.Equals(deserializedModel))
{
throw new InvalidOperationException("Failed comparison with XmlSerializer");
}
}
// Portable Xaml
using (MemoryStream stream = new MemoryStream())
{
Portable.Xaml.XamlServices.Save(stream, Model);
PortableXamlData = stream.GetBuffer();
stream.Seek(0, SeekOrigin.Begin);
_ = Portable.Xaml.XamlServices.Load(stream);
if (!Model.Equals(deserializedModel))
{
throw new InvalidOperationException("Failed comparison with Portable.Xaml");
}
}
// Utf8Json
using (MemoryStream stream = new MemoryStream())
{
Utf8JsonSerializer.Serialize(stream, Model);
Utf8JsonData = stream.GetBuffer();
stream.Seek(0, SeekOrigin.Begin);
deserializedModel = Utf8JsonSerializer.Deserialize <T>(stream);
if (!Model.Equals(deserializedModel))
{
throw new InvalidOperationException("Failed comparison with Utf8Json");
}
}
// MessagePack
using (MemoryStream stream = new MemoryStream())
{
MessagePack.MessagePackSerializer.Serialize(stream, Model, MessagePack.Resolvers.ContractlessStandardResolver.Instance);
MessagePackData = stream.GetBuffer();
stream.Seek(0, SeekOrigin.Begin);
deserializedModel = MessagePack.MessagePackSerializer.Deserialize <T>(stream, MessagePack.Resolvers.ContractlessStandardResolver.Instance);
if (!Model.Equals(deserializedModel))
{
throw new InvalidOperationException("Failed comparison with MessagePack");
}
}
// BinaryPack
using (MemoryStream stream = new MemoryStream())
{
BinaryConverter.Serialize(Model, stream);
BinaryPackData = stream.GetBuffer();
stream.Seek(0, SeekOrigin.Begin);
deserializedModel = BinaryConverter.Deserialize <T>(stream);
if (!Model.Equals(deserializedModel))
{
throw new InvalidOperationException("Failed comparison with BinaryPack");
}
}
}
private async Task<MethodResponse> ToggleAlarmSiren(MethodRequest methodRequest, object userContext)
{
var state = await _mediator.Send(new ToggleAlarmSirenCommand());
return new MethodResponse(JsonSerializer.Serialize(state), 200);
}
private async Task <MethodResponse> ToggleGardenLights(MethodRequest methodRequest, object userContext)
{
var state = await _mediator.Send(new ToggleGardenLightsCommand());
return(new MethodResponse(JsonSerializer.Serialize(state), 200));
}
