gRPC 指南

2025-05-27

gRPC 指南

总结

在本指南中，我旨在提供有关gRPC和Protocol Buffers的要点。如果您已经了解gRPC和Protocol Buffers是什么，那么本指南不适合您阅读。本指南面向初学者或对其稍感兴趣的用户。

gRPC是一个用于构建 API 的框架，是基于 JSON 和 XML 的服务的替代方案。gRPC 具有以下属性：

  • 一个免费的开源框架，最初由谷歌开发，但现在是云原生计算基金会 (CNCF) 的一部分
  • 跨平台、语言无关
  • 基于HTTP/2构建，支持一元和流通信

协议缓冲区用于序列化结构化数据，gRPC 默认使用它。协议缓冲区具有以下属性：

  • 与语言无关
  • 序列化的帮助结构信息
  • 促进代码生成
  • 由于数据是二进制的，因此有效载荷较小，序列化效率高

本指南中的大多数概念与语言无关。不过，目前我仅提供使用 .NET Core 3.1 的 C# 示例。这些示例已在 Linux 和 Windows 上测试过。所有示例均使用Visual Studio Code和C# for Visual Studio Code扩展创建。示例可在此处找到：

介绍

简而言之，gRPC 可以概括如下：

高性能、开源的通用RPC框架

-- https://grpc.io

在深入探讨 gRPC 之前，我想先回顾一下，了解 gRPC 所要解决的问题。为此，我需要讨论一下通信基础理论。虽然这是一篇技术文章，但我不会讨论如何将通信理论应用于计算系统。相反，我将讨论一个两个人对话的例子。

假设有两个人在同一个房间里进行讨论。两个人说着同一种语言，沟通媒介本质上就是两个人交谈的同一个共享空间。现在，我们先简单假设这种沟通是单向的（一次只以一种方式进行沟通）。

  • 发送者向接收者发送消息（请求）并等待响应
  • 接收方接收消息（请求）并以另一条消息的形式返回响应

因为两个人在同一个房间里，说着同一种语言，所以沟通非常简单。无需任何特殊手段即可顺利沟通。为了清晰起见，可以观察到此类沟通的以下特点。

  • 同一种语言
  • 相同空间（非分布式）
  • 相同介质

下图进一步说明了此场景中的通信是如何发生的。

grpc-comms-1

现在想象一下，有两个人分别在不同的房间，来自不同的国家，说着不同的语言。以下属性与上面的例子形成了对比：

  • 不同的语言
  • 不同空间（分布式）
  • 不同的介质

在这个例子中，为了实现成功的通信，我们需要一种机制来实现分布式通信。该机制需要定义某种形式的协议（约定的规则），并且还需要对发送方和接收方之间发送的消息进行某种形式的编码和解码。如下图所示。

grpc-comms-2

现在想象一下，我们简单地用两个计算系统替换两个人。一个客户端和一个服务器。客户端可能是用 Javascript 编写的NodeJS 控制台应用程序。服务器可能正在运行C# .NET应用程序。我们有 2 个独立的系统，它们在不同的数据中心运行并通过网络连接。换句话说，我们有一个分布式计算系统。为了使客户端和服务器进行通信，需要使用具有协议的机制。协议缓冲区（Protobuf）和gRPC就是这样一种机制。下图说明了如何将我们的基本通信模型转换为 gRPC 客户端和服务器。客户端和服务器可以完全分布并运行在世界各地不同位置的不同数据中心。

grpc-stub-服务器

还有其他解决方案也解决了这个问题。在撰写本文时，我们仍在使用其中一些。例如，Http 服务 (REST) 仍然非常流行。gRPC 只是一种实现分布式服务和系统之间通信的替代方案。重要的是要记住，尽管解决一个常见问题的方法有很多，但我们使用这些不同方法的方式可能大相径庭。例如，构建和使用 Http 服务与构建和使用 gRPC 服务完全不同。

有一些非常好的在线文档描述了gRPC和协议缓冲区。

由于在线文档非常出色，我不会重复一些已经完成的优秀工作。相反，我将重点介绍gRPC和Protocol Buffers的要点。我还将提供一些示例来说明如何开始使用gRPC 。所有示例都将使用.NET Core 上的 gRPC提供。有关在 .NET Core 上构建和使用 gRPC 服务的更多具体文档，请参阅以下优秀的在线文档：

