public static Expression GenerateDictionaryGenericExpression(Type type, List <ParameterExpression> variables, ParameterExpression outputStream, ParameterExpression objToSerialize, ParameterExpression objTracking) { var ctor = type.GetConstructor(new Type[0]); if (ctor == null) { throw new MissingConstructorException("Type " + type + " must have a public constructor without parameter."); } var notTrackedExpressions = new List <Expression>(); var genericDictionaryType = DictionaryHelper.GetDictionaryType(type); var comparerConstructor = DictionaryHelper.GetComparerConstructor(type); var serializeDictionaryWithDefaultComparer = SerializeDictionaryWithDefaultComparer(genericDictionaryType, variables, type, outputStream, objToSerialize, objTracking); if (comparerConstructor == null) { notTrackedExpressions.Add(serializeDictionaryWithDefaultComparer); } else { notTrackedExpressions.Add(Expression.IfThenElse(Expression.IsTrue(Expression.Call(DictionaryMih.IsDefaultEqualityComparer(), Expression.Constant(genericDictionaryType.GetGenericArguments()[0]), Expression.Property(objToSerialize, nameof(Dictionary <int, int> .Comparer)))), serializeDictionaryWithDefaultComparer, SerializeDictionaryWithCustomComparer(genericDictionaryType, variables, type, outputStream, objToSerialize, objTracking))); } return(Serializer.GenerateNullTrackedOrUntrackedExpression(type, outputStream, objToSerialize, objTracking, notTrackedExpressions, variables)); }
public static Expression GenerateDictionaryGenericExpression(List <ParameterExpression> variables, ParameterExpression source, ParameterExpression clone, Type sourceType, ParameterExpression refTrackerParam) { var ctor = sourceType.GetConstructor(new Type[0]); if (ctor == null) { throw new MissingConstructorException("Type " + sourceType + " must have a public constructor without parameter."); } var genericDictionaryType = DictionaryHelper.GetDictionaryType(sourceType); var comparerConstructor = DictionaryHelper.GetComparerConstructor(sourceType); var cloneDictionaryWithDefaultComparer = CloneDictionaryWithDefaultComparer(genericDictionaryType, variables, source, clone, sourceType, refTrackerParam); if (comparerConstructor == null) { return(cloneDictionaryWithDefaultComparer); } return(Expression.IfThenElse(Expression.IsTrue(Expression.Call(DictionaryMih.IsDefaultEqualityComparer(), Expression.Constant(genericDictionaryType.GetGenericArguments()[0]), Expression.Property(source, nameof(Dictionary <int, int> .Comparer)))), cloneDictionaryWithDefaultComparer, CloneDictionaryWithCustomComparer(genericDictionaryType, comparerConstructor, variables, source, clone, sourceType, refTrackerParam))); }
public static Expression GenerateDictionaryGenericExpression(Type type, List <ParameterExpression> variables, ParameterExpression inputStream, ParameterExpression objTracker) { var ctor = type.GetConstructor(new Type[0]); if (ctor == null) { throw new MissingConstructorException("Type " + type + " must have a public constructor without parameter."); } var notTrackedExpressions = new List <Expression>(); var newInstance = Expression.Parameter(type, "newInstanceDict"); var comparerType = Expression.Parameter(typeof(byte), "comparerType"); var typeExpr = Expression.Parameter(typeof(TypeWithHashCode), "typeExpr"); var typeName = Expression.Parameter(typeof(string), "typeName"); var typeHashCode = Expression.Parameter(typeof(int), "typeHashCode"); var deserializer = Expression.Parameter(typeof(Func <Stream, DeserializerObjectTracker, object>), "deserializer"); variables.Add(deserializer); variables.Add(typeExpr); variables.Add(typeName); variables.Add(typeHashCode); variables.Add(newInstance); variables.Add(comparerType); var genericDictionaryType = DictionaryHelper.GetDictionaryType(type); var comparerConstructor = DictionaryHelper.GetComparerConstructor(type); var deserializeDictionaryWithDefaultComparer = DeserializeDictionary(type, genericDictionaryType, variables, newInstance, inputStream, objTracker, deserializer, typeExpr, typeName, typeHashCode, (exprs, newIns) => exprs.Add(Expression.Assign(newIns, Expression.New(type.GetConstructor(new Type[0]))))); if (comparerConstructor == null) { notTrackedExpressions.Add(PrimitiveHelpers.ReadByte(inputStream, objTracker)); notTrackedExpressions.Add(deserializeDictionaryWithDefaultComparer); } else { notTrackedExpressions.Add(Expression.IfThenElse(Expression.Equal(PrimitiveHelpers.ReadByte(inputStream, objTracker), Expression.Constant(0, typeof(int))), deserializeDictionaryWithDefaultComparer, DeserializeDictionary(type, genericDictionaryType, variables, newInstance, inputStream, objTracker, deserializer, typeExpr, typeName, typeHashCode, (exprs, newIns) => { var eqType = typeof(IEqualityComparer <>).MakeGenericType(genericDictionaryType.GetGenericArguments()[0]); var comparer = Expression.Parameter(eqType, "comparer"); variables.Add(comparer); exprs.Add(Deserializer.GetReadClassExpression(inputStream, objTracker, comparer, typeExpr, typeName, typeHashCode, deserializer, eqType)); exprs.Add(Expression.Assign(newIns, Expression.New(comparerConstructor, comparer))); }))); } return(Deserializer.GenerateNullTrackedOrUntrackedExpression(type, inputStream, objTracker, newInstance, notTrackedExpressions, comparerType, variables)); }