public void WriteStructureStampIfNeeded(ObjectWriter writer)
{
if (StampHelpers.IsStampNeeded(this, writer.TreatCollectionAsUserObject))
{
WriteStructureStamp(writer);
}
}
public void ReadStructureStampIfNeeded(ObjectReader reader, VersionToleranceLevel versionToleranceLevel)
{
if (StampHelpers.IsStampNeeded(this, reader.TreatCollectionAsUserObject))
{
ReadStructureStamp(reader, versionToleranceLevel);
}
}
public TypeStamp(Type type, bool withTransient = false) : this()
{
var structure = StampHelpers.GetFieldsStructureInSerializationOrder(type, withTransient);
ModuleGUID = type.Module.ModuleVersionId;
foreach (var cl in structure)
{
Classes.Add(new TypeDescriptor(cl));
}
}
private void GenerateUpdateStructFields(Type formalType, LocalBuilder structLocal)
{
var fields = StampHelpers.GetFieldsInSerializationOrder(formalType).ToList();
foreach (var field in fields)
{
generator.Emit(OpCodes.Ldloca, structLocal);
GenerateReadField(field.FieldType, false);
generator.Emit(OpCodes.Stfld, field);
}
}
private void WriteObjectsFields(object o, Type type)
{
// fields in the alphabetical order
var fields = StampHelpers.GetFieldsInSerializationOrder(type);
foreach (var field in fields)
{
var fieldType = field.FieldType;
var value = field.GetValue(o);
WriteField(fieldType, value);
}
}
private void GenerateWriteFields(Action <ILGenerator> putValueToWriteOnTop, Type actualType)
{
var fields = StampHelpers.GetFieldsInSerializationOrder(actualType);
foreach (var field in fields)
{
GenerateWriteType(gen =>
{
putValueToWriteOnTop(gen);
gen.Emit(OpCodes.Ldfld, field);
}, field.FieldType);
}
}
private static void GenerateWriteFields(WriterGenerationContext context, Variable value, Type actualType)
{
var fields = StampHelpers.GetFieldsInSerializationOrder(actualType);
foreach (var field in fields)
{
var fieldValueLocal = context.Generator.DeclareLocal(field.FieldType);
var fieldValue = new Variable(fieldValueLocal);
context.Generator.PushVariableOntoStack(value);
if (!actualType.IsValueType)
{
context.Generator.Emit(OpCodes.Castclass, actualType);
}
context.Generator.Emit(OpCodes.Ldfld, field);
context.Generator.StoreLocalValueFromStack(fieldValueLocal);
GenerateWriteField(context, fieldValue, field.FieldType);
}
}
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 void WriteObjectsFields(object o, Type type)
{
// fields in the alphabetical order
var fields = StampHelpers.GetFieldsInSerializationOrder(type);
foreach (var field in fields)
{
var formalType = field.FieldType;
var value = field.GetValue(o);
if (value != null)
{
parentObjects[value] = o;
}
if (Helpers.IsTypeWritableDirectly(formalType))
{
WriteValueType(formalType, value);
}
else
{
CheckForNullOrTransientnessAndWriteDeferredReference(value, formalType);
}
}
}
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);
}
