public Task InitializeAsync()
{
Tuple <Nerdbank.FullDuplexStream, Nerdbank.FullDuplexStream> streams = Nerdbank.FullDuplexStream.CreateStreams();
this.InitializeFormattersAndHandlers();
var serverHandler = new LengthHeaderMessageHandler(streams.Item1.UsePipe(), this.serverMessageFormatter);
var clientHandler = new LengthHeaderMessageHandler(streams.Item2.UsePipe(), this.clientMessageFormatter);
this.serverRpc = new JsonRpc(serverHandler, this.server);
this.clientRpc = new JsonRpc(clientHandler);
// Don't use Verbose as it has nasty side-effects leading to test failures, which we need to fix!
this.serverRpc.TraceSource = new TraceSource("Server", SourceLevels.Information);
this.clientRpc.TraceSource = new TraceSource("Client", SourceLevels.Information);
this.serverRpc.TraceSource.Listeners.Add(new XunitTraceListener(this.Logger));
this.clientRpc.TraceSource.Listeners.Add(new XunitTraceListener(this.Logger));
this.serverRpc.StartListening();
this.clientRpc.StartListening();
this.clientProxy = new Lazy <IServer>(() => this.clientRpc.Attach <IServer>());
return(Task.CompletedTask);
}
static async Task Main(string[] args)
{
Console.WriteLine("正在与服务端建立连接...");
var tcpClient = new TcpClient("localhost", 6000);
var jsonRpcStream = tcpClient.GetStream();
Console.WriteLine("已建立连接");
var messageFormatter = new JsonMessageFormatter(Encoding.UTF8);
var messageHandler = new LengthHeaderMessageHandler(jsonRpcStream, jsonRpcStream, messageFormatter);
var greeterClient = JsonRpc.Attach <IGreeter>(messageHandler);
Console.WriteLine("开始向服务端发送消息...");
var request = new HelloRequest {
Name = "精致码农"
};
var response = await greeterClient.SayHelloAsync(request);
Console.WriteLine($"收到来自服务端的响应：{response.Message}");
Console.WriteLine(response.Message);
Console.WriteLine("正在断开连接...");
jsonRpcStream.Close();
Console.WriteLine("已断开连接");
Console.ReadKey();
}
public async Task BasicJsonRpc()
{
var(clientStream, serverStream) = FullDuplexStream.CreatePair();
var clientFormatter = new MessagePackFormatter();
var serverFormatter = new MessagePackFormatter();
var clientHandler = new LengthHeaderMessageHandler(clientStream.UsePipe(), clientFormatter);
var serverHandler = new LengthHeaderMessageHandler(serverStream.UsePipe(), serverFormatter);
var clientRpc = new JsonRpc(clientHandler);
var serverRpc = new JsonRpc(serverHandler, new Server());
serverRpc.TraceSource = new TraceSource("Server", SourceLevels.Verbose);
clientRpc.TraceSource = new TraceSource("Client", SourceLevels.Verbose);
serverRpc.TraceSource.Listeners.Add(new XunitTraceListener(this.Logger));
clientRpc.TraceSource.Listeners.Add(new XunitTraceListener(this.Logger));
clientRpc.StartListening();
serverRpc.StartListening();
int result = await clientRpc.InvokeAsync <int>(nameof(Server.Add), 3, 5).WithCancellation(this.TimeoutToken);
Assert.Equal(8, result);
}
private JsonRpcClient(string ipAddress, int port)
{
m_TcpClient = new TcpClient(AddressFamily.InterNetwork);
m_TcpClient.Connect(IPAddress.Parse(ipAddress), port);
var formatter = new JsonMessageFormatter(Encoding.UTF8);
var handler = new LengthHeaderMessageHandler(m_TcpClient.GetStream(), m_TcpClient.GetStream(), formatter);
m_JsonRpc = new JsonRpc(handler);
// Add any applicable target objects/methods here, or in the JsonRpc constructor above
m_JsonRpc.StartListening();
}
private static JsonRpc CreateRpc(string name, Stream duplexStream)
{
// Create a JsonRpcMessagePackFormatter as an IJsonRpcMessageFormatter.
var formatter = new JsonRpcMessagePackFormatter(MyCompositeResolver.Instance);
// Create a JsonRpc that uses the IJsonRpcMessageFormatter.
var handler = new LengthHeaderMessageHandler(duplexStream, duplexStream, formatter);
var rpc = new JsonRpc(handler)
{
TraceSource = new TraceSource(name, SourceLevels.Verbose),
};
rpc.AddLocalRpcTarget(new ServerObject());
rpc.StartListening();
return(rpc);
}
static async Task Main(string[] args)
{
TcpClient tcpClient = new TcpClient("localhost", 6000);
Stream jsonRpcStream = tcpClient.GetStream();
IJsonRpcMessageFormatter jsonRpcMessageFormatter = new JsonMessageFormatter(Encoding.UTF8);
IJsonRpcMessageHandler jsonRpcMessageHandler = new LengthHeaderMessageHandler(jsonRpcStream, jsonRpcStream, jsonRpcMessageFormatter);
IGreeter jsonRpcGreeterClient = JsonRpc.Attach <IGreeter>(jsonRpcMessageHandler);
HelloReply helloReply = await jsonRpcGreeterClient.SayHelloAsync(new HelloRequest { Name = "Tomasz Pęczek" });
Console.WriteLine(helloReply.Message);
jsonRpcStream.Close();
Console.ReadKey();
}
public async Task <LengthHeaderMessageHandler> GetMessageHandlerAsync()
{
var tries = 0;
do
{
try
{
var tcpClient = new TcpClient(m_ServerAddress, m_Port);
var jsonStream = tcpClient.GetStream();
var jsonRpcMessageFormatter = new JsonMessageFormatter(Encoding.UTF8);
var jsonRpcMessageHandler = new LengthHeaderMessageHandler(
jsonStream,
jsonStream,
jsonRpcMessageFormatter);
return(jsonRpcMessageHandler);
}
catch (SocketException socketException)
{
Console.WriteLine($"Failed to connect, will retry {tries}/{MaxConnectionRetries}, '{socketException.Message}'");
}
catch (Exception exception)
{
Console.WriteLine($"Failed to connect, will retry {tries}/{MaxConnectionRetries}, '{exception.Message}'");
}
finally
{
tries++;
await Task.Delay(1000);
}
} while (tries < MaxConnectionRetries);
throw new TimeoutException("Failed to connect to the RPC server.");
}
public async Task InitializeAsync()
{
Tuple <Nerdbank.FullDuplexStream, Nerdbank.FullDuplexStream> streams = Nerdbank.FullDuplexStream.CreateStreams();
TraceSource mxServerTraceSource = new TraceSource("MX Server", SourceLevels.Information);
TraceSource mxClientTraceSource = new TraceSource("MX Client", SourceLevels.Information);
mxServerTraceSource.Listeners.Add(new XunitTraceListener(this.Logger));
mxClientTraceSource.Listeners.Add(new XunitTraceListener(this.Logger));
MultiplexingStream[] mxStreams = await Task.WhenAll(
MultiplexingStream.CreateAsync(
streams.Item1,
new MultiplexingStream.Options
{
TraceSource = mxServerTraceSource,
DefaultChannelTraceSourceFactory = (id, name) => new TraceSource("MX Server channel " + id, SourceLevels.Verbose)
{
Listeners = { new XunitTraceListener(this.Logger) }
},
},
this.TimeoutToken),
MultiplexingStream.CreateAsync(
streams.Item2,
new MultiplexingStream.Options
{
TraceSource = mxClientTraceSource,
DefaultChannelTraceSourceFactory = (id, name) => new TraceSource("MX Client channel " + id, SourceLevels.Verbose)
{
Listeners = { new XunitTraceListener(this.Logger) }
},
},
this.TimeoutToken));
this.serverMx = mxStreams[0];
this.clientMx = mxStreams[1];
MultiplexingStream.Channel[] rpcStreams = await Task.WhenAll(
this.serverMx.AcceptChannelAsync(string.Empty, this.TimeoutToken),
this.clientMx.OfferChannelAsync(string.Empty, this.TimeoutToken));
MultiplexingStream.Channel rpcServerStream = rpcStreams[0];
MultiplexingStream.Channel rpcClientStream = rpcStreams[1];
this.InitializeFormattersAndHandlers();
var serverHandler = new LengthHeaderMessageHandler(rpcServerStream, this.serverMessageFormatter);
var clientHandler = new LengthHeaderMessageHandler(rpcClientStream, this.clientMessageFormatter);
this.serverRpc = new JsonRpc(serverHandler, this.server);
this.clientRpc = new JsonRpc(clientHandler);
this.serverRpc.TraceSource = new TraceSource("Server", SourceLevels.Information);
this.clientRpc.TraceSource = new TraceSource("Client", SourceLevels.Information);
this.serverRpc.TraceSource.Listeners.Add(new XunitTraceListener(this.Logger));
this.clientRpc.TraceSource.Listeners.Add(new XunitTraceListener(this.Logger));
this.serverRpc.StartListening();
this.clientRpc.StartListening();
}
public void Ctor_NullReadStream()
{
this.handler = new LengthHeaderMessageHandler(new MemoryStream(), null, new JsonMessageFormatter());
Assert.False(this.handler.CanRead);
Assert.True(this.handler.CanWrite);
}
public LengthHeaderMessageHandlerTests(ITestOutputHelper logger)
: base(logger)
{
this.handler = new LengthHeaderMessageHandler(this.halfDuplexStream, this.halfDuplexStream, new JsonMessageFormatter());
}
public void Ctor_NullWriter()
{
this.handler = new LengthHeaderMessageHandler(null, new MemoryStream().UsePipeReader(), new MessagePackFormatter());
Assert.True(this.handler.CanRead);
Assert.False(this.handler.CanWrite);
}
