提升数据序列化效率：.NET 与 Protocol Buffers (Protobuf) 的完美结合

一只拉古
409 阅读3分钟

简介

Protocol Buffers (Protobuf) 是一种与语言无关、平台中立的可扩展机制，用于序列化结构化数据。由 Google 开发，Protobuf 因其相对于 JSON 和 XML 等其他序列化方法的效率和性能优势，广泛用于系统之间的数据交换。在本文中，我们将探讨如何在 .NET 应用程序中使用 Protobuf，为什么工作流可能会有所不同，以及如何确保与其他语言的互操作性。

通常，使用 Protobuf 需要先定义 Protobuf 模式（创建 .proto 文件），然后从 .proto 文件生成对象（类）。然而，为了简化这个过程，在 .NET 中，可以利用诸如 protobuf-net 之类的库，将工作流反过来：您可以使用属性定义类，然后从这些类生成 .proto 文件。以下是一些示例：

在 .NET 中设置 Protobuf

要在 .NET 项目中开始使用 Protobuf，您需要安装 protobuf-net NuGet 包。该包提供了使用 C# 属性定义 Protobuf 模式和从 C# 类生成 .proto 文件的支持。

定义数据模型

using ProtoBuf;

[ProtoContract]
public class Person
{
    [ProtoMember(1)]
    public int Id { get; set; }

    [ProtoMember(2)]
    public string Name { get; set; }

    [ProtoMember(3)]
    public string Email { get; set; }
}

序列化和反序列化

定义数据模型后，可以使用 Serializer 类来序列化和反序列化对象。

为了简化这一过程，我们可以创建一些实用方法来进行序列化和反序列化：

using ProtoBuf;
using System.IO;

public static class ProtoHelpers
{
    public static byte[] Serialize<T>(T source)
    {
        using (var stream = new MemoryStream())
        {
            Serializer.Serialize(stream, source);
            return stream.ToArray();
        }
    }

    public static T Deserialize<T>(byte[] source)
    {
        using (var stream = new MemoryStream(source))
        {
            return Serializer.Deserialize<T>(stream);
        }
    }
}

然后您可以按如下方式使用这些方法：

using System;

public class Program
{
    public static void Main(string[] args)
    {
        Person person = new Person
        {
            Id = 123,
            Name = "John Doe",
            Email = "john.doe@example.com"
        };

        // 序列化 Person 对象为字节数组
        byte[] serializedPerson = ProtoHelpers.Serialize(person);

        // 将字节数组反序列化回 Person 对象
        Person deserializedPerson = ProtoHelpers.Deserialize<Person>(serializedPerson);

        Console.WriteLine($"ID: {deserializedPerson.Id}");
        Console.WriteLine($"Name: {deserializedPerson.Name}");
        Console.WriteLine($"Email: {deserializedPerson.Email}");
    }
}

生成 .proto 文件

在许多情况下，首先在代码中定义您的 Protobuf 模式更为方便。一旦定义了 C# 类，就可以使用自定义方法生成 .proto 文件。以下是一个示例：

using ProtoBuf.Meta;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;

public static class ProtoUtils
{
    public static string GenerateProto(IEnumerable<Type> protoTypes, string packageName)
    {
        StringBuilder sb = new StringBuilder();
        sb.AppendLine("syntax = \"proto2\";");
        sb.AppendLine("");
        sb.AppendLine($"package {packageName};");
        sb.AppendLine("option optimize_for = LITE_RUNTIME;");
        sb.AppendLine("option cc_enable_arenas = true;");
        sb.AppendLine("");

        var getProto = typeof(RuntimeTypeModel).GetMethod("GetSchema", new[] { typeof(Type) });

        Dictionary<string, string> allProto = new Dictionary<string, string>();
        List<string> removeNames = new List<string> { "\r", "package" };

        foreach (var type in protoTypes)
        {
            string result = (string)getProto.Invoke(RuntimeTypeModel.Default, new object[] { type });

            List<string> splitMsg = result.Split(new[] { "message " }, StringSplitOptions.None).ToList();

            foreach (string s in splitMsg)
            {
                List<string> splitEnum = s.Split(new[] { "enum " }, StringSplitOptions.None).ToList();

                string sMsg = splitEnum[0];
                string sMsgName = sMsg.Split(new[] { "{" }, StringSplitOptions.None)[0];

                if (removeNames.All(n => !sMsg.StartsWith(n)))
                {
                    allProto[sMsgName] = "message " + sMsg;
                }
                removeNames.Add(sMsgName);

                if (splitEnum.Count > 1)
                {
                    for (int i = 1; i < splitEnum.Count; i++)
                    {
                        string sEnum = splitEnum[i];
                        string sEnumName = sEnum.Split(new[] { "{" }, StringSplitOptions.None)[0];

                        if (removeNames.All(n => !sEnum.StartsWith(n)))
                        {
                            allProto[sEnumName] = "enum " + sEnum;
                        }
                        removeNames.Add(sEnumName);
                    }
                }
            }
        }

        string proto = string.Join("", allProto.OrderBy(a => a.Key).Select(a => a.Value));

        sb.Append(proto);
        string protoContent = sb.ToString();

        GenerateProtoFile(packageName, protoContent);
        return protoContent;
    }

    public static void GenerateProtoFile(string protoFileName, string protoContent)
    {
        if (string.IsNullOrWhiteSpace(protoFileName)) return;

        if (!protoFileName.EndsWith(".proto"))
        {
            protoFileName += ".proto";
        }

        string filePath = Path.Combine(AppContext.BaseDirectory, protoFileName);

        // 覆盖已存在的文件
        File.WriteAllText(filePath, protoContent);
    }
}

这是如何使用这些方法生成 .proto 文件的示例：

public static string GeneratePersonProto()
{
    string packageName = "PersonProto";

    List<Type> protoTypes = new List<Type>
    {
        typeof(Person)
    };

    return ProtoUtils.GenerateProto(protoTypes, packageName);
}

这将生成一个 person.proto 文件，可用于与其他系统和语言的互操作性。

与其他语言的互操作性

生成的 .proto 文件可用于其他编程语言的数据反序列化。以下是如何在 Python 应用程序中使用 person.proto 文件的示例：

import person_pb2

# 反序列化数据
person = person_pb2.Person()
with open("person.bin", "rb") as f:
    person.ParseFromString(f.read())

print(f"ID: {person.id}")
print(f"Name: {person.name}")
print(f"Email: {person.email}")

最佳实践

在 .NET 中使用 Protobuf 时，请考虑以下最佳实践：

  • 模式演进：使用新的字段编号添加新字段，但避免删除或重命名现有字段，以保持向后兼容性。
  • 性能：在您的特定用例中测试 Protobuf 的性能，尤其是对于大型数据集。根据需要进行优化。

结论

在 .NET 中使用 Protocol Buffers 简化了数据序列化，并确保系统之间的高效可靠通信。通过在代码中定义模式、生成 .proto 文件并遵循最佳实践，您可以构建易于扩展和与其他技术互操作的健壮和可维护的应用程序。

请随意进一步探索并在您的项目中实现 Protobuf。如果您有任何问题或其他建议，请在评论中分享！

avatar
文章
阅读
粉丝