/// <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 ); } }