O relacionamento entre C # e C #: REST, gRPC e tudo mais

Cenário ideal

// 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 estáticas apenas com métodos estáticos.
• Classes POCO nas quais não há nada além de campos e propriedades cujo tipo é uma classe POCO primitiva ou outra.

Abordagem REST tradicional

• GET é usado para obter o recurso
• PUT é usado para alterar o estado de um recurso.
• POST é usado para criar um recurso.
• DELETE é usado para excluir um recurso.

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

Remontar

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

• Todos os caminhos (URLs) na API.
• Operações esperadas (GET, POST, ...) para cada caminho. Cada caminho pode lidar com operações diferentes. Por exemplo, o mesmo caminho mystore.com/Product pode aceitar uma operação POST que adiciona um produto e uma operação GET que retorna um produto.
• Os parâmetros esperados para cada caminho e operação.
• Respostas esperadas para cada caminho.
• Tipos de cada parâmetro e objeto de resposta.

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

Adicionando Swagger ao seu servidor 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)
{
    //...
}

Gerando um cliente a partir do Swagger usando o 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 tradicional vs Swagger vs ReFit

• Se você possui uma API REST privada muito simples, pode não precisar se preocupar com a geração de clientes e interfaces comuns. Uma pequena tarefa não justifica um esforço adicional.
• O Swagger suporta muitos idiomas e o ReFit suporta apenas .NET. O Swagger também é a base de muitas ferramentas, testes, ferramentas de automação e ferramentas de interface do usuário. Essa provavelmente será a melhor opção se você estiver criando uma API pública grande.
• O Swagger é muito mais complicado que o ReFit. Com o ReFit, basta adicionar uma única interface ao projeto do servidor e do cliente. Por outro lado, com o ReFit, você terá que criar novas interfaces para cada controlador, enquanto o Swagger cuidará disso automaticamente.

gRPC

• Como o REST, o gRPC é independente do idioma. Existem ferramentas para todos os idiomas populares, incluindo C #.
• O gRPC é baseado em contrato e usa arquivos .proto para definir o contrato. Isso é um pouco semelhante ao Swagger swagger.json e à interface comum do ReFit. Um cliente de qualquer linguagem de programação pode ser gerado a partir desses arquivos.
• 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 .

Lado do servidor GRPC para .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>

GRPC para .NET lado do cliente

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

Outras formas de comunicação

• GraphQL é uma linguagem de consulta API desenvolvida pelo Facebook. Isso permite que o cliente solicite exatamente os dados necessários ao servidor. Assim, você pode criar apenas um terminal no servidor, que será extremamente flexível e retornará apenas os dados necessários ao cliente. O GraphQL se tornou muito popular nos últimos anos.
• TcpClient TcpListener ( System.Net.Sockets) TCP. , . , ASP.NET API.
• UdpClient UDP. TCP , UDP . TCP , , UDP — . UDP , , . : , IP (VoIP).
• O WCF é uma tecnologia antiga que usa principalmente a comunicação entre processos baseada em SOAP. Essa é uma estrutura enorme em que não vou entrar, só posso dizer que perdeu a popularidade das cargas úteis REST e JSON.