public AssemblyTypeInfoGenerator(string assembly, IAssemblyResolver resolver)
{
this.classes_ = new List <ClassInfo>();
this.typeResolver = new Unity.SerializationLogic.TypeResolver(null);
ReaderParameters parameters = new ReaderParameters {
AssemblyResolver = resolver
};
this.assembly_ = AssemblyDefinition.ReadAssembly(assembly, parameters);
}
public void Add(GenericInstanceMethod genericInstanceMethod)
{
this.Add(TypeResolver.ElementTypeFor(genericInstanceMethod).FullName, genericInstanceMethod);
}
public void Add(GenericInstanceType genericInstanceType)
{
this.Add(TypeResolver.ElementTypeFor(genericInstanceType).FullName, genericInstanceType);
}
private static bool CanFieldContainUnityEngineObjectReference(TypeReference typeReference, FieldDefinition t, TypeResolver typeResolver)
{
if (typeResolver.Resolve(t.FieldType) == typeReference)
{
return(false);
}
if (!WillUnitySerialize(t, typeResolver))
{
return(false);
}
if (UnityEngineTypePredicates.IsUnityEngineValueType(typeReference))
{
return(false);
}
return(true);
}
private static IEnumerable <KeyValuePair <FieldDefinition, TypeResolver> > AllFieldsFor(TypeDefinition definition, TypeResolver typeResolver)
{
var baseType = definition.BaseType;
if (baseType != null)
{
var genericBaseInstanceType = baseType as GenericInstanceType;
if (genericBaseInstanceType != null)
{
typeResolver.Add(genericBaseInstanceType);
}
foreach (var kv in AllFieldsFor(baseType.Resolve(), typeResolver))
{
yield return(kv);
}
if (genericBaseInstanceType != null)
{
typeResolver.Remove(genericBaseInstanceType);
}
}
foreach (var fieldDefinition in definition.Fields)
{
yield return(new KeyValuePair <FieldDefinition, TypeResolver>(fieldDefinition, typeResolver));
}
}
private static bool HasFieldsThatCanContainUnityEngineObjectReferences(TypeDefinition definition, TypeResolver typeResolver)
{
return(AllFieldsFor(definition, typeResolver).Where(kv => kv.Value.Resolve(kv.Key.FieldType).Resolve() != definition).Any(kv => CanFieldContainUnityEngineObjectReference(definition, kv.Key, kv.Value)));
}
public static bool ShouldFieldBePPtrRemapped(FieldDefinition fieldDefinition, TypeResolver typeResolver)
{
if (!WillUnitySerialize(fieldDefinition, typeResolver))
{
return(false);
}
return(CanTypeContainUnityEngineObjectReference(typeResolver.Resolve(fieldDefinition.FieldType)));
}
public static bool WillUnitySerialize(FieldDefinition fieldDefinition, TypeResolver typeResolver)
{
if (fieldDefinition == null)
{
return(false);
}
//skip static, const and NotSerialized fields before even checking the type
if (fieldDefinition.IsStatic || IsConst(fieldDefinition) || fieldDefinition.IsNotSerialized || fieldDefinition.IsInitOnly)
{
return(false);
}
// The field must have correct visibility/decoration to be serialized.
if (!fieldDefinition.IsPublic &&
!ShouldHaveHadAllFieldsPublic(fieldDefinition) &&
!HasSerializeFieldAttribute(fieldDefinition) &&
!HasSerializeReferenceAttribute(fieldDefinition))
{
return(false);
}
// Don't try to resolve types that come from Windows assembly,
// as serialization weaver will fail to resolve that (due to it being in platform specific SDKs)
if (ShouldNotTryToResolve(fieldDefinition.FieldType))
{
return(false);
}
if (IsFixedBuffer(fieldDefinition))
{
return(true);
}
// Resolving types is more complex and slower than checking their names or attributes,
// thus keep those checks below
var typeReference = typeResolver.Resolve(fieldDefinition.FieldType);
//the type of the field must be serializable in the first place.
if (typeReference.MetadataType == MetadataType.String)
{
return(true);
}
if (typeReference.IsValueType)
{
return(IsValueTypeSerializable(typeReference));
}
if (typeReference is ArrayType || CecilUtils.IsGenericList(typeReference))
{
if (!HasSerializeReferenceAttribute(fieldDefinition))
{
return(IsSupportedCollection(typeReference));
}
}
if (!IsReferenceTypeSerializable(typeReference) && !HasSerializeReferenceAttribute(fieldDefinition))
{
return(false);
}
if (IsDelegate(typeReference))
{
return(false);
}
return(true);
}