using Grpc.Core;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;

namespace Grpc.Demo.Server.Service
{
    public class MyGreetService : GreetService.GreetServiceBase
    {
        private readonly ILogger<MyGreetService> _logger;

        public MyGreetService(ILogger<MyGreetService> logger)
        {
            _logger = logger;
        }

        public override Task<HelloResponse> SayHello(HelloRequest request, ServerCallContext context)
        {
            return Task.FromResult(new HelloResponse
            {
                Message = "Hello " + request.Name + Guid.NewGuid().ToString()
            });
        }

        public override Task<EmployeeResponse> GetByNo(GetByNoRequest request, ServerCallContext context)
        {
            return Task.FromResult(new EmployeeResponse
            {
                Employee = new Employee()
                {
                    Id = 123,
                    No = 123456,
                    FirstName = Guid.NewGuid().ToString(),
                }
            });
        }

        public override async Task GetAll(GetAllRequest request, IServerStreamWriter<EmployeeResponse> responseStream, ServerCallContext context)
        {
            for (int i = 0; i < 10; i++)
            {
                await responseStream.WriteAsync(new EmployeeResponse()
                {
                    Employee = new Employee()
                    {
                        No = i,
                    }
                });
            }
        }

        public override async Task<AddPhotoResponse> AddPhoto(IAsyncStreamReader<AddPhotoRequest> requestStream, ServerCallContext context)
        {
            var data = new List<byte>();
            while (await requestStream.MoveNext())
            {
                data.AddRange(requestStream.Current.Data);
            }
            using MemoryStream memoryStream = new MemoryStream(data.ToArray());

            using FileStream fileStream = new FileStream("test.png", FileMode.OpenOrCreate);
            memoryStream.WriteTo(fileStream);

            return new AddPhotoResponse()
            {
                IsOk = true
            };
        }

        public override async Task<EmployeeResponse> Save(EmployeeRequest request, ServerCallContext context)
        {
            var employee = request.Employee;
            employee.FirstName = employee.FirstName + "1";
            return new EmployeeResponse()
            {
                Employee = employee
            };
        }

        public override async Task SaveAll(IAsyncStreamReader<EmployeeRequest> requestStream,
            IServerStreamWriter<EmployeeResponse> responseStream, ServerCallContext context)
        {
            var employees = new List<Employee>() {
            new Employee(){Id =1}
            };
            while (await requestStream.MoveNext())
            {
                employees.Add(requestStream.Current.Employee);
            }
            foreach (var employee in employees)
            {
                await responseStream.WriteAsync(new EmployeeResponse()
                {
                    Employee = employee
                });
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Grpc.Demo.Server.Service;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.HttpsPolicy;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

namespace Grpc.Demo.Server
{
    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        public void ConfigureServices(IServiceCollection services)
        {
            //添加grpc
            services.AddGrpc();

            services.AddControllersWithViews();
        }

        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            else
            {
                app.UseExceptionHandler("/Home/Error");
                app.UseHsts();
            }
            app.UseHttpsRedirection();
            app.UseStaticFiles();

            app.UseRouting();

            app.UseAuthorization();

            app.UseEndpoints(endpoints =>
            {
                //注册服务
                endpoints.MapGrpcService<MyGreetService>();

                endpoints.MapControllerRoute(
                    name: "default",
                    pattern: "{controller=Home}/{action=Index}/{id?}");
            });
        }
    }
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Grpc.Demo.Client.Models;
using Grpc.Net.Client;
using Grpc.Core;
using System.IO;
using Google.Protobuf;

namespace Grpc.Demo.Client.Controllers
{
    public class HomeController : Controller
    {
        private readonly ILogger<HomeController> _logger;

        public HomeController(ILogger<HomeController> logger)
        {
            _logger = logger;
        }

        public async Task<IActionResult> Index(int id)
        {
            var channel = GrpcChannel.ForAddress("https://localhost:5001");
            var client = new GreetService.GreetServiceClient(channel);
            string msg = string.Empty;
            switch (id)
            {
                case 1:
                    msg = await SayHelloAsync(client);
                    break;

                case 2:
                    msg = await GetByNoAsync(client);
                    break;

                case 3:
                    msg = await GetAllAsync(client);
                    break;

                case 4:
                    msg = await AddPhotoAsync(client);
                    break;

                case 5:
                    msg = await SaveAsync(client);
                    break;

                case 6:
                    msg = await SaveAllAsync(client);
                    break;

                default:
                    break;
            }

            ViewData["Message"] = msg;
            return View();
        }

        private async Task<string> SaveAllAsync(GreetService.GreetServiceClient client)
        {
            var employees = new List<Employee>()
            {
                new Employee(){Id=2, FirstName ="zhangsan"},
                new Employee(){Id=3, FirstName ="lisi"},
            };

            var cell = client.SaveAll();
            var requestStream = cell.RequestStream;
            var responseStream = cell.ResponseStream;

            var result = new List<Employee>();

            var responseTask = Task.Run(async () =>
            {
                while (await responseStream.MoveNext())
                {
                    result.Add(responseStream.Current.Employee);
                }
            });

            foreach (var employee in employees)
            {
                await requestStream.WriteAsync(new EmployeeRequest()
                {
                    Employee = employee
                });
            }

            await requestStream.CompleteAsync();
            await responseTask;

            return string.Join(",", result.Select(p => p.Id).ToList());
        }

        private async Task<string> SaveAsync(GreetService.GreetServiceClient client)
        {
            var cell = await client.SaveAsync(new EmployeeRequest()
            {
                Employee = new Employee
                {
                    FirstName = "zhangsan",
                }
            });
            return cell.Employee.FirstName;
        }

        private async Task<string> AddPhotoAsync(GreetService.GreetServiceClient client)
        {
            FileStream fs = System.IO.File.OpenRead("test.png");
            using var cell = client.AddPhoto();
            var stream = cell.RequestStream;
            while (true)
            {
                byte[] buffer = new byte[1024];
                int numRead = await fs.ReadAsync(buffer, 0, buffer.Length);
                if (numRead == 0)
                {
                    break;
                }
                if (numRead < buffer.Length)
                {
                    Array.Resize(ref buffer, numRead);
                }
                await stream.WriteAsync(new AddPhotoRequest()
                {
                    Data = ByteString.CopyFrom(buffer)
                });
            }

            await stream.CompleteAsync();
            var response = await cell.ResponseAsync;
            return response.IsOk.ToString();
        }

        private async Task<string> GetAllAsync(GreetService.GreetServiceClient client)
        {
            using var response = client.GetAll(new GetAllRequest());
            var responseStream = response.ResponseStream;
            List<Employee> list = new List<Employee>();
            while (await responseStream.MoveNext())
            {
                list.Add(responseStream.Current.Employee);
            }
            return string.Join(",", list.Select(p => p.Id).ToList());
        }

        private async Task<string> GetByNoAsync(GreetService.GreetServiceClient client)
        {
            var response = await client.GetByNoAsync(new GetByNoRequest()
            {
                No = 1
            });
            return response.Employee.LastName;
        }

        private async Task<string> SayHelloAsync(GreetService.GreetServiceClient client)
        {
            var response = await client.SayHelloAsync(new HelloRequest { Name = "World" });
            return response.Message;
        }
    }
}