/// <summary>
/// Gets an array of all serializable members on the given type.
/// </summary>
/// <param name="type">The type to get serializable members for.</param>
/// <param name="policy">The serialization policy to use. If null, <see cref="SerializationPolicies.Strict"/> is used.</param>
/// <returns>An array of all serializable members on the given type.</returns>
public static MemberInfo[] GetSerializableMembers(Type type, ISerializationPolicy policy)
{
MemberInfo[] result;
if (policy == null)
{
policy = SerializationPolicies.Strict;
}
lock (LOCK)
{
if (MemberArrayCache.TryGetInnerValue(policy, type, out result) == false)
{
List <MemberInfo> list = new List <MemberInfo>();
FindSerializableMembers(type, list, policy);
result = list.ToArray();
MemberArrayCache.AddInner(policy, type, result);
}
}
return(result);
}
private static Func <MemberInfo, bool, IValueGetterSetter> GetEmittedGetterSetterCreator(Type ownerType, Type valueType)
{
Func <MemberInfo, bool, IValueGetterSetter> result;
if (!GetterSetterCreators.TryGetInnerValue(ownerType, valueType, out result))
{
var type = typeof(GetterSetter <,>).MakeGenericType(ownerType, valueType);
var constructor = type.GetConstructor(GetterSetterConstructorSignature);
var method = new DynamicMethod("GetterSetterCreator<" + ownerType.GetNiceName() + ", " + valueType.GetNiceName() + ">", typeof(IValueGetterSetter), new Type[] { typeof(MemberInfo), typeof(bool) });
var il = method.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Newobj, constructor);
il.Emit(OpCodes.Ret);
result = (Func <MemberInfo, bool, IValueGetterSetter>)method.CreateDelegate(typeof(Func <MemberInfo, bool, IValueGetterSetter>));
GetterSetterCreators.AddInner(ownerType, valueType, result);
}
return(result);
}
/// <summary>
/// Gets a formatter for a given type.
/// </summary>
/// <param name="type">The type to get a formatter for.</param>
/// <param name="policy">The serialization policy to use if a formatter has to be emitted. If null, <see cref="SerializationPolicies.Strict"/> is used.</param>
/// <returns>
/// A formatter for the given type.
/// </returns>
/// <exception cref="System.ArgumentNullException">The type argument is null.</exception>
public static IFormatter GetFormatter(Type type, ISerializationPolicy policy)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (policy == null)
{
policy = SerializationPolicies.Strict;
}
IFormatter result;
lock (LOCK)
{
if (TypeFormatterMap.TryGetInnerValue(type, policy, out result) == false)
{
// System.ExecutionEngineException is marked obsolete in .NET 4.6.
// That's all very good for .NET, but Unity still uses it, and that means we use it as well!
#pragma warning disable 618
try
{
result = CreateFormatter(type, policy);
}
catch (TargetInvocationException ex)
{
if (ex.GetBaseException() is ExecutionEngineException)
{
LogAOTError(type, ex.GetBaseException() as ExecutionEngineException);
}
else
{
throw ex;
}
}
catch (TypeInitializationException ex)
{
if (ex.GetBaseException() is ExecutionEngineException)
{
LogAOTError(type, ex.GetBaseException() as ExecutionEngineException);
}
else
{
throw ex;
}
}
catch (ExecutionEngineException ex)
{
LogAOTError(type, ex);
}
TypeFormatterMap.AddInner(type, policy, result);
#pragma warning restore 618
}
}
#if UNITY_EDITOR
if (OnLocatedFormatter != null)
{
OnLocatedFormatter(result);
}
if (OnLocatedEmittableFormatterForType != null && result.GetType().IsGenericType)
{
#if CAN_EMIT
if (result.GetType().GetGenericTypeDefinition() == typeof(FormatterEmitter.RuntimeEmittedFormatter <>))
{
OnLocatedEmittableFormatterForType(type);
}
else
#endif
if (result.GetType().GetGenericTypeDefinition() == typeof(ReflectionFormatter <>))
{
OnLocatedEmittableFormatterForType(type);
}
}
#endif
return(result);
}
