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