/// <summary>
		///		Creates a new instance of the <see cref="PolymorphismSchema"/> class for dictionary object which uses ext-type code mapping based polymorphism.
		/// </summary>
		/// <param name="targetType">The type of the serialization target.</param>
		/// <param name="codeTypeMapping">The code type mapping which maps between ext-type codes and .NET <see cref="Type"/>s.</param>
		/// <param name="keySchema">The schema for dictionary keys of the serialization target dictionary.</param>
		/// <param name="valueSchema">The schema for dictionary values of the serialization target dictionary.</param>
		/// <returns>A new instance of the <see cref="PolymorphismSchema"/> class for dictionary object which uses ext-type code mapping based polymorphism.</returns>
		/// <exception cref="System.ArgumentNullException"><paramref name="targetType"/> is <c>null</c>.</exception>
		public static PolymorphismSchema ForPolymorphicDictionary(
			Type targetType,
			IDictionary<string, Type> codeTypeMapping,
			PolymorphismSchema keySchema,
			PolymorphismSchema valueSchema
		)
		{
			return
				new PolymorphismSchema(
					targetType,
					PolymorphismType.KnownTypes,
					codeTypeMapping,
					DefaultTypeVerfiier,
					PolymorphismSchemaChildrenType.DictionaryKeyValues,
					keySchema,
					valueSchema
				);
		}
		/// <summary>
		///		Creates a new instance of the <see cref="PolymorphismSchema"/> class for dictionary object which uses type embedding based polymorphism.
		/// </summary>
		/// <param name="targetType">The type of the serialization target.</param>
		/// <param name="keySchema">The schema for dictionary keys of the serialization target dictionary.</param>
		/// <param name="valueSchema">The schema for dictionary values of the serialization target dictionary.</param>
		/// <returns>A new instance of the <see cref="PolymorphismSchema"/> class for dictionary object which uses type embedding based polymorphism.</returns>
		/// <exception cref="System.ArgumentNullException"><paramref name="targetType"/> is <c>null</c>.</exception>
		public static PolymorphismSchema ForPolymorphicDictionary(
			Type targetType,
			PolymorphismSchema keySchema,
			PolymorphismSchema valueSchema
		)
		{
			return
				new PolymorphismSchema(
					targetType,
					PolymorphismType.RuntimeType,
					DefaultTypeVerfiier,
					PolymorphismSchemaChildrenType.DictionaryKeyValues,
					keySchema,
					valueSchema
				);
		}
		/// <summary>
		///		Creates a new instance of the <see cref="PolymorphismSchema"/> class for dictionary object which uses type embedding based polymorphism.
		/// </summary>
		/// <param name="targetType">The type of the serialization target.</param>
		/// <param name="keySchema">The schema for dictionary keys of the serialization target dictionary.</param>
		/// <param name="valueSchema">The schema for dictionary values of the serialization target dictionary.</param>
		/// <param name="typeVerifier">The delegate which verifies loading type in runtime type polymorphism.</param>
		/// <returns>A new instance of the <see cref="PolymorphismSchema"/> class for dictionary object which uses type embedding based polymorphism.</returns>
		/// <exception cref="System.ArgumentNullException"><paramref name="targetType"/> is <c>null</c>.</exception>
		public static PolymorphismSchema ForPolymorphicDictionary(
			Type targetType,
			PolymorphismSchema keySchema,
			PolymorphismSchema valueSchema,
			Func<PolymorphicTypeVerificationContext, bool> typeVerifier
		)
		{
			return
				new PolymorphismSchema(
					targetType,
					PolymorphismType.RuntimeType,
					typeVerifier,
					PolymorphismSchemaChildrenType.DictionaryKeyValues,
					keySchema,
					valueSchema
				);
		}
		/// <summary>
		///		Creates a new instance of the <see cref="PolymorphismSchema"/> class for collection object which uses ext-type code mapping based polymorphism.
		/// </summary>
		/// <param name="targetType">The type of the serialization target.</param>
		/// <param name="codeTypeMapping">The code type mapping which maps between ext-type codes and .NET <see cref="Type"/>s.</param>
		/// <param name="itemSchema">The schema for collection items of the serialization target collection.</param>
		/// <returns>A new instance of the <see cref="PolymorphismSchema"/> class for collection object which uses ext-type code mapping based polymorphism.</returns>
		/// <exception cref="System.ArgumentNullException"><paramref name="targetType"/> is <c>null</c>.</exception>
		public static PolymorphismSchema ForPolymorphicCollection(
			Type targetType,
			IDictionary<string, Type> codeTypeMapping,
			PolymorphismSchema itemSchema
		)
		{
			return
				new PolymorphismSchema(
					targetType,
					PolymorphismType.KnownTypes,
					codeTypeMapping,
					DefaultTypeVerfiier,
					PolymorphismSchemaChildrenType.CollectionItems,
					itemSchema
				);
		}
		// Dictionary key/values

		/// <summary>
		///		Creates a new instance of the <see cref="PolymorphismSchema"/> class for dictionary object which uses declared type or context specified concrete type.
		/// </summary>
		/// <param name="targetType">The type of the serialization target.</param>
		/// <param name="keySchema">The schema for dictionary keys of the serialization target dictionary.</param>
		/// <param name="valueSchema">The schema for dictionary values of the serialization target dictionary.</param>
		/// <returns>A new instance of the <see cref="PolymorphismSchema"/> class for dictionary object which uses declared type or context specified concrete type.</returns>
		/// <exception cref="System.ArgumentNullException"><paramref name="targetType"/> is <c>null</c>.</exception>
		public static PolymorphismSchema ForContextSpecifiedDictionary(
			Type targetType,
			PolymorphismSchema keySchema,
			PolymorphismSchema valueSchema
		)
		{
			return
				new PolymorphismSchema(
					targetType,
					PolymorphismType.None,
					DefaultTypeVerfiier,
					PolymorphismSchemaChildrenType.DictionaryKeyValues,
					keySchema,
					valueSchema
				);
		}
 internal ResolveSerializerEventArgs(SerializationContext context, Type targetType, PolymorphismSchema schema)
 {
     this.Context            = context;
     this.TargetType         = targetType;
     this.PolymorphismSchema = schema ?? PolymorphismSchema.Default;
 }
		/// <summary>
		///		Creates a new instance of the <see cref="PolymorphismSchema"/> class for collection object which uses type embedding based polymorphism.
		/// </summary>
		/// <param name="targetType">The type of the serialization target.</param>
		/// <param name="itemSchema">The schema for collection items of the serialization target collection.</param>
		/// <param name="typeVerifier">The delegate which verifies loading type in runtime type polymorphism.</param>
		/// <returns>A new instance of the <see cref="PolymorphismSchema"/> class for collection object which uses type embedding based polymorphism.</returns>
		/// <exception cref="System.ArgumentNullException"><paramref name="targetType"/> is <c>null</c>.</exception>
		public static PolymorphismSchema ForPolymorphicCollection( Type targetType, PolymorphismSchema itemSchema, Func<PolymorphicTypeVerificationContext, bool> typeVerifier )
		{
			return
				new PolymorphismSchema(
					targetType,
					PolymorphismType.RuntimeType,
					typeVerifier,
					PolymorphismSchemaChildrenType.CollectionItems,
					itemSchema
				);
		}
