public static MemberInfo[] GetSerializableMembers(ISerializationPredicates p, Type forType)
{
var members = forType.GetMembers(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
var result = members.Where(x => IsSerializableMember(p, x)).ToArray();
return(result);
}
public static Type[] GetSerializableMembersTypes(ISerializationPredicates p, Type forType)
{
var members = GetSerializableMembers(p, forType);
var result = GetMembersTypes(members);
return(result);
}
public EmitContext(ISerializationPredicates predicates, List <IBaseSerializer> serializers, Func <Type, int> getTypeId)
{
this.Predicates = predicates;
this.GetTypeId = getTypeId;
_serializers = serializers;
WriteStubs = new Dictionary <int, StubInfo>();
ReadStubs = new Dictionary <int, StubInfo>();
Types = new List <Type>();
}
public EmitContext(ISerializationPredicates predicates, List<IBaseSerializer> serializers, Func<Type, int> getTypeId)
{
this.Predicates = predicates;
this.GetTypeId = getTypeId;
_serializers = serializers;
WriteStubs = new Dictionary<int, StubInfo>();
ReadStubs = new Dictionary<int, StubInfo>();
Types = new List<Type>();
}
void Initialize(List <Type> userTypes, IBaseSerializer[] userSerializers, ISerializationPredicates userPredicates)
{
_predicates = userPredicates ?? DefaultPredicates;
_serializationCtx = new SerializationContext(this);
_typeLookup = new Dictionary <Type, int>();
var serializers = new List <IBaseSerializer>()
{
new Basic(),
new Array1DSerializer(),
new ListSerializer(),
new EnumSerializer(),
new DictionarySerializer(),
new UnityMiscSerializer(),
new TypeSerializer(),
new GuidSerializer(),
new StackSerializer(),
new QueueSerializer(),
new HashSetSerializer(),
new NullableSerializer(),
new Array2DSerializer(),
new FieldInfoSerializer(),
new PropertyInfoSerializer(),
new MethodInfoSerializer(),
new UniversalSerializer()
};
if (userSerializers != null)
{
serializers.InsertRange(0, userSerializers);
}
_emitCtx = new EmitContext(_predicates, serializers, GetTypeId);
for (int i = 0; i < serializers.Count; i++)
{
serializers[i].ctx = _emitCtx;
}
if (userTypes != null)
{
_nextId = 0;
for (int i = 0; i < userTypes.Count; i++)
{
TryResolveType(userTypes[i], ref _nextId, null);
}
}
}
public static bool IsSerializableMember(ISerializationPredicates p, MemberInfo member)
{
if (member.MemberType == MemberTypes.Method)
{
return(false);
}
var field = member as FieldInfo;
if (field != null)
{
return(p.IsSerializableField(field));
}
var property = member as PropertyInfo;
if (property != null)
{
return(p.IsSerializableProperty(property));
}
return(false);
}
public static FastSerializer CompileDynamic(List <Type> userTypes, IBaseSerializer[] userSerializers, ISerializationPredicates userPredicates, Action <Type> onTypeGenerated)
{
var serializer = new FastSerializer();
serializer._onTypeGenerated = onTypeGenerated;
serializer.Initialize(userTypes, userSerializers, userPredicates);
var ctx = serializer._emitCtx;
EmitHelper.EmitDynamic(ctx, out serializer._serialize, out serializer._deserialize);
// generate write null and serialize delegators
{
//public static void Write_Null(Stream, value, ctx)
//{
//}
// foreach type generate a delegator to the actual write method
//public static void Delegate_Write_X(Stream, object value, ctx)
//{
// Write_X(stream, (X)value, ctx);
//}
var emit = EmitHelper.emit;
var writeNull = new DynamicMethod("Write_Null", typeof(void), EmitHelper.SerializationParameters);
{
emit.il = writeNull.GetILGenerator();
emit.ret();
}
var writeNullDelegate = writeNull.CreateDelegate <SerializationDelegate>();
serializer._serializationDelegates.Add(writeNullDelegate);
for (int i = 0; i < ctx.Types.Count; i++)
{
var type = ctx.Types[i];
var writer = ctx.GetWriteStub(type);
var delegator = EmitHelper.EmitDynamicSerializeDelegator(type, writer);
serializer._serializationDelegates.Add(delegator);
}
}
// generate read null and deserialize delegators
{
//public static object Read_Null(Stream, ctx)
//{
// return null;
//}
// foreach type generate a delegator to the actual read method
//public static object Delegate_Read_X(Stream, ctx)
//{
// return <box if needed>Read_X(stream, ctx);
//}
var emit = EmitHelper.emit;
var readNull = new DynamicMethod("Read_Null", typeof(object), EmitHelper.DeserializationParameters);
{
emit.il = readNull.GetILGenerator();
emit.retnull();
}
var readNullDelegate = readNull.CreateDelegate <DeserializationDelegate>();
serializer._deserializationDelegates.Add(readNullDelegate);
for (int i = 0; i < ctx.Types.Count; i++)
{
var type = ctx.Types[i];
var reader = ctx.GetReadStub(type);
var delegator = EmitHelper.EmitDynamicDeserializeDelegator(type, reader);
serializer._deserializationDelegates.Add(delegator);
}
}
return(serializer);
}
public static void CompileAssembly(List <Type> userTypes, IBaseSerializer[] userSerializers, ISerializationPredicates userPredicates, string assemblyName, string assemblyDir, string typeName)
{
var serializer = new FastSerializer();
serializer.Initialize(userTypes, userSerializers, userPredicates);
EmitHelper.EmitAssembly(assemblyName, assemblyDir, typeName, serializer._emitCtx);
}
public void CompileWithPredicates(ISerializationPredicates p)
{
FastSerializer.CompileDynamic(types, null, p, onTypeGenerated: null);
}
