Indata (.proto-schema)

Utdata (C#)

Vad det här verktyget gör

Du har ett Protocol Buffers-schema och en C#-tjänst eller -klient som behöver matchande DTO:er. Den officiella vägen är att installera protoc med C#-pluginnet (eller koppla in Grpc.Tools i ditt .csproj) och låta MSBuild generera partial-klasserna under bygget. Det funkar, men det är overkill när du bara vill läsa schemat, skissa typer eller klistra in en message i en Razor-sida eller en engångsintegration. Den här konverteraren gör samma sorts jobb — klistra in, kopiera, släpp ner i Types.cs.

Typmappingen är av den tråkiga-men-korrekta sorten. string förblir string (med initialiseraren = "" så att projekt med nullable references inte gnäller). bool, int32, int64, uint32, uint64, float, double mappar mot bool, int, long, uint, ulong, float, double respektive. bytes blir byte[]. repeated T blir List<T>, map<K, V> blir Dictionary<K, V>, och kända wrappers som google.protobuf.Timestamp skrivs ut som string (proto3 JSON kodar tidsstämplar som RFC 3339, vilket på wire-nivå bara är en sträng — se proto3-JSON-specifikationen om du vill ha detaljerna).

Fältnamn får den vanliga PascalCase-behandlingen — order_id → OrderId, shipping_address → ShippingAddress — som matchar det officiella C#-protobuf-referensverktyget genererar. Enum-värden tappar sitt SCREAMING_SNAKE-prefix när schemat följer konventionen att prefixa varje värde med enum-namnet (så ORDER_STATUS_PENDING i enum OrderStatus blir OrderStatus.Pending). Utdataklasserna är platta — varje nästlad message lyfts upp till top-level så att du kan splitta eller flytta runt dem utan att riva upp scopes. Konverteringen sker helt och hållet i din webbläsare; inget av schemat laddas upp.

Så här använder du det

Tre steg. Utdatan är klar att kompileras — klistra in den i en <code>Types.cs</code>-fil i ditt projekt.

Klistra in ditt .proto-schema

Släpp schemat i den vänstra editorn. syntax = "proto3"; i toppen är valfritt. Parsern hanterar nästlade message-block, enum-deklarationer, oneof, map<K, V>, fältoptions och de vanliga package/import/option-direktiven. Imports känns igen men hoppas över, så klistra in importerade typer inline om ditt schema beror på dem.

Fältnamnskonverteringen är automatisk: customer_name i .proto blir CustomerName i C#. Klass- och enum-namn lämnas som de är (per konvention redan i PascalCase).

Läs utdatan

Till höger: public class-deklarationer med { get; set; }-auto-properties för varje message, plus public enum-deklarationer för varje enum. En using System.Collections.Generic;-rad läggs till när schemat använder repeated- eller map-fält (så att List och Dictionary löser sig). Släpp filen i ett projekt, vira den i din namespace, klart.

Koppla ihop

För ren DTO-användning är klasserna redo att serialiseras med System.Text.Json eller Newtonsoft.Json. För riktigt gRPC-C#-arbete — service-implementationer, streaming, deadlines — fortsätt använda Grpc.Tools för wire-format-typerna och använd den här konverteraren till handskrivna wrappers, mappinglager eller test-fixturer vid sidan av den genererade koden.

När det här faktiskt sparar tid

Skissa DTO:er för en ny gRPC-tjänst

Du startar en ASP.NET Core gRPC-tjänst och vill se hur messagen kommer se ut i C# innan du satsar på Grpc.Tools. Klistra in .proto-filen, ögna igenom klasserna, avgör om fältnamngivningen passar lagets stil, koppla sedan in codegen ordentligt.

Handskrivet mappinglager

Dina genererade gRPC-typer bor i sin egen namespace, och du vill ha rena DTO:er för domänlagret. Utdatan här ger dig snygga klasser utan metadatabruset från genererad kod — lätta att mappa fram och tillbaka med AutoMapper eller egna konverterare.

Granska en ändring i ett Protobuf-schema

En kollega har lagt till fält i en message i en PR. Du vill se konsekvenserna för C#-formen utan att checka ut branchen och köra ett bygge. Klistra in det nya schemat, gör diff mot de befintliga C#-typerna, lämna en fokuserad review-kommentar.

Test-fixturer och snabba skript

Du skriver ett engångs-LinqPad-skript eller en konsolapp som POST:ar mot en gRPC-gateway. Att rigga hela Protobuf-toolchainen för 50 rader testkod är overkill. Hämta klasserna härifrån, serialisera till JSON, skicka requestet, gå vidare.

Vanliga frågor

Skickas mitt schema någonstans?

Nej. Parsern och C#-emittern körs helt och hållet i din webbläsare som JavaScript. Öppna DevTools och titta på Network-fliken medan du klistrar in — noll requests. Praktiskt när schemat innehåller interna typnamn, paketsökvägar eller annat du inte vill skicka till en tredje part.

Funkar dessa klasser med Grpc.Tools-genererad kod?

De producerar likvärdiga former, men inte byte-för-byte identiska. Grpc.Tools genererar partial-klasser, parser-registreringar, descriptor-koppling och förfaderstyper från Google.Protobuf.IMessage — inget av det finns här. För riktigt arbete med gRPC:s wire-protokoll, använd Grpc.Tools. För kod som bara är DTO (exempelvis JSON-över-HTTP-gateways, mappinglager, testdata) duger den här utdatan.

Varför typas int64 och uint64 som long och ulong istället för string?

För i C# får de plats. Till skillnad från JavaScript-Numbers (som tappar precision över 2^53) klarar C#:s long hela int64-intervallet nativt, så det finns ingen anledning att falla tillbaka på string. Om du deserialiserar proto3-JSON där 64-bitars heltal kommer som strängar (enligt JSON-mappingsspecen) sköter System.Text.Json med JsonNumberHandling.AllowReadingFromString konverteringen.

Hur hanteras SCREAMING_SNAKE-konventionen för enum-värden?

Protobufs style guide rekommenderar att varje enum-värde prefixas med enumets namn i SCREAMING_SNAKE. Konverteraren upptäcker det och tar bort prefixet. ORDER_STATUS_UNSPECIFIED i enumet OrderStatus blir OrderStatus.Unspecified. Om enumet inte följer konventionen (vissa värden prefixade, andra inte) hoppas prefix-stripp:en över och värdena PascalCase:as som de är.

Hanterar det oneof?

Varje oneof-fält skrivs ut som en vanlig auto-property. Utdatan tvingar inte fram "exakt en"-villkoret som oneof innebär — språket C# har ännu inte nativa discriminated unions. Behöver du striktare modellering, kika på bibliotek som OneOf på NuGet eller redigera utdatan för hand till en basklass plus subklasser.

Vad händer med google.protobuf.Timestamp och well-known types?

Timestamp skrivs ut som string (proto3-JSON kodar tidsstämplar som RFC 3339-strängar). Empty och Any blir object-platshållare — justera till Google.Protobuf.WellKnownTypes.Any eller en starkare typ om ditt projekt drar in WKT-paketet. Utdatan är medvetet framework-fri så att du kan släppa den i vilket C#-projekt som helst utan att tvinga fram ett NuGet-beroende.

Relaterade verktyg

Om du jonglerar Protobuf, JSON och C# passar dessa bra ihop:

Protobuf till C#-konverterare