Example #8
0
        // Collection items

        /// <summary>
        ///		Creates a new instance of the <see cref="PolymorphismSchema"/> class for collection object which uses declared type or context specified concrete type.
        /// </summary>
        /// <param name="targetType">The type of the serialization target.</param>
        /// <param name="itemSchema">The schema for collection items of the serialization target collection.</param>
        /// <returns>A new instance of the <see cref="PolymorphismSchema"/> class for collection object which uses declared type or context specified concrete type.</returns>
        /// <exception cref="System.ArgumentNullException"><paramref name="targetType"/> is <c>null</c>.</exception>
        public static PolymorphismSchema ForContextSpecifiedCollection(Type targetType, PolymorphismSchema itemSchema)
        {
            return
                (new PolymorphismSchema(
                     targetType,
                     PolymorphismType.None,
                     DefaultTypeVerfiier,
                     PolymorphismSchemaChildrenType.CollectionItems,
                     itemSchema
                     ));
        }
		// Collection items

		/// <summary>
		///		Creates a new instance of the <see cref="PolymorphismSchema"/> class for collection object which uses declared type or context specified concrete type.
		/// </summary>
		/// <param name="targetType">The type of the serialization target.</param>
		/// <param name="itemSchema">The schema for collection items of the serialization target collection.</param>
		/// <returns>A new instance of the <see cref="PolymorphismSchema"/> class for collection object which uses declared type or context specified concrete type.</returns>
		/// <exception cref="System.ArgumentNullException"><paramref name="targetType"/> is <c>null</c>.</exception>
		public static PolymorphismSchema ForContextSpecifiedCollection( Type targetType, PolymorphismSchema itemSchema )
		{
			return
				new PolymorphismSchema(
					targetType,
					PolymorphismType.None,
					DefaultTypeVerfiier,
					PolymorphismSchemaChildrenType.CollectionItems,
					itemSchema
				);
		}
