public void Deserialize(byte[] buffer, ref int offset, ref Person value)
{
// Nothing interesting here, all the important stuff is explained in 'Serialize()'
value.Name = SerializerBinary.ReadString(buffer, ref offset);
value.Health = SerializerBinary.ReadInt32(buffer, ref offset);
PersonFormatter.Deserialize(buffer, ref offset, ref value.BestFriend);
}
public void Deserialize(byte[] buffer, ref int offset, ref T member)
{
// What type?
Type type = null;
_typeFormatter.Deserialize(buffer, ref offset, ref type);
// What kind of member?
var memberType = (MemberTypes)SerializerBinary.ReadInt32(buffer, ref offset);
string name = null;
switch (memberType)
{
case MemberTypes.Constructor:
case MemberTypes.Method:
_stringFormatter.Deserialize(buffer, ref offset, ref name);
var numArgs = SerializerBinary.ReadInt32(buffer, ref offset);
Type[] args = new Type[numArgs];
for (int i = 0; i < numArgs; i++)
{
_typeFormatter.Deserialize(buffer, ref offset, ref args[i]);
}
if (memberType == MemberTypes.Constructor)
{
member = (T)(MemberInfo)type.GetConstructor(args);
}
else
{
member = (T)(MemberInfo)type.GetMethod(name, args);
}
break;
case MemberTypes.Field:
case MemberTypes.Property:
_stringFormatter.Deserialize(buffer, ref offset, ref name);
Type fieldOrPropType = null;
_typeFormatter.Deserialize(buffer, ref offset, ref fieldOrPropType);
if (memberType == MemberTypes.Field)
{
member = (T)(MemberInfo)type.GetField(name);
}
else
{
member = (T)(MemberInfo)type.GetProperty(name, fieldOrPropType);
}
break;
default:
throw new ArgumentOutOfRangeException("Cannot deserialize member type '" + memberType + "'");
}
}
public void Deserialize(byte[] buffer, ref int offset, ref Person value)
{
// Just for illustration purposes we'll do exactly the same thing that Ceras would
// normally generate for us automatically, but instead we're doing it manually here.
value.Name = SerializerBinary.ReadString(buffer, ref offset);
value.Health = SerializerBinary.ReadInt32(buffer, ref offset);
PersonFormatter.Deserialize(buffer, ref offset, ref value.BestFriend);
}
public void Deserialize(byte[] buffer, ref int offset, ref Person value)
{
// Nothing interesting here, all the important stuff is explained in 'Serialize()'
value.Name = SerializerBinary.ReadString(buffer, ref offset);
value.Health = SerializerBinary.ReadInt32(buffer, ref offset);
PersonFormatter.Deserialize(buffer, ref offset, ref value.BestFriend);
// You can try changing 'BestFriend' into a property.
// If you do, you have to modify this last line a bit:
/*
* var f = value.BestFriend;
* PersonFormatter.Deserialize(buffer, ref offset, ref f);
* value.BestFriend = f;
*/
}
public void Deserialize(byte[] buffer, ref int offset, ref HashSet <byte?[]> set)
{
IEqualityComparer <byte?[]> equalityComparer = null;
_comparerFormatter.Deserialize(buffer, ref offset, ref equalityComparer);
// We can already create the hashset
set = new HashSet <byte?[]>(equalityComparer);
// Read content...
int count = SerializerBinary.ReadInt32(buffer, ref offset);
for (int i = 0; i < count; i++)
{
byte?[] ar = null;
_byteArrayFormatter.Deserialize(buffer, ref offset, ref ar);
set.Add(ar);
}
}
public void Deserialize(byte[] buffer, ref int offset, ref T value)
{
var objId = SerializerBinary.ReadUInt32Bias(buffer, ref offset, Bias);
if (objId == Null)
{
// Null
// Ok the data tells us that value should be null.
// But maybe we're recycling an object and it still contains an instance.
// Lets return it to the user
if (value != null)
{
_ceras.DiscardObjectMethod?.Invoke(value);
}
value = default;
return;
}
if (objId == InlineType)
{
Type type = null;
_typeFormatter.Deserialize(buffer, ref offset, ref type);
value = (T)(object)type; // This is ugly, but there's no way to prevent it, right?
return;
}
if (objId >= 0)
{
// Something we already know
value = _ceras.InstanceData.ObjectCache.GetExistingObject <T>(objId);
return;
}
if (objId == ExternalObject)
{
// External object, let the user resolve!
int externalId = SerializerBinary.ReadInt32(buffer, ref offset);
// Let the user resolve
_ceras.Config.ExternalObjectResolver.Resolve(externalId, out value);
return;
}
// New object, see Note#1
Type specificType = null;
if (objId == NewValue)
{
// == NewValue (EmbeddedType)
_typeFormatter.Deserialize(buffer, ref offset, ref specificType);
}
else
{
// == NewValueSameType
specificType = typeof(T);
}
var entry = GetOrCreateEntry(specificType);
// At this point we know that the 'value' will not be 'null', so if 'value' (the variable) is null we need to create an instance
if (!entry.IsValueType) // still possible that we're dealing with a boxed value;
{
// Do we already have an object?
if (value != null)
{
// Yes, then maybe we can overwrite its values (works for objects and collections)
// But only if it's the right type!
if (value.GetType() != specificType)
{
// Discard the old value
_ceras.DiscardObjectMethod?.Invoke(value);
// Create instance of the right type
value = (T)entry.Constructor();
}
else
{
// Existing object is the right type
}
}
else
{
// Instance is null, create one
value = (T)entry.Constructor();
}
}
else
{
// Not a reference type. So it doesn't matter anyway.
}
if (!_allowReferences)
{
entry.CurrentDeserializeDispatcher(buffer, ref offset, ref value);
return;
}
//
// Deserialize the object
// 1. First generate a proxy so we can do lookups
var objectProxy = _ceras.InstanceData.ObjectCache.CreateDeserializationProxy <T>();
// 2. Make sure that the deserializer can make use of an already existing object (if there is one)
objectProxy.Value = value;
// 3. Actually read the object
entry.CurrentDeserializeDispatcher(buffer, ref offset, ref objectProxy.Value);
// 4. Write back the actual value, which instantly resolves all references
value = objectProxy.Value;
}
public void Deserialize(byte[] buffer, ref int offset, ref T member)
{
// What type?
Type type = null;
_typeFormatter.Deserialize(buffer, ref offset, ref type);
// What kind of member?
var bindingData = SerializerBinary.ReadByte(buffer, ref offset);
UnpackBindingData(bindingData, out bool isStatic, out MemberType memberType);
var bindingFlags = isStatic ? BindingAllStatic : BindingAllInstance;
string name = null;
switch (memberType)
{
case MemberType.Constructor:
case MemberType.Method:
_stringFormatter.Deserialize(buffer, ref offset, ref name);
var numArgs = SerializerBinary.ReadInt32(buffer, ref offset);
Type[] args = new Type[numArgs];
for (int i = 0; i < numArgs; i++)
{
_typeFormatter.Deserialize(buffer, ref offset, ref args[i]);
}
if (memberType == MemberType.Constructor)
{
member = (T)(MemberInfo)type.GetConstructor(bindingFlags, null, args, null);
return;
}
else
{
// todo: add a full "isGenericMethod" flag to the binding information, support open and half open definitions...
var resolvedMethod = ReflectionHelper.ResolveMethod(type, name, args);
if (resolvedMethod != null)
{
member = (T)(MemberInfo)resolvedMethod;
return;
}
}
throw new AmbiguousMatchException($"Can't resolve method named '{name}' with '{numArgs}' arguments.");
case MemberType.Field:
case MemberType.Property:
_stringFormatter.Deserialize(buffer, ref offset, ref name);
Type fieldOrPropType = null;
_typeFormatter.Deserialize(buffer, ref offset, ref fieldOrPropType);
if (memberType == MemberType.Field)
{
member = (T)(MemberInfo)type.GetField(name, bindingFlags);
}
else
{
member = (T)(MemberInfo)type.GetProperty(name, bindingFlags, null, fieldOrPropType, types: new Type[0], null);
}
break;
default:
throw new ArgumentOutOfRangeException("Cannot deserialize member type '" + memberType + "'");
}
}
public void Deserialize(byte[] buffer, ref int offset, ref T member)
{
// What type?
Type type = null;
_typeFormatter.Deserialize(buffer, ref offset, ref type);
// What kind of member?
var bindingData = SerializerBinary.ReadByte(buffer, ref offset);
UnpackBindingData(bindingData, out bool isStatic, out MemberType memberType);
var bindingFlags = isStatic ? BindingAllStatic : BindingAllInstance;
string name = null;
switch (memberType)
{
case MemberType.Constructor:
case MemberType.Method:
_stringFormatter.Deserialize(buffer, ref offset, ref name);
var numArgs = SerializerBinary.ReadInt32(buffer, ref offset);
Type[] args = new Type[numArgs];
for (int i = 0; i < numArgs; i++)
{
_typeFormatter.Deserialize(buffer, ref offset, ref args[i]);
}
if (memberType == MemberType.Constructor)
{
member = (T)(MemberInfo)type.GetConstructor(bindingFlags, null, args, null);
}
else
{
member = (T)(MemberInfo)type.GetMethod(name, bindingFlags, binder: null, types: args, modifiers: null);
}
break;
case MemberType.Field:
case MemberType.Property:
_stringFormatter.Deserialize(buffer, ref offset, ref name);
Type fieldOrPropType = null;
_typeFormatter.Deserialize(buffer, ref offset, ref fieldOrPropType);
if (memberType == MemberType.Field)
{
member = (T)(MemberInfo)type.GetField(name, bindingFlags);
}
else
{
member = (T)(MemberInfo)type.GetProperty(name, bindingFlags, null, fieldOrPropType, types: new Type[0], null);
}
break;
default:
throw new ArgumentOutOfRangeException("Cannot deserialize member type '" + memberType + "'");
}
}
public void Deserialize(byte[] buffer, ref int offset, ref bool value)
{
value = SerializerBinary.ReadInt32(buffer, ref offset) != 0;
}
public void Deserialize(byte[] buffer, ref int offset, ref T value)
{
var objId = SerializerBinary.ReadUInt32Bias(buffer, ref offset, Bias);
if (objId == Null)
{
// Null
// Ok the data tells us that value should be null.
// But maybe we're recycling an object and it still contains an instance.
// Lets return it to the user
if (value != null)
{
_serializer.Config.DiscardObjectMethod?.Invoke(value);
}
value = default(T);
return;
}
if (objId >= 0)
{
// Something we already know
value = _serializer.InstanceData.ObjectCache.GetExistingObject <T>(objId);
return;
}
if (objId == ExternalObject)
{
// External object, let the user resolve!
int externalId = SerializerBinary.ReadInt32(buffer, ref offset);
// Let the user resolve
_serializer.Config.ExternalObjectResolver.Resolve(externalId, out value);
return;
}
// New object, see Note#1
Type specificType = null;
if (objId == NewValue)
{
_typeFormatter.Deserialize(buffer, ref offset, ref specificType);
}
else // if (objId == NewValueSameType) commented out, its the only possible remaining case
{
specificType = typeof(T);
}
// At this point we know that the 'value' will have value, so if 'value' (the variable) is null we need to create an instance
// todo: investigate if there is a way to do this better,
// todo: is the generic code optimized in the jit? is this check is never even done in the ASM?
// todo: have the recent fixes made these checks obsolete? What if someone forces serialization of private fields in a type that cannot be directly instantiated?
// todo: enforce all types to have a parameterless constructor
if (value == null &&
(typeof(T) != typeof(string) && typeof(T) != typeof(Type)))
{
var factory = _serializer.Config.ObjectFactoryMethod;
if (factory != null)
{
value = (T)_serializer.Config.ObjectFactoryMethod(specificType);
}
if (value == null)
{
try
{
// todo: can we optimize this? The specific type might be different, we cannot use "CreateInstance<T>" or "new T()"
// so is there a way we can quickly instantiate a new object given just the type? (sure there are lots of ways but any FAST ones??)
value = (T)Activator.CreateInstance(specificType);
}
catch (MissingMethodException e)
{
throw new Exception($"Cannot create an instance of type '{specificType.FullName}'", e);
}
}
}
var objectProxy = _serializer.InstanceData.ObjectCache.CreateDeserializationProxy <T>();
// Make sure that the deserializer can make use of an already existing object (if there is one)
objectProxy.Value = value;
// Read the object
GetSpecificDeserializerCall(specificType)(buffer, ref offset, ref objectProxy.Value);
// Write back the actual value
value = objectProxy.Value;
}
public void Deserialize(byte[] buffer, ref int offset, ref T value)
{
var objId = SerializerBinary.ReadUInt32Bias(buffer, ref offset, Bias);
if (objId == Null)
{
// Null
// Ok the data tells us that value should be null.
// But maybe we're recycling an object and it still contains an instance.
// Lets return it to the user
if (value != null)
{
_serializer.Config.DiscardObjectMethod?.Invoke(value);
}
value = default(T);
return;
}
if (objId >= 0)
{
// Something we already know
value = _serializer.InstanceData.ObjectCache.GetExistingObject <T>(objId);
return;
}
if (objId == ExternalObject)
{
// External object, let the user resolve!
int externalId = SerializerBinary.ReadInt32(buffer, ref offset);
// Let the user resolve
_serializer.Config.ExternalObjectResolver.Resolve(externalId, out value);
return;
}
// New object, see Note#1
Type specificType = null;
if (objId == NewValue)
{
_typeFormatter.Deserialize(buffer, ref offset, ref specificType);
}
else // if (objId == NewValueSameType) commented out, its the only possible remaining case
{
specificType = typeof(T);
}
// At this point we know that the 'value' will have value, so if 'value' (the variable) is null we need to create an instance
// todo: investigate if there is a way to do this better,
// todo: is the generic code optimized in the jit? is this check is never even done in the ASM?
// todo: have the recent fixes made these checks obsolete? What if someone forces serialization of private fields in a type that cannot be directly instantiated?
// todo: enforce all types to have a parameterless constructor
bool isRefType = !specificType.IsValueType;
bool isStringOrType = typeof(T) == typeof(string) || typeof(T) == typeof(Type);
if (value == null)
{
if (!isStringOrType && // we can't create instances of String or Type, they are special cases
isRefType) // only ref types have a ctor
{
value = CreateInstance(specificType);
}
}
else
{
// There is a value already, but is it the right type?
// Maybe the field is 'ICollection<int>' and the data says we should have a List<int>, but there's already a LinkedList<int> present!
// What we need to do is throw out the
if (isRefType)
{
if (value.GetType() != specificType) // todo: types using a SerializationCtor (in the future) are handled in a different ReferenceFormatter
{
// Discard the old value
_serializer.Config.DiscardObjectMethod?.Invoke(value);
// Create instance of the right type
value = CreateInstance(specificType);
}
}
}
var objectProxy = _serializer.InstanceData.ObjectCache.CreateDeserializationProxy <T>();
// Make sure that the deserializer can make use of an already existing object (if there is one)
objectProxy.Value = value;
// Read the object
GetSpecificDeserializerDispatcher(specificType)(buffer, ref offset, ref objectProxy.Value);
// Write back the actual value
value = objectProxy.Value;
}
public void Deserialize(byte[] buffer, ref int offset, ref T value)
{
var objId = SerializerBinary.ReadUInt32Bias(buffer, ref offset, Bias);
if (objId == Null)
{
// Null
// Ok the data tells us that value should be null.
// But maybe we're recycling an object and it still contains an instance.
// Lets return it to the user
if (value != null)
{
_serializer.Config.DiscardObjectMethod?.Invoke(value);
}
value = default;
return;
}
if (objId == InlineType)
{
Type type = null;
_typeFormatter.Deserialize(buffer, ref offset, ref type);
value = (T)(object)type; // This is ugly, but there's no way to prevent it, right?
return;
}
if (objId >= 0)
{
// Something we already know
value = _serializer.InstanceData.ObjectCache.GetExistingObject <T>(objId);
return;
}
if (objId == ExternalObject)
{
// External object, let the user resolve!
int externalId = SerializerBinary.ReadInt32(buffer, ref offset);
// Let the user resolve
_serializer.Config.ExternalObjectResolver.Resolve(externalId, out value);
return;
}
// New object, see Note#1
Type specificType = null;
if (objId == NewValue)
{
_typeFormatter.Deserialize(buffer, ref offset, ref specificType);
}
else // if (objId == NewValueSameType) commented out, its the only possible remaining case
{
specificType = typeof(T);
}
// At this point we know that the 'value' will not be 'null', so if 'value' (the variable) is null we need to create an instance
bool isRefType = !specificType.IsValueType;
if (isRefType)
{
// Do we already have an object?
if (value != null)
{
// Yes, then maybe we can overwrite its values (works for objects and collections)
// But only if it's the right type!
// todo: types using a SerializationCtor (in the future) are handled in a different ReferenceFormatter
// where we first read all members into local variables, then create the object (passing some of them into the constructor), and then writing the remaining as usual
if (value.GetType() != specificType)
{
// Discard the old value
_serializer.Config.DiscardObjectMethod?.Invoke(value);
// Create instance of the right type
value = CreateInstance(specificType);
}
else
{
// Existing object is the right type
}
}
else
{
// Instance is null, create one
// Note: that we *could* check if the type is one of the types that we cannot instantiate (String, Type, MemberInfo, ...) and then
// just not call CreateInstance, but the check itself would be expensive as well (HashSet look up?), so what's the point of complicating the code more?
// CreateInstance will do a dictionary lookup for us and simply return null for those types.
value = CreateInstance(specificType);
}
}
else
{
// Not a reference type. So it doesn't matter.
}
//
// Deserialize the object
// 1. First generate a proxy so we can do lookups
var objectProxy = _serializer.InstanceData.ObjectCache.CreateDeserializationProxy <T>();
// 2. Make sure that the deserializer can make use of an already existing object (if there is one)
objectProxy.Value = value;
// 3. Actually read the object
GetSpecificDeserializerDispatcher(specificType)(buffer, ref offset, ref objectProxy.Value);
// 4. Write back the actual value, which instantly resolves all references
value = objectProxy.Value;
}
