La relación entre C # y C #: REST, gRPC y todo lo demás

Escenario óptimo

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

• Clases estáticas solo con métodos estáticos.
• Clases de POCO en las que no hay nada más que campos y propiedades cuyo tipo es una primitiva u otra clase de POCO.

Enfoque REST tradicional

• GET se usa para obtener el recurso
• PUT se usa para cambiar el estado de un recurso.
• POST se usa para crear un recurso.
• DELETE se usa para eliminar un 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);

Repararse

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

Pavonearse

• Todas las rutas (URL) en la API.
• Operaciones esperadas (GET, POST, ...) para cada ruta. Cada ruta puede manejar diferentes operaciones. Por ejemplo, la misma ruta mystore.com/Product puede aceptar una operación POST que agrega un producto y una operación GET que devuelve un producto.
• Los parámetros esperados para cada ruta y operación.
• Respuestas esperadas para cada ruta.
• Tipos de cada parámetro y objeto de respuesta.

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

Agregar Swagger a su 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)
{
    //...
}

Generando un cliente de Swagger usando 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

• Si tiene una API REST privada muy simple, es posible que no tenga que preocuparse por la generación de clientes y las interfaces comunes. Una tarea pequeña no justifica un esfuerzo adicional.
• Swagger admite muchos idiomas, y ReFit solo admite .NET. Swagger también es la base de muchas herramientas, pruebas, herramientas de automatización y herramientas de interfaz de usuario. Esta será probablemente la mejor opción si está creando una gran API pública.
• Swagger es mucho más complicado que ReFit. Con ReFit, es solo cuestión de agregar una sola interfaz tanto a su servidor como a su proyecto de cliente. Por otro lado, con ReFit tendrás que crear nuevas interfaces para cada controlador, mientras que Swagger se encargará de esto automáticamente.

gRPC

• Al igual que REST, gRPC es independiente del lenguaje. Existen herramientas para todos los lenguajes populares, incluido C #.
• gRPC se basa en contratos y utiliza archivos .proto para definir el contrato. Esto es algo similar a Swagger swagger.json y la interfaz común ReFit. Se puede generar un cliente de cualquier lenguaje de programación a partir de estos archivos.
• 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 para el lado del servidor .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 el lado del cliente .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

Otras formas de comunicación

• GraphQL es un lenguaje de consulta API desarrollado por Facebook. Esto permite al cliente solicitar exactamente los datos que necesita del servidor. Por lo tanto, puede crear solo un punto final en el servidor, que será extremadamente flexible y devolverá solo los datos que el cliente necesita. GraphQL se ha vuelto muy popular en los últimos años.
• TcpClient TcpListener ( System.Net.Sockets) TCP. , . , ASP.NET API.
• UdpClient UDP. TCP , UDP . TCP , , UDP — . UDP , , . : , IP (VoIP).
• WCF es una tecnología antigua que utiliza principalmente la comunicación entre procesos basada en SOAP. Este es un gran marco en el que no entraré, solo puedo decir que ha perdido su popularidad para las cargas útiles REST y JSON.