public EntityPropertiesTests() { var context = new SerializationContext(); context.SerializationMethod = SerializationMethod.Map; _serializer = context.GetSerializer<BasicEntity>(); }
public BatchedWebServiceTarget(IBatchWebService WebService = null) { this.logEventSerializer = MessagePackSerializer.Get<Dictionary<String,String>>(); this.logBatchSerializer = BatchedWebService.PayLoadSerializer.getSerializer(); if (WebService == null) { this.webService = new BatchWebService(); }else { this.webService = WebService; } this.Layout = new DictionaryLayout(); this.Layout.Attributes.Add(new DictionaryLayoutAttribute("time", "${longdate}")); this.Layout.Attributes.Add(new DictionaryLayoutAttribute("level", "${level:upperCase=True}")); this.Layout.Attributes.Add(new DictionaryLayoutAttribute("message", "${message}")); this.Layout.Attributes.Add(new DictionaryLayoutAttribute("exception", "${exception:format=ToString,Message,StackTrace}")); }
public TypedMessagePackSerializerWrapper(SerializationContext context, MessagePackSerializer underlying) : base(context) { this._underlyingSerializer = underlying; this._underlyingFactory = underlying as ICollectionInstanceFactory; }
public static T InvokeUnpackFrom <T>(MessagePackSerializer <T> serializer, Unpacker unpacker) { return(serializer.UnpackFromCore(unpacker)); }
public static void UnpackMapTo <TKey, TValue>(Unpacker unpacker, MessagePackSerializer <TKey> keySerializer, MessagePackSerializer <TValue> valueSerializer, IDictionary <TKey, TValue> dictionary) { #if DEBUG if (unpacker == null) { throw new ArgumentNullException("unpacker"); } if (dictionary == null) { throw new ArgumentNullException("dictionary"); } if (!unpacker.IsMapHeader) { throw SerializationExceptions.NewIsNotMapHeader(); } Contract.EndContractBlock(); #endif int count = GetItemsCount(unpacker); for (int i = 0; i < count; i++) { if (!unpacker.Read()) { throw SerializationExceptions.NewMissingItem(i); } TKey key; if (!unpacker.IsArrayHeader && !unpacker.IsMapHeader) { key = keySerializer.UnpackFrom(unpacker); } else { using (Unpacker subtreeUnpacker = unpacker.ReadSubtree()) { key = keySerializer.UnpackFrom(subtreeUnpacker); } } if (!unpacker.Read()) { throw SerializationExceptions.NewMissingItem(i); } TValue value; if (!unpacker.IsArrayHeader && !unpacker.IsMapHeader) { value = valueSerializer.UnpackFrom(unpacker); } else { using (Unpacker subtreeUnpacker = unpacker.ReadSubtree()) { value = valueSerializer.UnpackFrom(subtreeUnpacker); } } dictionary.Add(key, value); } }
private MessagePackSerializer <T> CreateTarget <T>(SerializationContext context) { return(MessagePackSerializer.CreateInternal <T>(context, PolymorphismSchema.Default)); }
internal static MessagePackSerializer <T> Wrap <T>(SerializationContext context, MessagePackSerializer nonGeneric) { return (nonGeneric == null ? null : (nonGeneric as TypedMessagePackSerializerWrapper <T>) ?? ( nonGeneric is ICustomizableEnumSerializer ? new EnumTypedMessagePackSerializerWrapper <T>(context, nonGeneric) : new TypedMessagePackSerializerWrapper <T>(context, nonGeneric) )); }
/// <summary> /// Creates new <see cref="MessagePackSerializer{T}"/> instance with <see cref="SerializationContext.Default"/>. /// </summary> /// <typeparam name="T">Target type.</typeparam> /// <returns> /// New <see cref="MessagePackSerializer{T}"/> instance to serialize/deserialize the object tree which the top is <typeparamref name="T"/>. /// </returns> public static MessagePackSerializer <T> Create <T>() { Contract.Ensures(Contract.Result <MessagePackSerializer <T> >() != null); return(MessagePackSerializer.Create <T>(SerializationContext.Default)); }
/// <summary> /// Creates new <see cref="IMessagePackSerializer"/> instance with <see cref="SerializationContext.Default"/>. /// </summary> /// <param name="targetType">Target type.</param> /// <returns> /// New <see cref="IMessagePackSingleObjectSerializer"/> instance to serialize/deserialize the object tree which the top is <paramref name="targetType"/>. /// </returns> /// <exception cref="ArgumentNullException"> /// <paramref name="targetType"/> is <c>null</c>. /// </exception> /// <remarks> /// To avoid boxing and strongly typed API is prefered, use <see cref="Create{T}()"/> instead when possible. /// </remarks> public static IMessagePackSingleObjectSerializer Create(Type targetType) { return(MessagePackSerializer.Create(targetType, SerializationContext.Default)); }
/// <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 } } } }
public TestValueTypeWrapperSerializer(SerializationContext context) : base(context) { this._serializer0 = context.GetSerializer <TestValueType>(PolymorphismSchema.Default); }
private MessagePackSerializer <T> CreateTarget <T>(SerializationContext context) { return(MessagePackSerializer.CreateInternal <T>(context)); }
public void TestCreation_ReferenceType_AllOk() { Assert.NotNull(MessagePackSerializer.Create <NilImplicationTestTargetForReferenceType>(this.CreateSerializationContext())); }