C#常用类库Google.Protobuf的使用小结

// 核心包（必装，包含Protobuf核心API与序列化/反序列化逻辑）
dotnet add package Google.Protobuf

// 辅助包（可选，用于ASP.NET Core gRPC集成，微服务场景推荐）
dotnet add package Grpc.AspNetCore

// 编译工具包（必装，用于将.proto文件编译为C#代码）
dotnet add package Google.Protobuf.Tools

<!-- 在.csproj文件的<Project&gt;标签内添加 -->
&lt;ItemGroup&gt;
  <!-- 配置proto文件，设置编译类型为Protobuf -->
  <Protobuf Include="Protos\*.proto" GrpcServices="None" /&gt;
  <!-- GrpcServices="None" 表示仅生成实体类，若需gRPC则设为Server/Client -->
</ItemGroup>

// 1. 进入项目根目录（Protos文件夹存放.proto文件）
// 2. 执行编译命令（适配Windows系统，其他系统替换protoc.exe为对应可执行文件）
protoc --csharp_out=./Models Protos/Student.proto
// 说明：--csharp_out=输出目录，Protos/Student.proto 为proto文件路径
// 执行后会在Models文件夹生成Student.cs实体类

using Google.Protobuf; // 核心API（序列化/反序列化、消息对象）
using Google.Protobuf.Collections; // 集合类型（如RepeatedField，对应proto中的repeated）

// Protos/Student.proto
syntax = "proto3"; // 声明使用proto3版本
option csharp_namespace = "ProtobufDemo.Models"; // 生成C#类的命名空间

// 定义消息体（对应C#中的类）
message Student {
  // 字段格式：类型 字段名 = 字段编号;
  int32 id = 1; // 整数类型，字段编号1（1-15占用1字节，推荐优先使用）
  string name = 2; // 字符串类型
  int32 age = 3; // 整数类型
  bool is_adult = 4; // 布尔类型
  double score = 5; // 浮点类型
  
  // 枚举类型（需先定义枚举）
  enum Gender {
    GENDER_UNSPECIFIED = 0; // proto3要求枚举第一个值必须为0，作为默认值
    MALE = 1;
    FEMALE = 2;
  }
  Gender gender = 6; // 枚举类型字段
  
  // 重复字段（对应C#中的RepeatedField<T>，类似List）
  repeated string hobbies = 7; // 字符串列表
}

// 定义嵌套消息体（对应C#中的嵌套类）
message Class {
  int32 class_id = 1;
  string class_name = 2;
  repeated Student students = 3; // 消息体列表（班级包含多个学生）
}

// 编译后生成的Student类（简化版，实际包含更多核心方法）
namespace ProtobufDemo.Models;

public sealed partial class Student : IMessage<Student>
{
    public int Id { get; set; }
    public string Name { get; set; } = "";
    public int Age { get; set; }
    public bool IsAdult { get; set; }
    public double Score { get; set; }
    public Student.Types.Gender Gender { get; set; }
    public RepeatedField<string> Hobbies { get; } = new RepeatedField<string>();
    
    // 嵌套枚举（对应proto中的Gender）
    public enum Types
    {
        GenderUnspecified = 0,
        Male = 1,
        Female = 2
    }
    
    // 核心方法（序列化/反序列化）
    public byte[] ToByteArray(); // 序列化为二进制数组
    public static Student ParseFrom(byte[] data); // 从二进制数组反序列化
    public void WriteTo(CodedOutputStream output); // 写入输出流
    public static Student ParseFrom(CodedInputStream input); // 从输入流读取
}