Example #10
0
        internal static MessagePackSerializer CreateInternal(SerializationContext context, Type targetType, PolymorphismSchema schema)
        {
#if UNITY
            return
                ((
                     Delegate.CreateDelegate(
                         typeof(Func <SerializationContext, PolymorphismSchema, object>),
                         CreateInternal_2.MakeGenericMethod(targetType)
                         )
                     as Func <SerializationContext, PolymorphismSchema, object>)(context, schema) as MessagePackSerializer);
#else
            return
                ((CreateInternal_2.MakeGenericMethod(targetType).CreateDelegate(typeof(Func <SerializationContext, PolymorphismSchema, object>))
                  as Func <SerializationContext, PolymorphismSchema, object>)(context, schema) as MessagePackSerializer);
#endif // UNITY
        }
Example #11
0
        internal static MessagePackSerializer <T> CreateReflectionInternal <T>(SerializationContext context, Type concreteType, PolymorphismSchema schema)
        {
            if (concreteType.GetIsAbstract() || concreteType.GetIsInterface())
            {
                // return null for polymoirphic provider.
                return(null);
            }

            var serializer = context.Serializers.Get <T>(context);

            if (serializer != null)
            {
                // For MessagePack.Create compatibility.
                // Required for built-in types.
                return(serializer);
            }

            ValidateType(typeof(T));
            var traits =
#if !UNITY
                typeof(T).GetCollectionTraits(CollectionTraitOptions.WithAddMethod, context.CompatibilityOptions.AllowNonCollectionEnumerableTypes);
#else
                typeof(T).GetCollectionTraits(CollectionTraitOptions.WithAddMethod | CollectionTraitOptions.WithCountPropertyGetter, context.CompatibilityOptions.AllowNonCollectionEnumerableTypes);
#endif
            switch (traits.CollectionType)
            {
            case CollectionKind.Array:
            case CollectionKind.Map:
            {
                return
                    (#if !UNITY
                     ReflectionSerializerHelper.CreateCollectionSerializer <T>(context, concreteType, traits, (schema ?? PolymorphismSchema.Default)));
#else
                     Wrap <T>(
                         context,
                         ReflectionSerializerHelper.CreateCollectionSerializer <T>(context, concreteType, traits, (schema ?? PolymorphismSchema.Default))
                         );
#endif // !UNITY
            }

            default:
            {
                if (typeof(T).GetIsEnum())
                {
                    return(ReflectionSerializerHelper.CreateReflectionEnumMessagePackSerializer <T>(context));
                }
#if !NETFX_35 && !UNITY
                if (TupleItems.IsTuple(typeof(T)))
                {
                    return
                        (new ReflectionTupleMessagePackSerializer <T>(
                             context,
                             (schema ?? PolymorphismSchema.Default).ChildSchemaList
                             ));
                }
#endif // !NETFX_35 && !UNITY

                SerializationTarget.VerifyType(typeof(T));
                var target = SerializationTarget.Prepare(context, typeof(T));
                return(new ReflectionObjectMessagePackSerializer <T>(context, target, target.GetCapabilitiesForObject()));
            }
            }
        }
