La relation entre C # et C #: REST, gRPC et tout le reste

Scénario optimal

// 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;
    }
}

• Classes statiques avec méthodes statiques uniquement.
• Classes POCO dans lesquelles il n'y a que des champs et des propriétés dont le type est une classe POCO primitive ou autre.

Approche REST traditionnelle

• GET est utilisé pour obtenir la ressource
• PUT est utilisé pour changer l'état d'une ressource.
• POST est utilisé pour créer une ressource.
• DELETE est utilisé pour supprimer une ressource.

[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);

Remonter

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");

Swagger

• Tous les chemins (URL) dans l'API.
• Opérations attendues (GET, POST, ...) pour chaque chemin. Chaque chemin peut gérer différentes opérations. Par exemple, le même chemin mystore.com/Product peut accepter une opération POST qui ajoute un produit et une opération GET qui renvoie un produit.
• Les paramètres attendus pour chaque chemin et opération.
• Réponses attendues pour chaque chemin.
• Types de chaque paramètre et objet de réponse.

{ 
   "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"
                     }
                  }
               },
...
 

Ajout de Swagger à votre serveur ASP.NET

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)
{
    //...
}

Génération d'un client à partir de Swagger à l'aide d'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");

REST traditionnel vs Swagger vs ReFit

• Si vous disposez d'une API REST privée très simple, vous n'aurez peut-être pas à vous soucier de la génération de clients et des interfaces communes. Une petite tâche ne justifie pas un effort supplémentaire.
• Swagger prend en charge de nombreuses langues et ReFit ne prend en charge que .NET. Swagger est également la base de nombreux outils, tests, outils d'automatisation et outils d'interface utilisateur. Ce sera probablement le meilleur choix si vous créez une grande API publique.
• Swagger est beaucoup plus compliqué que ReFit. Avec ReFit, il suffit d'ajouter une interface unique à la fois à votre projet serveur et client. En revanche, avec ReFit, vous devrez créer de nouvelles interfaces pour chaque contrôleur, tandis que Swagger s'en chargera automatiquement.

gRPC

• Comme REST, gRPC est indépendant du langage. Il existe des outils pour tous les langages populaires, y compris C #.
• gRPC est basé sur un contrat et utilise des fichiers .proto pour définir le contrat. Ceci est quelque peu similaire à Swagger swagger.json et à l'interface ReFit commune. Un client de n'importe quel langage de programmation peut être généré à partir de ces fichiers.
• 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 .

Côté serveur GRPC pour .NET

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>

Côté client GRPC pour .NET

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

Autres moyens de communication

• GraphQL est un langage de requête API développé par Facebook. Cela permet au client de demander exactement les données dont il a besoin au serveur. Ainsi, vous ne pouvez créer qu'un seul point de terminaison sur le serveur, ce qui sera extrêmement flexible et ne renverra que les données dont le client a besoin. GraphQL est devenu très populaire ces dernières années.
• TcpClient TcpListener ( System.Net.Sockets) TCP. , . , ASP.NET API.
• UdpClient UDP. TCP , UDP . TCP , , UDP — . UDP , , . : , IP (VoIP).
• WCF est une ancienne technologie qui utilise principalement la communication inter-processus basée sur SOAP. Il s'agit d'un cadre énorme dans lequel je n'entrerai pas, je peux seulement dire qu'il a perdu sa popularité pour les charges utiles REST et JSON.