// 调用示例：创建实体、赋值、序列化/反序列化
var task = Task.Run(() =>
{
    // 1. 创建实体并赋值
    var student = new Student
    {
        Id = 101,
        Name = "张三",
        Age = 20,
        IsAdult = true,
        Score = 95.5,
        Gender = Student.Types.Gender.Male
    };
    // 给重复字段赋值（RepeatedField用法类似List）
    student.Hobbies.Add("篮球");
    student.Hobbies.Add("编程");
    
    // 2. 序列化为二进制数组（核心操作）
    byte[] bytes = student.ToByteArray();
    Console.WriteLine($"序列化后长度：{bytes.Length}"); // 体积远小于JSON
    
    // 3. 从二进制数组反序列化为实体（核心操作）
    Student deserializedStudent = Student.ParseFrom(bytes);
    Console.WriteLine($"反序列化后：{deserializedStudent.Name}，{deserializedStudent.Age}岁");
    
    // 4. 嵌套消息体使用（Class类）
    var @class = new Class
    {
        ClassId = 1,
        ClassName = "计算机1班"
    };
    @class.Students.Add(student); // 添加学生到班级
});
task.Wait();

var student = new Student { Id = 101, Name = "张三" };

// 1. 序列化为二进制数组（最常用，适合网络传输、内存存储）
byte[] bytes = student.ToByteArray();

// 2. 从二进制数组反序列化
Student student1 = Student.ParseFrom(bytes);

// 3. 序列化到文件（适合持久化存储）
using (var stream = new FileStream("student.bin", FileMode.Create))
{
    student.WriteTo(stream);
}

// 4. 从文件反序列化
using (var stream = new FileStream("student.bin", FileMode.Open))
{
    Student student2 = Student.ParseFrom(stream);
}

// 5. 序列化为JSON（可选，适合调试，需安装Google.Protobuf.JsonFormat包）
// dotnet add package Google.Protobuf.JsonFormat
string json = JsonFormatter.Default.Format(student);
// 从JSON反序列化
Student student3 = JsonParser.Default.Parse<Student>(json);

// 升级后的Student.proto（新增字段，标记废弃字段）
syntax = "proto3";
option csharp_namespace = "ProtobufDemo.Models";

message Student {
  int32 id = 1;
  string name = 2;
  int32 age = 3;
  bool is_adult = 4;
  double score = 5;
  Gender gender = 6;
  repeated string hobbies = 7;
  
  // 新增字段（字段编号8，未被使用过）
  string address = 8;
  
  // 废弃字段（标记id=9为reserved，禁止后续使用）
  reserved 9;
  reserved "old_field"; // 也可通过字段名标记
  
  enum Gender {
    GENDER_UNSPECIFIED = 0;
    MALE = 1;
    FEMALE = 2;
  }
}

var student = new Student();
// RepeatedField赋值
student.Hobbies.Add("篮球");
student.Hobbies.AddRange(new List<string> { "编程", "读书" });

// 转为List<T>
List<string> hobbyList = student.Hobbies.ToList();

// List<T>转为RepeatedField
var newHobbies = new RepeatedField<string>();
newHobbies.AddRange(hobbyList);

// C# 端：序列化Student实体为二进制数组，发送到Java端
var student = new Student { Id = 101, Name = "张三", Age = 20 };
byte[] bytes = student.ToByteArray();
// 发送bytes到Java端（通过HTTP、TCP等方式）

// Java 端：接收二进制数组，反序列化为Student实体（proto文件与C#共用）
// 1. 编译proto文件为Java实体（使用protoc工具）
// 2. 反序列化
byte[] bytes = 接收的二进制数据;
Student student = Student.parseFrom(bytes);
System.out.println("接收数据：" + student.getName() + "，" + student.getAge());

// Protos/StudentService.proto
syntax = "proto3";
option csharp_namespace = "ProtobufDemo.Grpc";

// 定义gRPC服务
service StudentService {
  // 定义接口（请求参数、响应参数均为Protobuf消息体）
  rpc GetStudent (GetStudentRequest) returns (Student);
}

// 请求消息体
message GetStudentRequest {
  int32 student_id = 1;
}

// 响应消息体（复用之前定义的Student）
message Student {
  int32 id = 1;
  string name = 2;
  int32 age = 3;
}

var builder = WebApplication.CreateBuilder(args);

// 添加gRPC服务（自动编译proto文件）
builder.Services.AddGrpc();