协议缓冲区

什么？

协议缓冲区是一种序列化结构化数据的机制。gRPC 使用它们作为默认的序列化机制。

更多信息：

如何？

由于Protocol Buffers用于序列化结构化数据，因此您需要定义待序列化信息的结构。我们通过在.proto文件中定义 Protocol Buffers 消息类型来实现这一点。

例如：

message User {
    string firstName = 1;
    string lastName = 2;
    string email = 3;

    enum AddressType {
        HOME = 0;
        POSTAL = 1;
        WORK = 2;
    }

    message Address {
        string line1 = 1;
        string line2 = 2;
        string region = 3;
        string city = 4;
        string suburb = 5;
        string code = 6;
        AddressType type = 7;        
    }

    repeated Address addresses = 4;
}
Enter fullscreen mode Exit fullscreen mode

练习时间

1. 设置协议编译器

编译上述“meetings.proto”文件的最基本方法是使用“protoc”编译器。protoc编译器适用于多种不同平台。请参阅protobuf发布页面。

如果您和我一样是 Debian/Ubuntu 和/或 Windows 上的开发人员，您会发现以下在线资源对于安装protobuf 编译器很有用。

# For Windows using Chocolatey

  - Install Chocolatey (https://chocolatey.org/install)

  - Install protoc (https://chocolatey.org/packages/protoc) 

    choco install protoc

# For Debian Stretch using apt

  - Install protoc (https://packages.debian.org/stretch/protobuf-compiler)

    sudo apt install protobuf-compiler

# For Ubuntu Bionic using apt

  - Install protoc (https://launchpad.net/ubuntu/bionic/+package/protobuf-compiler)

    sudo apt install protobuf-compiler
Enter fullscreen mode Exit fullscreen mode
2. 创建“meetings.proto”文件
syntax = "proto3";

package examples;

message User {
    string firstName = 1;
    string lastName = 2;
    string email = 3;

    enum AddressType {
        HOME = 0;
        POSTAL = 1;
        WORK = 2;
    }

    message Address {
        string line1 = 1;
        string line2 = 2;
        string region = 3;
        string city = 4;
        string suburb = 5;
        string code = 6;
        AddressType type = 7;        
    }

    repeated Address addresses = 4;
}

message Meeting {
    repeated User users = 1;
}
Enter fullscreen mode Exit fullscreen mode
3. 编译'meetings.proto'文件
# For Python
protoc -I . --python_out=. ./meetings.proto

# For Node/Javascript
protoc -I . --js_out=. ./meetings.proto

# For C#
protoc -I . --csharp_out=. ./meetings.proto
Enter fullscreen mode Exit fullscreen mode

最后一步是将生成的代码与你选择的编程语言结合使用。更多教程请见：

gRPC

gRPC 是一个免费的开源 RPC（远程过程调用）框架，用于构建分布式服务。根据维基百科的介绍，RPC 可以概括如下：

在分布式计算中，远程过程调用 (RPC) 是指计算机程序使某个过程（子例程）在不同的地址空间（通常是共享网络上的另一台计算机）执行，其编码方式与普通的（本地）过程调用类似，程序员无需明确编写远程交互的细节。也就是说，无论子例程是在执行程序的本地还是远程执行，程序员编写的代码基本相同。这是一种客户端-服务器交互的形式（调用者是客户端，执行者是服务器），通常通过请求-响应消息传递系统实现。

——维基百科

gRPC使用Protocol Buffers进行通信。另外，gRPC总结如下：

  • 由 Google 设计
  • 2015 年开源，现为云原生计算基金会孵化项目
  • 丰富的语言支持
    • C++
    • Java
    • Python
    • 去
    • C#
    • Node.js
    • Android Java
    • 镖
  • 客户端可以在服务器应用程序（在不同的机器上）上执行方法，就像它是本地对象一样
  • gRPC 服务由服务（具有参数和返回类型的方法）和消息（具有指定类型的属性或数据）组成的接口定义
  • 该接口由服务器实现，并作为接受远程客户端调用的服务运行
  • 客户端使用存根（服务器使用的接口的精确表示）对服务器进行远程调用
  • 服务器和客户端与平台和语言无关。这意味着，你可以用 Java 实现服务器，但该服务器可以被用其他语言/平台（例如 Python、Node、C# 等）实现的客户端使用。
  • 默认使用协议缓冲区。协议缓冲区既可以用作接口定义语言 (IDL)，也可以用作底层消息交换格式。

为什么要关心 gRPC？

我将分享一个非常主观的观点（我的观点），说明为什么你应该学习 gRPC。

1. 我认为 gRPC 非常适合构建 API。因为 gRPC 可以帮助你像进行本地函数调用一样轻松地连接、执行和调试分布式系统，所以你不会觉得它与你通常的代码流程有任何不同。正是这种易用性和简洁性，我认为让它感觉更自然、更容易上手。

2. gRPC 以其高效（序列化）、快速和低延迟而闻名。因此我认为它非常适合构建微服务。

3. 为了讨论的目的，我列出了通常开发的 3 种类型的 API：

  • 内部 - 这意味着您的 API 可以在您选择的服务边界内的任何位置访问。换句话说，内部 API 仅供您私有网络上的内部使用。
  • 合作伙伴 - 合作伙伴 API 既是内部 API，也是公开 API。但它们旨在作为您应用程序和服务与合作伙伴应用程序和服务之间的集成点。通常，这些 API 会使用 VPN 和/或 IP 白名单等技术进行锁定。
  • 公开 - 公共互联网上的任何人都可以访问 API

考虑到这三种类型的 API，我认为 gRPC 最初是内部 API 的理想选择。随着越来越多的公司和开发者开始使用 gRPC，我认为它的大规模采用也将开始推动合作伙伴 API 和公共 API 的 gRPC 服务的发展。

4. 掌握构建 gRPC 服务的技能将对你的未来大有裨益。我认为 gRPC 的普及度将会持续增长。下面，我提供了过去 5 年 gRPC 的 Google 趋势（gRPC 于 2015 年开源）。请注意，趋势稳步上升。

在此处查看 gRPC 趋势

grpc趋势

工具

大多数使用 REST 或 HTTP 服务的开发者都熟悉出色的 Postman 工具。Postman是与 HTTP 服务交互的理想客户端工具。遗憾的是，Postman目前尚不支持 gRPC。幸运的是，有一款 gRPC 客户端工具值得一提，那就是bloomRPC。

bloomRPC

gRPC 服务的 GUI 客户端

特征

  • 原生 gRPC 调用
  • 一元调用和服务器端流支持
  • 客户端和双向流
  • 自动输入识别
  • 多标签操作
  • 元数据支持
  • 持久工作区
  • 请求取消

请查看bloomRPC代码库，顺便给它打个星。它值得这个 :)

grpc-bloomgrpc

其他

示例

先决条件

测试于

消息传递示例

此示例是一个简单的消息传递应用程序，演示了如何创建 .NET Core gRPC 客户端和gRPC 服务器。

完成本示例后，您将拥有一个用 C# 编写的 gRPC 客户端控制台应用程序，该应用程序能够与用 C# 编写的 gRPC 服务器控制台应用程序发送和接收消息。将演示以下概念：

  • 创建 gRPC 客户端（C# 控制台应用程序）
  • 创建 gRPC 服务器（C# 控制台应用程序）
  • 从 gRPC 客户端向 gRPC 服务器发送消息

1. 创建解决方案

mkdir grpc-messaging
cd grpc-messaging
dotnet new sln -n Messaging
Enter fullscreen mode Exit fullscreen mode

2.创建“messaging.proto”文件

# for linux
touch messaging.proto

# for powershell
New-Item -Name messaging.proto
Enter fullscreen mode Exit fullscreen mode

定义“messaging.proto”文件

syntax = "proto3";

package messaging;

option csharp_namespace = "Messaging";

message MessageRequest {
    string message = 1;
}

message MessageResponse {
    string message = 1;
}

service Messenger {
    rpc Message (MessageRequest) returns (MessageResponse);
}
Enter fullscreen mode Exit fullscreen mode

3.创建 gRPC 服务器

3.1 创建服务器控制台应用程序
dotnet new console -n Messaging.ServerApp
dotnet sln Messaging.sln add Messaging.ServerApp
Enter fullscreen mode Exit fullscreen mode
3.2 添加创建 gRPC 服务器所需的包
cd Messaging.ServerApp
dotnet add package gRPC
dotnet add package gRPC.Tools
dotnet add package Google.Protobuf

dotnet list package

Project 'Messaging.ServerApp' has the following package references
   [netcoreapp3.1]:
   Top-level Package      Requested   Resolved
   > Google.Protobuf      3.11.3      3.11.3
   > gRPC                 2.27.0      2.27.0
   > gRPC.Tools           2.27.0      2.27.0
Enter fullscreen mode Exit fullscreen mode
3.3 创建“服务”文件夹
mkdir Services
Enter fullscreen mode Exit fullscreen mode
3.4 编辑Messaging.ServerApp.csproj文件

我们需要将以下“ItemGroup”添加到Messaging.ServerApp.csproj以便为我们的 gRPC 服务器启用适当的代码生成。

<ItemGroup>
    <Protobuf Include="../*.proto" GrpcServices="Server" OutputDir="%(RelativePath)Services" CompileOutputs="false" />
</ItemGroup>
Enter fullscreen mode Exit fullscreen mode 
- Include="../*.proto" - Include all '.proto' files for code generation
- GrpcServices="Server" - Only generate code relevant to server
- OutputDir="%(RelativePath)Services" - path for generated files
- CompileOutputs="false" - prevents compiling generated files into assembly
Enter fullscreen mode Exit fullscreen mode

生成的Messaging.ServerApp.csproj文件应如下所示：

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp3.1</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
    <Protobuf Include="../*.proto" GrpcServices="Server" OutputDir="%(RelativePath)Services" CompileOutputs="false" />
  </ItemGroup>

  <ItemGroup>
    <PackageReference Include="Google.Protobuf" Version="3.11.3" />
    <PackageReference Include="gRPC" Version="2.27.0" />
    <PackageReference Include="gRPC.Tools" Version="2.27.0">
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
      <PrivateAssets>all</PrivateAssets>
    </PackageReference>
  </ItemGroup>

</Project>
Enter fullscreen mode Exit fullscreen mode
3.5 构建解决方案
# Build from the root of solution
cd ..
dotnet build
Enter fullscreen mode Exit fullscreen mode

构建完成后，您应该看到如下解决方案结构。请注意“Services”文件夹中的两个生成文件。

  • 消息传递.cs
  • MessagingGrpc.cs

grpc-服务器解决方案

3.6 创建“MessengerService”

创建一个实现生成的 gRPC“MessengerBase”代码的服务

using System.Threading.Tasks;
using Grpc.Core;

namespace Messaging.ServerApp
{
    public sealed class MessengerService : Messenger.MessengerBase
    {
        public override Task<MessageResponse> Message(MessageRequest request, ServerCallContext context)
        {
            return Task.FromResult(new MessageResponse
            {
                Message = $"This is your friendly gRPC Server. Received message: '{request.Message}'"
            });
        }
    }
}
Enter fullscreen mode Exit fullscreen mode
3.7 更新“Program.cs”以运行服务器
using System;
using System.IO;
using System.Threading.Tasks;
using Grpc.Core;

namespace Messaging.ServerApp
{
    internal sealed class Program
    {
        internal static async Task Main(string[] args)
        {
            const int Port = 50050;

            Server server = null;

            try
            {
                server = new Server
                {
                    Services = { Messenger.BindService(new MessengerService()) },
                    Ports = { new ServerPort("localhost", Port, ServerCredentials.Insecure ) }
                };

                server.Start();

                Console.WriteLine($"Messenger server listening on port {Port}");
                Console.WriteLine("Press any key to stop the server...");
                Console.ReadKey();
            }
            catch(IOException exception)
            {
                Console.WriteLine($"Server failed to start: {exception.Message}");
                throw;
            }
            finally
            {
                if (server != null)
                    await server.ShutdownAsync();
            }
        }
    }
}
Enter fullscreen mode Exit fullscreen mode
3.8 运行 gRPC 服务器
dotnet run -p Messaging.ServerApp

# You should see the following response
Messenger server listening on port 50050
Press any key to stop the server...
Enter fullscreen mode Exit fullscreen mode

4.创建 gRPC 客户端

4.1 创建客户端控制台应用程序
# From the root of solution

dotnet new console -n Messaging.ClientApp
dotnet sln Messaging.sln add Messaging.ClientApp
Enter fullscreen mode Exit fullscreen mode
4.2 添加创建 gRPC 客户端所需的包
cd Messaging.ClientApp
dotnet add package gRPC
dotnet add package gRPC.Tools
dotnet add package Google.Protobuf

dotnet list package

Project 'Messaging.ClientApp' has the following package references
   [netcoreapp3.1]:
   Top-level Package      Requested   Resolved
   > Google.Protobuf      3.11.3      3.11.3
   > gRPC                 2.27.0      2.27.0
   > gRPC.Tools           2.27.0      2.27.0
Enter fullscreen mode Exit fullscreen mode
4.3 创建“服务”文件夹
mkdir Services
Enter fullscreen mode Exit fullscreen mode
4.4 编辑Messaging.ClientApp.csproj文件

我们需要将以下“ItemGroup”添加到Messaging.ClientApp.csproj，以便为我们的gRPC客户端启用适当的代码生成。

<ItemGroup>
    <Protobuf Include="../*.proto" GrpcServices="Client" OutputDir="%(RelativePath)Services" CompileOutputs="false" />
</ItemGroup>
Enter fullscreen mode Exit fullscreen mode 
- Include="../*.proto" - Include all '.proto' files for code generation
- GrpcServices="Client" - Only generate code relevant to Client
- OutputDir="%(RelativePath)Services" - path for generated files
- CompileOutputs="false" - prevents compiling generated files into assembly
Enter fullscreen mode Exit fullscreen mode

生成的Messaging.ClientApp.csproj文件应如下所示：

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp3.1</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
    <Protobuf Include="../*.proto" GrpcServices="Client" OutputDir="%(RelativePath)Services" CompileOutputs="false" />
  </ItemGroup>

  <ItemGroup>
    <PackageReference Include="Google.Protobuf" Version="3.11.3" />
    <PackageReference Include="gRPC" Version="2.27.0" />
    <PackageReference Include="gRPC.Tools" Version="2.27.0">
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
      <PrivateAssets>all</PrivateAssets>
    </PackageReference>
  </ItemGroup>

</Project>
Enter fullscreen mode Exit fullscreen mode
4.5 构建解决方案
# Build from the root of solution
cd ..
dotnet build
Enter fullscreen mode Exit fullscreen mode

构建完成后，您应该看到如下解决方案结构。请注意“Services”文件夹中的两个生成文件。

  • 消息传递.cs
  • MessagingGrpc.cs

grpc-客户端解决方案

4.6 更新“Program.cs”以运行客户端
using Grpc.Core;
using Messaging;
using System;
using System.Threading.Tasks;

namespace Messaging.ClientApp
{
    internal sealed class Program
    {
        internal static async Task Main(string[] args)
        {
            Channel channel = new Channel("127.0.0.1:50050", ChannelCredentials.Insecure);

            var client = new Messenger.MessengerClient(channel);
            var reply = client.Message(new MessageRequest { Message = "These are not the droids you are looking for ..." });
            Console.WriteLine("Message: " + reply.Message);

            await channel.ShutdownAsync();

            Console.WriteLine("Press any key to exit...");
            Console.ReadKey();
        }
    }
}
Enter fullscreen mode Exit fullscreen mode
4.7 运行 gRPC 客户端
dotnet run -p Messaging.ClientApp

# You should see the following response
Message: This is your friendly gRPC Server. Received message: 'These are not the droids you are looking for ...'
Press any key to exit...
Enter fullscreen mode Exit fullscreen mode

解决方案

完整的解决方案可以在这里找到。

计算器示例

现在轮到你了。创建一个 gRPC 计算器服务，提供以下算术运算：

  • 添加
  • 减去
  • 乘
  • 划分

解决方案

完整的解决方案可以在这里找到。

原始文件
syntax = "proto3";
package calculators;
option csharp_namespace = "Calculators";

message OperationRequest {
    repeated double operands = 1;
}

message OperationResponse {
    double result = 1;
}

message DivisionRequest {
    double dividend = 1;
    double divisor = 2;
}

message DivisionResponse {
    double result = 1;
}

service Calculator {
    rpc Add (OperationRequest) returns (OperationResponse);
    rpc Subtract (OperationRequest) returns (OperationResponse);
    rpc Multiply (OperationRequest) returns (OperationResponse);
    rpc Divide (DivisionRequest) returns (DivisionResponse);
}
Enter fullscreen mode Exit fullscreen mode
gRPC 计算器服务器
/// ########################
/// CalculatorService
/// ########################

using Grpc.Core;
using System.Linq;
using System.Threading.Tasks;

namespace Calculators.ServerApp
{
    public sealed class CalculatorService : Calculator.CalculatorBase
    {
        public override Task<OperationResponse> Add(OperationRequest request, ServerCallContext context)
        {
            return Task.FromResult(new OperationResponse
            {
                Result = request.Operands.Sum()
            });
        }

        public override Task<DivisionResponse> Divide(DivisionRequest request, ServerCallContext context)
        {
            return Task.FromResult(new DivisionResponse
            {
                Result = request.Dividend / request.Divisor
            });
        }

        public override Task<OperationResponse> Multiply(OperationRequest request, ServerCallContext context)
        {
            return Task.FromResult(new OperationResponse
            {
                Result = request.Operands.Aggregate((acc, operand) => acc *= operand)
            });
        }

        public override Task<OperationResponse> Subtract(OperationRequest request, ServerCallContext context)
        {
            return Task.FromResult(new OperationResponse
            {
                Result = request.Operands.Aggregate((acc, operand) => acc -= operand)
            });
        }
    }
}
Enter fullscreen mode Exit fullscreen mode 
/// ########################
/// Program
/// ########################

using System;
using System.IO;
using System.Threading.Tasks;
using Grpc.Core;

namespace Calculators.ServerApp
{
    internal sealed class Program
    {
        internal static async Task Main(string[] args)
        {
            const int Port = 50050;

            Server server = null;

            try
            {
                server = new Server
                {
                    Services = { Calculator.BindService(new CalculatorService()) },
                    Ports = { new ServerPort("localhost", Port, ServerCredentials.Insecure) }
                };

                server.Start();

                Console.WriteLine($"Calculator server listening on port {Port}");
                Console.WriteLine("Press any key to stop the server...");
                Console.ReadKey();
            }
            catch (IOException exception)
            {
                Console.WriteLine($"Server failed to start: {exception.Message}");
                throw;
            }
            finally
            {
                if (server != null)
                    await server.ShutdownAsync();
            }
        }
    }
}
Enter fullscreen mode Exit fullscreen mode
gRPC 计算器客户端
/// ########################
/// Program
/// ########################

using System;
using System.Threading.Tasks;
using Grpc.Core;

namespace Calculators.ClientApp
{
    internal sealed class Program
    {
        internal static async Task Main(string[] args)
        {
            Channel channel = new Channel("127.0.0.1:50050", ChannelCredentials.Insecure);

            var client = new Calculator.CalculatorClient(channel);
            var operands = new double[5] { 1D, 2D, 3D, 4D, 5D };

            var addRequest = new OperationRequest();
            addRequest.Operands.AddRange(operands);

            var subtractRequest = new OperationRequest();
            subtractRequest.Operands.AddRange(operands);

            var multiplicationRequest = new OperationRequest();
            multiplicationRequest.Operands.AddRange(operands);

            var divisionRequest = new DivisionRequest
            {
                Dividend = 45,
                Divisor = 5
            };

            var sum = await client.AddAsync(addRequest);
            var difference = await client.SubtractAsync(subtractRequest);
            var product = await client.MultiplyAsync(multiplicationRequest);
            var division = await client.DivideAsync(divisionRequest);

            Console.WriteLine($"Sum: {sum.Result}, Difference: {difference.Result}, Product: {product.Result}, Division: {division.Result}");

            await channel.ShutdownAsync();

            Console.WriteLine("Press any key to exit...");
            Console.ReadKey();
        }
    }
}
Enter fullscreen mode Exit fullscreen mode

接下来去哪里？

本指南中我仅介绍了 gRPC 和 Protocol Buffer 的基础知识。建议您在线查找与您选择的平台/语言相关的信息。例如，本指南中我仅讨论了一元通信。请务必研究一下其他替代方案，例如：

  • 服务器流式传输
  • 客户端流
  • 双向流

我期待社区的反馈，看看是否有任何方法可以帮助开发者更多地了解 gRPC。之后，我很可能会在未来的文章中探讨一些后续主题。

gRPC 获胜

文章来源：https://dev.to/drminnaar/grpc-guide-25mo
Devto 翻译
PREV
我的 2021 年 Web 开发学习计划
NEXT
在您的 Vue PWA 中处理 Service Worker 更新 更新 Service Worker 注册 进行更新混合 更新我们的 UI 跳过服务工作等待 更新我们的服务 Worker 重新加载页面 TL;DR