首页/资讯中心/详情

[GRPC]基于C#和GO 的GRPC快速上手

[GRPC]基于C#和GO 的GRPC快速上手
📅 发布时间：2026/6/21 21:44:30

[GRPC]GRPC快速上手

概述(Overview)

本文仅记录快速上手的方案

GoLand 前置准备

Go Modules配置

go install google.golang.org/protobuf/cmd/protoc-gen-go@latest

go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest

go get google.golang.org/grpc

系统配置

需要手动安装Releases · protocolbuffers/protobuf 至系统 并配置路径到

IUVZHORCAAADY

GoLand插件

7ET2RPZCADQFU

C#前置准备

项目配置

EEOH5PZCAAAGI

插件与包配置

安装 Grpc.Tools 至项目

JKEIBPZCADQDW

核心(Core)

GRPC基于一类中间语言规范Proto生成适配各类语言的服务文件

文件规范

相关文件需要以.proto结尾

语法规范

Proto关键字

syntax

Proto的语法等级,一般为3

package

包名，会根据不同语言适配

option

命名空间选项，比如C#的命名空间，GO的包名

import

引入其他的Proto文件

message

定义一个类型，比如GO的Stract，C#的Class

<基元类型>

int，float，string这些。并非C#的基元

repeated

数组类型，或者称为GO的切片类型

map

字典类型，GO的map，C#的Dictionary

oneof

用于控制一个片段内只能有一个有值

enum

枚举类型，GO的实现极其本土化

Proto案例

  1. syntax = "proto3";
  2. package person;
  3. // GO_Package <包名>;<别名>
  4. option go_package = "GRPC/pb/person;person";
  5. import "student.proto";
  6. message Person{
  7. // 基元类型
  8. string name = 1;
  9. int32 age = 2;
  10. // bool sex = 3;
  11. // enum 枚举类型
  12. enum SEX {
  13. // 是否允许同Key枚举
  14. option allow_alias = true;
  15. MAN = 0;
  16. WOMAN = 1;
  17. BOY = 0;
  18. }
  19. SEX sex = 3;
  20. // 切片
  21. repeated string text = 4;
  22. // 映射 test_map 会自转换为TestMap
  23. map <string, string> test_map = 5;
  24. // 控制片段中只能有一个有值 这个会定义为 Flag
  25. // 有个函数 isPerson_Falg
  26. oneof Flag{
  27. string one = 7;
  28. string two = 8;
  29. string three = 9;
  30. }
  31. student.Student student = 10;
  32. // reserved <key>;
  33. // reserved "test_map"
  34. // reserved <number>;
  35. }
  36. message Home{
  37. repeated Person persons = 1;
  38. message V {
  39. string name = 1;
  40. }
  41. V v = 2;
  42. }

案例(Example)

基于GRPC实现一个简单的计算器。其中GO作为Client，C#作为Server

GO开发准备

初始项目

C5OJFPZCAAAC2

6TNJLPZCACQFO

安装依赖

  1. go env -w GO111MODULE=on
  2. go env -w GOPROXY=https://goproxy.io,direct
  3. go get google.golang.org/grpc

ZHTQJQBCAAAGS

C#开发准备

初始项目

PV7QPQBCABQGG

VO6QRQBCABAB6

安装依赖

XYSJ3QBCADQAG

编写Proto文件

定义请求体CalculateRequest和回应体CalculateResponse，随后定义计算服务CalculateService

  1. syntax = "proto3";
  2. package Calculate;
  3. option go_package = "Calculate.calculate;calculator";
  4. option csharp_namespace = "CalculatorServer";
  5. message CalculateRequest {
  6. float X = 1;
  7. float Y = 2;
  8. enum CalculateMethod {
  9. ADD = 0;
  10. SUB = 1;
  11. MUL = 2;
  12. DIV = 3;
  13. }
  14. CalculateMethod Method = 3;
  15. }
  16. message CalculateResponse {
  17. bool Ok = 1;
  18. float Result = 2;
  19. string Message = 3;
  20. }
  21. service CalculateService{
  22. rpc BinaryCalculate(CalculateRequest) returns (CalculateResponse);
  23. }

实现C#服务端

定义一个服务，使其继承自动生成的服务基类，并实现其方法

  1. using Grpc.Core;
  2. namespace CalculatorServer.Services
  3. {
  4. public class CalculatorService: CalculateService.CalculateServiceBase
  5. {
  6. public override Task<CalculateResponse> BinaryCalculate(CalculateRequest request, ServerCallContext context)
  7. {
  8. float calculateResult = 0.0f;
  9. switch (request.Method)
  10. {
  11. case CalculateRequest.Types.CalculateMethod.Add:
  12. {
  13. calculateResult = request.X + request.Y;
  14. }
  15. break;
  16. case CalculateRequest.Types.CalculateMethod.Sub:
  17. {
  18. calculateResult = request.X - request.Y;
  19. }
  20. break;
  21. case CalculateRequest.Types.CalculateMethod.Mul:
  22. {
  23. calculateResult = request.X * request.Y;
  24. }
  25. break;
  26. case CalculateRequest.Types.CalculateMethod.Div:
  27. {
  28. calculateResult = request.X / request.Y;
  29. }
  30. break;
  31. }
  32. return Task.FromResult(new CalculateResponse { Result = calculateResult,Ok =true,Message = "SUCCESS"});
  33. }
  34. }
  35. }

FHJFDQJCAAABW

4M5FTQJCADQDW

实现GO客户端

注意GO的相关文件需要手动执行脚本构建一下！

protoc --go_out=. --go_opt=paths=source_relative --go-grpc_out=. --go-grpc_opt=paths=source_relative <文件位置>

ML3FVQJCADAC6

构建完成后会生成calculate.pb.go和calculate_grpc.pb.go

  1. package main
  2. import (
  3.     calculator "Calculator/protoBuffer"
  4.     "context"
  5.     "fmt"
  6.     "google.golang.org/grpc"
  7. )
  8. const (
  9.     LocalHost = "localhost:5047"
  10.     HOST = "localhost"
  11.     PORT = ":5047"
  12. )
  13. func main() {
  14.     listener, err := grpc.NewClient(LocalHost, grpc.WithInsecure())
  15.     defer func() {
  16.         _ = listener.Close()
  17.     }()
  18.     client := calculator.NewCalculateServiceClient(listener)
  19.     calculateResponse, err := client.BinaryCalculate(context.Background(), &calculator.CalculateRequest{
  20.         X: 10,
  21.         Y: 20,
  22.         Method: calculator.CalculateRequest_MUL,
  23.     })
  24.     if err != nil {
  25.         fmt.Println(err.Error())
  26.         return
  27.     }
  28.     fmt.Println(calculateResponse)
  29. }

ZSLFTQJCACQHQ

测试

服务端执行结果

J66VZQJCACQCC

客户端执行结果

JERV3QJCADQFQ