Die Beziehung zwischen C # und C #: REST, gRPC und alles dazwischen

Optimales Szenario

// on client side
public void Foo()
{
    var server = new MyServer(new Uri("https://www.myserver.com/");)
    int sum = server.Calculator.SumNumbers(12,13); 
}

// on server side
class CalculatorController : Controller{
    public int SumNumbers(int a, int b)
    {
        return a + b;
    }
}

• Statische Klassen nur mit statischen Methoden.
• POCO-Klassen, in denen es nur Felder und Eigenschaften gibt, deren Typ eine primitive oder eine andere POCO-Klasse ist.

Traditioneller REST-Ansatz

• GET wird verwendet, um die Ressource abzurufen
• PUT wird verwendet, um den Status einer Ressource zu ändern.
• POST wird zum Erstellen einer Ressource verwendet.
• DELETE wird verwendet, um eine Ressource zu löschen.

[Route("People")]
public class PeopleController : Controller
{
    [HttpGet]
    public Person GetPersonById(int id)
    {
        Person person = _db.GetPerson(id);
        return person;//Automatically serialized to JSON
    }
} 

var client = new HttpClient();
string resultJson = await client.GetStringAsync("https://www.myserver.com/People/GetPersonById?id=123");
Person person = JsonConvert.DeserializeObject<Person>(resultJson);

Überholen

public interface IMyEmployeeApi
{
    [Get("/employee/{id}")]
    Task<Employee> GetEmployee(string id);
}

var api = RestService.For<IMyEmployeeApi>("https://www.myserver.com");
var employee = await api.GetEmployee("abc");

Stolzieren

• Alle Pfade (URLs) in der API.
• Erwartete Operationen (GET, POST, ...) für jeden Pfad. Jeder Pfad kann unterschiedliche Operationen ausführen. Der gleiche Pfad mystore.com/Product kann beispielsweise eine POST-Operation akzeptieren, die ein Produkt hinzufügt, und eine GET-Operation, die ein Produkt zurückgibt.
• Die erwarteten Parameter für jeden Pfad und jede Operation.
• Erwartete Antworten für jeden Pfad.
• Typen der einzelnen Parameter und Antwortobjekte.

