public void Should_be_able_to_serialize_and_deserialize_a_complex_type() { var complex = new ComplexSerializerType(); var serializer = new DefaultSerializer(); serializer.AddSerializerType(typeof(ComplexSerializerType), typeof(v1.SomeSerializerType)); serializer.AddSerializerType(typeof(ComplexSerializerType), typeof(v1.AnotherSerializerType)); serializer.AddSerializerType(typeof(ComplexSerializerType), typeof(v2.SomeSerializerType)); serializer.AddSerializerType(typeof(ComplexSerializerType), typeof(v2.AnotherSerializerType)); var stream = serializer.Serialize(complex); var xml = new StreamReader(stream).ReadToEnd(); Assert.IsTrue(xml.Contains(complex.Id.ToString())); stream.Position = 0; Assert.AreEqual(complex.Id, ((ComplexSerializerType)serializer.Deserialize(typeof(ComplexSerializerType), stream)).Id); Console.WriteLine(xml); var some1 = new v1.SomeSerializerType(); var some2 = new v2.SomeSerializerType(); Assert.AreEqual(some1.Id, ((v1.SomeSerializerType)serializer.Deserialize(typeof(v1.SomeSerializerType), serializer.Serialize(some1))).Id); Assert.AreEqual(some2.Id, ((v2.SomeSerializerType)serializer.Deserialize(typeof(v2.SomeSerializerType), serializer.Serialize(some2))).Id); }
private async Task test <T>(DefaultSerializer serializer, MockResolveProxyIds resolver, params T[] values) { Assert.IsTrue(serializer.CanSerialize(typeof(T))); foreach (var value in values) { var stream = new MemoryStream(); using (var writer = new BinaryWriter(stream, Encoding.UTF8, true)) { await serializer.Serialize(writer, typeof(T), value, resolver).ConfigureAwait(false); } Console.WriteLine($"Size of {value}: {stream.Length}"); stream.Position = 0; using (var reader = new BinaryReader(stream, Encoding.UTF8, true)) { var deserializedValue = await serializer.Deserialize(reader, typeof(T), resolver, CancellationToken.None).ConfigureAwait(false); Assert.AreEqual(value, deserializedValue); } } }
public async Task Test() { var resolver = new MockResolveProxyIds(); var serializer = new DefaultSerializer(); Assert.IsTrue(serializer.CanSerialize(typeof(DateTime))); var values = new[] { DateTime.MinValue, DateTime.Today, DateTime.Now, DateTime.UtcNow, DateTime.MaxValue }; foreach (var value in values) { var stream = new MemoryStream(); using (var writer = new BinaryWriter(stream, Encoding.UTF8, true)) { await serializer.Serialize(writer, typeof(DateTime), value, resolver).ConfigureAwait(false); } Console.WriteLine($"Size of {value}: {stream.Length}"); stream.Position = 0; using (var reader = new BinaryReader(stream, Encoding.UTF8, true)) { var deserializedValue = await serializer.Deserialize(reader, typeof(DateTime), resolver, CancellationToken.None).ConfigureAwait(false); Assert.AreEqual(value, deserializedValue); } } }
public void BehavesLikeDefaultSerializerByDefault() { var result = serializer.Serialize(null, entity, context).Single(); var expected = defaultSerializer.Serialize(null, entity, context).Single(); Assert.That(result.ToString(), Is.EqualTo(expected.ToString())); }
public void SerializeDefault() { IStandardSerializer <User> serializer = new DefaultSerializer <User>(); string user = serializer.Serialize(new User("Test", "test")); Assert.AreEqual("Test test", user); }
public void ChangeToDefaultSerializer() { DefaultSerializer <User> serializer = new DefaultSerializer <User>(); serializer.setBinding(System.Reflection.BindingFlags.NonPublic);//all fields are public so no fields return serializer.Serialize(new User("Toto", "Titi")); }
public void SerializeEmptyEnum() { var serializer = new DefaultSerializer(); var json = serializer.Serialize(new { test = new FactorStatus(string.Empty) }); json.Should().Be("{\"test\":\"\"}"); }
public void SerializeNullEnum() { var serializer = new DefaultSerializer(); var json = serializer.Serialize(new { test = new FactorStatus(null) }); json.Should().Be("{\"test\":\"\"}"); }
public void TagHelper_Serialization() { using (var stream = new MemoryStream()) using (var writer = new StreamWriter(stream, Encoding.UTF8, bufferSize: 4096)) { DefaultSerializer.Serialize(writer, DefaultTagHelpers); } }
public void SerializeObject() { var serializer = new DefaultSerializer(); var json = serializer.Serialize(new { foo = "bar" }); json.Should().Be("{\"foo\":\"bar\"}"); }
public void SerializeObjectAndPreserveCase() { var serializer = new DefaultSerializer(); var json = serializer.Serialize(new { Foo = "bar" }); json.Should().Be("{\"Foo\":\"bar\"}"); }
public void SerializeEnum() { var serializer = new DefaultSerializer(); var json = serializer.Serialize(new { test = TestEnum.Foo }); json.Should().Be("{\"test\":\"FOO\"}"); }
public void SerializeEnum() { var serializer = new DefaultSerializer(); var json = serializer.Serialize(new { test = FactorStatus.Active }); json.Should().Be("{\"test\":\"ACTIVE\"}"); }
static string ConvertObjectToString(IEnumerable <OutboxOperation> operations) { if (operations == null || !operations.Any()) { return(null); } return(DefaultSerializer.Serialize(operations)); }
public async Task Enqueue(IOutboundMessage message) { await DbSet.AddAsync(new OutboundMessage { Message = DefaultSerializer.Serialize(message), Endpoint = message.Endpoint.Name, Created = DateTime.UtcNow }); }
private static void SerializeToFile(string path, object obj) { using (StreamWriter sw = new StreamWriter(File.Create(path))) using (JsonTextWriter jtw = new JsonTextWriter(sw) { Formatting = Formatting.Indented, IndentChar = '\t', Indentation = 1 }) DefaultSerializer.Serialize(jtw, obj); }
public static string ToYaml(object target) { if (target == null) { throw new ArgumentNullException(nameof(target)); } return(DefaultSerializer.Serialize(target)); }
public void SampleMessageFieldParams() { var defaultSerializer = new DefaultSerializer<SampleMessage>(this.messageRegistry, this.typeRegistry); var d = new MessageDispatcher<SampleApiClass>(this.messageRegistry, this.typeRegistry); using (var buf = new ThreadSafeWriteQueue(1024)) { var orig = new SampleMessage { MessageId = defaultSerializer.MessageId, A = 10 }; defaultSerializer.Serialize(buf, orig); var pos = buf.ReadMessage(); Assert.IsTrue(d.Dispatch(buf, pos, defaultSerializer.MessageId, new SampleApiClass())); } }
public void Add(object message, IEndpoint endpoint) { lock (_lock) { DbSet.Add(new InboundMessage { MessageId = _messageKeyProvider.GetKey(message), Message = DefaultSerializer.Serialize(message), EndpointName = endpoint.Name, Consumed = DateTime.UtcNow }); } }
public Task Enqueue(IOutboundMessage message) { DbSet.Add(new OutboundMessage { Content = message.RawContent ?? message.Endpoint.Serializer.Serialize(message.Content, message.Headers), Headers = DefaultSerializer.Serialize((IEnumerable <MessageHeader>)message.Headers), Endpoint = DefaultSerializer.Serialize(message.Endpoint), EndpointName = message.Endpoint.Name, Created = DateTime.UtcNow }); return(Task.CompletedTask); }
public void BinarySerialization() { var reg = new MessageRegistry(); var ser = new DefaultSerializer<SubMessage>(reg, new TypeRegistry( new[] { TypeRegistry.StandartTypes, new[] { new VectorXYZBinarySerializer() }})); using (var buf = new ThreadSafeWriteQueue(1024)) { var src = new SubMessage { Vector3 = new Vector3(1.1f, 2.2f, 3.3f) }; ser.Serialize(buf, src); var dst = new SubMessage(); ser.Deserialize(buf, buf.ReadMessage(), dst); Assert.AreEqual(src.Vector3, dst.Vector3); } }
public void Should_be_able_to_serialize_and_deserialize_a_simple_type() { var original = new SimpleSerializerType(); var serializer = new DefaultSerializer(); var stream = serializer.Serialize(original); var xml = new StreamReader(stream).ReadToEnd(); Assert.IsTrue(xml.Contains(original.Id.ToString())); stream.Position = 0; Assert.AreEqual(original.Id, ((SimpleSerializerType)serializer.Deserialize(typeof(SimpleSerializerType), stream)).Id); }
public void TestVec4() { var r = new DefaultSerializer<SingleMessage<Vector4>>(this.messageRegistry, this.typeRegistry,4); using (var buf = new ThreadSafeWriteQueue(1024)) { var orig = new SingleMessage<Vector4> { MessageId = r.MessageId, A = new Vector4(1.1f, 2.2f, 3.3f,( 4.4f)) }; r.Serialize(buf, orig); SingleMessage<Vector4> message = new SingleMessage<Vector4>(); r.Deserialize(buf, buf.ReadMessage(), message); Assert.AreEqual(orig.MessageId, message.MessageId); Assert.AreEqual(orig.A, message.A); } }
public void StripBrackets_EmptyList_RemovesBrackets() { //arrange var serializer = new DefaultSerializer(); object values = new List <int> { }; //act var valuesBytes = serializer.Serialize(values); var actual = valuesBytes.StripBrackets(); //assert var expected = new byte[] { }; Assert.AreEqual(expected, actual); }
public void EmptyString() { var r = new DefaultSerializer<SubMessage>(this.messageRegistry, this.typeRegistry); using (var buf = new ThreadSafeWriteQueue(1024)) { var orig = new SubMessage { Text = string.Empty, }; r.Serialize(buf, orig); SubMessage message = new SubMessage(); r.Deserialize(buf, buf.ReadMessage(), message); Assert.AreEqual(orig.MessageId, message.MessageId); Assert.IsTrue(string.IsNullOrEmpty(message.Text)); } }
public void StripBrackets_StringList_RemovesBrackets() { //arrange var serializer = new DefaultSerializer(); object values = new List <string> { "1", "2", "3", "4" }; //act var valuesBytes = serializer.Serialize(values); var actual = valuesBytes.StripBrackets(); //assert var expected = new byte[] { 0x22, 0x31, 0x22, 0x2c, 0x22, 0x32, 0x22, 0x2c, 0x22, 0x33, 0x22, 0x2c, 0x22, 0x34, 0x22 }; Assert.AreEqual(expected, actual); }
public void StripBrackets_WhenString_DoesNothing() { //arrange var serializer = new DefaultSerializer(); object values = "howdy pardner"; //act var valuesBytes = serializer.Serialize(values); var actual = valuesBytes.StripBrackets(); //assert var expected = new byte[] { 0x22, 0x68, 0x6f, 0x77, 0x64, 0x79, 0x20, 0x70, 0x61, 0x72, 0x64, 0x6e, 0x65, 0x72, 0x22 }; Assert.AreEqual(expected, actual); }
public void SerializeResourceWithCustomProperties() { var serializer = new DefaultSerializer(); var profile = new UserProfile { FirstName = "Foo", }; profile["Custom"] = "Bar"; var user = new User { Profile = profile, }; var json = serializer.Serialize(user); json.Should().Be("{\"profile\":{\"firstName\":\"Foo\",\"Custom\":\"Bar\"}}"); }
public void SerializeResource() { var serializer = new DefaultSerializer(); var user = new User { Credentials = new UserCredentials { Password = new PasswordCredential { Value = "secret", }, }, }; var json = serializer.Serialize(user); json.Should().Be("{\"credentials\":{\"password\":{\"value\":\"secret\"}}}"); }
/// <summary> /// Please note this is a shallow overwrite with no real sophistication past the root object. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="destination"></param> /// <param name="source"></param> public static void CopyFromObj <T>(this JObject destination, T source) where T : class { var serializer = new DefaultSerializer(); var json = serializer.Serialize(source); var jobj = JObject.Parse(json); foreach (var prop in jobj.Properties()) { if (destination.Properties().Any(x => x.Name == prop.Name)) { destination[prop.Name].Replace(jobj[prop.Name]); } else { destination.Add(prop.Name, jobj[prop.Name]); } } }
public Task <string> GetBodyAsync(string href, CancellationToken ct) { var resources = _items .Skip(_currentPage * _pageSize) .Take(_pageSize) .Cast <Resource>(); var itemData = resources .Select(x => x.GetData()) .ToArray(); // Increment page _currentPage++; var serializer = new DefaultSerializer(); return(Task.FromResult(serializer.Serialize(itemData))); }
public async Task Test() { var resolver = new MockResolveProxyIds(); var serializer = new DefaultSerializer(); var stream = new MemoryStream(); var str = new string(new[] { char.MinValue, //standard ASCII 'A', 'Z', 'a', 'z', //extended ASCII 'À', 'Ï', //unicode 'Ā', 'ď', char.MaxValue }); using (var writer = new BinaryWriter(stream, Encoding.UTF8, true)) { await serializer.Serialize(writer, typeof(string), str, resolver).ConfigureAwait(false); } Console.WriteLine($"Size of \"{str}\": {stream.Length}"); stream.Position = 0; using (var reader = new BinaryReader(stream, Encoding.UTF8, true)) { var deserializedValue = await serializer.Deserialize(reader, typeof(string), resolver, CancellationToken.None).ConfigureAwait(false); Assert.AreEqual(deserializedValue, str); } }
public async Task Add(object message, IEndpoint endpoint) { await _semaphore.WaitAsync(); try { DbSet.Add(new InboundMessage { MessageId = _messageKeyProvider.GetKey(message), Message = DefaultSerializer.Serialize(message), EndpointName = endpoint.Name, Consumed = DateTime.UtcNow }); } finally { _semaphore.Release(); } }
public void SerializeResource() { var serializer = new DefaultSerializer(); var nestedResource = new TestNestedResource() { Nested = new TestNestedResource() { Nested = new TestNestedResource() { Foo = "foobar", } } }; var json = serializer.Serialize(nestedResource); json.Should().Be("{\"nested\":{\"nested\":{\"foo\":\"foobar\"}}}"); }
public void StripBrackets_StringList_RemovesBrackets() { //arrange var serializer = new DefaultSerializer(); object values = new List<string> { "1", "2", "3", "4" }; //act var valuesBytes = serializer.Serialize(values); var actual = valuesBytes.StripBrackets(); //assert var expected = new byte[] {0x22, 0x31, 0x22, 0x2c, 0x22, 0x32, 0x22, 0x2c, 0x22, 0x33, 0x22, 0x2c, 0x22, 0x34, 0x22}; Assert.AreEqual(expected, actual); }
public void ThreeBytesString() { var r = new DefaultSerializer<SubMessage>(this.messageRegistry, this.typeRegistry); using (var buf = new ThreadSafeWriteQueue(1024)) { var orig = new SubMessage { Text = "aaa", }; r.Serialize(buf, orig); r.Serialize(buf, orig); SubMessage message = new SubMessage(); r.Deserialize(buf, buf.ReadMessage(), message); Assert.AreEqual(orig.MessageId, message.MessageId); Assert.AreEqual(orig.Text, message.Text); r.Deserialize(buf, buf.ReadMessage(), message); Assert.AreEqual(orig.MessageId, message.MessageId); Assert.AreEqual(orig.Text, message.Text); } }
public void TwoMessages() { var r = new DefaultSerializer<SubMessage>(this.messageRegistry, this.typeRegistry); using (var buf = new ThreadSafeWriteQueue(1024)) { var orig = new SubMessage { MessageId = int.MaxValue, A = int.MinValue, B = float.Epsilon, C = uint.MinValue, Byte = 1, Text = "aaaвпаав", }; var orig2 = new SubMessage { MessageId = int.MaxValue, A = int.MaxValue, B = float.MaxValue, C = uint.MaxValue, Byte = 255, Text = "впаавzz", }; r.Serialize(buf, orig); r.Serialize(buf, orig2); SubMessage message = new SubMessage(); r.Deserialize(buf, buf.ReadMessage(), message); Assert.AreEqual(orig.MessageId, message.MessageId); Assert.AreEqual(orig.A, message.A); Assert.AreEqual(orig.B, message.B); Assert.AreEqual(orig.C, message.C); Assert.AreEqual(orig.Text, message.Text); r.Deserialize(buf, buf.ReadMessage(), message); Assert.AreEqual(orig2.MessageId, message.MessageId); Assert.AreEqual(orig2.A, message.A); Assert.AreEqual(orig2.B, message.B); Assert.AreEqual(orig2.C, message.C); Assert.AreEqual(orig2.Text, message.Text); } }
public void StripBrackets_EmptyList_RemovesBrackets() { //arrange var serializer = new DefaultSerializer(); object values = new List<int> { }; //act var valuesBytes = serializer.Serialize(values); var actual = valuesBytes.StripBrackets(); //assert var expected = new byte[] { }; Assert.AreEqual(expected, actual); }