static void Main(string[] args)
{
Console.WriteLine("Command Line Chat Server");
Console.WriteLine("----------------------------------");
var compositionHost = new TalkCompositionHost();
compositionHost.AddExecutionDirAssemblies();
compositionHost.RegisterLocalSharedService <IChatBroker>(); // one global instance
compositionHost.RegisterLocalSessionService <IChatService>(); // one instance for each session
compositionHost.RegisterRemoteService <IChatClient>(); // one proxy instance for each session
var tcpBackendService = new TcpCommunicationController();
tcpBackendService.LogDataStream = true;
compositionHost.InitGenericCommunication(tcpBackendService);
tcpBackendService.InitService(52274);
Console.WriteLine("Press return to exit");
Console.ReadLine();
Console.WriteLine("Exit...");
tcpBackendService.Shutdown();
}
public async Task Setup()
{
onConnectionEstablished = new TaskCompletionSource <bool>();
const int timeoutMs = 20000;
var ct = new CancellationTokenSource(timeoutMs);
ct.Token.Register(() => onConnectionEstablished.TrySetCanceled(), useSynchronizationContext: false);
int port = 33255;
StressTestService localService;
{
// init service
var compositionHostService = new TalkCompositionHost();
//compositionHostService.AddAssembly(typeof(IStressTestService).Assembly);
compositionHostService.AddAssembly(typeof(StressTestService).Assembly);
//compositionHostService.RegisterLocalSharedService<ILogger>(log);
compositionHostService.RegisterLocalSharedService <IStressTestService>();
compositionHostService.RegisterLocalSharedService <IMyRemoteAsyncAwaitTestService>();
tcpBackendService = new TcpCommunicationController();
compositionHostService.InitGenericCommunication(tcpBackendService);
tcpBackendService.InitService(port);
localService = (StressTestService)compositionHostService.GetExport <IStressTestService>();
}
{
// init client
var compositionHostClient = new TalkCompositionHost();
//compositionHostClient.RegisterLocalSharedService<ILogger>(log);
compositionHostClient.RegisterRemoteService <IStressTestService>();
compositionHostClient.RegisterAsyncVoidMethod <IStressTestService>(nameof(IStressTestService.AsyncCallTest));
compositionHostClient.RegisterRemoteService <IMyRemoteAsyncAwaitTestService>();
tcpClient = new TcpCommunicationController();
compositionHostClient.SessionCreated += OnCompositionHostClient_SessionCreated;
compositionHostClient.InitGenericCommunication(tcpClient);
tcpClient.InitClient(IPAddress.Loopback.ToString(), port);
}
await onConnectionEstablished.Task;
}
static void Main(string[] args)
{
Console.WriteLine("Command Line Chat Frontend");
Console.WriteLine("----------------------------------");
var compositionHost = new TalkCompositionHost();
compositionHost.AddExecutionDirAssemblies();
compositionHost.RegisterLocalSessionService <IChatClient>();
compositionHost.RegisterRemoteService <IChatService>();
var tcpClientService = new TcpCommunicationController();
compositionHost.InitGenericCommunication(tcpClientService);
tcpClientService.InitClient("127.0.0.1", 52274);
Thread.CurrentThread.Join(); // wait infinite
}
public async Task ClientServiceStressTest1()
{
onConnectionEstablished = new TaskCompletionSource <bool>();
const int timeoutMs = 20000;
var ct = new CancellationTokenSource(timeoutMs);
ct.Token.Register(() => onConnectionEstablished.TrySetCanceled(), useSynchronizationContext: false);
int port = 33254;
var log = new UnitTestLogger(xUnitLog);
TcpCommunicationController tcpClient;
TcpCommunicationController tcpBackendService;
StressTestService localService;
{
// init service
var compositionHostService = new TalkCompositionHost();
//compositionHostService.AddAssembly(typeof(IStressTestService).Assembly);
compositionHostService.AddAssembly(typeof(StressTestService).Assembly);
compositionHostService.RegisterLocalSharedService <ILogger>(log);
compositionHostService.RegisterLocalSharedService <IStressTestService>();
tcpBackendService = new TcpCommunicationController(log);
compositionHostService.InitGenericCommunication(tcpBackendService);
tcpBackendService.InitService(port);
localService = (StressTestService)compositionHostService.GetExport <IStressTestService>();
}
{
// init client
var compositionHostClient = new TalkCompositionHost();
//compositionHostClient.AddAssembly(typeof(IStressTestService).Assembly);
compositionHostClient.RegisterLocalSharedService <ILogger>(log);
compositionHostClient.RegisterRemoteService <IStressTestService>();
compositionHostClient.RegisterAsyncVoidMethod <IStressTestService>(nameof(IStressTestService.AsyncCallTest));
tcpClient = new TcpCommunicationController(log);
compositionHostClient.SessionCreated += OnCompositionHostClient_SessionCreated;
compositionHostClient.InitGenericCommunication(tcpClient);
tcpClient.InitClient(IPAddress.Loopback.ToString(), port);
}
Assert.True(await onConnectionEstablished.Task);
int number = 0;
for (; number < 10000; number++)
{
currentStressTestServiceClientProxyInstance.AsyncCallTest(number);
}
for (; number < 20000; number++)
{
var result = currentStressTestServiceClientProxyInstance.SyncCallTest(number);
Assert.Equal(number, result);
}
Assert.Equal(number, localService.CurrentNumber);
string longTestData = "TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST";
for (; number < 25000; number++)
{
var data = new DataTransferTest
{
ID = number,
Name = longTestData
};
var result = currentStressTestServiceClientProxyInstance.ComplexCall(number, data);
Assert.Equal(number, result);
}
Assert.Equal(number, localService.CurrentNumber);
tcpClient.Shutdown();
tcpBackendService.Shutdown();
}
public async Task TestMethodBuildDataTransferInterfaceAsyncImplementation()
{
onConnectionEstablished = new TaskCompletionSource <bool>();
const int timeoutMs = 20000;
var ct = new CancellationTokenSource(timeoutMs);
ct.Token.Register(() => onConnectionEstablished.TrySetCanceled(), useSynchronizationContext: false);
int port = 33255;
var log = new UnitTestLogger(xUnitLog);
TcpCommunicationController tcpClient;
TcpCommunicationController tcpBackendService;
MyRemoteAsyncTestService localService;
{
// init service
var compositionHostService = new TalkCompositionHost();
compositionHostService.AddAssembly(typeof(MyRemoteAsyncTestService).Assembly);
compositionHostService.RegisterLocalSharedService <ILogger>(log);
compositionHostService.RegisterLocalSharedService <IMyRemoteAsyncAwaitTestService>();
tcpBackendService = new TcpCommunicationController(log);
tcpBackendService.LogDataStream = true;
compositionHostService.InitGenericCommunication(tcpBackendService);
tcpBackendService.InitService(port);
localService = (MyRemoteAsyncTestService)compositionHostService.GetExport <IMyRemoteAsyncAwaitTestService>();
}
{
// init client
var compositionHostClient = new TalkCompositionHost();
//compositionHostClient.AddAssembly(typeof(IStressTestService).Assembly);
compositionHostClient.RegisterLocalSharedService <ILogger>(log);
compositionHostClient.RegisterRemoteService <IMyRemoteAsyncAwaitTestService>();
tcpClient = new TcpCommunicationController(log);
tcpClient.LogDataStream = true;
tcpClient.RequestTimeoutSeconds = 15;
compositionHostClient.SessionCreated += OnCompositionHostClient_SessionCreated;
compositionHostClient.InitGenericCommunication(tcpClient);
tcpClient.InitClient(IPAddress.Loopback.ToString(), port);
}
Assert.True(await onConnectionEstablished.Task);
var dataResponse = await currentAsyncAwaitTestServiceClientProxyInstance.GetDataAsync();
Assert.Equal("Hello world", dataResponse);
int expected = 23134;
var response2 = await currentAsyncAwaitTestServiceClientProxyInstance.GetDataAsync2(expected);
Assert.Equal(expected, response2);
// without return value
MyRemoteAsyncTestService.RunSomeWorkCounter = 0;
await currentAsyncAwaitTestServiceClientProxyInstance.RunSomeWork();
Assert.Equal(1, MyRemoteAsyncTestService.RunSomeWorkCounter);
tcpClient.Shutdown();
tcpBackendService.Shutdown();
}
