ProtoGenNet 0.0.1.12

ProtoGen - C# to Protocol Buffer Generator

ProtoGenNet is a C# console application that automatically generates .proto files from C# classes.

Getting Started

default command line

$(ProjectDir)../ClientInterfaceCs/bin/$(Configuration)/net9.0/ClientInterfaceCs.dll

full command line

$(ProjectDir)../ClientInterfaceCs/bin/$(Configuration)/net9.0/ClientInterfaceCs.dll client_interface_cs_package $(ProjectDir)/../Protos/icalculatorservice.proto

Features

• Attribute-Based Generation: Uses [Browsable(true)] attributes on classes to control what gets included in the generated .proto file
• Automatic Type Mapping: Maps C# types (primitives, classes, structs, enums, collections) to Protocol Buffer types

How It Works

1. Proto Generation from C# Classes

Classes decorated with [Browsable(true)] are used as service definitions. All virtual methods in the class are included as RPC methods.

[Browsable(true)]
public class SampleService
{
    public virtual string GetGreeting(string name)
    {
        // Implementation
    }

    public virtual UserProfile GetUserProfile(string userId)
    {
        // Implementation
    }

    // This method is NOT included (not virtual)
    void InternalMethod()
    {
        // Implementation
    }
}

2. Generated Proto Output

The above class generates:

syntax = "proto3";

package sample;

service SampleService {
  rpc GetGreeting (GetGreetingRequest) returns (GetGreetingResponse) {}
  rpc GetUserProfile (GetUserProfileRequest) returns (UserProfile) {}
}

message GetGreetingRequest {
  string name = 1;
}

message GetGreetingResponse {
  string value = 1;
}

message GetUserProfileRequest {
  string userId = 1;
}

message UserProfile {
  PersonInfo person = 1;
  Address address = 2;
  repeated string interests = 3;
}

3. Type Mapping

ProtoGen automatically maps C# types to Protocol Buffer types:

Project Structure

ProtoGen/
├── ProtoGen.csproj          # Project file with NuGet dependencies
├── Program.cs               # Demo application
├── Generator/
│   ├── ProtoGenerator.cs    # Main proto file generator
│   ├── TypeMapper.cs        # C# to Protobuf type mapping
│   └── ProtoFileWriter.cs   # (future: file writing utilities)
└── Samples/
    ├── SampleService.cs     # Example service class
    └── SampleModels.cs      # Example data models

Dependencies

• Google.Protobuf (3.32.1) - Protobuf runtime
• Grpc.Core (2.46.6) - gRPC runtime
• Grpc.Tools (2.72.0) - Build-time proto compilation

Usage

Running the Demo

cd ProtoGen
dotnet run

This will:

1. Generate a .proto file from classes decorated with [Browsable(true)]
2. Save it to ../Protos/<service_name>.proto
3. Display the generated content

Generating Proto from Your Own Class

var generator = new ProtoGen.Generator.ProtoGenerator
{
    PackageName = "myapp",
    ServiceName = "MyService"
};

var protoContent = generator.GenerateProto(typeof(MyService));
File.WriteAllText("my_service.proto", protoContent);

Complete Workflow

1. Define Class: Create C# class with [Browsable(true)] attribute on the class
2. Mark Methods: Make methods virtual to include them in the service
3. Generate Proto: Run ProtoGen to create .proto file
4. Compile Proto: Use Grpc.Tools to generate C# gRPC client/server code
5. Implement Server: Create gRPC server implementing the service

Key Design Decisions

Why [Browsable(true)]?

• Existing attribute from System.ComponentModel
• Semantic meaning: "expose this to external systems"
• No custom attributes needed
• Works well with PropertyGrid and other reflection tools
• Applied only to classes to mark them as service definitions

Why Virtual Methods Only?

• Ensures interface compatibility
• Prevents generation of non-overrideable methods
• All virtual methods in [Browsable(true)] classes are automatically included

Why Wrapper Messages for Primitives?

• gRPC best practices recommend message types for requests/responses
• Allows future extensibility (add fields without breaking changes)
• Avoids proto3 limitations with primitive types
• Consistent patterns across all RPC methods

Limitations

• Only supports [Browsable(true)] on classes for filtering (not on interfaces or methods)
• No support for client/server streaming (yet)
• No support for bidirectional streaming (yet)
• Decimal types map to double (proto3 limitation)
• No circular reference detection (can cause stack overflow)

Future Enhancements

• Support for streaming RPC patterns
• Custom attribute support beyond [Browsable]
• Circular reference detection
• Source generator version (compile-time)
• Integration with ASP.NET Core gRPC
• Support for proto options and annotations
• Validation rule generation
• Method-level filtering support

Example Output

See sample_service.proto for example generated output from SampleService.

License

Part of the FlexUI gRPC examples project.