private static ValueWriter GenerateFieldInfoSerializer(Serializer serializer, FieldInfo field)
{
if (serializer == null)
{
throw new ArgumentNullException(nameof(serializer));
}
if (field == null)
{
throw new ArgumentNullException(nameof(field));
}
//get the serializer for the type of the field
var valueSerializer = serializer.GetSerializerByType(field.FieldType);
//runtime generate a delegate that reads the content of the given field
var getFieldValue = GenerateFieldInfoReader(field);
//if the type is one of our special primitives, ignore manifest as the content will always only be of this type
if (!serializer.Options.VersionTolerance && Serializer.IsPrimitiveType(field.FieldType))
{
//primitive types does not need to write any manifest, if the field type is known
//nor can they be null (StringSerializer has it's own null handling)
ValueWriter fieldWriter = (stream, o, session) =>
{
var value = getFieldValue(o);
valueSerializer.WriteValue(stream, value, session);
};
return(fieldWriter);
}
else
{
var valueType = field.FieldType;
if (field.FieldType.IsGenericType && field.FieldType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
var nullableType = field.FieldType.GetGenericArguments()[0];
valueSerializer = serializer.GetSerializerByType(nullableType);
valueType = nullableType;
}
var preserveObjectReferences = serializer.Options.PreserveObjectReferences;
ValueWriter fieldWriter = (stream, o, session) =>
{
var value = getFieldValue(o);
stream.WriteObject(value, valueType, valueSerializer, preserveObjectReferences, session);
};
return(fieldWriter);
}
}
private static Action <Stream, object, DeserializerSession> GenerateFieldInfoDeserializer(Serializer serializer,
Type type, FieldInfo field)
{
if (serializer == null)
{
throw new ArgumentNullException(nameof(serializer));
}
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (field == null)
{
throw new ArgumentNullException(nameof(field));
}
var s = serializer.GetSerializerByType(field.FieldType);
Action <object, object> setter;
if (field.IsInitOnly)
{
setter = field.SetValue;
}
else
{
var targetExp = Parameter(typeof(object), "target");
var valueExp = Parameter(typeof(object), "value");
// ReSharper disable once PossibleNullReferenceException
Expression castTartgetExp = field.DeclaringType.IsValueType
? Unbox(targetExp, type)
: Convert(targetExp, type);
Expression castValueExp = Convert(valueExp, field.FieldType);
var fieldExp = Field(castTartgetExp, field);
var assignExp = Assign(fieldExp, castValueExp);
setter = Lambda <Action <object, object> >(assignExp, targetExp, valueExp).Compile();
}
if (!serializer.Options.VersionTolerance && Serializer.IsPrimitiveType(field.FieldType))
{
//Only optimize if property names are not included.
//if they are included, we need to be able to skip past unknown property data
//e.g. if sender have added a new property that the receiveing end does not yet know about
//which we cannot do w/o a manifest
Action <Stream, object, DeserializerSession> fieldReader = (stream, o, session) =>
{
var value = s.ReadValue(stream, session);
setter(o, value);
};
return(fieldReader);
}
else
{
Action <Stream, object, DeserializerSession> fieldReader = (stream, o, session) =>
{
var value = stream.ReadObject(session);
setter(o, value);
};
return(fieldReader);
}
}
private static Action <Stream, object, SerializerSession> GenerateFieldDeserializer(Serializer serializer,
Type type, FieldInfo field)
{
var s = serializer.GetSerializerByType(field.FieldType);
Action <object, object> setter;
if (field.IsInitOnly)
{
setter = field.SetValue;
}
else
{
ParameterExpression targetExp = Expression.Parameter(typeof(object), "target");
ParameterExpression valueExp = Expression.Parameter(typeof(object), "value");
Expression castTartgetExp = field.DeclaringType.IsValueType
? Expression.Unbox(targetExp, type)
: Expression.Convert(targetExp, type);
Expression castValueExp = Expression.Convert(valueExp, field.FieldType);
MemberExpression fieldExp = Expression.Field(castTartgetExp, field);
BinaryExpression assignExp = Expression.Assign(fieldExp, castValueExp);
setter = Expression.Lambda <Action <object, object> >(assignExp, targetExp, valueExp).Compile();
}
if (!serializer.Options.VersionTolerance && Serializer.IsPrimitiveType(field.FieldType))
{
//Only optimize if property names are not included.
//if they are included, we need to be able to skip past unknown property data
//e.g. if sender have added a new property that the receiveing end does not yet know about
//which we cannot do w/o a manifest
Action <Stream, object, SerializerSession> fieldReader = (stream, o, session) =>
{
var value = s.ReadValue(stream, session);
setter(o, value);
//var x = field.GetValue(o);
//if (value != null && !value.Equals(x))
//{
//}
// field.SetValue(o, value);
};
return(fieldReader);
}
else
{
Action <Stream, object, SerializerSession> fieldReader = (stream, o, session) =>
{
var value = stream.ReadObject(session);
// field.SetValue(o, value);
setter(o, value);
//var x = field.GetValue(o);
//if (value != null && !value.Equals(x))
//{
//}
};
return(fieldReader);
}
}