var app = builder.Build();

// 映射gRPC服务
app.MapGrpcService<StudentServiceImpl>();

app.Run();

namespace ProtobufDemo.Grpc;

public class StudentServiceImpl : StudentService.StudentServiceBase
{
    // 实现接口方法
    public override Task<Student> GetStudent(GetStudentRequest request, ServerCallContext context)
    {
        // 模拟从数据库获取学生信息
        var student = new Student
        {
            Id = request.StudentId,
            Name = "张三",
            Age = 20
        };
        return Task.FromResult(student);
    }
}

// 客户端代码（C#）
var channel = GrpcChannel.ForAddress("https://localhost:5001");
var client = new StudentService.StudentServiceClient(channel);

// 调用gRPC接口（请求、响应均为Protobuf实体）
var response = await client.GetStudentAsync(new GetStudentRequest { StudentId = 101 });
Console.WriteLine($"获取学生：{response.Name}，{response.Age}岁");

// 1. 定义proto文件（UserList.proto）
syntax = "proto3";
option csharp_namespace = "ProtobufDemo.Models";

message User {
  int32 id = 1;
  string username = 2;
  string email = 3;
}

message UserList {
  repeated User users = 1; // 存储多个用户
}

// 2. 编译后，实现序列化与持久化
public async Task PersistUserList()
{
    // 创建用户列表
    var userList = new UserList();
    userList.Users.AddRange(new List<User>
    {
        new User { Id = 1, Username = "zhangsan", Email = "zhangsan@example.com" },
        new User { Id = 2, Username = "lisi", Email = "lisi@example.com" }
    });
    
    // 1. 序列化到文件（备份）
    using (var stream = new FileStream("users.bin", FileMode.Create))
    {
        userList.WriteTo(stream);
    }
    
    // 2. 从文件反序列化（恢复）
    using (var stream = new FileStream("users.bin", FileMode.Open))
    {
        UserList restoredList = UserList.ParseFrom(stream);
        foreach (var user in restoredList.Users)
        {
            Console.WriteLine($"用户：{user.Username}，邮箱：{user.Email}");
        }
    }
    
    // 3. 序列化到数据库（存储二进制数据）
    byte[] bytes = userList.ToByteArray();
    // 假设使用EF Core存储到数据库（字段类型为varbinary）
    var dbContext = new AppDbContext();
    dbContext.UserData.Add(new UserData { Data = bytes, CreateTime = DateTime.Now });
    await dbContext.SaveChangesAsync();
}

// 数据库实体
public class UserData
{
    public int Id { get; set; }
    public byte[] Data { get; set; } // 存储Protobuf序列化后的二进制数据
    public DateTime CreateTime { get; set; }
}

// C# 微服务：序列化User实体，通过HTTP发送到Python服务
public async Task SendToPythonService()
{
    var user = new User { Id = 1, Username = "zhangsan", Email = "zhangsan@example.com" };
    byte[] bytes = user.ToByteArray(); // 序列化为二进制
    
    // 通过HTTP发送二进制数据
    var client = new HttpClient();
    var content = new ByteArrayContent(bytes);
    content.Headers.ContentType = new MediaTypeHeaderValue("application/x-protobuf");
    var response = await client.PostAsync("http://python-service:5000/receive-user", content);
}

# Python 微服务：接收二进制数据，反序列化为User实体（共用同一proto文件）
# 1. 安装Python Protobuf包：pip install protobuf
# 2. 编译proto文件为Python代码：protoc --python_out=./ Protos/User.proto
from flask import Flask, request
import User_pb2 # 编译后的Python实体类
app = Flask(__name__)
@app.route('/receive-user', methods=['POST'])
def receive_user():
    # 接收二进制数据
    data = request.get_data()
    # 反序列化为User实体
    user = User_pb2.User()
    user.ParseFromString(data)
    # 处理数据
    print(f"接收用户：{user.username}，邮箱：{user.email}")
    return "success"
if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)