IClientBuilder IClientBuilder.SetSerializer(ISerializerBuilder serializerBuilder)
{
if (serializerBuilder == null)
{
throw new ArgumentNullException(nameof(serializerBuilder));
}
this.serializerBuilder = serializerBuilder;
return(this);
}
public AutoMessagePackSerializer(
SerializationContext context, ISerializerBuilder <T> builder)
: base(context)
{
var serializer = context.Serializers.Get <T>(context);
if (serializer != null)
{
// For MessagePack.Create compatibility.
// Required for built-in types.
this._underlying = serializer;
return;
}
serializer = builder.BuildSerializerInstance(context);
Contract.Assert(serializer != null);
this._underlying = serializer;
}
protected override void Configure(ISerializerBuilder builder)
{
builder.AddJsonSerializer(isSupported: type => type.GetCustomAttribute <MyJsonSerializableAttribute>(inherit: false) is not null);
}
private static void TestCore(EmitterFlavor emittingFlavor, SerializationMethod serializationMethod, ISerializerBuilder generator)
{
var root = new DirectoryItem()
{
Name = "/"
};
root.Directories =
new[]
{
new DirectoryItem()
{
Name = "tmp/"
},
new DirectoryItem()
{
Name = "var/",
Directories = new DirectoryItem[0],
Files = new [] { new FileItem()
{
Name = "system.log"
} }
}
};
root.Files = new FileItem[0];
var context =
new SerializationContext
{
SerializationMethod = serializationMethod,
SerializerOptions =
{
#if !NETSTANDARD1_3
GeneratorOption = SerializationMethodGeneratorOption.CanDump,
#endif // !NETSTANDARD1_3
EmitterFlavor = emittingFlavor
}
};
var serializer =
(MessagePackSerializer <DirectoryItem>)generator.BuildSerializerInstance(
context,
typeof(DirectoryItem),
PolymorphismSchema.Default
);
using (var memoryStream = new MemoryStream())
{
serializer.Pack(memoryStream, root);
memoryStream.Position = 0;
var result = serializer.Unpack(memoryStream);
Assert.That(result.Name, Is.EqualTo("/"));
Assert.That(result.Files, Is.Not.Null.And.Empty);
Assert.That(result.Directories, Is.Not.Null.And.Length.EqualTo(2));
Assert.That(result.Directories[0], Is.Not.Null);
Assert.That(result.Directories[0].Name, Is.EqualTo("tmp/"));
Assert.That(result.Directories[0].Files, Is.Null);
Assert.That(result.Directories[0].Directories, Is.Null);
Assert.That(result.Directories[1], Is.Not.Null);
Assert.That(result.Directories[1].Name, Is.EqualTo("var/"));
Assert.That(result.Directories[1].Files, Is.Not.Null.And.Length.EqualTo(1));
Assert.That(result.Directories[1].Files[0], Is.Not.Null);
Assert.That(result.Directories[1].Files[0].Name, Is.EqualTo("system.log"));
Assert.That(result.Directories[1].Directories, Is.Not.Null.And.Empty);
}
}
private static void TestCore( EmitterFlavor emittingFlavor, SerializationMethod serializationMethod, ISerializerBuilder generator )
{
var root = new DirectoryItem() { Name = "/" };
root.Directories =
new[]
{
new DirectoryItem() { Name = "tmp/" },
new DirectoryItem()
{
Name = "var/",
Directories = new DirectoryItem[ 0 ],
Files = new []{ new FileItem(){ Name = "system.log" } }
}
};
root.Files = new FileItem[ 0 ];
var context =
new SerializationContext
{
SerializationMethod = serializationMethod,
SerializerOptions =
{
GeneratorOption = SerializationMethodGeneratorOption.CanDump,
EmitterFlavor = emittingFlavor
}
};
var serializer =
( MessagePackSerializer<DirectoryItem> ) generator.BuildSerializerInstance(
context,
typeof( DirectoryItem ),
PolymorphismSchema.Default
);
using ( var memoryStream = new MemoryStream() )
{
serializer.Pack( memoryStream, root );
memoryStream.Position = 0;
var result = serializer.Unpack( memoryStream );
Assert.That( result.Name, Is.EqualTo( "/" ) );
Assert.That( result.Files, Is.Not.Null.And.Empty );
Assert.That( result.Directories, Is.Not.Null.And.Length.EqualTo( 2 ) );
Assert.That( result.Directories[ 0 ], Is.Not.Null );
Assert.That( result.Directories[ 0 ].Name, Is.EqualTo( "tmp/" ) );
Assert.That( result.Directories[ 0 ].Files, Is.Null );
Assert.That( result.Directories[ 0 ].Directories, Is.Null );
Assert.That( result.Directories[ 1 ], Is.Not.Null );
Assert.That( result.Directories[ 1 ].Name, Is.EqualTo( "var/" ) );
Assert.That( result.Directories[ 1 ].Files, Is.Not.Null.And.Length.EqualTo( 1 ) );
Assert.That( result.Directories[ 1 ].Files[ 0 ], Is.Not.Null );
Assert.That( result.Directories[ 1 ].Files[ 0 ].Name, Is.EqualTo( "system.log" ) );
Assert.That( result.Directories[ 1 ].Directories, Is.Not.Null.And.Empty );
}
}
public SerDesBuilder(IMemoryPolicy policy)
{
_serBuilder = new SerializerBuilder();
_desBuilder = new DeserializerBuilder(policy);
}
protected virtual void Configure(ISerializerBuilder builder)
{
}
IClient IClientBuilder.Build()
{
if (this.apiKey == null)
{
if (this.clientApiKeyBuilder != null)
{
this.apiKey = this.clientApiKeyBuilder.Build();
}
else
{
throw new ApplicationException("No valid API Key and Secret could be found.");
}
}
var logger = this.logger ?? new NullLogger();
IJsonSerializer serializer = null;
if (this.overrideSerializer != null)
{
serializer = this.overrideSerializer;
}
else
{
if (this.serializerBuilder == null)
{
this.logger.Info("No serializer plugin specified, using default.");
this.serializerBuilder = Serializers.Create().AutoDetect();
}
serializer = this.serializerBuilder.Build();
}
IHttpClient httpClient = null;
if (this.overrideHttpClient != null)
{
httpClient = this.overrideHttpClient;
}
else
{
if (this.httpClientBuilder == null)
{
this.logger.Info("No HTTP client plugin specified, using default.");
this.httpClientBuilder = HttpClients.Create().AutoDetect();
}
this.httpClientBuilder
.SetBaseUrl(this.baseUrl)
.SetConnectionTimeout(this.connectionTimeout)
.SetProxy(this.proxy)
.SetLogger(this.logger);
httpClient = this.httpClientBuilder.Build();
}
if (this.cacheProvider == null)
{
this.logger.Info("No CacheProvider configured. Defaulting to in-memory CacheProvider with default TTL and TTI of one hour.");
this.cacheProvider = Caches
.NewInMemoryCacheProvider()
.WithDefaultTimeToIdle(TimeSpan.FromHours(1))
.WithDefaultTimeToLive(TimeSpan.FromHours(1))
.Build();
}
else
{
var injectableWithSerializer = this.cacheProvider as ISerializerConsumer <ICacheProvider>;
if (injectableWithSerializer != null)
{
injectableWithSerializer.SetSerializer(serializer);
}
var injectableWithLogger = this.cacheProvider as ILoggerConsumer <ICacheProvider>;
if (injectableWithLogger != null)
{
injectableWithLogger.SetLogger(this.logger);
}
}
return(new DefaultClient(
this.apiKey,
this.baseUrl,
this.authenticationScheme,
this.connectionTimeout,
this.proxy,
httpClient,
serializer,
this.cacheProvider,
this.userAgentBuilder,
logger,
DefaultIdentityMapSlidingExpiration));
}
private static void TestCore(EmitterFlavor emittingFlavor, SerializationMethod serializationMethod, ISerializerBuilder <DirectoryItem> generator)
{
var root = new DirectoryItem()
{
Name = "/"
};
root.Directories =
new[]
{
new DirectoryItem()
{
Name = "tmp/"
},
new DirectoryItem()
{
Name = "var/",
Directories = new DirectoryItem[0],
Files = new [] { new FileItem()
{
Name = "system.log"
} }
}
};
root.Files = new FileItem[0];
var serializer =
new AutoMessagePackSerializer <DirectoryItem>(
new SerializationContext
{
EmitterFlavor = emittingFlavor,
SerializationMethod = serializationMethod,
#if SILVERLIGHT
GeneratorOption = SerializationMethodGeneratorOption.Fast
#else
GeneratorOption = SerializationMethodGeneratorOption.CanDump
#endif
},
private static void TestCore( EmitterFlavor emittingFlavor, SerializationMethod serializationMethod, ISerializerBuilder<DirectoryItem> generator )
{
var root = new DirectoryItem() { Name = "/" };
root.Directories =
new[]
{
new DirectoryItem() { Name = "tmp/" },
new DirectoryItem()
{
Name = "var/",
Directories = new DirectoryItem[ 0 ],
Files = new []{ new FileItem(){ Name = "system.log" } }
}
};
root.Files = new FileItem[ 0 ];
var serializer =
new AutoMessagePackSerializer<DirectoryItem>(
new SerializationContext
{
EmitterFlavor = emittingFlavor,
SerializationMethod = serializationMethod,
#if SILVERLIGHT
GeneratorOption = SerializationMethodGeneratorOption.Fast
#else
GeneratorOption = SerializationMethodGeneratorOption.CanDump
#endif
},
generator
);
using ( var memoryStream = new MemoryStream() )
{
serializer.Pack( memoryStream, root );
memoryStream.Position = 0;
var result = serializer.Unpack( memoryStream );
Assert.That( result.Name, Is.EqualTo( "/" ) );
Assert.That( result.Files, Is.Not.Null.And.Empty );
Assert.That( result.Directories, Is.Not.Null.And.Length.EqualTo( 2 ) );
Assert.That( result.Directories[ 0 ], Is.Not.Null );
Assert.That( result.Directories[ 0 ].Name, Is.EqualTo( "tmp/" ) );
Assert.That( result.Directories[ 0 ].Files, Is.Null );
Assert.That( result.Directories[ 0 ].Directories, Is.Null );
Assert.That( result.Directories[ 1 ], Is.Not.Null );
Assert.That( result.Directories[ 1 ].Name, Is.EqualTo( "var/" ) );
Assert.That( result.Directories[ 1 ].Files, Is.Not.Null.And.Length.EqualTo( 1 ) );
Assert.That( result.Directories[ 1 ].Files[ 0 ], Is.Not.Null );
Assert.That( result.Directories[ 1 ].Files[ 0 ].Name, Is.EqualTo( "system.log" ) );
Assert.That( result.Directories[ 1 ].Directories, Is.Not.Null.And.Empty );
}
}
