public void SharedMemIPC_Parallel() { // Verify multiple client/server IPC calls happening in parallel. SharedMemServer <MessageFactory> server = null; SharedMemClient <MessageFactory> client = null; try { // Configure a test server that echos the argument passed. server = new SharedMemServer <MessageFactory>("test-server", rawRequest => { var request = (RequestMessage)rawRequest; return(new ResponseMessage() { Result = request.Arg }); }); // Configure the client. client = new SharedMemClient <MessageFactory>("test-server"); // Peform the parallel operations. var count = 50000; var tasks = new Task <ResponseMessage> [count]; for (int i = 0; i < count; i++) { tasks[i] = client.CallAsync <ResponseMessage>(new RequestMessage() { Arg = i.ToString() }); } Task.WaitAll(tasks, TimeSpan.FromSeconds(10)); for (int i = 0; i < count; i++) { var response = (ResponseMessage)tasks[i].Result; Assert.AreEqual <string>(i.ToString(), response.Result); } } finally { if (server != null) { server.Dispose(); } if (client != null) { client.Dispose(); } } }
public async Task SharedMemIPC_ServerException() { // Verify that exceptions thrown by the server are rethrown by the client. SharedMemServer <MessageFactory> server = null; SharedMemClient <MessageFactory> client = null; try { // Configure a test server that echos the argument passed. server = new SharedMemServer <MessageFactory>("test-server", rawRequest => { throw new ArgumentException("Bad arg"); }); // Configure the client. client = new SharedMemClient <MessageFactory>("test-server"); // Make the call. try { await client.CallAsync(new RequestMessage()); Assert.Fail("Expected a [{0}].", typeof(SharedMemException).FullName); } catch (SharedMemException e) { Assert.AreEqual("System.ArgumentException: Bad arg", e.Message); } catch { Assert.Fail("Expected a [{0}].", typeof(SharedMemException).FullName); } } finally { if (server != null) { server.Dispose(); } if (client != null) { client.Dispose(); } } }
public async Task SharedMemIPC_Basic() { // Verify basic client/server IPC. SharedMemServer <MessageFactory> server = null; SharedMemClient <MessageFactory> client = null; try { // Configure a test server that echos the argument passed. server = new SharedMemServer <MessageFactory>("test-server", rawRequest => { var request = (RequestMessage)rawRequest; return(new ResponseMessage() { Result = request.Arg }); }); // Configure the client. client = new SharedMemClient <MessageFactory>("test-server"); // Verify that we can handle query/response end-to-end. var response = await client.CallAsync <ResponseMessage>(new RequestMessage() { Arg = "Hello World!" }); Assert.AreEqual("Hello World!", response.Result); } finally { if (server != null) { server.Dispose(); } if (client != null) { client.Dispose(); } } }
public async Task SharedMemIPC_Performance() { // Measure calls per second. SharedMemServer <MessageFactory> server = null; SharedMemClient <MessageFactory> client = null; try { // Configure a test server that echos the argument passed. server = new SharedMemServer <MessageFactory>("test-server", rawRequest => { var request = (RequestMessage)rawRequest; return(new ResponseMessage() { Result = request.Arg }); }); // Configure the client. client = new SharedMemClient <MessageFactory>("test-server"); // Peform the operations. var count = 10000; var stopwatch = new Stopwatch(); stopwatch.Start(); for (int i = 0; i < count; i++) { await client.CallAsync(new RequestMessage() { Arg = "Test" }); } stopwatch.Stop(); var callsPerSecond = count / stopwatch.Elapsed.TotalSeconds; var msPerCall = stopwatch.Elapsed.TotalMilliseconds / count; Debug.WriteLine("Calls/sec: {0}", callsPerSecond); Debug.WriteLine("Milliseconds/call: {0}", msPerCall); } finally { if (server != null) { server.Dispose(); } if (client != null) { client.Dispose(); } } }
public async Task SharedMemIPC_Timeout() { // Verify that the client implements timeout. SharedMemServer <MessageFactory> server = null; SharedMemClient <MessageFactory> client = null; try { // Configure a test server that can delay for 5 seconds before returning. server = new SharedMemServer <MessageFactory>("test-server", rawRequest => { var request = (RequestMessage)rawRequest; if (request.Arg == "DELAY") { Thread.Sleep(TimeSpan.FromSeconds(5)); } return(new ResponseMessage() { Result = request.Arg }); }); // Configure the client. client = new SharedMemClient <MessageFactory>("test-server"); // Verify that we get a timeout. await ExtendedAssert.ThrowsAsync <TimeoutException>( async() => await client.CallAsync <ResponseMessage>(new RequestMessage() { Arg = "DELAY" }, TimeSpan.FromSeconds(1))); // Verify that regular requests still work. var response = await client.CallAsync <ResponseMessage>(new RequestMessage() { Arg = "NODELAY" }, TimeSpan.FromSeconds(1)); Assert.AreEqual("NODELAY", response.Result); } finally { if (server != null) { server.Dispose(); } if (client != null) { client.Dispose(); } } }