public async Task <IConnection> Connect()
{
var tcpClient = new TcpClient
{
NoDelay = true,
ReceiveTimeout = 0,
SendTimeout = 0,
ReceiveBufferSize = 256,
SendBufferSize = 256
};
config.Register <TcpClient>()
.ImplementedBy(c => tcpClient)
.As <Singleton>();
var container = config.Create();
config.Register <IContainer>()
.ImplementedBy(c => c)
.As <Singleton>();
var connection = container.Resolve <IConnection>();
config.Register <IConnection>()
.ImplementedBy(c => connection)
.As <Singleton>();
var communicator = container.Resolve <ITransport>();
await communicator.Connect().ConfigureAwait(false);
return(connection);
}
public HandlerBuilder <TData, TCommand> Call <THandler>()
where THandler : IHandler <TData, TCommand>
{
using (var container = config.Create())
{
container.Resolve <ISerializerConfig>()
.Match <TData>();
container.Resolve <CommandCollection>()
.Add <TData, TCommand>();
container.Resolve <HandlerCollection>()
.Add <TData, TCommand, THandler>();
return(this);
}
}
public CommandRaiser(IContainerConfig config)
{
this.config = config;
using (var container = config.Create())
{
commandHolder = container.Resolve <ICommandHolder>();
}
}
public ConverterDto TryGetDto(Type type)
{
var converterDto = TryGetDtoRecursive(type);
if (converterDto != null)
{
if (converterDto.Converter == null && converterDto.ConverterType != null)
{
using (var container = config.Create())
{
converterDto.Converter = (IConverter)container.Resolve(converterDto.ConverterType);
}
}
}
return(converterDto);
}
public async Task Run()
{
using (var rootContainer = config.Create())
{
var configuration = rootContainer.Resolve <IConfiguration>();
var tcpListener = new TcpListener(new IPEndPoint(IPAddress.Parse(configuration.Host), configuration.Port));
tcpListener.Start();
while (true)
{
var tcpClient = await tcpListener.AcceptTcpClientAsync().ConfigureAwait(false);
tcpClient.NoDelay = true;
tcpClient.ReceiveTimeout = 0;
tcpClient.SendTimeout = 0;
tcpClient.ReceiveBufferSize = 256;
tcpClient.SendBufferSize = 256;
var scope = config.CreateScope();
scope.Register <IContainerConfig>()
.ImplementedBy(c => scope)
.As <Singleton>();
var container = scope.Create();
scope.Register <IContainer>()
.ImplementedBy(c => c)
.As <Singleton>();
scope.Register <TcpClient>()
.ImplementedBy(c => tcpClient)
.As <Singleton>();
var connection = container.Resolve <IConnection>();
scope.Register <IConnection>()
.ImplementedBy(c => connection)
.As <Singleton>();
}
}
}
public Connection(IContainerConfig config)
{
config.Register <IPacketsComposer>()
.ImplementedBy <PacketsComposer>()
.As <Singleton>();
config.Register <IMessageComposer>()
.ImplementedBy <MessageComposer>()
.As <Singleton>();
config.Register <ICommandRaiser>()
.ImplementedBy <CommandRaiser>()
.As <Singleton>();
config.Register <ITransport>()
.ImplementedBy <Transport>()
.As <Singleton>();
container = config.Create();
receiveLoopTask = Task.Run(ReceiveLoop);
}