{ 
   "swagger":"2.0",
   "info":{ 
      "version":"1.0.0",
      "title":"Swagger Petstore",
      "description":"A sample API that uses a petstore as an example to demonstrate features in the swagger-2.0 specification",
   },
   "host":"petstore.swagger.io",
   "basePath":"/api",
   "schemes":[ 
      "http"
   ],
   "consumes":[ 
      "application/json"
   ],
   "produces":[ 
      "application/json"
   ],
   "paths":{ 
      "/pets":{ 
         "get":{ 
            "description":"Returns all pets from the system that the user has access to",
            "operationId":"findPets",
            "produces":[ 
               "application/json",
               "application/xml",
            ],
            "parameters":[ 
               { 
                  "name":"tags",
                  "in":"query",
                  "description":"tags to filter by",
                  "required":false,
                  "type":"array",
                  "items":{ 
                     "type":"string"
                  },
                  "collectionFormat":"csv"
               },
               { 
                  "name":"limit",
                  "in":"query",
                  "description":"maximum number of results to return",
                  "required":false,
                  "type":"integer",
                  "format":"int32"
               }
            ],
            "responses":{ 
               "200":{ 
                  "description":"pet response",
                  "schema":{ 
                     "type":"array",
                     "items":{ 
                        "$ref":"#/definitions/Pet"
                     }
                  }
               },
...
 

Hinzufügen von Swagger zu Ihrem ASP.NET-Server

services.AddSwaggerGen(options => 
	options.SwaggerDoc("v1", new OpenApiInfo {Title = "My Web API", Version = "v1"}));

app.UseSwagger();

[HttpPost]
public async Task AddEmployee([FromBody]Employee employee)
{
    //...
}
 
[HttpGet]
public async Task<Employee> Employee([FromQuery]string id)
{
    //...
}

Generieren eines Clients aus Swagger mit AutoRest

autorest --input-file="./swagger.json" --output-folder="GeneratedClient" --namespace="MyClient" --override-client-name="MyClient" --csharp

var client = new MyClient();
Employee employee = client.Employee(id: "abc");

Traditionelle REST vs Swagger vs ReFit

• Wenn Sie über eine sehr einfache private REST-API verfügen, müssen Sie sich möglicherweise nicht um die Clientgenerierung und die allgemeinen Schnittstellen kümmern. Eine kleine Aufgabe rechtfertigt keinen zusätzlichen Aufwand.
• Swagger unterstützt viele Sprachen und ReFit unterstützt nur .NET. Swagger ist auch die Basis für viele Tools, Tests, Automatisierungstools und Tools für die Benutzeroberfläche. Dies ist wahrscheinlich die beste Wahl, wenn Sie eine große öffentliche API erstellen.
• Swagger ist viel komplizierter als ReFit. Mit ReFit müssen Sie lediglich Ihrem Server- und Client-Projekt eine einzige Schnittstelle hinzufügen. Andererseits müssen Sie mit ReFit neue Schnittstellen für jeden Controller erstellen, während Swagger sich automatisch darum kümmert.

gRPC

• GRPC ist wie REST sprachunabhängig. Es gibt Tools für alle gängigen Sprachen, einschließlich C #.
• gRPC ist vertragsbasiert und verwendet .proto- Dateien, um den Vertrag zu definieren. Dies ähnelt in gewisser Weise Swagger swagger.json und der allgemeinen ReFit-Schnittstelle. Aus diesen Dateien kann ein Client einer beliebigen Programmiersprache generiert werden.
• gRPC Protocol Buffer (Protobuf). REST, JSON XML. , , .
• gRPC HTTP/2. . , REST HTTP 1.x ( HTTP 1.1).
• HTTP 1.1 TCP- () , HTTP/2 .
• HTTP/2 . , TCP- . , , HTTP 1.1.
• gRPC .

GRPC für .NET-Serverseite

public class GreeterService : Greeter.GreeterBase
{
    public override Task<HelloReply> SayHello(HelloRequest request,
        ServerCallContext context)
    {
        _logger.LogInformation("Saying hello to {Name}", request.Name);
        return Task.FromResult(new HelloReply 
        {
            Message = "Hello " + request.Name
        });
    }
}

app.UseEndpoints(endpoints =>
{
    endpoints.MapGrpcService<GreeterService>();
});

syntax = "proto3";
 
service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply);
}
 
message HelloRequest {
  string name = 1;
}
 
message HelloReply {
  string message = 1;
}

<ItemGroup>
  <Protobuf Include="Protos\greet.proto"/>
</ItemGroup>

GRPC für .NET-Clientseite

var channel = GrpcChannel.ForAddress("https://localhost:5001");
var client = new Greeter.GreeterClient(channel);
 
var response = await client.SayHello(
    new HelloRequest { Name = "World" });
 
Console.WriteLine(response.Message);

gRPC vs REST

Andere Kommunikationswege

• GraphQL ist eine von Facebook entwickelte API-Abfragesprache. Dadurch kann der Client genau die Daten anfordern, die er vom Server benötigt. Auf diese Weise können Sie nur einen Endpunkt auf dem Server erstellen, der äußerst flexibel ist und nur die Daten zurückgibt, die der Client benötigt. GraphQL ist in den letzten Jahren sehr beliebt geworden.
• TcpClient TcpListener ( System.Net.Sockets) TCP. , . , ASP.NET API.
• UdpClient UDP. TCP , UDP . TCP , , UDP — . UDP , , . : , IP (VoIP).
• WCF ist eine alte Technologie, die hauptsächlich SOAP-basierte Kommunikation zwischen Prozessen verwendet. Dies ist ein riesiges Framework, auf das ich nicht eingehen werde. Ich kann nur sagen, dass es seine Popularität für REST- und JSON-Nutzdaten verloren hat.