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 void Add <TEvent>()
where TEvent : class, IEvent <object>
{
var @event = typeof(TEvent);
if (!events.ContainsValue(@event))
{
config.Register <TEvent>();
events.Add(GetHash(@event.Name), @event);
}
}
public void Add <TData, TCommand>()
where TCommand : ICommand <TData>
{
var command = typeof(TCommand);
for (var i = 0; i < commands.Count; i++)
{
if (commands[i].CommandType == command)
{
return;
}
}
config.Register <TCommand>();
commands.Add(new CommandDto(GetHash(command.Name), command));
}
public void UseEncryption <TEncryption>()
where TEncryption : IEncryption
{
config.Register <IEncryption>()
.ImplementedBy <TEncryption>()
.As <Singleton>();
}
public SerializerConfig()
{
config = new ContainerConfig();
config.Register <IActivator>()
.ImplementedBy(c => new ActivatorConfig().Create())
.As <Singleton>();
var innerScope = config.CreateScope();
converterContainer = new ConverterContainer(innerScope);
Match <byte>().With <Core.ByteConverter>();
Match <sbyte>().With <SByteConverter>();
Match <short>().With <ShortConverter>();
Match <ushort>().With <UShortConverter>();
Match <int>().With <Int32Converter>();
Match <uint>().With <UInt32Converter>();
Match <long>().With <Int64Converter>();
Match <ulong>().With <UInt64Converter>();
Match <string>().With <StringConverter>();
Match <bool>().With <BoolConverter>();
Match <float>().With <SingleConverter>();
Match <double>().With <DoubleConverter>();
Match <DateTime>().With <DateTimeConverter>();
Match <Array>().With <ArrayConverter>();
Match <IList>().With <IListConverter>();
Match <ICollection>().With <CollectionConverter>();
Match <IEnumerable>().With <IEnumerableConverter>();
Match <Guid>().With <GuidConverter>();
config = innerScope;
converterContainer = new ConverterContainer(config, converterContainer);
}
public void With <TConverter>()
where TConverter : IConverter <TData>
{
converters.RegisterConverterTypeFor(typeof(TData), typeof(TConverter));
scope.Register <TConverter>()
.As <Singleton>();
}
public ICompressionBuilder UseSerializer <TSerializer>()
where TSerializer : ISerializer
{
config.Register <ISerializer>()
.ImplementedBy <TSerializer>()
.As <Singleton>();
return(new CompressionBuilder(config));
}
public IEncryptionBuilder UseCompression <TCompression>()
where TCompression : ICompression
{
config.Register <ICompression>()
.ImplementedBy <TCompression>()
.As <Singleton>();
return(new EncryptionBuilder(config));
}
public void Add <TData, TCommand, THandler>()
where TCommand : ICommand <TData>
where THandler : IHandler <TData, TCommand>
{
var command = typeof(TCommand);
var handler = typeof(THandler);
if (handlers.TryGetValue(command, out var list))
{
list.Add(new HandlerDto(handler));
}
else
{
config.Register <THandler>();
handlers.Add(command, new List <IHandlerDto> {
new HandlerDto(handler)
});
}
}
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);
}
public Connection(IContainerConfig config)
{
config.Register <IPacketsComposer>()
.ImplementedBy <PacketsComposer>()
.As <Singleton>();
config.Register <IMessageComposer>()
.ImplementedBy <MessageComposer>()
.As <Singleton>();
config.Register <IEventRaiser>()
.ImplementedBy <EventRaiser>()
.As <Singleton>();
config.Register <ICommunicator>()
.ImplementedBy <Communicator>()
.As <Singleton>();
container = config.Container;
Task.Run(async() => await ReceiveLoop());
}
protected ApplicationConfig()
{
var rootConfig = new ContainerConfig();
rootConfig.Register <ISerializerConfig>()
.ImplementedBy(c => new SerializerConfig())
.As <Singleton>();
rootConfig.Register <ISerializer>()
.ImplementedBy(c => c.Resolve <ISerializerConfig>().Create())
.As <Singleton>();
rootConfig.Register <IArrayPool>()
.ImplementedBy(c => new ArrayPoolConfig().Create())
.As <Singleton>();
rootConfig.Register <ICompression>()
.ImplementedBy <Compression>()
.As <Singleton>();
rootConfig.Register <IEncryption>()
.ImplementedBy <Encryption>()
.As <Singleton>();
rootConfig.Register <IConnection>()
.ImplementedBy <Connection>()
.As <Transient>();
rootConfig.Register <CommandCollection>()
.ImplementedBy <CommandCollection>()
.As <Singleton>();
rootConfig.Register <HandlerCollection>()
.ImplementedBy <HandlerCollection>()
.As <Singleton>();
rootConfig.Register <ICommandHolder>()
.ImplementedBy <CommandHolder>()
.As <Singleton>();
rootConfig.Register <Disconnect>();
rootConfig.Register <Connect>();
rootConfig.Register <Error>();
config = rootConfig.CreateScope();
config.Register <IContainerConfig>()
.ImplementedBy(c => config)
.As <Singleton>();
}
protected NodeConfig()
{
rootConfig.Register <ISerializer>()
.ImplementedBy <Serializer>()
.As <Singleton>();
rootConfig.Register <ICompression>()
.ImplementedBy <Compression>()
.As <Singleton>();
rootConfig.Register <IEncryption>()
.ImplementedBy <Encryption>()
.As <Singleton>();
rootConfig.Register <IConnection>()
.ImplementedBy <Connection>()
.As <Transient>();
rootConfig.Register <EventCollection>()
.ImplementedBy <EventCollection>()
.As <Singleton>();
rootConfig.Register <HandlerCollection>()
.ImplementedBy <HandlerCollection>()
.As <Singleton>();
rootConfig.Register <IEventHolder>()
.ImplementedBy <EventHolder>()
.As <Singleton>();
rootConfig.Register <Disconnect>();
rootConfig.Register <Error>();
Config = rootConfig.Scope();
Config.Register <IContainerConfig>()
.ImplementedBy(c => Config)
.As <Singleton>();
}
public ICompressionBuilder UseSerializer <TSerializer>(TSerializer serializer = default)
where TSerializer : ISerializer
{
var registry = config.Register <ISerializer>();
if (serializer == null)
{
registry.ImplementedBy <TSerializer>().As <Singleton>();
}
else
{
var serializerClosure = serializer;
registry.ImplementedBy(c => serializerClosure).As <Singleton>();
}
return(new CompressionBuilder(config));
}
public void Add <TEvent, THandler>()
where TEvent : class, IEvent <object>
where THandler : class, IHandler <TEvent>
{
var @event = typeof(TEvent);
var handler = typeof(THandler);
if (handlers.TryGetValue(@event, out var list))
{
list.Add(handler);
}
else
{
config.Register <THandler>();
handlers.Add(@event, new List <Type> {
handler
});
}
}
public ImplementedByBuilder <TRegistry> Register <TRegistry>()
{
return(config.Register <TRegistry>());
}
public IImplementedByBuilder <TRegister> Register <TRegister>()
where TRegister : class
{
return(Config.Register <TRegister>());
}