private void UpdateFields(Type actualType, object target)
{
var fieldOrTypeInfos = TypeDescriptor.CreateFromType(actualType).FieldsToDeserialize;
foreach (var fieldOrTypeInfo in fieldOrTypeInfos)
{
if (fieldOrTypeInfo.Field == null)
{
ReadField(fieldOrTypeInfo.TypeToOmit);
continue;
}
var field = fieldOrTypeInfo.Field;
if (field.IsDefined(typeof(TransientAttribute), false))
{
if (field.IsDefined(typeof(ConstructorAttribute), false))
{
var ctorAttribute = (ConstructorAttribute)field.GetCustomAttributes(false).First(x => x is ConstructorAttribute);
field.SetValue(target, Activator.CreateInstance(field.FieldType, ctorAttribute.Parameters));
}
continue;
}
field.SetValue(target, ReadField(field.FieldType));
}
}
public FieldDescriptor(FieldInfo finfo)
{
Name = finfo.Name;
DeclaringType = TypeDescriptor.CreateFromType(finfo.DeclaringType);
FieldType = TypeDescriptor.CreateFromType(finfo.FieldType);
IsTransient = finfo.IsTransient();
IsConstructor = finfo.IsConstructor();
UnderlyingFieldInfo = finfo;
}
internal int TouchAndWriteTypeId(Type type)
{
var typeDescriptor = TypeDescriptor.CreateFromType(type);
int typeId;
if (typeIndices.ContainsKey(typeDescriptor))
{
typeId = typeIndices[typeDescriptor];
writer.Write(typeId);
return(typeId);
}
typeId = nextTypeId++;
typeIndices.Add(typeDescriptor, typeId);
writer.Write(typeId);
typeDescriptor.WriteTypeStamp(this);
typeDescriptor.WriteStructureStampIfNeeded(this);
return(typeId);
}
private void Init(Type t)
{
UnderlyingType = t;
TypeAssembly = AssemblyDescriptor.CreateFromAssembly(t.Assembly);
genericArguments = new List <TypeDescriptor>();
if (UnderlyingType.IsGenericType)
{
GenericFullName = UnderlyingType.GetGenericTypeDefinition().FullName;
GenericAssemblyQualifiedName = UnderlyingType.GetGenericTypeDefinition().AssemblyQualifiedName;
foreach (var genericArgument in UnderlyingType.GetGenericArguments())
{
genericArguments.Add(TypeDescriptor.CreateFromType(genericArgument));
}
}
else
{
GenericAssemblyQualifiedName = UnderlyingType.AssemblyQualifiedName;
GenericFullName = UnderlyingType.FullName;
}
if (t.BaseType != null)
{
System.IO.File.AppendAllText("/tmp/log", string.Format("Setting base type '{0}' for '{1}' in Init method\n", t.BaseType.FullName, t.FullName));
baseType = TypeDescriptor.CreateFromType(t.BaseType);
}
var fieldsToDeserialize = new List <FieldInfoOrEntryToOmit>();
foreach (var field in StampHelpers.GetFieldsInSerializationOrder(UnderlyingType, true))
{
fieldsToDeserialize.Add(new FieldInfoOrEntryToOmit(field));
if (!field.IsTransient())
{
fields.Add(new FieldDescriptor(field));
}
}
FieldsToDeserialize = fieldsToDeserialize;
}
private void Init(Type t)
{
UnderlyingType = t;
TypeAssembly = AssemblyDescriptor.CreateFromAssembly(t.Assembly);
genericArguments = new List <TypeDescriptor>();
if (UnderlyingType.IsGenericType)
{
GenericFullName = UnderlyingType.GetGenericTypeDefinition().FullName;
GenericAssemblyQualifiedName = UnderlyingType.GetGenericTypeDefinition().AssemblyQualifiedName;
foreach (var genericArgument in UnderlyingType.GetGenericArguments())
{
genericArguments.Add(TypeDescriptor.CreateFromType(genericArgument));
}
}
else
{
GenericAssemblyQualifiedName = UnderlyingType.AssemblyQualifiedName;
GenericFullName = UnderlyingType.FullName;
}
if (t.BaseType != null)
{
baseType = TypeDescriptor.CreateFromType(t.BaseType);
}
var fieldsToDeserialize = new List <FieldInfoOrEntryToOmit>();
foreach (var field in StampHelpers.GetFieldsInSerializationOrder(UnderlyingType, true))
{
fieldsToDeserialize.Add(new FieldInfoOrEntryToOmit(field));
if (!field.IsTransient())
{
fields.Add(new FieldDescriptor(field));
}
}
FieldsToDeserialize = fieldsToDeserialize;
}
private Action <PrimitiveWriter, object> PrepareWriteMethod(Type actualType, int surrogateId)
{
var typeId = -1;
if (surrogateId == -1)
{
typeId = typeIndices[TypeDescriptor.CreateFromType(actualType)];
var specialWrite = LinkSpecialWrite(actualType, typeId);
if (specialWrite != null)
{
// linked methods are not added to writeMethodCache, there's no point
return(specialWrite);
}
}
if (!isGenerating)
{
if (surrogateId != -1)
{
return((pw, o) => InvokeCallbacksAndWriteObject(surrogatesForObjects.GetByIndex(surrogateId).DynamicInvoke(new [] { o })));
}
return((pw, o) => WriteObjectUsingReflection(pw, o, typeId));
}
var method = new WriteMethodGenerator(actualType, treatCollectionAsUserObject, surrogateId,
Helpers.GetFieldInfo <ObjectWriter, Dictionary <TypeDescriptor, int> >(x => x.typeIndices),
Helpers.GetFieldInfo <ObjectWriter, InheritanceAwareList <Delegate> >(x => x.surrogatesForObjects),
Helpers.GetFieldInfo <ObjectWriter, bool>(x => x.typeIdJustWritten),
Helpers.GetMethodInfo <ObjectWriter>(x => x.InvokeCallbacksAndWriteObject(null))).Method;
var result = (Action <PrimitiveWriter, object>)method.CreateDelegate(typeof(Action <PrimitiveWriter, object>), this);
if (writeMethodCache != null)
{
writeMethodCache.Add(actualType, method);
}
return(result);
}
private List <FieldInfoOrEntryToOmit> VerifyStructure(VersionToleranceLevel versionToleranceLevel)
{
if (TypeAssembly.ModuleGUID == UnderlyingType.Module.ModuleVersionId)
{
return(StampHelpers.GetFieldsInSerializationOrder(UnderlyingType, true).Select(x => new FieldInfoOrEntryToOmit(x)).ToList());
}
if (!versionToleranceLevel.HasFlag(VersionToleranceLevel.AllowGuidChange))
{
throw new InvalidOperationException(string.Format("The class was serialized with different module version id {0}, current one is {1}.",
TypeAssembly.ModuleGUID, UnderlyingType.Module.ModuleVersionId));
}
var result = new List <FieldInfoOrEntryToOmit>();
var assemblyTypeDescriptor = TypeDescriptor.CreateFromType(UnderlyingType);
if (!(assemblyTypeDescriptor.baseType == null && baseType == null) &&
((assemblyTypeDescriptor.baseType == null && baseType != null) || !assemblyTypeDescriptor.baseType.Equals(baseType)) &&
!versionToleranceLevel.HasFlag(VersionToleranceLevel.AllowInheritanceChainChange))
{
throw new InvalidOperationException(string.Format("Class hierarchy changed. Expected '{1}' as base class, but found '{0}'.", baseType != null ? baseType.UnderlyingType.FullName : "null", assemblyTypeDescriptor.baseType != null ? assemblyTypeDescriptor.baseType.UnderlyingType.FullName : "null"));
}
if (assemblyTypeDescriptor.TypeAssembly.Version != TypeAssembly.Version && !versionToleranceLevel.HasFlag(VersionToleranceLevel.AllowAssemblyVersionChange))
{
throw new InvalidOperationException(string.Format("Assembly version changed from {0} to {1} for class {2}", TypeAssembly.Version, assemblyTypeDescriptor.TypeAssembly.Version, UnderlyingType.FullName));
}
var cmpResult = assemblyTypeDescriptor.CompareWith(this, versionToleranceLevel);
if (cmpResult.FieldsChanged.Any())
{
throw new InvalidOperationException(string.Format("Field {0} type changed.", cmpResult.FieldsChanged[0].Name));
}
if (cmpResult.FieldsAdded.Any() && !versionToleranceLevel.HasFlag(VersionToleranceLevel.AllowFieldAddition))
{
throw new InvalidOperationException(string.Format("Field added: {0}.", cmpResult.FieldsAdded[0].Name));
}
if (cmpResult.FieldsRemoved.Any() && !versionToleranceLevel.HasFlag(VersionToleranceLevel.AllowFieldRemoval))
{
throw new InvalidOperationException(string.Format("Field removed: {0}.", cmpResult.FieldsRemoved[0].Name));
}
foreach (var field in fields)
{
if (cmpResult.FieldsRemoved.Contains(field))
{
result.Add(new FieldInfoOrEntryToOmit(field.FieldType.UnderlyingType));
}
else
{
result.Add(new FieldInfoOrEntryToOmit(field.UnderlyingFieldInfo));
}
}
foreach (var field in assemblyTypeDescriptor.GetConstructorRecreatedFields().Select(x => x.Field))
{
result.Add(new FieldInfoOrEntryToOmit(field));
}
return(result);
}
