public void CorrectlyMapsTypesToConverters(object obj, Type expectedType)
{
var fromGetType = ConvertersSelector.SelectConverter(obj);
var fromType = ConvertersSelector.ForSerializedType(fromGetType.Type);
fromGetType.Should().Be(fromType);
fromGetType.Should().BeOfType(expectedType);
}
public void CorrectlyMapsTypesToConverters(object obj, Type expectedType)
{
var fromType = ConvertersSelector.SelectConverter(obj);
var fromSerializedType = ConvertersSelector.ForSerializedType(fromType.Type);
Assert.Equal(fromType, fromSerializedType);
Assert.Equal(fromType.GetType(), expectedType);
}
protected override void SerializeInternal(object obj, SerializationStream stream)
{
var fields = obj.GetType().GetFieldsAccessibleForSerializer();
foreach (var field in fields)
{
object prop = field.GetValue(obj);
var converter = ConvertersSelector.SelectConverter(prop);
converter.Serialize(prop, stream);
}
}
protected override void WriteObjectToStream(object obj, Stream stream)
{
Type t = obj.GetType();
ICollection <PropertyInfo> properties = t.GetTypeInfo().GetAllProperties().ToArray();
foreach (PropertyInfo property in properties)
{
if (!property.CanWrite || property.GetMethod.IsStatic)
{
continue;
}
object prop = property.GetValue(obj);
var converter = ConvertersSelector.SelectConverter(prop);
converter.Serialize(prop, stream);
}
}
private void DeserializeProperty <T>(PropertyInfo property, ref T instance, byte[] stream, ref int offset)
{
Type instanceType = property.PropertyType;
TypeInfo instanceTypeInfo = instanceType.GetTypeInfo();
SerializedType type = stream.ReadSerializedType(ref offset);
if (!excludedDlls.Any(x => property.PropertyType.AssemblyQualifiedName.Contains(x)))
{
if (type == SerializedType.Null)
{
property.SetValue(instance, null);
}
else
{
object propertyValue = Activator.CreateInstance(property.PropertyType);
property.SetValue(instance, propertyValue);
DeserializeObject(stream, ref propertyValue, ref offset);
}
return;
}
if (type == SerializedType.Null)
{
property.SetValue(instance, null, property.GetIndexParameters());
return;
}
if (!property.PropertyType.GetTypeInfo().IsBaseType())
{
int typeInfoSize = BitConverter.ToInt32(stream, offset);
offset += sizeof(int);
offset += typeInfoSize;
}
BaseTypeConverter converter = ConvertersSelector.ForSerializedType(type);
object data;
if (type == SerializedType.Null)
{
data = null;
}
else if (type == SerializedType.IEnumerable)
{
var preparedData = converter.DeserializeToObject(stream, ref offset) as IEnumerable;
var prop = property;
var listType = typeof(List <>);
var genericArgs = prop.PropertyType.GenericTypeArguments;
var concreteType = listType.MakeGenericType(genericArgs);
data = Activator.CreateInstance(concreteType);
foreach (var item in preparedData)
{
((IList)data).Add(item);
}
}
else
{
data = converter.DeserializeToObject(stream, ref offset);
}
if (instanceTypeInfo.IsValueType && !instanceTypeInfo.IsPrimitive)
{
object boxedInstance = instance;
property.SetValue(boxedInstance, data, property.GetIndexParameters());
instance = (T)boxedInstance;
}
else
{
property.SetValue(instance, data, property.GetIndexParameters());
}
}
private void DeserializeField <T>(FieldInfo field, ref T instance, DeserializationStream stream)
{
Type instanceType = field.FieldType;
TypeInfo instanceTypeInfo = instanceType.GetTypeInfo();
SerializedType type = stream.ReadSerializedType();
if (!ExcludedDlls.Any(x => field.FieldType.AssemblyQualifiedName.Contains(x)))
{
if (type == SerializedType.Null)
{
field.SetValue(instance, null);
}
else if (type == SerializedType.Enum)
{
object propertyValue = Activator.CreateInstance(field.FieldType);
DeserializeEnum(stream, ref propertyValue);
field.SetValue(instance, propertyValue);
}
else
{
object propertyValue = Activator.CreateInstance(field.FieldType);
DeserializeObject(stream, ref propertyValue);
field.SetValue(instance, propertyValue);
}
return;
}
if (type == SerializedType.Null)
{
field.SetValue(instance, null);
return;
}
if (!field.FieldType.IsBaseTypeSupportedBySerializer())
{
stream.ReadType();
}
BaseTypeConverter converter = ConvertersSelector.ForSerializedType(type);
object data;
if (type == SerializedType.Null)
{
data = null;
}
else if (type == SerializedType.IEnumerable)
{
var preparedData = converter.Deserialize(stream) as IEnumerable;
var prop = field;
var listType = typeof(List <>);
var genericArgs = prop.FieldType.GenericTypeArguments;
var concreteType = listType.MakeGenericType(genericArgs);
data = Activator.CreateInstance(concreteType);
foreach (var item in preparedData)
{
((IList)data).Add(item);
}
}
else
{
data = converter.Deserialize(stream);
}
if (instanceTypeInfo.IsValueType && !instanceTypeInfo.IsPrimitive)
{
object boxedInstance = instance;
field.SetValue(boxedInstance, data);
instance = (T)boxedInstance;
}
else
{
field.SetValue(instance, data);
}
}
public void ReturnsNullConverter_WhenObjIsNull()
{
var converter = ConvertersSelector.SelectConverter(null);
converter.Should().BeOfType <NullConverter>();
}
public void ReturnsNullConverter_WhenObjIsNull()
{
var converter = ConvertersSelector.SelectConverter(null);
Assert.True(converter is NullConverter);
}
