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));
}
