<ItemGroup>  
    <Protobuf Include="Protos\xxxx.proto" GrpcServices="Server" />
</ItemGroup>
 
<ItemGroup>  
    <Protobuf Include="Protos\xxxx.proto" GrpcServices="Client" />
</ItemGroup>

services.AddGrpc();

app.UseEndpoints(endpoints =>
{
    // Communication with gRPC endpoints must be made through a gRPC client.
    // To learn how to create a client, visit: https://go.microsoft.com/fwlink/?linkid=2086909
    endpoints.MapGrpcService<GreeterService>();
});

{
  "Kestrel": {
    "Endpoints": {
      "HttpsInlineCertFile": {
        "Url": "https://localhost:5001",
        "Protocols": "Http2",
        "Certificate": {
          "Path": "<path to .pfx file>",
          "Password": "<certificate password>"
        }
      }
    }
  }
}

public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureWebHostDefaults(webBuilder =>
        {
            webBuilder.ConfigureKestrel(options =>
            {
                options.Listen(IPAddress.Any, 5001, listenOptions =>
                {
                    listenOptions.Protocols = HttpProtocols.Http2;
                    listenOptions.UseHttps("<path to .pfx file>",
                        "<certificate password>");
                });
            });
            webBuilder.UseStartup<Startup>();
        });

public class GreeterService : Greeter.GreeterBase
{
    private readonly ILogger<GreeterService> _logger;
    public GreeterService(ILogger<GreeterService> logger)
    {
        _logger = logger;
    }
 
    public override Task<HelloReply> SayHello(HelloRequest request, ServerCallContext context)
    {
        return Task.FromResult(new HelloReply
        {
            Message = "Hello " + request.Name
        });
    }
}

var channel = GrpcChannel.ForAddress("https://localhost:5001");
var client = new Greet.GreeterClient(channel);

var reply1 = await client.SayHelloAsync(new HelloRequest { Name = "GreeterClient" });
var reply2 =  client.SayHello(new HelloRequest { Name = "GreeterClient" });

var client = new Greet.GreeterClient(channel);
using (var call = client.SayHellos(new HelloRequest { Name = "World" }))
{
    while (await call.ResponseStream.MoveNext())
    {
        Console.WriteLine("Greeting: " + call.ResponseStream.Current.Message);
        // "Greeting: Hello World" is written multiple times
    }
}
 
//或者C# 8以上通過(guò)await foreach來(lái)處理返回信息
using (var call = client.SayHellos(new HelloRequest { Name = "World" }))
{
    await foreach (var response in call.ResponseStream.ReadAllAsync())
    {
        Console.WriteLine("Greeting: " + response.Message);
        // "Greeting: Hello World" is written multiple times
    }
}

var client = new Counter.CounterClient(channel);
using (var call = client.AccumulateCount())
{
    //調(diào)用三次
    for (var i = 0; i < 3; i++)
    {
        await call.RequestStream.WriteAsync(new CounterRequest { Count = 1 });
    }
    //通知服務(wù)寫(xiě)好了
    await call.RequestStream.CompleteAsync();
    //獲取返回結(jié)果
    var response = await call;
    Console.WriteLine($"Count: {response.Count}");
    // Count: 3
}

using (var call = client.Echo())
{
    Console.WriteLine("Starting background task to receive messages");
    var readTask = Task.Run(async () =>
    {
        await foreach (var response in call.ResponseStream.ReadAllAsync())
        {
            Console.WriteLine(response.Message);
            // Echo messages sent to the service
        }
    });
 
    Console.WriteLine("Starting to send messages");
    Console.WriteLine("Type a message to echo then press enter.");
    while (true)
    {
        var result = Console.ReadLine();
        if (string.IsNullOrEmpty(result))
        {
            break;
        }
 
        await call.RequestStream.WriteAsync(new EchoMessage { Message = result });
    }
 
    Console.WriteLine("Disconnecting");
    await call.RequestStream.CompleteAsync();
    await readTask;
}

syntax = "proto3";
 
option csharp_namespace = "GrpcService";
 
package Hello;
 
service Hello {
  //通過(guò)一元方式傳輸
  rpc SayHello (HelloRequest) returns (HelloReply);
  //通過(guò)客戶端流的方式傳輸
  rpc SayHelloClientStream (stream HelloRequest) returns (HelloReply);
  //通過(guò)服務(wù)端流的方式傳輸
  rpc SayHelloServerStream (HelloRequest) returns (stream HelloReply);
  //通過(guò)雙向流的方式傳輸
  rpc SayHelloStream (stream HelloRequest) returns (stream HelloReply);
}
 
message HelloRequest {
  string name = 1;
}
 
message HelloReply {
  string message = 1;
}

<ItemGroup>   
     <Protobuf Include="Hello.proto" GrpcServices="Server" />
</ItemGroup>

