/// <summary>
/// Initializes a new instance of the <see cref="SerializerEmitter"/> class for enum.
/// </summary>
/// <param name="context">A <see cref="SerializationContext"/>.</param>
/// <param name="host">The host <see cref="ModuleBuilder"/>.</param>
/// <param name="specification">The specification of the serializer.</param>
/// <param name="isDebuggable">Set to <c>true</c> when <paramref name="host"/> is debuggable.</param>
public SerializerEmitter( SerializationContext context, ModuleBuilder host, SerializerSpecification specification, bool isDebuggable )
: this( host, specification, typeof( EnumMessagePackSerializer<> ).MakeGenericType( specification.TargetType ), isDebuggable )
{
Tracer.Emit.TraceEvent( Tracer.EventType.DefineType, Tracer.EventId.DefineType, "Create {0}", specification.SerializerTypeFullName );
this._defaultEnumSerializationMethod = context.EnumSerializationOptions.SerializationMethod;
}
/// <summary>
/// Initializes a new instance of the <see cref="SerializerEmitter"/> class for enum.
/// </summary>
/// <param name="context">A <see cref="SerializationContext"/>.</param>
/// <param name="host">The host <see cref="ModuleBuilder"/>.</param>
/// <param name="specification">The specification of the serializer.</param>
/// <param name="isDebuggable">Set to <c>true</c> when <paramref name="host"/> is debuggable.</param>
public SerializerEmitter(SerializationContext context, ModuleBuilder host, SerializerSpecification specification, bool isDebuggable)
: this(host, specification, typeof(EnumMessagePackSerializer <>).MakeGenericType(specification.TargetType), isDebuggable)
{
Tracer.Emit.TraceEvent(Tracer.EventType.DefineType, Tracer.EventId.DefineType, "Create {0}", specification.SerializerTypeFullName);
this._defaultEnumSerializationMethod = context.EnumSerializationOptions.SerializationMethod;
}
ICustomizableEnumSerializer ICustomizableEnumSerializer.GetCopyAs(EnumSerializationMethod method)
{
return
(new EnumTypedMessagePackSerializerWrapper <T>(
this.OwnerContext,
this._underlyingEnumSerializer.GetCopyAs(method) as MessagePackSerializer
));
}
public static EnumSerializationMethod DetermineEnumSerializationMethod(
SerializationContext context,
Type enumType,
EnumMemberSerializationMethod enumMemberSerializationMethod
)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (enumType == null)
{
throw new ArgumentNullException("enumType");
}
EnumSerializationMethod method = context.EnumSerializationMethod;
switch (enumMemberSerializationMethod)
{
case EnumMemberSerializationMethod.ByName:
{
method = EnumSerializationMethod.ByName;
break;
}
case EnumMemberSerializationMethod.ByUnderlyingValue:
{
method = EnumSerializationMethod.ByUnderlyingValue;
break;
}
default:
{
#if NETFX_CORE
var messagePackEnumAttribute =
enumType.GetTypeInfo().GetCustomAttribute <MessagePackEnumAttribute>();
if (messagePackEnumAttribute != null)
{
method = messagePackEnumAttribute.SerializationMethod;
#else
var messagePackEnumAttributes =
enumType.GetCustomAttributes(typeof(MessagePackEnumAttribute), true);
if (messagePackEnumAttributes.Length > 0)
{
// ReSharper disable once PossibleNullReferenceException
method = (messagePackEnumAttributes[0] as MessagePackEnumAttribute).SerializationMethod;
#endif // NETFX_CORE
}
break;
}
}
return(method);
}
}
public ExpressionCallbackEnumMessagePackSerializer(
SerializationContext ownerContext,
EnumSerializationMethod serializationMethod,
Action <ExpressionCallbackEnumMessagePackSerializer <TEnum>, Packer, TEnum> packUnderlyingValueTo,
Func <ExpressionCallbackEnumMessagePackSerializer <TEnum>, MessagePackObject, TEnum> unpackFromUnderlyingValue
) : base(ownerContext, serializationMethod)
{
this._packUnderlyingValueTo = packUnderlyingValueTo;
this._unpackFromUnderlyingValue = unpackFromUnderlyingValue;
}
ICustomizableEnumSerializer ICustomizableEnumSerializer.GetCopyAs(EnumSerializationMethod method)
{
if (method == this._serializationMethod)
{
return(this);
}
var clone = this.MemberwiseClone() as UnityEnumMessagePackSerializer;
// ReSharper disable once PossibleNullReferenceException
clone._serializationMethod = method;
return(clone);
}
private EnumSerializationMethod _serializationMethod; // not readonly -- changed in cloned instance in GetCopyAs()
/// <summary>
/// Initializes a new instance of the <see cref="EnumMessagePackSerializer{TEnum}"/> class.
/// </summary>
/// <param name="ownerContext">A <see cref="SerializationContext"/> which owns this serializer.</param>
/// <param name="serializationMethod">The <see cref="EnumSerializationMethod"/> which determines serialization form of the enums.</param>
/// <exception cref="InvalidOperationException"><c>TEnum</c> is not enum type.</exception>
protected EnumMessagePackSerializer(SerializationContext ownerContext, EnumSerializationMethod serializationMethod)
: base(ownerContext)
{
if (!typeof(TEnum).GetIsEnum())
{
throw new InvalidOperationException(
String.Format(CultureInfo.CurrentCulture, "Type '{0}' is not enum.", typeof(TEnum))
);
}
this._serializationMethod = serializationMethod;
this._underlyingType = Enum.GetUnderlyingType(typeof(TEnum));
}
protected EnumMessagePackSerializer(SerializationContext ownerContext, EnumSerializationMethod serializationMethod)
: base(ownerContext, SerializerCapabilities.PackTo | SerializerCapabilities.UnpackFrom)
{
if (!typeof(TEnum).GetIsEnum())
{
throw new InvalidOperationException(
String.Format(CultureInfo.CurrentCulture, "Type '{0}' is not enum.", typeof(TEnum))
);
}
this._serializationMethod = serializationMethod;
this._underlyingType = Enum.GetUnderlyingType(typeof(TEnum));
var members = Enum.GetValues(typeof(TEnum)) as TEnum[];
this._serializationMapping = new Dictionary <TEnum, string>(members.Length);
this._deserializationMapping = new Dictionary <string, TEnum>(members.Length);
foreach (var member in members)
{
var asString = ownerContext.EnumSerializationOptions.SafeNameTransformer(member.ToString());
this._serializationMapping[member] = asString;
this._deserializationMapping[asString] = member;
}
}
private EnumSerializationMethod _serializationMethod; // not readonly -- changed in cloned instance in GetCopyAs()
protected UnityEnumMessagePackSerializer(SerializationContext ownerContext, Type targetType, EnumSerializationMethod serializationMethod)
: base(ownerContext, targetType, SerializerCapabilities.PackTo | SerializerCapabilities.UnpackFrom)
{
if (!targetType.GetIsEnum())
{
throw new InvalidOperationException(
String.Format(CultureInfo.CurrentCulture, "Type '{0}' is not enum.", targetType)
);
}
this._serializationMethod = serializationMethod;
this._underlyingType = Enum.GetUnderlyingType(targetType);
var members = Array.ConvertAll((int[])Enum.GetValues(targetType), v => (object)v);;
this._serializationMapping = new Dictionary <object, string>(members.Length);
this._deserializationMapping = new Dictionary <string, object>(members.Length);
foreach (var member in members)
{
var asString = ownerContext.EnumSerializationOptions.SafeNameTransformer(member.ToString());
this._serializationMapping[member] = asString;
this._deserializationMapping[asString] = member;
}
}
/// <summary>
/// Determines <see cref="EnumSerializationMethod"/> for the target.
/// </summary>
/// <param name="context">Context information.</param>
/// <param name="enumType">The target enum type.</param>
/// <param name="enumMemberSerializationMethod">The method argued by the member.</param>
/// <returns>Determined <see cref="EnumSerializationMethod"/> for the target.</returns>
public static EnumSerializationMethod DetermineEnumSerializationMethod(
SerializationContext context,
Type enumType,
EnumMemberSerializationMethod enumMemberSerializationMethod)
{
EnumSerializationMethod method = context.EnumSerializationMethod;
switch (enumMemberSerializationMethod)
{
case EnumMemberSerializationMethod.ByName:
{
method = EnumSerializationMethod.ByName;
break;
}
case EnumMemberSerializationMethod.ByUnderlyingValue:
{
method = EnumSerializationMethod.ByUnderlyingValue;
break;
}
default:
{
var attributesOnType = enumType.GetCustomAttributes(typeof(MessagePackEnumAttribute), false);
if (attributesOnType.Length > 0)
{
// ReSharper disable once PossibleNullReferenceException
method = (attributesOnType[0] as MessagePackEnumAttribute).SerializationMethod;
}
break;
}
}
return(method);
}
/// <summary>
/// Initializes a new instance of the <see cref="FieldBasedSerializerEmitter"/> class.
/// </summary>
/// <param name="context">A <see cref="SerializationContext"/>.</param>
/// <param name="host">The host <see cref="ModuleBuilder"/>.</param>
/// <param name="specification">The specification of the serializer.</param>
/// <param name="isDebuggable">Set to <c>true</c> when <paramref name="host"/> is debuggable.</param>
public FieldBasedEnumSerializerEmitter(SerializationContext context, ModuleBuilder host, SerializerSpecification specification, bool isDebuggable)
{
Contract.Requires(host != null);
Contract.Requires(specification != null);
Tracer.Emit.TraceEvent(Tracer.EventType.DefineType, Tracer.EventId.DefineType, "Create {0}", specification.SerializerTypeFullName);
this._typeBuilder =
host.DefineType(
specification.SerializerTypeFullName,
TypeAttributes.Sealed | TypeAttributes.Public | TypeAttributes.UnicodeClass | TypeAttributes.AutoLayout |
TypeAttributes.BeforeFieldInit,
typeof(EnumMessagePackSerializer <>).MakeGenericType(specification.TargetType)
);
this._contextConstructorBuilder =
this._typeBuilder.DefineConstructor(
MethodAttributes.Public,
CallingConventions.Standard,
ContextConstructorParameterTypes
);
this._defaultEnumSerializationMethod = context.EnumSerializationMethod;
this._contextAndEnumSerializationMethodConstructorBuilder =
this._typeBuilder.DefineConstructor(
MethodAttributes.Public,
CallingConventions.Standard,
ContextAndEnumSerializationMethodConstructorParameterTypes
);
this._packUnderlyingValueToMethodBuilder =
this._typeBuilder.DefineMethod(
"PackUnderlyingValueTo",
MethodAttributes.Family | MethodAttributes.Virtual | MethodAttributes.Final | MethodAttributes.HideBySig,
CallingConventions.HasThis,
typeof(void),
new[] { typeof(Packer), specification.TargetType }
);
this._unpackFromUnderlyingValueMethodBuilder =
this._typeBuilder.DefineMethod(
"UnpackFromUnderlyingValue",
MethodAttributes.Family | MethodAttributes.Virtual | MethodAttributes.Final | MethodAttributes.HideBySig,
CallingConventions.HasThis,
specification.TargetType,
UnpackFromUnderlyingValueParameterTypes
);
var baseType = this._typeBuilder.BaseType;
#if DEBUG
Contract.Assert(baseType != null, "baseType != null");
#endif
this._typeBuilder.DefineMethodOverride(
this._packUnderlyingValueToMethodBuilder,
baseType.GetMethod(
this._packUnderlyingValueToMethodBuilder.Name,
BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic
)
);
this._typeBuilder.DefineMethodOverride(
this._unpackFromUnderlyingValueMethodBuilder,
baseType.GetMethod(
this._unpackFromUnderlyingValueMethodBuilder.Name,
BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic
)
);
this._isDebuggable = isDebuggable;
#if !SILVERLIGHT && !NETFX_35
if (isDebuggable && SerializerDebugging.DumpEnabled)
{
SerializerDebugging.PrepareDump(host.Assembly as AssemblyBuilder);
}
#endif
}
/// <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="serializationMethod">The <see cref="EnumSerializationMethod"/> which determines serialization form of the enums.</param>
/// <returns>
/// Newly built <see cref="MessagePackSerializer{T}"/> instance.
/// This value will not be <c>null</c>.
/// </returns>
public MessagePackSerializer CreateEnumInstance(SerializationContext context, EnumSerializationMethod serializationMethod)
{
return(this.CreateEnumConstructor()(context, serializationMethod));
}
private static void TestOnWorkerAppDomain( string geneartedAssemblyFilePath, PackerCompatibilityOptions packerCompatibilityOptions, EnumSerializationMethod enumSerializationMethod, TestEnumType enumValue, byte[] expectedPackedValue )
{
var appDomainSetUp = new AppDomainSetup() { ApplicationBase = AppDomain.CurrentDomain.SetupInformation.ApplicationBase };
var workerDomain = AppDomain.CreateDomain( "Worker", null, appDomainSetUp );
try
{
var testerProxy =
workerDomain.CreateInstanceAndUnwrap( typeof( Tester ).Assembly.FullName, typeof( Tester ).FullName ) as Tester;
testerProxy.DoTest( geneartedAssemblyFilePath, ( int )packerCompatibilityOptions, ( int )enumSerializationMethod, enumValue, expectedPackedValue, 1 );
}
finally
{
AppDomain.Unload( workerDomain );
}
}
/// <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="serializationMethod">The <see cref="EnumSerializationMethod"/> which determines serialization form of the enums.</param>
/// <returns>
/// Newly built <see cref="MessagePackSerializer{T}"/> instance.
/// This value will not be <c>null</c>.
/// </returns>
public MessagePackSerializer CreateEnumInstance( SerializationContext context, EnumSerializationMethod serializationMethod )
{
return this.CreateEnumConstructor()( context, serializationMethod );
}
private static TestResult[] Test(
EmitterFlavor flavor,
SerializationMethod method,
EnumSerializationMethod enumMethod)
{
var stopWatch = new Stopwatch();
using (var buffer = new MemoryStream())
{
// JIT
TestCreateSerializer(
stopWatch,
new SerializationContext
{
EmitterFlavor = flavor,
SerializationMethod = method,
EnumSerializationMethod = enumMethod
}
);
TestSerialize(
stopWatch,
buffer,
new SerializationContext
{
EmitterFlavor = flavor,
SerializationMethod = method,
EnumSerializationMethod = enumMethod
}
);
buffer.Position = 0;
TestDeserialize(
stopWatch,
buffer,
new SerializationContext
{
EmitterFlavor = flavor,
SerializationMethod = method,
EnumSerializationMethod = enumMethod
}
);
var samples = new long[flavor == EmitterFlavor.CodeDomBased ? 10 : Iteration];
// 1st-time only
for (int i = 0; i < samples.Length; i++)
{
TestCreateSerializer(
stopWatch,
new SerializationContext
{
EmitterFlavor = flavor,
SerializationMethod = method,
EnumSerializationMethod = enumMethod
}
);
samples[i] = stopWatch.Elapsed.Ticks;
}
var creationResult = Calculate(samples);
samples = new long[Iteration];
// Exept-1st time
var context =
new SerializationContext
{
EmitterFlavor = flavor,
SerializationMethod = method,
EnumSerializationMethod = enumMethod
};
var samples2 = new long[samples.Length];
// Dry-run
buffer.SetLength(0);
TestSerialize(stopWatch, buffer, context);
buffer.Position = 0;
TestDeserialize(stopWatch, buffer, context);
for (int i = 0; i < samples.Length; i++)
{
buffer.SetLength(0);
TestSerialize(stopWatch, buffer, context);
samples[i] = stopWatch.Elapsed.Ticks;
buffer.Position = 0;
TestDeserialize(stopWatch, buffer, context);
samples2[i] = stopWatch.Elapsed.Ticks;
}
var serializationResult = Calculate(samples);
var deserializationResult = Calculate(samples2);
return(new TestResult[] { creationResult, serializationResult, deserializationResult });
}
}
/// <summary>
/// Creates the serializer type built now and returns its new instance.
/// </summary>
/// <typeparam name="T">Target type to be serialized/deserialized.</typeparam>
/// <param name="context">The <see cref="SerializationContext"/> to holds serializers.</param>
/// <param name="serializationMethod">The <see cref="EnumSerializationMethod"/> which determines serialization form of the enums.</param>
/// <returns>
/// Newly built <see cref="MessagePackSerializer{T}"/> instance.
/// This value will not be <c>null</c>.
/// </returns>
public MessagePackSerializer <T> CreateInstance <T>(SerializationContext context, EnumSerializationMethod serializationMethod)
{
return(this.CreateConstructor <T>()(context, serializationMethod));
}
private static TestResult[] Test(
EmitterFlavor flavor,
SerializationMethod method,
EnumSerializationMethod enumMethod )
{
var stopWatch = new Stopwatch();
using ( var buffer = new MemoryStream() )
{
// JIT
TestCreateSerializer(
stopWatch,
new SerializationContext
{
EmitterFlavor = flavor,
SerializationMethod = method,
EnumSerializationMethod = enumMethod
}
);
TestSerialize(
stopWatch,
buffer,
new SerializationContext
{
EmitterFlavor = flavor,
SerializationMethod = method,
EnumSerializationMethod = enumMethod
}
);
buffer.Position = 0;
TestDeserialize(
stopWatch,
buffer,
new SerializationContext
{
EmitterFlavor = flavor,
SerializationMethod = method,
EnumSerializationMethod = enumMethod
}
);
var samples = new long[ flavor == EmitterFlavor.CodeDomBased ? 10 : Iteration ];
// 1st-time only
for ( int i = 0; i < samples.Length; i++ )
{
TestCreateSerializer(
stopWatch,
new SerializationContext
{
EmitterFlavor = flavor,
SerializationMethod = method,
EnumSerializationMethod = enumMethod
}
);
samples[ i ] = stopWatch.Elapsed.Ticks;
}
var creationResult = Calculate( samples );
samples = new long[ Iteration ];
// Exept-1st time
var context =
new SerializationContext
{
EmitterFlavor = flavor,
SerializationMethod = method,
EnumSerializationMethod = enumMethod
};
var samples2 = new long[ samples.Length ];
// Dry-run
buffer.SetLength( 0 );
TestSerialize( stopWatch, buffer, context );
buffer.Position = 0;
TestDeserialize( stopWatch, buffer, context );
for ( int i = 0; i < samples.Length; i++ )
{
buffer.SetLength( 0 );
TestSerialize( stopWatch, buffer, context );
samples[ i ] = stopWatch.Elapsed.Ticks;
buffer.Position = 0;
TestDeserialize( stopWatch, buffer, context );
samples2[ i ] = stopWatch.Elapsed.Ticks;
}
var serializationResult = Calculate( samples );
var deserializationResult = Calculate( samples2 );
return new TestResult[] { creationResult, serializationResult, deserializationResult };
}
}
private static void TestOnWorkerAppDomainWithCompile( string geneartedSourceFilePath, PackerCompatibilityOptions packerCompatibilityOptions, EnumSerializationMethod enumSerializationMethod, TestEnumType enumValue, byte[] expectedPackedValue )
{
var parameters = new CompilerParameters();
parameters.ReferencedAssemblies.Add( typeof( GeneratedCodeAttribute ).Assembly.Location );
parameters.ReferencedAssemblies.Add( typeof( MessagePackObject ).Assembly.Location );
parameters.ReferencedAssemblies.Add( Assembly.GetExecutingAssembly().Location );
var result =
CodeDomProvider.CreateProvider( "C#" ).CompileAssemblyFromFile( parameters, geneartedSourceFilePath );
Assert.That( result.Errors.Count, Is.EqualTo( 0 ), String.Join( Environment.NewLine, result.Output.OfType<string>().ToArray() ) );
try
{
var appDomainSetUp =
new AppDomainSetup
{
ApplicationBase = AppDomain.CurrentDomain.SetupInformation.ApplicationBase
};
var workerDomain = AppDomain.CreateDomain( "Worker", null, appDomainSetUp );
try
{
var testerProxy =
workerDomain.CreateInstanceAndUnwrap( typeof( Tester ).Assembly.FullName, typeof( Tester ).FullName ) as Tester;
testerProxy.DoTest(
result.PathToAssembly,
( int ) packerCompatibilityOptions,
( int ) enumSerializationMethod,
enumValue,
expectedPackedValue,
1
);
}
finally
{
AppDomain.Unload( workerDomain );
}
}
finally
{
File.Delete( result.PathToAssembly );
}
}