Example #12
0
        internal static MessagePackSerializer <T> CreateInternal <T>(SerializationContext context, PolymorphismSchema schema)
        {
#if DEBUG
            Contract.Ensures(Contract.Result <MessagePackSerializer <T> >() != null);
#endif // DEBUG

#if DEBUG && !AOT && !SILVERLIGHT
            SerializerDebugging.TraceEmitEvent(
                "SerializationContext::CreateInternal<{0}>(@{1}, {2})",
                typeof(T),
                context.GetHashCode(),
                schema == null ? "null" : schema.DebugString
                );
#endif // DEBUG && !AOT && !SILVERLIGHT
            Type             concreteType     = null;
            CollectionTraits collectionTraits =
#if AOT
                typeof(T).GetCollectionTraits(CollectionTraitOptions.None, context.CompatibilityOptions.AllowNonCollectionEnumerableTypes);
#else
                typeof(T).GetCollectionTraits(CollectionTraitOptions.Full, context.CompatibilityOptions.AllowNonCollectionEnumerableTypes);
#endif // AOT

            if (typeof(T).GetIsAbstract() || typeof(T).GetIsInterface())
            {
                // Abstract collection types will be handled correctly.
                if (collectionTraits.CollectionType != CollectionKind.NotCollection)
                {
                    concreteType = context.DefaultCollectionTypes.GetConcreteType(typeof(T));
                }

                if (concreteType == null)
                {
                    // return null for polymoirphic provider.
                    return(null);
                }

                ValidateType(concreteType);
            }
            else
            {
                ValidateType(typeof(T));
            }

#if FEATURE_EMIT
            ISerializerBuilder builder;
            switch (context.SerializerOptions.EmitterFlavor)
            {
            case EmitterFlavor.CodeDomBased:
            {
#if DEBUG
                if (!SerializerDebugging.OnTheFlyCodeGenerationEnabled)
                {
                    throw new NotSupportedException(
                              String.Format(
                                  CultureInfo.CurrentCulture,
                                  "Flavor '{0:G}'({0:D}) is not supported for serializer instance creation.",
                                  context.SerializerOptions.EmitterFlavor
                                  )
                              );
                }

                builder = new CodeDomSerializerBuilder(typeof(T), collectionTraits);
                break;
#else
                throw new NotSupportedException();
#endif
            }

            case EmitterFlavor.FieldBased:
            {
                builder = new AssemblyBuilderSerializerBuilder(typeof(T), collectionTraits);
                break;
            }

            default:                     // EmitterFlavor.ReflectionBased
            {
#endif // FEATURE_EMIT
            return
                (GenericSerializer.TryCreateAbstractCollectionSerializer(context, typeof(T), concreteType, schema) as MessagePackSerializer <T>
                 ?? CreateReflectionInternal <T>(context, concreteType ?? typeof(T), schema));

#if FEATURE_EMIT
        }
    }

    return((MessagePackSerializer <T>)builder.BuildSerializerInstance(context, concreteType, schema == null ? null : schema.FilterSelf()));
#endif // FEATURE_EMIT
        }
		/// <summary>
		///		Gets the <see cref="MessagePackSerializer{T}"/> with this instance.
		/// </summary>
		/// <typeparam name="T">Type of serialization/deserialization target.</typeparam>
		/// <param name="providerParameter">A provider specific parameter. See remarks section for details.</param>
		/// <returns>
		///		<see cref="MessagePackSerializer{T}"/>.
		///		If there is exiting one, returns it.
		///		Else the new instance will be created.
		/// </returns>
		/// <remarks>
		///		<para>
		///			This method automatically register new instance via <see cref="SerializerRepository.Register{T}(MessagePackSerializer{T})"/>.
		///		</para>
		///		<para>
		///			Currently, only following provider parameters are supported.
		///			<list type="table">
		///				<listheader>
		///					<term>Target type</term>
		///					<description>Provider parameter</description>
		///				</listheader>
		///				<item>
		///					<term><see cref="EnumMessagePackSerializer{TEnum}"/> or its descendants.</term>
		///					<description><see cref="EnumSerializationMethod"/>. The returning instance corresponds to this value for serialization.</description>
		///				</item>
		///			</list>
		///			<note><c>null</c> is valid value for <paramref name="providerParameter"/> and it indeicates default behavior of parameter.</note>
		///		</para>
		/// </remarks>
		public MessagePackSerializer<T> GetSerializer<T>( object providerParameter )
		{
#if DEBUG
			Contract.Ensures( Contract.Result<MessagePackSerializer<T>>() != null );
#endif // DEBUG

			// Explicitly generated serializer should always used, so get it first.
			MessagePackSerializer<T> serializer = this._serializers.Get<T>( this, providerParameter );

			if ( serializer != null )
			{
				return serializer;
			}

			bool lockTaken = false;
			lock ( this._generationLock )
			{
				// Re-get to check because other thread might create the serializer when I wait the lock.
				serializer = this._serializers.Get<T>( this, providerParameter );

				if ( serializer != null )
				{
					return serializer;
				}

				try
				{
					try { }
					finally
					{
#if !FEATURE_CONCURRENT
						lock ( this._typeLock )
						{
							var typeLock = new object();
							object aquiredLock;
							lockTaken = !this._typeLock.TryGetValue( typeof( T ), out aquiredLock );
							if ( lockTaken )
							{
								this._typeLock.Add( typeof( T ), typeLock );
							}
						}
#else
						var typeLock = new object();
						var aquiredTypeLock = this._typeLock.GetOrAdd( typeof( T ), _ => typeLock );
						lockTaken = typeLock == aquiredTypeLock;
#endif // !FEATURE_CONCURRENT
					}

					if ( lockTaken )
					{
						// First try to create generic serializer w/o code generation.
						var schema = ( providerParameter ?? PolymorphismSchema.Create( typeof( T ), null ) ) as PolymorphismSchema;
						serializer = GenericSerializer.Create<T>( this, schema );

						if ( serializer == null )
						{
#if !UNITY
							if ( !this._serializerGeneratorOptions.CanRuntimeCodeGeneration )
							{
#endif // !UNITY
								// On debugging, or AOT only envs, use reflection based aproach.
								serializer =
									this.GetSerializerWithoutGeneration<T>( schema )
									?? this.OnResolveSerializer<T>( schema )
									?? MessagePackSerializer.CreateReflectionInternal<T>( this, this.EnsureConcreteTypeRegistered( typeof( T ) ), schema );
#if !UNITY
							}
							else
							{
								// This thread creating new type serializer.
								serializer = this.OnResolveSerializer<T>( schema ) ?? MessagePackSerializer.CreateInternal<T>( this, schema );
							}
#endif // !UNITY
						}
					}
					else
					{
						// This thread owns existing lock -- thus, constructing self-composite type.
						return new LazyDelegatingMessagePackSerializer<T>( this, providerParameter );
					}


					// Some types always have to use provider. 
					MessagePackSerializerProvider provider;
					var asEnumSerializer = serializer as ICustomizableEnumSerializer;
					if ( asEnumSerializer != null )
					{
#if DEBUG
						Contract.Assert( typeof( T ).GetIsEnum(), typeof( T ) + " is not enum but generated serializer is ICustomizableEnumSerializer" );
#endif // DEBUG

						provider = new EnumMessagePackSerializerProvider( typeof( T ), asEnumSerializer );
					}
					else
					{
#if DEBUG
						Contract.Assert( !typeof( T ).GetIsEnum(), typeof( T ) + " is enum but generated serializer is not ICustomizableEnumSerializer : " + ( serializer == null ? "null" : serializer.GetType().FullName ) );
#endif // DEBUG

						// Creates provider even if no schema -- the schema might be specified future for the type.
						// It is OK to use polymorphic provider for value type.
#if !UNITY
						provider = new PolymorphicSerializerProvider<T>( serializer );
#else
						provider = new PolymorphicSerializerProvider<T>( this, serializer );
#endif // !UNITY
					}

#if !UNITY
					Type nullableType;
					MessagePackSerializerProvider nullableSerializerProvider;
					SerializerRepository.GetNullableCompanion(
						typeof( T ),
						this,
						serializer,
						out nullableType,
						out nullableSerializerProvider
					);

					this._serializers.Register(
						typeof( T ),
						provider,
						nullableType,
						nullableSerializerProvider,
						SerializerRegistrationOptions.WithNullable
					);
#else
					this._serializers.Register(
						typeof( T ),
						provider,
						null,
						null,
						SerializerRegistrationOptions.None
					);
#endif // !UNITY

					// Re-get to avoid duplicated registration and handle provider parameter or get the one created by prececing thread.
					// If T is null and schema is not provided or default schema is provided, then exception will be thrown here from the new provider.
					return this._serializers.Get<T>( this, providerParameter );
				}
				finally
				{
					if ( lockTaken )
					{
#if !FEATURE_CONCURRENT
					lock ( this._typeLock )
					{
						this._typeLock.Remove( typeof( T ) );
					}
#else
						object dummy;
						this._typeLock.TryRemove( typeof( T ), out dummy );
#endif // !FEATURE_CONCURRENT
					}
				}
			}
		}
