Esempio n. 1
0
        public void TearDown()
        {
            if (SerializerDebugging.DumpEnabled)
            {
#if !NETSTANDARD2_0
                try
                {
                    SerializerDebugging.Dump();
                }
                catch (NotSupportedException ex)
                {
                    Console.Error.WriteLine(ex);
                }
                finally
                {
                    SerializationMethodGeneratorManager.Refresh();
                }
#else // !NETSTANDARD2_0
                SerializationMethodGeneratorManager.Refresh();
#endif // !NETSTANDARD2_0
            }

            SerializerDebugging.Reset();
            SerializerDebugging.OnTheFlyCodeGenerationEnabled = false;
        }
        public void TearDown()
        {
            if (SerializerDebugging.DumpEnabled)
            {
                try
                {
                    SerializerDebugging.Dump();
                }
                finally
                {
                    SerializationMethodGeneratorManager.Refresh();
                }
            }

            SerializerDebugging.Reset();
            SerializerDebugging.OnTheFlyCodeDomEnabled = false;
        }
Esempio n. 3
0
        internal NullableMessagePackSerializer(SerializationContext context, EmitterFlavor emitterFlavor)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }
            if (NullableMessagePackSerializer <T> ._nullableTImplicitOperator == null)
            {
                throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, "'{0}' is not nullable type.", new object[] { typeof(T) }));
            }
            SerializerEmitter emitter = SerializationMethodGeneratorManager.Get().CreateEmitter(typeof(T), emitterFlavor);

            NullableMessagePackSerializer <T> .CreatePacking(emitter);

            NullableMessagePackSerializer <T> .CreateUnpacking(emitter);

            this._underlying = emitter.CreateInstance <T>(context);
        }
Esempio n. 4
0
        public void TearDown()
        {
#if !NETSTANDARD1_1 && !NETSTANDARD1_3
            if (SerializerDebugging.DumpEnabled)
            {
                try
                {
                    SerializerDebugging.Dump();
                }
                finally
                {
                    SerializationMethodGeneratorManager.Refresh();
                }
            }

            SerializerDebugging.Reset();
            SerializerDebugging.OnTheFlyCodeGenerationEnabled = false;
#endif // !NETSTANDARD1_1 && !NETSTANDARD1_3
        }
        private void GenerateAssemblyFile(AssemblyBuilder assemblyBuilder)
        {
            var context = new SerializationContext();

            context.EmitterFlavor       = EmitterFlavor.FieldBased;
            context.GeneratorOption     = SerializationMethodGeneratorOption.CanDump;
            context.SerializationMethod = this._method;

            // AssemblyBuilder cannot be debugged because no PDB files (and 'dummy' source files to step).
            DefaultSerializationMethodGeneratorManager.SetUpAssemblyBuilderAttributes(assemblyBuilder, false);

            var generatorManager = SerializationMethodGeneratorManager.Get(assemblyBuilder);

            foreach (var targetType in this._targetTypes)
            {
                (Activator.CreateInstance(typeof(Builder <>).MakeGenericType(targetType)) as Builder).GenerateSerializerTo(context, generatorManager);
            }

            assemblyBuilder.Save(this._assemblyName.Name + ".dll");
        }
        public void TearDown()
        {
            if (SerializerDebugging.DumpEnabled && this.CanDump)
            {
                try
                {
                    SerializerDebugging.Dump();
                }
                catch (NotSupportedException ex)
                {
                    Console.Error.WriteLine(ex);
                }
                finally
                {
                    SerializationMethodGeneratorManager.Refresh();
                }
            }

            SerializerDebugging.Reset();
            SerializerDebugging.OnTheFlyCodeDomEnabled = false;
        }
			/// <summary>
			///		Generates serializers using a specified assembly builder.
			/// </summary>
			/// <param name="context">The dedicated <see cref="SerializationContext"/>.</param>
			/// <param name="generatorManager">The dedicated <see cref="SerializationMethodGeneratorManager"/>.</param>
			public abstract void GenerateSerializerTo( SerializationContext context, SerializationMethodGeneratorManager generatorManager );
 /// <summary>
 ///		Generates serializers using a specified assembly builder.
 /// </summary>
 /// <param name="context">The dedicated <see cref="SerializationContext"/>.</param>
 /// <param name="generatorManager">The dedicated <see cref="SerializationMethodGeneratorManager"/>.</param>
 public abstract void GenerateSerializerTo(SerializationContext context, SerializationMethodGeneratorManager generatorManager);