public void ReturnTupleTest()
{
var callsCount = 0;
var serviceInstance = new TestService(() => callsCount++);
var serializerFactory = new MessagePackSerializerFactory();
var serviceDispatcher = new ServiceDispatcher <ITestService>(serializerFactory, new LoggerStub());
var argumentsData = new byte[2][];
argumentsData[0] = serializerFactory.CreateSerializer <int>().Serialize(0);
argumentsData[1] = serializerFactory.CreateSerializer <int>().Serialize(2);
var result = serviceDispatcher.Dispatch(serviceInstance, new RpcMessage()
{
ServiceCode = typeof(ITestService).FullName.GetHashCode(),
OperationCode = 3,
ArgumentsData = argumentsData
});
Assert.NotNull(result);
Assert.True(result.HasReturnValue);
var resultTuple = serializerFactory.CreateSerializer <(int count, SerializableObject[] objects)>()
.Deserialize(result.ReturnValue);
Assert.Equal(2, resultTuple.count);
Assert.Equal(SerializableObject.TestInt, resultTuple.objects[0].IntProperty);
Assert.Equal(SerializableObject.TestString, resultTuple.objects[0].StringProperty);
Assert.Equal(
SerializableObject.TestDouble,
resultTuple.objects[0].NestedObject.DoubleProperty);
}
public async void AsyncClientMethodsTest()
{
var serializerFactory = new MessagePackSerializerFactory();
var serviceClientFactory = new ServiceClientFactory(new LoggerStub());
using (var _ = GetTestService(serializerFactory))
{
using (var client = serviceClientFactory.CreateServiceClient <ITestService>(
"localhost",
serializerFactory))
{
var myHashcode = await client.ServiceInstance.GetHashCodeOfMeAsync(SerializableObject.GetTestInstance());
Assert.Equal(SerializableObject.TestInt, myHashcode);
var constructedObject = await client.ServiceInstance.ConstructObjectAsync(
SerializableObject.TestInt,
SerializableObject.TestString,
SerializableObject.TestDouble);
Assert.NotNull(constructedObject);
Assert.Equal(SerializableObject.TestInt, constructedObject.IntProperty);
Assert.Equal(SerializableObject.TestString, constructedObject.StringProperty);
Assert.Equal(SerializableObject.TestDouble, constructedObject.NestedObject.DoubleProperty);
var(count, objects) = await client.ServiceInstance.GetObjectsAsync(1, 1);
Assert.Equal(2, count);
constructedObject = objects.Single();
Assert.Equal(SerializableObject.TestInt, constructedObject.IntProperty);
Assert.Equal(SerializableObject.TestString, constructedObject.StringProperty);
Assert.Equal(SerializableObject.TestDouble, constructedObject.NestedObject.DoubleProperty);
}
}
}
static void Main(string[] args)
{
var logger = new LoggerStub();
// using (var logger = new ConsoleLoggerWrapper(new LoggerStub()))
// {
Helpers.LogCurrentMemoryUsage(logger);
// Console.ReadLine();
var messagePackSerializerFactory = new MessagePackSerializerFactory();
using (var testServiceClient = ServiceClientFactory.CreateServiceClient <ITestService>(
"localhost",
logger,
messagePackSerializerFactory))
{
using (var wcfTestServiceClient = CommonWcfComponents.ServiceClient <ITestService> .Create())
{
Console.WriteLine("Test service client created.");
RunTest(wcfTestServiceClient.Service, logger);
Helpers.LogCurrentMemoryUsage(logger);
Console.WriteLine("All requests send.");
Console.ReadLine();
}
}
// }
}
public static void Main(string[] args)
{
var logger = new LoggerStub();
// using (var logger = new ConsoleLoggerWrapper(new LoggerStub()))
// {
Helpers.LogCurrentMemoryUsage(logger);
// Console.ReadLine();
var messagePackSerializerFactory = new MessagePackSerializerFactory();
var rpcTcpServicePublisher = new RpcTcpServicePublisher(messagePackSerializerFactory, logger);
var defaultServiceTimeout = TimeSpan.FromMinutes(1);
var testService = new TestService(logger);
using (new DisposableCollectionHolder(
rpcTcpServicePublisher.PublishUnsecured <ITestService>(
testService,
defaultServiceTimeout)))
{
using (ServiceHostContainerFactory.Create <TestService, ITestService>())
{
Console.WriteLine("Services started. Press Enter to stop.");
Console.ReadLine();
Helpers.LogCurrentMemoryUsage(logger);
}
}
// }
Console.WriteLine("Services stopped.");
}
public void ServiceTest()
{
var callsCount = 0;
var serviceInstance = new TestService(() => callsCount++);
var serializerFactory = new MessagePackSerializerFactory();
var testObject = SerializableObject.GetTestInstance();
var argumentsData = new byte[1][];
argumentsData[0] = serializerFactory.CreateSerializer <SerializableObject>().Serialize(testObject);
var serviceDispatcher = new ServiceDispatcher <ITestService>(serializerFactory, new LoggerStub());
Assert.Equal(serviceDispatcher.ServicePort, TestService.ServicePort);
var result = serviceDispatcher.Dispatch(serviceInstance, new RpcMessage
{
ServiceCode = typeof(ITestService).FullName.GetHashCode(),
OperationCode = 0,
ArgumentsData = argumentsData
});
Assert.NotNull(result);
Assert.True(result.HasReturnValue);
Assert.Equal(
testObject.IntProperty,
serializerFactory.CreateSerializer <int>().Deserialize(result.ReturnValue));
argumentsData = new byte[3][];
argumentsData[0] = serializerFactory.CreateSerializer <int>()
.Serialize(SerializableObject.TestInt);
argumentsData[1] = serializerFactory.CreateSerializer <string>()
.Serialize(SerializableObject.TestString);
argumentsData[2] = serializerFactory.CreateSerializer <double>()
.Serialize(SerializableObject.TestDouble);
result = serviceDispatcher.Dispatch(serviceInstance, new RpcMessage
{
ServiceCode = typeof(ITestService).FullName.GetHashCode(),
OperationCode = 1,
ArgumentsData = argumentsData
});
Assert.NotNull(result);
Assert.True(result.HasReturnValue);
var resultObject = serializerFactory.CreateSerializer <SerializableObject>()
.Deserialize(result.ReturnValue);
Assert.NotNull(resultObject);
Assert.Equal(testObject.IntProperty, resultObject.IntProperty);
Assert.Equal(testObject.StringProperty, resultObject.StringProperty);
Assert.Equal(
testObject.NestedObject.DoubleProperty,
resultObject.NestedObject.DoubleProperty);
argumentsData = new byte[1][];
argumentsData[0] = serializerFactory.CreateSerializer <string>()
.Serialize(SerializableObject.TestString);
result = serviceDispatcher.Dispatch(serviceInstance, new RpcMessage
{
ServiceCode = typeof(ITestService).FullName.GetHashCode(),
OperationCode = 2,
ArgumentsData = argumentsData
});
Assert.NotNull(result);
Assert.False(result.HasReturnValue);
Assert.Equal(1, callsCount);
}
public void ServerTest()
{
var callsCount = 0;
var serviceInstance = new TestService(() => callsCount++);
var serializerFactory = new MessagePackSerializerFactory();
var servicePublisher = new RpcTcpServicePublisher(serializerFactory, new LoggerStub());
using (servicePublisher.PublishUnsecured <ITestService>(serviceInstance, TimeSpan.FromMinutes(1)))
{
PerformTestWithConnectedNetworkStream(networkStream =>
{
var argumentsData = new byte[1][];
argumentsData[0] = serializerFactory
.CreateSerializer <SerializableObject>()
.Serialize(SerializableObject.GetTestInstance());
var rpcMessage = serializerFactory.CreateSerializer <RpcMessage>().Serialize(new RpcMessage()
{
ServiceCode = typeof(ITestService).FullName.GetHashCode(),
OperationCode = 0,
ArgumentsData = argumentsData
});
networkStream.Write(rpcMessage, 0, rpcMessage.Length);
networkStream.WriteEndOfSessionMessage();
var data = new List <byte>();
var dataChunk = new byte[128];
do
{
var bytesRead = networkStream.Read(dataChunk, 0, dataChunk.Length);
data.AddRange(dataChunk.Take(bytesRead).ToArray());
} while (networkStream.DataAvailable);
var serviceCallResult = serializerFactory.CreateSerializer <ServiceCallResult>().Deserialize(data.ToArray());
var result = serializerFactory.CreateSerializer <int>().Deserialize(serviceCallResult.ReturnValue);
Assert.Equal(SerializableObject.TestInt, result);
});
PerformTestWithConnectedNetworkStream(networkStream =>
{
var argumentsData = new byte[2][];
argumentsData[0] = serializerFactory.CreateSerializer <int>().Serialize(0);
argumentsData[1] = serializerFactory.CreateSerializer <int>().Serialize(2);
var rpcMessage = serializerFactory.CreateSerializer <RpcMessage>().Serialize(new RpcMessage()
{
ServiceCode = typeof(ITestService).FullName.GetHashCode(),
OperationCode = 3,
ArgumentsData = argumentsData
});
networkStream.Write(rpcMessage, 0, rpcMessage.Length);
networkStream.WriteEndOfSessionMessage();
var data = new List <byte>();
var dataChunk = new byte[128];
do
{
var bytesRead = networkStream.Read(dataChunk, 0, dataChunk.Length);
data.AddRange(dataChunk.Take(bytesRead).ToArray());
} while (networkStream.DataAvailable);
var serviceCallResult = serializerFactory.CreateSerializer <ServiceCallResult>().Deserialize(data.ToArray());
var resultTuple = serializerFactory.CreateSerializer <(int count, SerializableObject[] objects)>()
.Deserialize(serviceCallResult.ReturnValue);
Assert.Equal(2, resultTuple.count);
Assert.Equal(SerializableObject.TestInt, resultTuple.objects[0].IntProperty);
Assert.Equal(SerializableObject.TestString, resultTuple.objects[0].StringProperty);
Assert.Equal(SerializableObject.TestDouble, resultTuple.objects[0].NestedObject.DoubleProperty);
});
}
}
