public override Task <GreetingResponse> Greet(GreetingRequest request, ServerCallContext context)
{
string result = $"Hello {request.Greeting.FirstName} {request.Greeting.LastName}";
return(Task.FromResult(new GreetingResponse()
{
Result = result
}));
//return base.Greet(request, context);
}
public override async Task <GreetingResponse> GreetWithDeadline(GreetingRequest request, ServerCallContext context)
{
Console.WriteLine("Received call");
await Task.Delay(300);
return(new GreetingResponse()
{
Result = "Hellooo " + request.Greeting.FirstName + " " + request.Greeting.LastName
});
}
public Task <GreetingResponse> Unary(GreetingRequest request, MethodCallContext context)
{
Console.WriteLine("Received unary request from {{{0}}}", context);
Console.WriteLine("Received: {0}", request.Name);
var greeting = $"Hello, {request.Name}! This is .NET app.";
Console.WriteLine("Sending response: {0}", greeting);
return(Task.FromResult(new GreetingResponse {
Greeting = greeting
}));
}
public void InvokeTargetUsingConnectionIdWithoutAppId()
{
RunWith10SecTimeout(async() =>
{
var server1RequestCount = 0;
var server1 = ConnectEchoServer((request, context) =>
{
server1RequestCount++;
return(Task.FromResult(new GreetingResponse {
Greeting = "FromServer1"
}));
});
var server2RequestCount = 0;
var server2 = ConnectEchoServer((request, context) =>
{
server2RequestCount++;
return(Task.FromResult(new GreetingResponse {
Greeting = "FromServer2"
}));
});
var client = CreateClient <EchoClient>();
await client.ConnectAsync();
server1RequestCount.ShouldBe(0);
server2RequestCount.ShouldBe(0);
var providedMethodReference = ProvidedMethodReference.CreateWithConnectionId(GreetingService.Id,
GreetingService.HelloMethodId, server1.ConnectionId);
var methodCallDescriptor = new MethodCallDescriptor(providedMethodReference);
var greetingRequest = new GreetingRequest {
Name = "Client"
};
var response =
await client.CallInvoker.CallUnary <GreetingRequest, GreetingResponse>(methodCallDescriptor,
greetingRequest);
response.Greeting.ShouldBe("FromServer1");
server1RequestCount.ShouldBe(1);
server2RequestCount.ShouldBe(0);
providedMethodReference = ProvidedMethodReference.CreateWithConnectionId(GreetingService.Id,
GreetingService.HelloMethodId, server2.ConnectionId);
methodCallDescriptor = new MethodCallDescriptor(providedMethodReference);
response = await client.CallInvoker.CallUnary <GreetingRequest, GreetingResponse>(methodCallDescriptor,
greetingRequest);
response.Greeting.ShouldBe("FromServer2");
server1RequestCount.ShouldBe(1);
server2RequestCount.ShouldBe(1);
});
}
internal static async Task UnaryRequestExampleAsync(IGreetingClient client)
{
Console.Write("> Enter name to send: ");
var name = Console.ReadLine();
var request = new GreetingRequest {
Name = name
};
Console.WriteLine("Sending: {0}", name);
var response = await client.GreetingService.Unary(request);
Console.WriteLine("Received: {0}", response.Greeting);
}
private static async Task UnaryRequestExampleAsync(IClient client, IUnaryMethod <GreetingRequest, GreetingResponse> unaryMethod)
{
Console.Write("> Enter name to send: ");
var name = Console.ReadLine();
var request = new GreetingRequest {
Name = name
};
Console.WriteLine("Sending: {0}", name);
var response = await client.Call(unaryMethod, request);
Console.WriteLine("Received: {0}", response.Greeting);
}
//Unary Greet
public static void DoSimpleGreet(GreetingService.GreetingServiceClient client)
{
var greeting = new Greeting()
{
FirstName = "Bartu",
LastName = "Gozet"
};
var request = new GreetingRequest()
{
Greeting = greeting
};
var response = client.Greet(request);
Console.WriteLine(response.Result);
}
private static void Greet(GreetingService.GreetingServiceClient greetingClient)
{
var greeting = new Greeting()
{
FirstName = "Kevin Hayes",
LastName = "Anderson"
};
var greetRequest = new GreetingRequest()
{
Greeting = greeting
};
var greetResponse = greetingClient.Greet(greetRequest);
Console.WriteLine(greetResponse.Result);
}
public static void handleGreeting()
{
var greeting = new Greeting()
{
FirstName = "Petru",
LastName = "Ritivoiu"
};
var greetingRequest = new GreetingRequest()
{
Greeting = greeting
};
var greetingResponse = GreetRPC.Execute(host, port, greetingRequest).Result;
Console.WriteLine($"Result: {greetingResponse.Result}");
}
public async Task ServerStreaming(GreetingRequest request, IWritableChannel <GreetingResponse> responseStream, MethodCallContext context)
{
Console.WriteLine("Received server streaming request from {{{0}}}", context);
Console.WriteLine("Received: {0}", request.Name);
var greeting = $"Hello, {request.Name}!";
await responseStream
.WriteAsync(new GreetingResponse { Greeting = greeting })
.ConfigureAwait(false);
Console.WriteLine("Sent: {0}", greeting);
await Task.Delay(500).ConfigureAwait(false);
greeting = $"Hello again, {request.Name}!";
await responseStream
.WriteAsync(new GreetingResponse { Greeting = greeting })
.ConfigureAwait(false);
Console.WriteLine("Sent: {0}", greeting);
Console.WriteLine("Completed");
}
internal static async Task ServerStreamingRequestExampleAsync(IGreetingClient client)
{
Console.Write("> Enter name to send: ");
var name = Console.ReadLine();
var request = new GreetingRequest {
Name = name
};
Console.WriteLine("Sending: {0}", name);
var responseStream = client.GreetingService.ServerStreaming(request).ResponseStream;
while (await responseStream.WaitReadAvailableAsync())
{
while (responseStream.TryRead(out var response))
{
Console.WriteLine("Received: {0}", response.Greeting);
}
}
Console.WriteLine("Server stream completed");
}
public async Task Measure_Greeter_SayHello_Sequential_GRPC(int numberOfsamples)
{
var sut = this.fixture.gRPC();
var request = new GreetingRequest()
{
Name = "greetling"
};
TestAction act = async() =>
{
var reply = await sut.SayHelloAsync(request);
return(() => Task.FromResult(reply.Should().NotBeNull()));
};
var samples = await act.MeasureAsync(ApiStack.GRPC, numberOfsamples, Measure_Greeter_SayHello_Sequential);
samples.Should().Be(numberOfsamples);
}
static async Task GreetUnary(Channel channel)
{
WriteHeader("GreetUnary");
var client = new GreetingService.GreetingServiceClient(channel);
var greeting = new Greeting
{
FirstName = "John",
LastName = "Doe"
};
var request = new GreetingRequest()
{
Greeting = greeting
};
var response = await client.GreetAsync(request);
Console.WriteLine(response.Result);
}
private static void GreetUnary(Channel channel)
{
Console.WriteLine("Greet unary");
var client = new GreetingService.GreetingServiceClient(channel);
var greeting = new Greeting()
{
FirstName = "Stanislaw",
LastName = "Banski"
};
var request = new GreetingRequest()
{
Greeting = greeting
};
var response = client.Greet(request);
Console.WriteLine(response.Result);
Console.WriteLine("");
}
public void HomeController_GetCustomGreeting_SuccessTest()
{
//Arrange
var mockHelloWorldService = new Mock <IBusinessService>();
mockHelloWorldService.Setup(x => x.GetGreetings(It.IsAny <string>())).Returns("Hello World from Sethu!");
var mockconfig = new Mock <IConfiguration>();
mockconfig.Setup(x => x.GetSection("DisplaySettings")["WriteInfoTo"]).Returns("Client");
var controller = new HomeController(mockHelloWorldService.Object, mockconfig.Object);
var request = new GreetingRequest {
Name = "Sethu"
};
//Act
var response = controller.GetCustomGreeting(request);
//Assert
Assert.Equal("Hello World from Sethu!", response.Value.GreetingMessage);
}
static async Task Main(string[] args)
{
//var clientCert = File.ReadAllText("ssl/client.crt");
//var clientKey = File.ReadAllText("ssl/client.key");
//var caCrt = File.ReadAllText("ssl/ca.crt");
//var channelCredentials = new SslCredentials(caCrt, new KeyCertificatePair(clientCert, clientKey));
Channel channel = new Channel(target, ChannelCredentials.Insecure);
await channel.ConnectAsync().ContinueWith((task) =>
{
if (task.Status == TaskStatus.RanToCompletion)
{
Console.WriteLine("The client connected sussesfully");
}
});
var client = new GreetingService.GreetingServiceClient(channel);
var greeting = new Greeting()
{
FirstName = "Edison",
LastName = "Plaza"
};
// Unary
var request = new GreetingRequest()
{
Greeting = greeting
};
var response = client.Greet(request);
Console.WriteLine(response.Result);
channel.ShutdownAsync().Wait();
Console.ReadKey();
}
static void Main(string[] args)
{
Thread.Sleep(2000);
Channel channel = new Channel(Target, ChannelCredentials.Insecure);
channel.ConnectAsync().ContinueWith((task) =>
{
if (task.Status == TaskStatus.RanToCompletion)
{
Console.WriteLine("The Client connected successfully");
}
else
{
Console.WriteLine($"Client Task Status: {task.ToString()}");
}
});
//var client = new DummyService.DummyServiceClient(channel);
var client = new GreetingService.GreetingServiceClient(channel);
var greeting = new Greeting()
{
FirstName = "Francis",
LastName = "Chung"
};
var request = new GreetingRequest()
{
Greeting = greeting
};
var response = client.Greet(request);
Console.WriteLine($"Response : {response.Result}");
channel.ShutdownAsync().Wait();
Console.ReadKey();
}
public static async Task DuplexStreamingRequestExampleAsync(IClient client)
{
Console.WriteLine("Calling duplex streaming");
var duplexStreaming = Method.DuplexStreaming <GreetingRequest, GreetingResponse>("interop.samples.GreetingService", "DuplexStreaming");
var call = client.Call(duplexStreaming);
var requestStream = call.RequestStream;
var responseStream = call.ResponseStream;
var response = await responseStream.ReadAsync();
Console.WriteLine("Received: {0}", response.Greeting);
while (true)
{
Console.Write("> Enter next name to send\n> or empty line to complete request stream: ");
var name = Console.ReadLine();
if (string.IsNullOrEmpty(name))
{
break;
}
var request = new GreetingRequest {
Name = name
};
Console.WriteLine("Sending: {0}", name);
await requestStream.WriteAsync(request);
response = await responseStream.ReadAsync();
Console.WriteLine("Received: {0}", response.Greeting);
}
Console.WriteLine("Completing request stream");
requestStream.TryComplete();
while (await responseStream.WaitForNextSafeAsync())
{
while (responseStream.TryReadSafe(out response))
{
Console.WriteLine("Received: {0}", response.Greeting);
}
}
Console.WriteLine("Response stream completed");
}
public static async Task ServerStreamingRequestExampleAsync(IClient client)
{
var serverStreaming = Method.ServerStreaming <GreetingRequest, GreetingResponse>("interop.samples.GreetingService", "ServerStreaming");
Console.Write("> Enter name to send: ");
var name = Console.ReadLine();
var request = new GreetingRequest {
Name = name
};
Console.WriteLine("Sending: {0}", name);
var responseStream = client.Call(serverStreaming, request).ResponseStream;
while (await responseStream.WaitForNextSafeAsync())
{
while (responseStream.TryReadSafe(out var response))
{
Console.WriteLine("Received: {0}", response.Greeting);
}
}
Console.WriteLine("Server stream completed");
}
static void Main(string[] args)
{
using (var endpoint = new ClientEndpoint())
{
var request = new GreetingRequest
{
Message = "Hi",
SenderName = "Gabi"
};
Console.WriteLine("Client sending request: ");
Console.WriteLine($"{request} {System.Environment.NewLine}");
using var response = endpoint.Client.GreetAsync(request);
Console.WriteLine("Client received response: ");
Console.WriteLine(response.ResponseAsync.Result);
}
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
}
internal static async Task DuplexStreamingRequestExampleAsync(IGreetingClient client)
{
Console.WriteLine("Calling duplex streaming");
var call = client.GreetingService.DuplexStreaming();
var requestStream = call.RequestStream;
var responseStream = call.ResponseStream;
var response = await responseStream.ReadAsync();
Console.WriteLine("Received: {0}", response.Greeting);
while (true)
{
Console.Write("> Enter next name to send\n> or empty line to complete request stream: ");
var name = Console.ReadLine();
if (string.IsNullOrEmpty(name))
{
break;
}
var request = new GreetingRequest {
Name = name
};
Console.WriteLine("Sending: {0}", name);
await requestStream.WriteAsync(request);
response = await responseStream.ReadAsync();
Console.WriteLine("Received: {0}", response.Greeting);
}
Console.WriteLine("Completing request stream");
requestStream.TryComplete();
while (await responseStream.WaitReadAvailableAsync())
{
while (responseStream.TryRead(out response))
{
Console.WriteLine("Received: {0}", response.Greeting);
}
}
Console.WriteLine("Response stream completed");
}
internal static async Task DiscoveryExampleAsync(IGreetingClient client)
{
Console.WriteLine("Calling discovery for method {0}", GreetingService.DefaultDescriptor.UnaryMethod);
var discoveredProviders = (await client.DiscoveryInvoker.DiscoverAsync(GreetingService.DefaultDescriptor.UnaryMethod)).ToArray();
Console.WriteLine("Discovered {0} actions:", discoveredProviders.Length);
for (var i = 0; i < discoveredProviders.Length; i++)
{
Console.WriteLine(" {0}: {1} ({2})", i, discoveredProviders[i].Title, discoveredProviders[i].ProvidedMethod.ProvidedService.ApplicationId);
}
while (true)
{
Console.WriteLine("> Please choose which one to invoke\n> or empty line to skip invocation: ");
var s = Console.ReadLine();
if (string.IsNullOrEmpty(s))
{
break;
}
if (!int.TryParse(s, out var index) || index < 0 || index > discoveredProviders.Length)
{
Console.WriteLine("Invalid input. Please try again.");
}
var provider = discoveredProviders[index];
Console.WriteLine("Invoking {0} ({1})", provider.Title, provider.ProvidedMethod.ProvidedService.ApplicationId);
Console.Write("> Enter name to send: ");
var name = Console.ReadLine();
var request = new GreetingRequest {
Name = name
};
Console.WriteLine("Sending: {0}", name);
var response = await client.CallInvoker.Call(provider, request);
Console.WriteLine("Received: {0}", response.Greeting);
break;
}
}
public async Task <IActionResult> GetIndex([FromQuery] GreetingRequest req)
{
var greeting = await _greetingService.GetGreeting(req);
return(Content(greeting.Message));
}
public override Task <GreetingReply> SayHello(GreetingRequest request, ServerCallContext context)
{
var greeting = greeter.SayHello(request.Name);
return(Task.FromResult(GreetingReply.MapFrom(greeting)));
}
public async Task <IActionResult> PostIndex([FromBody] GreetingRequest req)
{
var greeting = await _greetingService.GetGreeting(req);
return(Json(greeting));
}
public override Task <GreetingResponse> GreetFunc(GreetingRequest request, ServerCallContext context)
{
return(Task.FromResult(new GreetingResponse {
Response = $"Hello {request.Request.Firstname} {request.Request.Lastname}"
}));
}
public static void DoSimpleGreet(GreetingService.GreetingServiceClient client, GreetingRequest request)
{
var response = client.Greet(request);
Console.WriteLine(response.Result);
}
static async Task Main(string[] args)
{
Channel channel = new Channel(target, ChannelCredentials.Insecure);
await channel.ConnectAsync().ContinueWith((task) =>
{
if (task.Status == TaskStatus.RanToCompletion)
{
Console.WriteLine("The client connected successfully");
}
});
//var client = new DummyService.DummyServiceClient(channel);
var greetingClient = new GreetingService.GreetingServiceClient(channel);
var greeting = new Greeting()
{
FirstName = "Shai",
LastName = "Blaustien"
};
var request = new GreetingRequest()
{
Greeting = greeting
};
var response = greetingClient.Greet(request);
Console.WriteLine(response.Result);
var calculatorService = new CalculatorService.CalculatorServiceClient(channel);
var sumRequest = new CalRequest {
A = 15, B = 28
};
var mulRequest = new CalRequest {
A = 5, B = 3
};
var sumResponse = calculatorService.Sum(sumRequest);
Console.WriteLine(sumResponse.Result);
var mulResponse = calculatorService.Mul(mulRequest);
Console.WriteLine(mulResponse.Result);
//var requestForMultiGreet = new GreetManyTimesRequest() { Greeting = greeting };
//var manyGreetingsResponse = greetingClient.GreetManyTimes(requestForMultiGreet);
//while(await manyGreetingsResponse.ResponseStream.MoveNext())
//{
// Console.WriteLine(manyGreetingsResponse.ResponseStream.Current.Result);
// await Task.Delay(200);
//}
var requestForPrimeNumbers = new PrimeRequest()
{
Number = 135
};
var PrimeResponse = calculatorService.Prime(requestForPrimeNumbers);
while (await PrimeResponse.ResponseStream.MoveNext())
{
Console.WriteLine(PrimeResponse.ResponseStream.Current.Result);
await Task.Delay(1500);
}
channel.ShutdownAsync().Wait();
Console.ReadKey();
}
public void Post([FromBody] GreetingRequest request)
{
var mailer = new EmailerClient(new HardCodedEmailSettingsProvider());
mailer.SendGreetingEmailTo(request.EmailAddressToUse);
}
