LightProto 0.4.0

LightProto

A high-performance, NativeAOT-compatible Protocol Buffers implementation for C#/.NET, designed as a native aot solution for Protobuf-net.

Why LightProto?

Protobuf-net is a popular choice for Protocol Buffers in .NET,However it has limitations when it comes to NativeAOT scenarios. LightProto addresses these issues by providing a fully NativeAOT-compatible solution with zero runtime overhead.

So, LightProto has three main goals:

1. NativeAOT Compatibility: Ensure full support for ahead-of-time compilation scenarios without any runtime reflection or code generation.
2. Protobuf-net Compatibility: Maintain the same serialization behavior and API patterns as Protobuf-net, making migration seamless.
3. Performance: Performance should be better or at least same as Protobuf-net.

Performance & Benchmarks

The following benchmarks compare serialization performance between LightProto, Protobuf-net, and Google.Protobuf.

You can reproduce these benchmarks by cloning the repository and running the tests/Benchmark project.

BenchmarkDotNet v0.15.2, Windows 11 (10.0.26100.4652/24H2/2024Update/HudsonValley)
AMD Ryzen 7 5800X 3.80GHz, 1 CPU, 16 logical and 8 physical cores
.NET SDK 9.0.305
[Host]     : .NET 9.0.9 (9.0.925.41916), X64 RyuJIT AVX2
DefaultJob : .NET 9.0.9 (9.0.925.41916), X64 RyuJIT AVX2

⚠️ Development Status

This project is under active development and may introduce breaking changes. use it in production at your own risk.

Todo list:

• Add more tests for other possible types supported by Protobuf-net
• Add more benchmarks and performance tests
• Improve documentation and examples

Quick Start

dotnet add package LightProto

1. Configure your ProtoContracts

using LightProto;
[ProtoContract]
public partial class Person 
{
    [ProtoMember(1)]
    public string Name { get; set; }
    
    [ProtoMember(2)]  
    public int Age { get; set; }
}
var person = new Person { Name = "Alice", Age = 30 };
// Serialization
var bytes = person.ToByteArray();
// or through API in protobuf-net style
var stream = new MemoryStream();
Serializer.Serialize(stream, person);
var bytes = stream.ToArray();

// Deserialization  
var obj = Serializer.Deserialize<Person>(bytes);

Migration from Protobuf-net

Change the namespace from ProtoBuf to LightProto and ensure your classes marked as partial.

-using ProtoBuf;
+using LightProto;
[ProtoContract]
-public class Person
+public partial class Person
{
    [ProtoMember(1)]
    public string Name { get; set; }
    
    [ProtoMember(2)]  
    public int Age { get; set; }
}
var myObject = new MyClass { /* Initialize properties */ };
// Serialization
var stream = new MemoryStream();
Serializer.Serialize(stream, myObject);
byte[] data = stream.ToArray();

// Deserialization  
var obj = Serializer.Deserialize<MyClass>(new MemoryStream(data));

Known Differences

• Partial Classes: Ensure all protobuf classes are declared as partial to allow the source generator to extend them.

If you found any other different behavior with Protobuf-net, please report them via GitHub issues.

.proto files

LightProto does not include a built-in tool for generating C# classes from .proto files. However, you can use the protobuf-net tool to generate the classes and then modify them to be compatible with LightProto.

License

MIT License - see LICENSE file for details.

Contributing

Contributions are welcome! Please feel free to submit issues and pull requests.

Before contributing:

1. Check existing issues and discussions
2. Follow the coding standards used in the project
3. Add tests for new functionality
4. Update documentation as needed

Development Setup:

git clone https://github.com/dameng324/LightProto.git
cd LightProto
dotnet restore
dotnet build
dotnet test