C # और C #: REST, gRPC और बीच में सब कुछ के बीच संबंध

इष्टतम परिदृश्य

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

• केवल स्थैतिक विधियों के साथ स्थिर वर्ग।
• POCO क्लासेस जिसमें फ़ील्ड और प्रॉपर्टी के अलावा और कुछ नहीं है जिसका प्रकार एक आदिम या अन्य POCO क्लास है।

पारंपरिक रीस्ट दृष्टिकोण

• GET का उपयोग संसाधन प्राप्त करने के लिए किया जाता है
• PUT का उपयोग किसी संसाधन की स्थिति को बदलने के लिए किया जाता है।
• POST का उपयोग रिसोर्स बनाने के लिए किया जाता है।
• DELETE का उपयोग किसी संसाधन को हटाने के लिए किया जाता है।

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

मरम्मत

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

अकड़

• एपीआई में सभी पथ (यूआरएल)।
• प्रत्येक पथ के लिए अपेक्षित संचालन (GET, POST, ...)। प्रत्येक पथ विभिन्न कार्यों को संभाल सकता है। उदाहरण के लिए, एक ही रास्ता मिस्ट्री। प्रोडक्ट एक पोस्ट ऑपरेशन को स्वीकार कर सकता है जो एक उत्पाद जोड़ता है और एक जीईटी ऑपरेशन जो एक उत्पाद लौटाता है।
• प्रत्येक पथ और संचालन के लिए अपेक्षित पैरामीटर।
• प्रत्येक पथ के लिए अपेक्षित उत्तर।
• प्रत्येक पैरामीटर और प्रतिक्रिया ऑब्जेक्ट के प्रकार।

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

अपने 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)
{
    //...
}

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 API है, तो आपको क्लाइंट पीढ़ी और सामान्य इंटरफेस के बारे में चिंता करने की आवश्यकता नहीं है। एक छोटा कार्य अतिरिक्त प्रयास को उचित नहीं ठहराता है।
• स्वैगर कई भाषाओं का समर्थन करता है, और रीफिट केवल .NET का समर्थन करता है। स्वैगर कई टूल्स, टेस्ट, ऑटोमेशन टूल्स और यूजर इंटरफेस टूल्स का भी आधार है। यदि आप एक बड़ी सार्वजनिक एपीआई बना रहे हैं तो यह संभवतः सबसे अच्छा विकल्प होगा।
• स्वैगर रेफ़िट की तुलना में बहुत अधिक जटिल है। ReFit के साथ, यह आपके सर्वर और क्लाइंट प्रोजेक्ट दोनों के लिए एकल इंटरफ़ेस जोड़ने की बात है। दूसरी ओर, रीफिट के साथ आपको प्रत्येक नियंत्रक के लिए नए इंटरफेस बनाने होंगे, जबकि स्वैगर इस बात का स्वत: ध्यान रखेगा।

gRPC

• REST की तरह, gRPC भाषा स्वतंत्र है। C # सहित सभी लोकप्रिय भाषाओं के लिए उपकरण हैं।
• gRPC अनुबंध आधारित है और अनुबंध को परिभाषित करने के लिए .proto फ़ाइलों का उपयोग करता है । यह कुछ हद तक Swagger swagger.json और सामान्य ReFit इंटरफ़ेस के समान है। इन फ़ाइलों से किसी भी प्रोग्रामिंग भाषा का क्लाइंट जेनरेट किया जा सकता है।
• 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 .

.NET सर्वर साइड के लिए GRPC

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>

.NET क्लाइंट पक्ष के लिए GRPC

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 बनाम REST

संचार के अन्य तरीके

• ग्राफकॉक फेसबुक द्वारा विकसित एक एपीआई क्वेरी भाषा है। यह क्लाइंट को सर्वर से आवश्यक डेटा का अनुरोध करने की अनुमति देता है। इस प्रकार, आप सर्वर पर केवल एक एंडपॉइंट बना सकते हैं, जो बेहद लचीला होगा और केवल उसी डेटा को लौटाएगा जो क्लाइंट को चाहिए। हाल के वर्षों में ग्राफकॉल बहुत लोकप्रिय हो गया है।
• TcpClient TcpListener ( System.Net.Sockets) TCP. , . , ASP.NET API.
• UdpClient UDP. TCP , UDP . TCP , , UDP — . UDP , , . : , IP (VoIP).
• WCF एक पुरानी तकनीक है जो मुख्य रूप से SOAP- आधारित अंतर-प्रक्रिया संचार का उपयोग करती है। यह एक बहुत बड़ा ढांचा है जिसे मैंने जाना नहीं है, मैं केवल यह कह सकता हूं कि इसने REST और JSON पेलोड के लिए अपनी लोकप्रियता खो दी है।