protected override ILConstruct EmitGetSerializerExpression(AssemblyBuilderEmittingContext context, Type targetType, SerializingMember?memberInfo, PolymorphismSchema itemsSchema)
{
var realSchema = itemsSchema ?? PolymorphismSchema.Create(targetType, memberInfo);
var instructions =
context.Emitter.RegisterSerializer(
targetType,
memberInfo == null
? EnumMemberSerializationMethod.Default
: memberInfo.Value.GetEnumMemberSerializationMethod(),
memberInfo == null
? DateTimeMemberConversionMethod.Default
: memberInfo.Value.GetDateTimeMemberConversionMethod(),
realSchema,
() => this.EmitConstructPolymorphismSchema(context, realSchema)
);
return
(ILConstruct.Instruction(
"getserializer",
typeof(MessagePackSerializer <>).MakeGenericType(targetType),
false,
// Both of this pointer for FieldBasedSerializerEmitter and context argument of methods for ContextBasedSerializerEmitter are 0.
il => instructions(il, 0)
));
}
/// <summary>
/// Creates the serializer type built now and returns its new instance.
/// </summary>
/// <param name="context">The <see cref="SerializationContext"/> to holds serializers.</param>
/// <param name="builder">The builder which implements actions initialization emit.</param>
/// <param name="targetInfo">The information of the target.</param>
/// <param name="schema">The <see cref="PolymorphismSchema"/> for this instance.</param>
/// <param name="capabilities">The capabilities of the generating serializer.</param>
/// <returns>
/// Newly built <see cref="MessagePackSerializer"/> instance.
/// This value will not be <c>null</c>.
/// </returns>
public MessagePackSerializer CreateObjectInstance(
AssemblyBuilderEmittingContext context,
AssemblyBuilderSerializerBuilder builder,
SerializationTarget targetInfo,
PolymorphismSchema schema,
SerializerCapabilities?capabilities
)
{
return(this.CreateObjectConstructor(context, builder, targetInfo, capabilities)(context.SerializationContext, schema));
}
protected override ILConstruct EmitMethodOfExpression(AssemblyBuilderEmittingContext context, MethodBase method)
{
var instructions =
context.Emitter.RegisterMethod(
method
);
return
(ILConstruct.Instruction(
"getsetter",
typeof(MethodBase),
false,
// Both of this pointer for FieldBasedSerializerEmitter and context argument of methods for ContextBasedSerializerEmitter are 0.
il => instructions(il, 0)
));
}
private IEnumerable <ILConstruct> EmitConstructPolymorphismSchema(
AssemblyBuilderEmittingContext context,
PolymorphismSchema currentSchema
)
{
var schema = this.DeclareLocal(context, typeof(PolymorphismSchema), "schema");
yield return(schema);
foreach (var construct in this.EmitConstructPolymorphismSchema(context, schema, currentSchema))
{
yield return(construct);
}
yield return(this.EmitLoadVariableExpression(context, schema));
}
protected override ILConstruct EmitGetSerializerExpression(AssemblyBuilderEmittingContext context, Type targetType, SerializingMember?memberInfo)
{
var instructions =
context.Emitter.RegisterSerializer(
targetType,
memberInfo == null
? EnumMemberSerializationMethod.Default
: memberInfo.Value.GetEnumMemberSerializationMethod()
);
return
(ILConstruct.Instruction(
"getserializer",
typeof(MessagePackSerializer <>).MakeGenericType(targetType),
false,
// Both of this pointer for FieldBasedSerializerEmitter and context argument of methods for ContextBasedSerializerEmitter are 0.
il => instructions(il, 0)
));
}
private void CreateContextfulObjectConstructor(
AssemblyBuilderEmittingContext context,
Type baseType,
TracingILGenerator il,
Func <ILConstruct> packActionListInitializerProvider,
Func <ILConstruct> packActionTableInitializerProvider,
Func <ILConstruct> unpackActionListInitializerProvider,
Func <ILConstruct> unpackActionTableInitializerProvider,
#if FEATURE_TAP
Func <ILConstruct> packAsyncActionListInitializerProvider,
Func <ILConstruct> packAsyncActionTableInitializerProvider,
Func <ILConstruct> unpackAsyncActionListInitializerProvider,
Func <ILConstruct> unpackAsyncActionTableInitializerProvider,
#endif // FEATURE_TAP
Func <ILConstruct> memberNamesInitializerProvider,
Func <ILConstruct> unpackToInitializerProvider
)
{
/*
* .ctor( SerializationContext context )
* : base( ( context ?? SerializationContext.Default ).CompabilityOptions.PackerCompatibilityOptions )
* {
* this._serializer0 = context.GetSerializer<T0>();
* this._serializer1 = context.GetSerializer<T1>();
* this._serializer2 = context.GetSerializer<T2>();
* :
* }
*/
// : base()
il.EmitLdarg_0();
il.EmitLdarg_1();
if (this._specification.TargetCollectionTraits.CollectionType == CollectionKind.NotCollection)
{
il.EmitCallConstructor(
baseType.GetRuntimeConstructor(ConstructorParameterTypes)
);
}
else
{
il.EmitCall(this._methodTable[MethodName.RestoreSchema]);
il.EmitCallConstructor(
baseType.GetRuntimeConstructor(CollectionConstructorParameterTypes)
);
}
// this._serializerN = context.GetSerializer<T>();
foreach (var entry in this._serializers)
{
var targetType = Type.GetTypeFromHandle(entry.Key.TypeHandle);
MethodInfo getMethod = Metadata._SerializationContext.GetSerializer1_Parameter_Method.MakeGenericMethod(targetType);
il.EmitLdarg_0();
il.EmitLdarg_1();
if (targetType.GetIsEnum())
{
il.EmitLdarg_1();
il.EmitTypeOf(targetType);
il.EmitAnyLdc_I4(( int )entry.Key.EnumSerializationMethod);
il.EmitCall(Metadata._EnumMessagePackSerializerHelpers.DetermineEnumSerializationMethodMethod);
il.EmitBox(typeof(EnumSerializationMethod));
}
else if (DateTimeMessagePackSerializerHelpers.IsDateTime(targetType))
{
il.EmitLdarg_1();
il.EmitAnyLdc_I4(( int )entry.Key.DateTimeConversionMethod);
il.EmitCall(Metadata._DateTimeMessagePackSerializerHelpers.DetermineDateTimeConversionMethodMethod);
il.EmitBox(typeof(DateTimeConversionMethod));
}
else
{
if (entry.Key.PolymorphismSchema == null)
{
il.EmitLdnull();
}
else
{
entry.Value.SchemaProvider(il);
}
}
il.EmitCallvirt(getMethod);
il.EmitStfld(entry.Value.Field);
}
foreach (var entry in this._cachedFieldInfos)
{
il.EmitLdarg_0();
il.EmitLdtoken(entry.Value.Target);
il.EmitLdtoken(entry.Value.Target.DeclaringType);
il.EmitCall(Metadata._FieldInfo.GetFieldFromHandle);
il.EmitStfld(entry.Value.StorageFieldBuilder);
}
foreach (var entry in this._cachedMethodBases)
{
il.EmitLdarg_0();
il.EmitLdtoken(entry.Value.Target);
il.EmitLdtoken(entry.Value.Target.DeclaringType);
il.EmitCall(Metadata._MethodBase.GetMethodFromHandle);
il.EmitStfld(entry.Value.StorageFieldBuilder);
}
if (packActionListInitializerProvider != null)
{
packActionListInitializerProvider().Evaluate(il);
}
#if FEATURE_TAP
if (packAsyncActionListInitializerProvider != null)
{
packAsyncActionListInitializerProvider().Evaluate(il);
}
#endif // FEATURE_TAP
if (packActionTableInitializerProvider != null)
{
packActionTableInitializerProvider().Evaluate(il);
}
#if FEATURE_TAP
if (packAsyncActionTableInitializerProvider != null)
{
packAsyncActionTableInitializerProvider().Evaluate(il);
}
#endif // FEATURE_TAP
if (unpackActionListInitializerProvider != null)
{
unpackActionListInitializerProvider().Evaluate(il);
}
#if FEATURE_TAP
if (unpackAsyncActionListInitializerProvider != null)
{
unpackAsyncActionListInitializerProvider().Evaluate(il);
}
#endif // FEATURE_TAP
if (unpackActionTableInitializerProvider != null)
{
unpackActionTableInitializerProvider().Evaluate(il);
}
#if FEATURE_TAP
if (unpackAsyncActionTableInitializerProvider != null)
{
unpackAsyncActionTableInitializerProvider().Evaluate(il);
}
#endif // FEATURE_TAP
if (memberNamesInitializerProvider != null)
{
memberNamesInitializerProvider().Evaluate(il);
}
if (unpackToInitializerProvider != null)
{
unpackToInitializerProvider().Evaluate(il);
}
foreach (var cachedDelegateInfo in context.GetCachedDelegateInfos())
{
// this for stfld
il.EmitLdargThis();
var delegateType = cachedDelegateInfo.BackingField.FieldType.ResolveRuntimeType();
// Declare backing field now.
var field = context.GetDeclaredField(cachedDelegateInfo.BackingField.FieldName).ResolveRuntimeField();
if (cachedDelegateInfo.IsThisInstance)
{
il.EmitLdargThis();
}
else
{
il.EmitLdnull();
}
// OK this should not be ldvirtftn because target is private or static.
il.EmitLdftn(cachedDelegateInfo.TargetMethod.ResolveRuntimeMethod());
// call extern .ctor(Object, void*)
il.EmitNewobj(delegateType.GetConstructors().Single());
il.EmitStfld(field);
}
il.EmitRet();
}
public Func <SerializationContext, PolymorphismSchema, MessagePackSerializer> CreateObjectConstructor(AssemblyBuilderEmittingContext context, AssemblyBuilderSerializerBuilder builder, SerializationTarget targetInfo)
{
var hasPackActions = targetInfo != null && !typeof(IPackable).IsAssignableFrom(builder.TargetType);
var hasUnpackActions = targetInfo != null && !typeof(IUnpackable).IsAssignableFrom(builder.TargetType);
var hasUnpackActionTables = hasUnpackActions && targetInfo.Members.Any(m => m.Member != null); // Except tuples
#if FEATURE_TAP
var hasPackAsyncActions = targetInfo != null && !typeof(IAsyncPackable).IsAssignableFrom(builder.TargetType);
var hasUnpackAsyncActions = targetInfo != null && !typeof(IAsyncUnpackable).IsAssignableFrom(builder.TargetType);
var hasUnpackAsyncActionTables = hasUnpackAsyncActions && targetInfo.Members.Any(m => m.Member != null); // Except tuples
#endif // FEATURE_TAP
// ReSharper disable RedundantDelegateCreation
Func <bool, Func <ILConstruct> > packActionsInitialization =
isAsync =>
new Func <ILConstruct>(() => builder.EmitPackOperationListInitialization(context, targetInfo, isAsync));
Func <bool, Func <ILConstruct> > packActionTableInitialization =
isAsync =>
new Func <ILConstruct>(() => builder.EmitPackOperationTableInitialization(context, targetInfo, isAsync));
Func <bool, Func <ILConstruct> > unpackActionsInitialization =
isAsync => new Func <ILConstruct>(() => builder.EmitUnpackOperationListInitialization(context, targetInfo, isAsync));
Func <bool, Func <ILConstruct> > unpackActionTableInitialization =
isAsync => new Func <ILConstruct>(() => builder.EmitUnpackOperationTableInitialization(context, targetInfo, isAsync));
// ReSharper restore RedundantDelegateCreation
var contextfulConstructor =
this.CreateConstructor(
MethodAttributes.Public,
ConstructorParameterTypes,
(type, il) =>
this.CreateContextfulObjectConstructor(
context,
type,
il,
hasPackActions
? packActionsInitialization(false)
: default(Func <ILConstruct>),
hasPackActions
? packActionTableInitialization(false)
: default(Func <ILConstruct>),
hasUnpackActions
? unpackActionsInitialization(false)
: default(Func <ILConstruct>),
hasUnpackActionTables
? unpackActionTableInitialization(false)
: default(Func <ILConstruct>),
#if FEATURE_TAP
hasPackAsyncActions&& context.SerializationContext.SerializerOptions.WithAsync
? packActionsInitialization(true)
: default(Func <ILConstruct>),
hasPackAsyncActions && context.SerializationContext.SerializerOptions.WithAsync
? packActionTableInitialization(true)
: default(Func <ILConstruct>),
hasUnpackAsyncActions && context.SerializationContext.SerializerOptions.WithAsync
? unpackActionsInitialization(true)
: default(Func <ILConstruct>),
hasUnpackAsyncActionTables && context.SerializationContext.SerializerOptions.WithAsync
? unpackActionTableInitialization(true)
: default(Func <ILConstruct>),
#endif // FEATURE_TAP
(
hasUnpackActions
#if FEATURE_TAP
|| hasUnpackAsyncActions
#endif // FEATURE_TAP
) ? () => builder.EmitMemberListInitialization(context, targetInfo)
: default(Func <ILConstruct>),
context.IsUnpackToUsed
? () => builder.EmitUnpackToInitialization(context)
: default(Func <ILConstruct>)
)
);
this.CreateConstructor(
MethodAttributes.Public,
ReflectionAbstractions.EmptyTypes,
(_, il) => CreateDefaultObjectConstructor(contextfulConstructor, il)
);
#if !NETSTANDARD1_1 && !NETSTANDARD1_3
var ctor = this._typeBuilder.CreateType().GetConstructor(ConstructorParameterTypes);
#else
var ctor = this._typeBuilder.CreateTypeInfo().GetConstructor(ConstructorParameterTypes);
#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3
var contextParameter = Expression.Parameter(typeof(SerializationContext), "context");
var schemaParameter = Expression.Parameter(typeof(PolymorphismSchema), "schema");
#if DEBUG
Contract.Assert(ctor != null, "ctor != null");
#endif
return
(Expression.Lambda <Func <SerializationContext, PolymorphismSchema, MessagePackSerializer> >(
Expression.New(
ctor,
contextParameter
),
contextParameter,
schemaParameter
).Compile());
}
public Func <SerializationContext, PolymorphismSchema, MessagePackSerializer> CreateObjectConstructor(
AssemblyBuilderEmittingContext context,
AssemblyBuilderSerializerBuilder builder,
SerializationTarget targetInfo,
SerializerCapabilities?capabilities
)
{
var hasPackActions = targetInfo != null && !typeof(IPackable).IsAssignableFrom(builder.TargetType);
var hasUnpackActions = targetInfo != null && !typeof(IUnpackable).IsAssignableFrom(builder.TargetType);
var hasUnpackActionTables = hasUnpackActions && targetInfo.Members.Any(m => m.Member != null); // Except tuples
#if FEATURE_TAP
var hasPackAsyncActions = targetInfo != null && !typeof(IAsyncPackable).IsAssignableFrom(builder.TargetType);
var hasUnpackAsyncActions = targetInfo != null && !typeof(IAsyncUnpackable).IsAssignableFrom(builder.TargetType);
var hasUnpackAsyncActionTables = hasUnpackAsyncActions && targetInfo.Members.Any(m => m.Member != null); // Except tuples
#endif // FEATURE_TAP
// ReSharper disable RedundantDelegateCreation
Func <bool, Func <ILConstruct> > packActionsInitialization =
isAsync =>
new Func <ILConstruct>(() => builder.EmitPackOperationListInitialization(context, targetInfo, isAsync));
Func <bool, Func <ILConstruct> > packActionTableInitialization =
isAsync =>
new Func <ILConstruct>(() => builder.EmitPackOperationTableInitialization(context, targetInfo, isAsync));
Func <ILConstruct> nullCheckerTableInitializtion = () => builder.EmitPackNullCheckerTableInitialization(context, targetInfo);
Func <bool, Func <ILConstruct> > unpackActionsInitialization =
isAsync => new Func <ILConstruct>(() => builder.EmitUnpackOperationListInitialization(context, targetInfo, isAsync));
Func <bool, Func <ILConstruct> > unpackActionTableInitialization =
isAsync => new Func <ILConstruct>(() => builder.EmitUnpackOperationTableInitialization(context, targetInfo, isAsync));
// ReSharper restore RedundantDelegateCreation
var contextfulConstructor =
this.CreateConstructor(
MethodAttributes.Public,
ConstructorParameterTypesWithoutCapabilities,
(type, il) =>
this.CreateContextfulObjectConstructor(
context,
type,
capabilities,
il,
hasPackActions
? packActionsInitialization(false)
: default(Func <ILConstruct>),
hasPackActions
? packActionTableInitialization(false)
: default(Func <ILConstruct>),
#if DEBUG
!SerializerDebugging.UseLegacyNullMapEntryHandling &&
#endif // DEBUG
hasPackActions
#if FEATURE_TAP
|| hasPackAsyncActions
#endif // FEATURE_TAP
? nullCheckerTableInitializtion
: default(Func <ILConstruct>),
hasUnpackActions
? unpackActionsInitialization(false)
: default(Func <ILConstruct>),
hasUnpackActionTables
? unpackActionTableInitialization(false)
: default(Func <ILConstruct>),
#if FEATURE_TAP
hasPackAsyncActions&& context.SerializationContext.SerializerOptions.WithAsync
? packActionsInitialization(true)
: default(Func <ILConstruct>),
hasPackAsyncActions && context.SerializationContext.SerializerOptions.WithAsync
? packActionTableInitialization(true)
: default(Func <ILConstruct>),
hasUnpackAsyncActions && context.SerializationContext.SerializerOptions.WithAsync
? unpackActionsInitialization(true)
: default(Func <ILConstruct>),
hasUnpackAsyncActionTables && context.SerializationContext.SerializerOptions.WithAsync
? unpackActionTableInitialization(true)
: default(Func <ILConstruct>),
#endif // FEATURE_TAP
(
hasUnpackActions
#if FEATURE_TAP
|| hasUnpackAsyncActions
#endif // FEATURE_TAP
) ? () => builder.EmitMemberListInitialization(context, targetInfo)
: default(Func <ILConstruct>),
context.IsUnpackToUsed
? () => builder.EmitUnpackToInitialization(context)
: default(Func <ILConstruct>)
)
);
this.CreateConstructor(
MethodAttributes.Public,
ReflectionAbstractions.EmptyTypes,
(_, il) => CreateDefaultObjectConstructor(contextfulConstructor, il)
);
#if !NETSTANDARD1_1 && !NETSTANDARD1_3 && !NETSTANDARD2_0
var ctor = this._typeBuilder.CreateType().GetConstructor(ConstructorParameterTypesWithoutCapabilities);
#else
var ctor = this._typeBuilder.CreateTypeInfo().GetConstructor(ConstructorParameterTypesWithoutCapabilities);
#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 && !NETSTANDARD2_0
#if DEBUG
Contract.Assert(ctor != null, "ctor != null");
#endif
var actualFunc = ctor.CreateConstructorDelegate <Func <SerializationContext, MessagePackSerializer> >();
return((c, _) => actualFunc(c));
}
