public async Task ProduceToMultiplePartitions(int numberOfPartitions, int numberOfKeys, int numberOfMessages) { var keySerializer = new Int32Serializer(); var valueSerializer = new StringSerializer(); var messagePartitioner = new Int32Partitioner(); using (var temporaryTopic = testCluster.CreateTemporaryTopic(partitions: 2)) using (var brokers = new KafkaBrokers(testCluster.CreateBrokerUris())) { var topic = temporaryTopic.Name; { var producer = KafkaProducer.Create(brokers, keySerializer, valueSerializer, messagePartitioner); var messages = Enumerable .Range(0, numberOfMessages) .Select(i => KeyedMessage.Create(topic, i % numberOfKeys, i % numberOfPartitions, "Message " + i)); await producer.SendAsync(messages, CancellationToken.None); } { var selectors = Enumerable .Range(0, numberOfPartitions) .Select(partition => new TopicSelector { Partition = partition, Topic = topic }) .ToArray(); var consumer = KafkaConsumer.Create(defaultConsumerGroup, brokers, keySerializer, valueSerializer, selectors); var responses = await consumer.ReceiveAsync(CancellationToken.None); Assert.That(responses, Has.Count.EqualTo(numberOfMessages)); var received = new bool[numberOfMessages]; var offsets = new long[numberOfPartitions]; foreach (var response in responses) { var split = response.Value.Split(' '); Assert.That(split, Has.Length.EqualTo(2)); Assert.That(split[0], Is.EqualTo("Message")); int messageNumber; var parsed = Int32.TryParse(split[1], out messageNumber); Assert.That(parsed, Is.True); Assert.That(messageNumber, Is.InRange(0, numberOfMessages - 1)); var key = messageNumber % numberOfKeys; Assert.That(response.Key, Is.EqualTo(key)); var partition = messageNumber % numberOfPartitions; Assert.That(response.Partition, Is.EqualTo(partition)); Assert.That(received[messageNumber], Is.False); received[messageNumber] = true; Assert.That(response.Offset, Is.EqualTo(offsets[response.Partition])); offsets[response.Partition] += 1; Assert.That(response.Topic, Is.EqualTo(topic)); } } } }
public override ValueSerializer BuildSerializer(Serializer serializer, Type type, ConcurrentDictionary <Type, ValueSerializer> typeMapping) { var preserveObjectReferences = serializer.Options.PreserveObjectReferences; var ser = new ObjectSerializer(type); typeMapping.TryAdd(type, ser); var elementSerializer = serializer.GetSerializerByType(typeof(DictionaryEntry)); ObjectReader reader = (stream, session) => { throw new NotSupportedException("Generic IDictionary<TKey,TValue> are not yet supported"); #pragma warning disable CS0162 // Unreachable code detected var instance = Activator.CreateInstance(type); #pragma warning restore CS0162 // Unreachable code detected if (preserveObjectReferences) { session.TrackDeserializedObject(instance); } var count = stream.ReadInt32(session); var entries = new DictionaryEntry[count]; for (var i = 0; i < count; i++) { var entry = (DictionaryEntry)stream.ReadObject(session); entries[i] = entry; } //TODO: populate dictionary return(instance); }; ObjectWriter writer = (stream, obj, session) => { if (preserveObjectReferences) { session.TrackSerializedObject(obj); } var dict = obj as IDictionary; /* * if (dict == null) * { * Console.ForegroundColor = ConsoleColor.Yellow; * Console.WriteLine(obj.GetType().FullName); * return; * } * //*/ // ReSharper disable once PossibleNullReferenceException Int32Serializer.WriteValueImpl(stream, dict.Count, session); foreach (var item in dict) { stream.WriteObject(item, typeof(DictionaryEntry), elementSerializer, serializer.Options.PreserveObjectReferences, session); // elementSerializer.WriteValue(stream,item,session); } }; ser.Initialize(reader, writer); return(ser); }
public void TestReset() { var classMap = new BsonClassMap <TestClass>(cm => { var mm = cm.MapMember(c => c.Property); }); var originalSerializer = new Int32Serializer(); var memberMap = classMap.GetMemberMap(x => x.Property); memberMap.SetDefaultValue(42); memberMap.SetElementName("oops"); memberMap.SetIdGenerator(new GuidGenerator()); memberMap.SetIgnoreIfDefault(true); memberMap.SetIsRequired(true); memberMap.SetOrder(21); memberMap.SetSerializer(originalSerializer); memberMap.SetShouldSerializeMethod(o => false); memberMap.Reset(); Assert.AreEqual(0, (int)memberMap.DefaultValue); Assert.AreEqual("Property", memberMap.ElementName); Assert.IsNull(memberMap.IdGenerator); Assert.IsFalse(memberMap.IgnoreIfDefault); Assert.IsFalse(memberMap.IgnoreIfNull); Assert.IsFalse(memberMap.IsRequired); Assert.AreEqual(int.MaxValue, memberMap.Order); Assert.AreNotSame(originalSerializer, memberMap.GetSerializer()); Assert.IsNull(memberMap.ShouldSerializeMethod); }
public void Pack(Packer packer, object obj) { var buffer = (ME.ECS.Collections.IBufferArray)obj; var arr = buffer.GetArray(); if (arr == null) { packer.WriteByte((byte)TypeValue.Null); var int32 = new Int32Serializer(); int32.Pack(packer, packer.GetMetaTypeId(obj.GetType().GenericTypeArguments[0])); } else { packer.WriteByte((byte)TypeValue.ObjectArray); var length = buffer.Count; var int32 = new Int32Serializer(); int32.Pack(packer, length); int32.Pack(packer, packer.GetMetaTypeId(arr.GetType().GetElementType())); for (var i = 0; i < length; ++i) { packer.PackInternal(arr.GetValue(i)); } } }
public void SerializeThrowsWhenBufferIsWrongSize(int badSize) { Int32Serializer serializer = new Int32Serializer(); Assert.ThrowsException <ArgumentException>(() => { serializer.Serialize(0, new byte[badSize]); }); }
public void SerializeThrowsWhenBufferIsNull() { Int32Serializer serializer = new Int32Serializer(); Assert.ThrowsException <ArgumentNullException>(() => { serializer.Serialize(0, null); }); }
public void SerializeThenDeserializeWorks(bool littleEndian) { int[] numbers = new int[] { int.MinValue, int.MinValue + 1, int.MinValue + 2, int.MinValue + 3, int.MinValue / 2, -65537, -65536, -65535, -65534, -257, -256, -255, -254 - 126, -127, -128 - 5, -4, -3, -2, -1, 0, int.MaxValue, int.MaxValue - 1, int.MaxValue - 2, int.MaxValue - 3, int.MaxValue / 2, 65537, 65536, 65535, 65534, 257, 256, 255, 254, 126, 127, 128, 5, 4, 3, 2, 1, }; Int32Serializer serializer = new Int32Serializer(littleEndian); for (int i = 0; i < numbers.Length; i++) { byte[] buffer = new byte[serializer.DataSize]; serializer.Serialize(numbers[i], buffer); Assert.AreEqual(numbers[i], serializer.Deserialize(buffer)); } }
public void SerializeAndDeserializeToTheSameObject(int originalValue) { Serializer <int> serializer = new Int32Serializer(); byte[] serializedValue = serializer.Serialize(originalValue); int deserializedValue = serializer.Deserialize(serializedValue); Assert.Equal(originalValue, deserializedValue); }
public TestDocumentClassSerializer() { var itemSerializer = new Int32Serializer(BsonType.String); var listSerializer = new EnumerableInterfaceImplementerSerializer <List <int> >(itemSerializer); this.RegisterMember("Id", "_id", new ObjectIdSerializer()); this.RegisterMember("Name", "name", new StringSerializer()); this.RegisterMember("Colors", "colors", listSerializer); this.RegisterMember("Colors2", "colors2", listSerializer); }
private static void WriteValues <T>(T[] array, Stream stream, Type elementType, ValueSerializer elementSerializer, SerializerSession session) { Int32Serializer.WriteValueImpl(stream, array.Length, session); var preserveObjectReferences = session.Serializer.Options.PreserveObjectReferences; foreach (var value in array) { stream.WriteObject(value, elementType, elementSerializer, preserveObjectReferences, session); } }
private static void WriteValues <T>(LinkedList <T> list, Stream stream, Type elementType, ValueSerializer elementSerializer, SerializerSession session) { Int32Serializer.WriteValueImpl(stream, list.Count, session); var preserveObjectReferences = session.Serializer.Options.PreserveObjectReferences; foreach (var value in list) { stream.WriteObject(value, elementType, elementSerializer, preserveObjectReferences, session); } }
public override ValueSerializer BuildSerializer(Serializer serializer, Type type, ConcurrentDictionary <Type, ValueSerializer> typeMapping) { var ser = new ObjectSerializer(type); if (serializer.Options.KnownTypesDict.TryGetValue(type, out var index)) { var wrapper = new KnownTypeObjectSerializer(ser, index); typeMapping.TryAdd(type, wrapper); } else { typeMapping.TryAdd(type, ser); } var elementSerializer = serializer.GetSerializerByType(typeof(DictionaryEntry)); var preserveObjectReferences = serializer.Options.PreserveObjectReferences; ObjectReader reader = (stream, session) => { var count = stream.ReadInt32(session); var instance = (IDictionary)Activator.CreateInstance(type, count); if (preserveObjectReferences) { session.TrackDeserializedObject(instance); } for (var i = 0; i < count; i++) { var entry = (DictionaryEntry)stream.ReadObject(session); instance.Add(entry.Key, entry.Value); } return(instance); }; ObjectWriter writer = (stream, obj, session) => { if (preserveObjectReferences) { session.TrackSerializedObject(obj); } var dict = obj as IDictionary; // ReSharper disable once PossibleNullReferenceException Int32Serializer.WriteValueImpl(stream, dict.Count, session); foreach (DictionaryEntry item in dict) { stream.WriteObject(item, typeof(DictionaryEntry), elementSerializer, serializer.Options.PreserveObjectReferences, session); // elementSerializer.WriteValue(stream,item,session); } }; ser.Initialize(reader, writer); return(ser); }
private static void WriteValues(Array array, Stream stream, Type elementType, ValueSerializer elementSerializer, SerializerSession session) { for (var i = 0; i < array.Rank; i++) { Int32Serializer.WriteValueImpl(stream, array.GetLength(i), session); } var preserveObjectReferences = session.Serializer.Options.PreserveObjectReferences; foreach (var value in array) { stream.WriteObject(value, elementType, elementSerializer, preserveObjectReferences, session); } }
private static bool TryTranslateDateTimeProperty(MemberExpression expression, AggregationExpression container, MemberInfo memberInfo, out AggregationExpression result) { result = null; if (container.Expression.Type == typeof(DateTime) && memberInfo is PropertyInfo propertyInfo) { AstExpression ast; IBsonSerializer serializer; if (propertyInfo.Name == "DayOfWeek") { ast = AstExpression.Subtract(AstExpression.DatePart(AstDatePart.DayOfWeek, container.Ast), 1); serializer = new EnumSerializer <DayOfWeek>(BsonType.Int32); } else { AstDatePart datePart; switch (propertyInfo.Name) { case "Day": datePart = AstDatePart.DayOfMonth; break; case "DayOfWeek": datePart = AstDatePart.DayOfWeek; break; case "DayOfYear": datePart = AstDatePart.DayOfYear; break; case "Hour": datePart = AstDatePart.Hour; break; case "Millisecond": datePart = AstDatePart.Millisecond; break; case "Minute": datePart = AstDatePart.Minute; break; case "Month": datePart = AstDatePart.Month; break; case "Second": datePart = AstDatePart.Second; break; case "Week": datePart = AstDatePart.Week; break; case "Year": datePart = AstDatePart.Year; break; default: return(false); } ast = AstExpression.DatePart(datePart, container.Ast); serializer = new Int32Serializer(); } result = new AggregationExpression(expression, ast, serializer); return(true); } return(false); }
private static void WriteValues <T>(T[] array, Stream stream, Type elementType, ValueSerializer elementSerializer, SerializerSession session, bool preserveObjectReferences) { if (preserveObjectReferences) { session.TrackSerializedObject(array); } Int32Serializer.WriteValueImpl(stream, array.Length, session); foreach (var value in array) { stream.WriteObject(value, elementType, elementSerializer, preserveObjectReferences, session); } }
private static void WriteValues <T>(LinkedList <T> llist, Stream stream, Type elementType, ValueSerializer elementSerializer, SerializerSession session, bool preserveObjectReferences) { if (preserveObjectReferences) { session.TrackSerializedObject(llist); } Int32Serializer.WriteValueImpl(stream, llist.Count, session); foreach (var value in llist) { stream.WriteObject(value, elementType, elementSerializer, preserveObjectReferences, session); } }
public override ValueSerializer BuildSerializer(Serializer serializer, Type type, ConcurrentDictionary <Type, ValueSerializer> typeMapping) { var preserveObjectReferences = serializer.Options.PreserveObjectReferences; var ser = new ObjectSerializer(type); typeMapping.TryAdd(type, ser); var elementSerializer = serializer.GetSerializerByType(typeof(DictionaryEntry)); object Reader(Stream stream, DeserializerSession session) { var instance = (IDictionary <string, object>)Activator.CreateInstance(type) !; if (preserveObjectReferences) { session.TrackDeserializedObject(instance); } var count = stream.ReadInt32(session); for (var i = 0; i < count; i++) { var entry = (KeyValuePair <string, object>)stream.ReadObject(session); instance.Add(entry); } return(instance); } void Writer(Stream stream, object obj, SerializerSession session) { if (preserveObjectReferences) { session.TrackSerializedObject(obj); } var dict = (IDictionary <string, object>)obj; // ReSharper disable once PossibleNullReferenceException Int32Serializer.WriteValueImpl(stream, dict.Count, session); foreach (var item in dict) { stream.WriteObject(item, typeof(DictionaryEntry), elementSerializer, serializer.Options.PreserveObjectReferences, session); } // elementSerializer.WriteValue(stream,item,session); } ser.Initialize(Reader, Writer); return(ser); }
private static void WriteHashSet <T>(HashSet <T> set, Stream stream, SerializerSession session, Type elementType, ValueSerializer elementSerializer, bool preserveObjectReferences) { if (preserveObjectReferences) { session.TrackSerializedObject(set); } // ReSharper disable once PossibleNullReferenceException Int32Serializer.WriteValueImpl(stream, set.Count, session); foreach (var item in set) { stream.WriteObject(item, elementType, elementSerializer, preserveObjectReferences, session); } }
public object Unpack(Packer packer) { int arrayTypeId = -1; int typeId = -1; object p1 = null; object p2 = null; var type = packer.ReadByte(); if (type == (byte)TypeValue.Null) { var int32 = new Int32Serializer(); arrayTypeId = (int)int32.Unpack(packer); typeId = (int)int32.Unpack(packer); p1 = null; p2 = 0; } else { var int32 = new Int32Serializer(); arrayTypeId = (int)int32.Unpack(packer); var length = (int)int32.Unpack(packer); typeId = (int)int32.Unpack(packer); var elementType = packer.GetMetaType(typeId); var poolArrayType = typeof(PoolArray <>).MakeGenericType(elementType); var spawnMethod = poolArrayType.GetMethod("Spawn", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static); var bufferArray = (ME.ECS.Collections.IBufferArray)spawnMethod.Invoke(null, new object[] { length, false }); var arr = bufferArray.GetArray(); for (var i = 0; i < length; ++i) { arr.SetValue(packer.UnpackInternal(), i); } p1 = arr; p2 = length; } var arrayType = packer.GetMetaType(arrayTypeId); var constructedType = arrayType.MakeGenericType(packer.GetMetaType(typeId)); var instance = (ME.ECS.Collections.IBufferArray)System.Activator.CreateInstance(constructedType, System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic, null, new object[] { p1, p2, -1, }, System.Globalization.CultureInfo.InvariantCulture); return(instance); }
public async Task ProduceToTwoPartitions() { var keySerializer = new Int32Serializer(); var valueSerializer = new StringSerializer(); var messagePartitioner = new Int32Partitioner(); using (var temporaryTopic = testCluster.CreateTemporaryTopic(partitions: 2)) using (var brokers = new KafkaBrokers(testCluster.CreateBrokerUris())) { var topic = temporaryTopic.Name; var producer = KafkaProducer.Create(brokers, keySerializer, valueSerializer, messagePartitioner); var consumers = new[] { KafkaConsumer.Create(defaultConsumerGroup, brokers, keySerializer, valueSerializer, new TopicSelector { Partition = 0, Topic = topic }), KafkaConsumer.Create(defaultConsumerGroup, brokers, keySerializer, valueSerializer, new TopicSelector { Partition = 1, Topic = topic }) }; await producer.SendAsync(new[] { KeyedMessage.Create(topic, 0, "Message to partition 0"), KeyedMessage.Create(topic, 1, "Message to partition 1") }, CancellationToken.None); for (var i = 0; i < consumers.Length; i++) { var responses = await consumers[i].ReceiveAsync(CancellationToken.None); Assert.That(responses, Is.Not.Null); Assert.That(responses, Has.Count.EqualTo(1)); var first = responses.First(); Assert.That(first.Offset, Is.EqualTo(0)); Assert.That(first.Partition, Is.EqualTo(i)); Assert.That(first.Key, Is.EqualTo(i)); Assert.That(first.Topic, Is.EqualTo(topic)); Assert.That(first.Value, Is.EqualTo("Message to partition " + i)); } } }
public object Unpack(Packer packer) { int typeId = -1; object p1 = null; object p2 = null; var type = packer.ReadByte(); if (type == (byte)TypeValue.Null) { var int32 = new Int32Serializer(); typeId = (int)int32.Unpack(packer); p1 = null; p2 = 0; } else { var int32 = new Int32Serializer(); var length = (int)int32.Unpack(packer); typeId = (int)int32.Unpack(packer); var elementType = packer.GetMetaType(typeId); var arr = System.Array.CreateInstance(elementType, PoolArrayUtilities.GetArrayLengthPot(length)); for (var i = 0; i < length; ++i) { arr.SetValue(packer.UnpackInternal(), i); } p1 = arr; p2 = length; } var constructedType = typeof(ME.ECS.Collections.BufferArray <>).MakeGenericType(packer.GetMetaType(typeId)); var instance = (ME.ECS.Collections.IBufferArray)System.Activator.CreateInstance(constructedType, System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic, null, new object[] { p1, p2 }, System.Globalization.CultureInfo.InvariantCulture); return(instance); }
public WKTSerializers(ISerializerStorage serializerStorage, IValueTypeObjectsDictionary objectCache) { Boolean = new BooleanSerializer(serializerStorage); Byte = new ByteSerializer(serializerStorage); Char = new CharSerializer(serializerStorage); DateTime = new DateTimeSerializer(serializerStorage); DateTimeOffset = new DateTimeOffsetSerializer(serializerStorage); Decimal = new DecimalSerializer(serializerStorage); Double = new DoubleSerializer(serializerStorage); Guid = new GuidSerializer(serializerStorage); Int16 = new Int16Serializer(serializerStorage); Int32 = new Int32Serializer(serializerStorage); Int64 = new Int64Serializer(serializerStorage); Object = new ObjectSerializer(serializerStorage); SByte = new SByteSerializer(serializerStorage); Single = new SingleSerializer(serializerStorage); String = new StringSerializer(serializerStorage, objectCache); TimeSpan = new TimeSpanSerializer(serializerStorage); UInt16 = new UInt16Serializer(serializerStorage); UInt32 = new UInt32Serializer(serializerStorage); }
public async Task ProduceToTwoPartitions() { var keySerializer = new Int32Serializer(); var valueSerializer = new StringSerializer(); var messagePartitioner = new Int32Partitioner(); using (var temporaryTopic = testCluster.CreateTemporaryTopic(partitions:2)) using (var brokers = new KafkaBrokers(testCluster.CreateBrokerUris())) { var topic = temporaryTopic.Name; var producer = KafkaProducer.Create(brokers, keySerializer, valueSerializer, messagePartitioner); var consumers = new[] { KafkaConsumer.Create(defaultConsumerGroup, brokers, keySerializer, valueSerializer, new TopicSelector { Partition = 0, Topic = topic }), KafkaConsumer.Create(defaultConsumerGroup, brokers, keySerializer, valueSerializer, new TopicSelector { Partition = 1, Topic = topic }) }; await producer.SendAsync(new[] { KeyedMessage.Create(topic, 0, "Message to partition 0"), KeyedMessage.Create(topic, 1, "Message to partition 1") }, CancellationToken.None); for (var i = 0; i < consumers.Length; i++) { var responses = await consumers[i].ReceiveAsync(CancellationToken.None); Assert.That(responses, Is.Not.Null); Assert.That(responses, Has.Count.EqualTo(1)); var first = responses.First(); Assert.That(first.Offset, Is.EqualTo(0)); Assert.That(first.Partition, Is.EqualTo(i)); Assert.That(first.Key, Is.EqualTo(i)); Assert.That(first.Topic, Is.EqualTo(topic)); Assert.That(first.Value, Is.EqualTo("Message to partition " + i)); } } }
public override ValueSerializer BuildSerializer(Serializer serializer, Type type, ConcurrentDictionary <Type, ValueSerializer> typeMapping) { var x = new ObjectSerializer(serializer.Options.FieldSelector, type); typeMapping.TryAdd(type, x); var preserveObjectReferences = serializer.Options.PreserveObjectReferences; var elementType = GetEnumerableType(type) ?? typeof(object); var elementSerializer = serializer.GetSerializerByType(elementType); var typeName = type.Name; var genericSufixIdx = typeName.IndexOf('`'); typeName = genericSufixIdx != -1 ? typeName.Substring(0, genericSufixIdx) : typeName; var creatorType = Type.GetType( ImmutableCollectionsNamespace + "." + typeName + ", " + ImmutableCollectionsAssembly, true); var genericTypes = elementType.IsGenericType() ? elementType.GetGenericArguments() : new[] { elementType }; var createRange = creatorType.GetMethods(BindingFlags.Public | BindingFlags.Static) .First(methodInfo => methodInfo.Name == "CreateRange" && methodInfo.GetParameters().Length == 1) .MakeGenericMethod(genericTypes); ObjectWriter writer = (stream, o, session) => { var enumerable = o as ICollection; if (enumerable == null) { // object can be IEnumerable but not ICollection i.e. ImmutableQueue var e = (IEnumerable)o; var list = e.Cast <object>().ToList(); // enumerable = list; } Int32Serializer.WriteValueImpl(stream, enumerable.Count, session); foreach (var value in enumerable) { stream.WriteObject(value, elementType, elementSerializer, preserveObjectReferences, session); } if (preserveObjectReferences) { session.TrackSerializedObject(o); } }; ObjectReader reader = (stream, session) => { var count = stream.ReadInt32(session); var items = Array.CreateInstance(elementType, count); for (var i = 0; i < count; i++) { var value = stream.ReadObject(session); items.SetValue(value, i); } var instance = createRange.Invoke(null, new object[] { items }); if (preserveObjectReferences) { session.TrackDeserializedObject(instance); } return(instance); }; x.Initialize(reader, writer); return(x); }
public override ValueSerializer BuildSerializer(Serializer serializer, Type type, ConcurrentDictionary <Type, ValueSerializer> typeMapping) { var x = new ObjectSerializer(type); typeMapping.TryAdd(type, x); var preserveObjectReferences = serializer.Options.PreserveObjectReferences; var elementType = GetEnumerableType(type) ?? typeof(object); var elementSerializer = serializer.GetSerializerByType(elementType); var typeName = type.Name; var genericSufixIdx = typeName.IndexOf('`'); typeName = genericSufixIdx != -1 ? typeName.Substring(0, genericSufixIdx) : typeName; var creatorType = Type.GetType(ImmutableCollectionsNamespace + "." + typeName + ", " + ImmutableCollectionsAssembly); var genericTypes = elementType.GetTypeInfo().IsGenericType ? elementType.GetTypeInfo().GetGenericArguments() : new[] { elementType }; // if creatorType == null it means that type is probably an interface // we propagate null to create mock serializer - it won't be used anyway var stackTypeDef = Type.GetType(ImmutableCollectionsNamespace + ".IImmutableStack`1, " + ImmutableCollectionsAssembly, true); var stackInterface = stackTypeDef.MakeGenericType(genericTypes[0]); var isStack = stackInterface.IsAssignableFrom(type); var createRange = creatorType != null ? creatorType.GetTypeInfo().GetMethods(BindingFlags.Public | BindingFlags.Static) .First(methodInfo => methodInfo.Name == "CreateRange" && methodInfo.GetParameters().Length == 1) .MakeGenericMethod(genericTypes) : null; ObjectWriter writer = (stream, o, session) => { var enumerable = o as ICollection; if (enumerable == null) { // object can be IEnumerable but not ICollection i.e. ImmutableQueue var e = (IEnumerable)o; var list = e.Cast <object>().ToList();// enumerable = list; } Int32Serializer.WriteValueImpl(stream, enumerable.Count, session); foreach (var value in enumerable) { stream.WriteObject(value, elementType, elementSerializer, preserveObjectReferences, session); } if (preserveObjectReferences) { session.TrackSerializedObject(o); } }; ObjectReader reader; if (isStack) { // if we are dealing with stack, we need to apply arguments in reverse order reader = (stream, session) => { var count = stream.ReadInt32(session); var items = Array.CreateInstance(elementType, count); for (var i = 0; i < count; i++) { var value = stream.ReadObject(session); items.SetValue(value, count - i - 1); } var instance = createRange.Invoke(null, new object[] { items }); if (preserveObjectReferences) { session.TrackDeserializedObject(instance); } return(instance); }; } else { reader = (stream, session) => { var count = stream.ReadInt32(session); var items = Array.CreateInstance(elementType, count); for (var i = 0; i < count; i++) { var value = stream.ReadObject(session); items.SetValue(value, i); } var instance = createRange.Invoke(null, new object[] { items }); if (preserveObjectReferences) { session.TrackDeserializedObject(instance); } return(instance); }; } x.Initialize(reader, writer); return(x); }
public override ValueSerializer BuildSerializer(Serializer serializer, Type type, ConcurrentDictionary <Type, ValueSerializer> typeMapping) { var x = new ObjectSerializer(type); typeMapping.TryAdd(type, x); var preserveObjectReferences = serializer.Options.PreserveObjectReferences; var elementType = GetEnumerableType(type) ?? typeof(object); var elementSerializer = serializer.GetSerializerByType(elementType); var countProperty = type.GetTypeInfo().GetProperty("Count"); var addMethod = type.GetTypeInfo().GetMethod("Add", BindingFlagsEx.All); var enumerableConstructor = GetEnumerableConstructor(type); Func <object, int> countGetter = o => (int)countProperty.GetValue(o); ObjectReader reader = null; if (HasParameterlessConstructor(type) && addMethod != null) { var add = CompileMethodToDelegate(addMethod, type, elementType); reader = (stream, session) => { var instance = Activator.CreateInstance(type, true); if (preserveObjectReferences) { session.TrackDeserializedObject(instance); } var count = stream.ReadInt32(session); for (var i = 0; i < count; i++) { var value = stream.ReadObject(session); add(instance, value); } return(instance); }; } else if (enumerableConstructor != null) { var construct = CompileCtorToDelegate(enumerableConstructor, elementType.MakeArrayType()); reader = (stream, session) => { var count = stream.ReadInt32(session); var items = Array.CreateInstance(elementType, count); for (var i = 0; i < count; i++) { var value = stream.ReadObject(session); items.SetValue(value, i); } var instance = construct(items); if (preserveObjectReferences) { session.TrackDeserializedObject(instance); } return(instance); }; } ObjectWriter writer = (stream, o, session) => { if (preserveObjectReferences) { session.TrackSerializedObject(o); } Int32Serializer.WriteValueImpl(stream, countGetter(o), session); var enumerable = o as IEnumerable; // ReSharper disable once PossibleNullReferenceException foreach (var value in enumerable) { stream.WriteObject(value, elementType, elementSerializer, preserveObjectReferences, session); } }; x.Initialize(reader, writer); return(x); }
public static void WriteLengthEncodedByteArray(this Stream self, byte[] bytes, SerializerSession session) { Int32Serializer.WriteValueImpl(self, bytes.Length, session); self.Write(bytes, 0, bytes.Length); }
public override ValueSerializer BuildSerializer(Serializer serializer, Type type, CachedReadConcurrentDictionary <Type, ValueSerializer> typeMapping) { var preserveObjectReferences = serializer.Options.PreserveObjectReferences; var ser = new ObjectSerializer(type); typeMapping.TryAdd(type, ser); var dictionaryTypes = GetKeyValuePairType(type); var elementSerializer = serializer.GetSerializerByType(dictionaryTypes.KeyValuePairType); ObjectReader reader = (stream, session) => { object instance; try { instance = Activator.CreateInstance(type, true); // IDictionary<TKey, TValue> } catch (Exception) { instance = Activator.CreateInstance(type); // IDictionary<TKey, TValue> } if (preserveObjectReferences) { session.TrackDeserializedObject(instance); } var count = stream.ReadInt32(session); for (var i = 0; i < count; i++) { var entry = stream.ReadObject(session); // KeyValuePair<TKey, TValue> // Get entry.Key and entry.Value var key = dictionaryTypes.KeyValuePairType.GetProperty(nameof(KeyValuePair <object, object> .Key)).GetValue(entry, null); var value = dictionaryTypes.KeyValuePairType.GetProperty(nameof(KeyValuePair <object, object> .Value)).GetValue(entry, null); // Same as: instance.Add(key, value) dictionaryTypes.DictionaryInterfaceType .GetMethod(nameof(IDictionary <object, object> .Add), new[] { dictionaryTypes.KeyType, dictionaryTypes.ValueType }) .Invoke(instance, new[] { key, value }); } return(instance); }; void writer(System.IO.Stream stream, object obj, SerializerSession session) { if (preserveObjectReferences) { session.TrackSerializedObject(obj); } var dict = obj as IEnumerable; // IDictionary<T, V> is IEnumerable<KeyValuePair<T, V>> var count = dict.Cast <object>().Count(); // ReSharper disable once PossibleNullReferenceException Int32Serializer.WriteValueImpl(stream, count, session); foreach (var item in dict) { stream.WriteObject(item, dictionaryTypes.KeyValuePairType, elementSerializer, serializer.Options.PreserveObjectReferences, session); } } ser.Initialize(reader, writer); return(ser); }
public override ValueSerializer BuildSerializer(Serializer serializer, Type type, ConcurrentDictionary <Type, ValueSerializer> typeMapping) { var x = new ObjectSerializer(type); typeMapping.TryAdd(type, x); var preserveObjectReferences = serializer.Options.PreserveObjectReferences; var elementType = GetEnumerableType(type) ?? typeof(object); var elementSerializer = serializer.GetSerializerByType(elementType); var countProperty = type.GetTypeInfo().GetProperty("Count"); var addRange = type.GetTypeInfo().GetMethod("AddRange"); var add = type.GetTypeInfo().GetMethod("Add"); Func <object, int> countGetter = o => (int)countProperty.GetValue(o); ObjectReader reader = (stream, session) => { var instance = Activator.CreateInstance(type); if (preserveObjectReferences) { session.TrackDeserializedObject(instance); } var count = stream.ReadInt32(session); if (addRange != null) { var items = Array.CreateInstance(elementType, count); for (var i = 0; i < count; i++) { var value = stream.ReadObject(session); items.SetValue(value, i); } //HACK: this needs to be fixed, codegenerated or whatever addRange.Invoke(instance, new object[] { items }); return(instance); } if (add != null) { for (var i = 0; i < count; i++) { var value = stream.ReadObject(session); add.Invoke(instance, new[] { value }); } } return(instance); }; ObjectWriter writer = (stream, o, session) => { if (preserveObjectReferences) { session.TrackSerializedObject(o); } Int32Serializer.WriteValueImpl(stream, countGetter(o), session); var enumerable = o as IEnumerable; // ReSharper disable once PossibleNullReferenceException foreach (var value in enumerable) { stream.WriteObject(value, elementType, elementSerializer, preserveObjectReferences, session); } }; x.Initialize(reader, writer); return(x); }
public void ConstructorWorks(bool littleEndian) { Int32Serializer serializer = new Int32Serializer(littleEndian); Assert.AreEqual(littleEndian, serializer.StoreAsLittleEndian); }
public void ShouldThrowIfDeserializingLessThanFourBytes(byte[] data) { Serializer <int> serializer = new Int32Serializer(); Assert.Throws <ArgumentOutOfRangeException>(() => serializer.Deserialize(data)); }