Example #14
0
        public static void TracePolimorphicSchemaEvent(string format, MemberInfo memberInfo, PolymorphismSchema schema)
        {
#if DEBUG
#if FEATURE_EMIT
            if (!_traceEnabled)
            {
                return;
            }

            Tracer.Emit.TraceEvent(Tracer.EventType.PolimorphicSchema, Tracer.EventId.PolimorphicSchema, format, memberInfo, schema == null ? "(null)" : schema.DebugString);
#endif // FEATURE_EMIT
#endif
        }
		// Tuple items

		/// <summary>
		///		Creates a new instance of the <see cref="PolymorphismSchema"/> class for <see cref="Tuple"/> object.
		/// </summary>
		/// <param name="targetType">The type of the serialization target.</param>
		/// <param name="itemSchemaList">The schema for collection items of the serialization target tuple. <c>null</c> or empty indicates all items do not have any polymorphism.</param>
		/// <returns>A new instance of the <see cref="PolymorphismSchema"/> class for <see cref="Tuple"/> object.</returns>
		/// <exception cref="System.ArgumentNullException"><paramref name="targetType"/> is <c>null</c>.</exception>
		/// <exception cref="System.ArgumentException">A count of <paramref name="itemSchemaList"/> does not match for an arity of the tuple type specified as <paramref name="targetType"/>.</exception>
		public static PolymorphismSchema ForPolymorphicTuple( Type targetType, PolymorphismSchema[] itemSchemaList )
		{
			VerifyArity( targetType, itemSchemaList );
			return
				new PolymorphismSchema(
					targetType,
					PolymorphismType.None,
					DefaultTypeVerfiier,
					PolymorphismSchemaChildrenType.TupleItems,
					itemSchemaList
				);
		}
		/// <summary>
		///		Creates a new instance of the <see cref="PolymorphismSchema"/> class for collection object which uses type embedding based polymorphism.
		/// </summary>
		/// <param name="targetType">The type of the serialization target.</param>
		/// <param name="itemSchema">The schema for collection items of the serialization target collection.</param>
		/// <returns>A new instance of the <see cref="PolymorphismSchema"/> class for collection object which uses type embedding based polymorphism.</returns>
		/// <exception cref="System.ArgumentNullException"><paramref name="targetType"/> is <c>null</c>.</exception>
		public static PolymorphismSchema ForPolymorphicCollection( Type targetType, PolymorphismSchema itemSchema )
		{
			return
				new PolymorphismSchema(
					targetType,
					PolymorphismType.RuntimeType,
					DefaultTypeVerfiier,
					PolymorphismSchemaChildrenType.CollectionItems,
					itemSchema
				);
		}
			public MessagePackSerializer Activate( SerializationContext context, PolymorphismSchema schema )
			{
				if ( this._constructor1 == null && this._constructor3 == null )
				{
					throw new Exception( "A cosntructor of type '" + this._serializerType.FullName + "' is not found." );
				}

#if !UNITY
				MessagePackSerializer<T> serializer;
				if ( this._constructor1 != null )
				{
					serializer = ( MessagePackSerializer<T> )this._constructor1.InvokePreservingExceptionType( context );
				}
				else
				{
					serializer = ( MessagePackSerializer<T> )this._constructor3.InvokePreservingExceptionType( context, this._serializationTargetType, null );
				}

				return new PolymorphicSerializerProvider<T>( serializer ).Get( context, schema ?? PolymorphismSchema.Default ) as MessagePackSerializer;
#else
				MessagePackSerializer serializer;
				if ( this._constructor1 != null )
				{
					serializer = this._constructor1.InvokePreservingExceptionType( context ) as MessagePackSerializer;
				}
				else
				{
					serializer = this._constructor3.InvokePreservingExceptionType( context, this._serializationTargetType, null ) as MessagePackSerializer;
				}

				return 
					ReflectionExtensions.CreateInstancePreservingExceptionType<MessagePackSerializerProvider>(
						typeof( PolymorphicSerializerProvider<> ).MakeGenericType( this._targetType ),
						context,
						serializer
					).Get( context, schema ?? PolymorphismSchema.Default ) as MessagePackSerializer;
#endif // !UNITY
			}
Example #18
0
        public static void TracePolimorphicSchemaEvent(string format, MemberInfo memberInfo, PolymorphismSchema schema)
        {
#if DEBUG
#if !UNITY && !SILVERLIGHT && !WINDOWS_UWP
            if (!_traceEnabled)
            {
                return;
            }

            Tracer.Emit.TraceEvent(Tracer.EventType.PolimorphicSchema, Tracer.EventId.PolimorphicSchema, format, memberInfo, schema == null ? "(null)" : schema.DebugString);
#endif // !UNITY && !SILVERLIGHT && !WINDOWS_UWP
#endif
        }