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);
}
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 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);
}
}
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);
}
}
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);
}
}
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);
}
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 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,
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 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 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 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 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;
void ReadDictionaryKeyValuePairs(object dictionaryInstance)
{
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(dictionaryInstance, new[] { key, value });
}
}
#region Special case for ReadOnlyDictionary
// Special case for ReadOnlyDictionary since ReadOnlyDictionary
// does not have a parameterless constructor
var genericReadOnlyDictionary = typeof(ReadOnlyDictionary <,>);
var readOnlyDictionaryType =
genericReadOnlyDictionary.MakeGenericType(dictionaryTypes.KeyType, dictionaryTypes.ValueType);
if (type.Equals(readOnlyDictionaryType))
{
var genericDictionary = typeof(Dictionary <,>);
var genericDictionaryType = genericDictionary.MakeGenericType(dictionaryTypes.KeyType, dictionaryTypes.ValueType);
var dictionary = Activator.CreateInstance(genericDictionaryType); // normal dictionary
ReadDictionaryKeyValuePairs(dictionary);
instance = Activator.CreateInstance(type, dictionary); // IDictionary<TKey, TValue>
if (preserveObjectReferences)
{
session.TrackDeserializedObject(instance);
}
return(instance);
}
#endregion
try
{
instance = Activator.CreateInstance(type, true); // IDictionary<TKey, TValue>
} catch (Exception) {
instance = Activator.CreateInstance(type); // IDictionary<TKey, TValue>
}
if (preserveObjectReferences)
{
session.TrackDeserializedObject(instance);
}
ReadDictionaryKeyValuePairs(instance);
return(instance);
};
ObjectWriter writer = (stream, obj, 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);
}