public async Task SendValidRequest_StreamedContentReturned()
{
// Arrage
var httpClient = CreateGrpcWebClient();
var channel = GrpcChannel.ForAddress(httpClient.BaseAddress, new GrpcChannelOptions
{
HttpClient = httpClient,
LoggerFactory = LoggerFactory
});
var client = new EchoService.EchoServiceClient(channel);
// Act
var call = client.ServerStreamingEcho(new ServerStreamingEchoRequest
{
Message = "test",
MessageCount = 3,
MessageInterval = TimeSpan.FromMilliseconds(10).ToDuration()
});
// Assert
Assert.IsTrue(await call.ResponseStream.MoveNext(CancellationToken.None).DefaultTimeout());
Assert.AreEqual("test", call.ResponseStream.Current.Message);
Assert.IsTrue(await call.ResponseStream.MoveNext(CancellationToken.None).DefaultTimeout());
Assert.AreEqual("test", call.ResponseStream.Current.Message);
Assert.IsTrue(await call.ResponseStream.MoveNext(CancellationToken.None).DefaultTimeout());
Assert.AreEqual("test", call.ResponseStream.Current.Message);
Assert.IsFalse(await call.ResponseStream.MoveNext(CancellationToken.None).DefaultTimeout());
Assert.AreEqual(null, call.ResponseStream.Current);
Assert.AreEqual(StatusCode.OK, call.GetStatus().StatusCode);
}
public async Task SendValidRequest_WithConnectionOptions(TestServerEndpointName endpointName, string?version, bool success)
{
SetExpectedErrorsFilter(writeContext =>
{
return(!success);
});
// Arrage
Version.TryParse(version, out var v);
var channel = CreateGrpcWebChannel(endpointName, v);
var client = new EchoService.EchoServiceClient(channel);
// Act
var call = client.EchoAsync(new EchoRequest {
Message = "test"
}).ResponseAsync.DefaultTimeout();
// Assert
if (success)
{
Assert.AreEqual("test", (await call).Message);
}
else
{
await ExceptionAssert.ThrowsAsync <RpcException>(async() => await call);
}
}
/// <summary>
/// This example uses the Grpc operations on the stats service client. The Grpc methods allow specifying
/// Grpc Headers and are tightly coupled with the Grpc interfaces.
/// </summary>
private static async Task GrpcOperations(EchoService.EchoServiceClient client)
{
// Unary operation
{
SingleMessage unaryResponse = await client.EchoUnary(new SingleMessage { Message = "hi there" }, default);
Console.WriteLine($"EchoUnary: {unaryResponse.Message}");
}
// Client streaming
{
AsyncClientStreamingCall <SingleMessage, MultiMessage> call = client.EchoClientStreaming(default);
private void Test()
{
var channel = new Channel("127.0.0.1:6565", ChannelCredentials.Insecure);
var client = new EchoService.EchoServiceClient(channel);
var reply = client.EchoService(new EchoMessage {
Message = "test"
});
channel.ShutdownAsync().Wait();
}
private async Task GrpcWebUnaryAbortAsync(EchoService.EchoServiceClient client)
{
try
{
await client.EchoAbortAsync(new EchoRequest { Message = "test" });
Assert.Fail();
}
catch (RpcException ex)
{
Assert.AreEqual(StatusCode.Aborted, ex.StatusCode);
}
}
public async Task SendValidRequest_ServerAbort_ClientThrowsAbortException()
{
// Arrage
SetExpectedErrorsFilter(r =>
{
if (r.EventId.Name == "RpcConnectionError" &&
r.Message == "Error status code 'Aborted' raised.")
{
return(true);
}
if (r.EventId.Name == "GrpcStatusError" &&
r.Message == "Call failed with gRPC error status. Status code: 'Aborted', Message: 'Aborted from server side.'.")
{
return(true);
}
return(false);
});
var httpClient = CreateGrpcWebClient();
var channel = GrpcChannel.ForAddress(httpClient.BaseAddress, new GrpcChannelOptions
{
HttpClient = httpClient,
LoggerFactory = LoggerFactory
});
var client = new EchoService.EchoServiceClient(channel);
// Act
var call = client.ServerStreamingEchoAbort(new ServerStreamingEchoRequest
{
Message = "test",
MessageCount = 3,
MessageInterval = TimeSpan.FromMilliseconds(10).ToDuration()
});
// Assert
Assert.IsTrue(await call.ResponseStream.MoveNext(CancellationToken.None).DefaultTimeout());
Assert.AreEqual("test", call.ResponseStream.Current.Message);
var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => call.ResponseStream.MoveNext(CancellationToken.None));
Assert.AreEqual(StatusCode.Aborted, ex.StatusCode);
Assert.AreEqual("Aborted from server side.", ex.Status.Detail);
Assert.AreEqual(StatusCode.Aborted, call.GetStatus().StatusCode);
}
static async Task Main(string[] args)
{
using var channel = GrpcChannel.ForAddress("https://localhost:5001");
var client = new EchoService.EchoServiceClient(channel);
// Create chat rpc stream
using var echoStream = client.Echo();
// Wire up CallbackHandler to ResponseStream - print echo from service
var callbackHandler = new CallbackHandler(echoStream.ResponseStream);
// Run input loop
await InputLoop(echoStream);
// Run callback loop
await callbackHandler.Task;
}
public void Echo()
{
Debug.Log("echo start");
var channel = new Channel("127.0.0.1" + kPortNum, ChannelCredentials.Insecure);
var client = new EchoService.EchoServiceClient(channel);
var reply = client.EchoService(new EchoMessage {
Message = echoField_.text
});
Debug.Log("<color=red>" + reply.Message + "</color>");
channel.ShutdownAsync().Wait();
Debug.Log("echo End");
}
static async Task Main(string[] args)
{
// The port number(5001) must match the port of the gRPC server.
using var channel = GrpcChannel.ForAddress("https://localhost:5001");
var weatherclient = new WeatherService.WeatherServiceClient(channel);
var currentData = await weatherclient.RequestCurrentWeatherDataAsync(new WeatherRequest { Location = "MyTown" });
var historicData = await weatherclient.RequestHistoricDataAsync(new WeatherRequest { Location = "MyTown" });
var client = new Greeter.GreeterClient(channel);
var reply = await client.SayHelloAsync(new HelloRequest { Name = "GreeterClient" });
Console.WriteLine(
$"The current weather for {currentData.Location} is {currentData.Temperature} degrees F with winds {currentData.Windspeed} from {currentData.Winddirection}");
Console.WriteLine(
$"The high temps for the past 10 days were ");
foreach (var data in historicData.Data)
{
Console.WriteLine($"{data.Temperature}");
}
var echoClient = new EchoService.EchoServiceClient(channel);
var response = echoClient.EchoMe(
new EchoRequest()
{
Text = $"ABCDEFG-{DateTime.Now.ToShortDateString()}"
});
Console.WriteLine($"[{response.Original}] => [{response.Result}]");
response = echoClient.ReverseEcho(
new EchoRequest()
{
Text = $"ABCDEFG-{DateTime.Now.ToShortDateString()}"
});
Console.WriteLine($"[{response.Original}] => [{response.Result}]");
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
}
public async Task SendValidRequest_SuccessResponse()
{
// Arrage
var httpClient = CreateGrpcWebClient();
var channel = GrpcChannel.ForAddress(httpClient.BaseAddress, new GrpcChannelOptions
{
HttpClient = httpClient,
LoggerFactory = LoggerFactory
});
var client = new EchoService.EchoServiceClient(channel);
// Act
var response = await client.EchoAsync(new EchoRequest { Message = "test" }).ResponseAsync.DefaultTimeout();
// Assert
Assert.AreEqual("test", response.Message);
}
private async Task GrpcWebServerStreamingAsync(EchoService.EchoServiceClient client)
{
var call = client.ServerStreamingEcho(new ServerStreamingEchoRequest
{
Message = "test",
MessageCount = 5,
MessageInterval = Google.Protobuf.WellKnownTypes.TimeExtensions.ToDuration(TimeSpan.FromMilliseconds(100))
});
var messages = new List <ServerStreamingEchoResponse>();
await foreach (var message in call.ResponseStream.ReadAllAsync())
{
messages.Add(message);
}
Assert.AreEqual(5, messages.Count);
}
private async Task EchoTest(Func <EchoService.EchoServiceClient, Task> callback)
{
Server server = new Server();
try
{
server.Services.Add(EchoService.BindService(new EchoServer()));
server.Ports.Add(new ServerPort("127.0.0.1", 0, ServerCredentials.Insecure));
server.Start();
int port = server.Ports.Single().BoundPort;
EchoService.EchoServiceClient client = new EchoService.EchoServiceClient(new Channel("127.0.0.1", port, ChannelCredentials.Insecure));
await callback(client);
}
finally
{
await server.KillAsync();
}
}
private async Task GrpcWebServerStreamingAbortAsync(EchoService.EchoServiceClient client)
{
var call = client.ServerStreamingEchoAbort(new ServerStreamingEchoRequest
{
Message = "test",
MessageCount = 5,
MessageInterval = Google.Protobuf.WellKnownTypes.TimeExtensions.ToDuration(TimeSpan.FromMilliseconds(100))
});
try
{
await foreach (var message in call.ResponseStream.ReadAllAsync())
{
}
Assert.Fail();
}
catch (RpcException ex)
{
Assert.AreEqual(StatusCode.Aborted, ex.StatusCode);
}
}
public async Task SendValidRequest_ClientAbort_ClientThrowsCancelledException()
{
// Arrage
var httpClient = CreateGrpcWebClient();
var channel = GrpcChannel.ForAddress(httpClient.BaseAddress !, new GrpcChannelOptions
{
HttpClient = httpClient,
LoggerFactory = LoggerFactory
});
var cts = new CancellationTokenSource();
var client = new EchoService.EchoServiceClient(channel);
// Act
var call = client.ServerStreamingEcho(new ServerStreamingEchoRequest
{
Message = "test",
MessageCount = 2,
MessageInterval = TimeSpan.FromMilliseconds(100).ToDuration()
}, cancellationToken: cts.Token);
// Assert
Assert.IsTrue(await call.ResponseStream.MoveNext(CancellationToken.None).DefaultTimeout());
Assert.AreEqual("test", call.ResponseStream.Current.Message);
cts.Cancel();
var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => call.ResponseStream.MoveNext(CancellationToken.None)).DefaultTimeout();
Assert.AreEqual(StatusCode.Cancelled, ex.StatusCode);
Assert.AreEqual("Call canceled by the client.", ex.Status.Detail);
Assert.AreEqual(StatusCode.Cancelled, call.GetStatus().StatusCode);
// It is possible get into a situation where the response stream finishes slightly before the call.
// Small delay to ensure call logging is complete.
await Task.Delay(50);
AssertHasLog(LogLevel.Information, "GrpcStatusError", "Call failed with gRPC error status. Status code: 'Cancelled', Message: 'Call canceled by the client.'.");
}
public async Task SendValidRequest_WithConnectionOptions(TestServerEndpointName endpointName, string?version, bool success)
{
#if NET6_0_OR_GREATER
if (endpointName == TestServerEndpointName.Http3WithTls &&
!RequireHttp3Attribute.IsSupported(out var message))
{
Assert.Ignore(message);
}
#endif
SetExpectedErrorsFilter(writeContext =>
{
return(!success);
});
// Arrage
Version.TryParse(version, out var v);
var channel = CreateGrpcWebChannel(endpointName, v);
var client = new EchoService.EchoServiceClient(channel);
// Act
var call = client.EchoAsync(new EchoRequest {
Message = "test"
}).ResponseAsync.DefaultTimeout();
// Assert
if (success)
{
Assert.AreEqual("test", (await call.DefaultTimeout()).Message);
}
else
{
await ExceptionAssert.ThrowsAsync <RpcException>(async() => await call).DefaultTimeout();
}
}
private async Task GrpcWebUnaryAsync(EchoService.EchoServiceClient client)
{
var response = await client.EchoAsync(new EchoRequest { Message = "test" });
Assert.AreEqual("test", response.Message);
}