public class HelloService : Hello.HelloBase
{
    public override Task<HelloReply> SayHello(HelloRequest request, ServerCallContext context)
    {
        return Task.FromResult(new HelloReply
        {
            Message = "Response:" + request.Name
        });
    }
 
    public override async Task<HelloReply> SayHelloClientStream(IAsyncStreamReader<HelloRequest> requestStream, ServerCallContext context)
    {
 
        var current = new HelloRequest();
        while (await requestStream.MoveNext())
        {
            current = requestStream.Current;
        }
 
        var task = new Task<HelloReply>(() =>
        {
            var reply = new HelloReply()
            {
                Message = "Response:" + current.Name
            };
            return reply;
        });
 
        task.Start();
 
        var result = await task;
 
        return result;
    }
 
    public override async Task SayHelloServerStream(HelloRequest request, IServerStreamWriter<HelloReply> responseStream, ServerCallContext context)
    {
        await responseStream.WriteAsync(new HelloReply() { Message = "Response:" + request.Name });
 
    }
 
    public override async Task SayHelloStream(IAsyncStreamReader<HelloRequest> requestStream,
        IServerStreamWriter<HelloReply> responseStream,
        ServerCallContext context)
    {
        while (await requestStream.MoveNext())
        {
            await responseStream.WriteAsync(new HelloReply() { Message = "Response:" + requestStream.Current.Name });
        }
    }
}

class Program
{
    private static Server _server;
 
    static void Main(string[] args)
    {
        _server = new Server
        {
            Services = { Hello.BindService(new HelloService()) },
            //這里使用的是不安全的方式
            Ports = { new ServerPort("localhost", 50001, ServerCredentials.Insecure) }
        };
        _server.Start();
 
        Console.WriteLine("Listen Port 50001");
        Console.ReadKey();
 
        _server?.ShutdownAsync().Wait();
    }
}

class Program
{
    static void Main(string[] args)
    {
        #region 使用Kestrel服務(wù)器
        CreateHostBuilder(args).Build().Run();
        #endregion
    }
 
    public static IHostBuilder CreateHostBuilder(string[] args) =>
      Host.CreateDefaultBuilder(args)
          .ConfigureWebHostDefaults(webBuilder =>
          {
              webBuilder.ConfigureKestrel(options =>
              {
                    // Setup a HTTP/2 endpoint without TLS.
                    options.ListenLocalhost(50001, o => o.Protocols =
                      HttpProtocols.Http2);
              });
 
              webBuilder.UseStartup<Startup>();
          });
}

public class Startup
{   
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddGrpc();
    }
 
    // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
 
        app.UseRouting();
 
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapGrpcService<HelloService>();
 
            endpoints.MapGet("/", async context =>
            {
                await context.Response.WriteAsync("Communication with gRPC endpoints must be made through a gRPC client." +
                    " To learn how to create a client, visit: https://go.microsoft.com/fwlink/?linkid=2086909");
            });
        });
    }
}

<ItemGroup>    
    <Protobuf Include="Hello.proto" GrpcServices="Client" />  
</ItemGroup>

class Program
{
    static async Task Main(string[] args)
    {
        // This switch must be set before creating the GrpcChannel/HttpClient.
        AppContext.SetSwitch("System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true);
 
        var channel = GrpcChannel.ForAddress("http://localhost:50001");
        var helloClient = new Hello.HelloClient(channel);
 
        //一元調(diào)用(同步方法）
        var reply = helloClient.SayHello(new HelloRequest { Name = "一元同步調(diào)用" });
        Console.WriteLine($"{reply.Message}");
 
        //一元調(diào)用(異步方法）
        var reply2 = helloClient.SayHelloAsync(new HelloRequest { Name = "一元異步調(diào)用" }).GetAwaiter().GetResult();
        Console.WriteLine($"{reply2.Message}");
 
        //服務(wù)端流
        var reply3 = helloClient.SayHelloServerStream(new HelloRequest { Name = "服務(wù)端流" });
        while (await reply3.ResponseStream.MoveNext())
        {
            Console.WriteLine(reply3.ResponseStream.Current.Message);
        }
 
        //客戶端流
        using (var call = helloClient.SayHelloClientStream())
        {  
            await call.RequestStream.WriteAsync(new HelloRequest { Name = "客戶端流" + i.ToString() });
            await call.RequestStream.CompleteAsync();
            var reply4 = await call;
            Console.WriteLine($"{reply4.Message}");
        }
 
        //雙向流
        using (var call = helloClient.SayHelloStream())
        {
            Console.WriteLine("Starting background task to receive messages");
            var readTask = Task.Run(async () =>
            {
                await foreach (var response in call.ResponseStream.ReadAllAsync())
                {
                    Console.WriteLine(response.Message);
                }
            });
             
            for (var i = 0; i < 3; i++)
            {
                await call.RequestStream.WriteAsync(new HelloRequest { Name = "雙向流" + i.ToString()});
            }
 
            await call.RequestStream.CompleteAsync();
            await readTask;
        }
        Console.ReadKey();
    }
}