Ի՞նչ պրոտոկոլներ կան տվյալների փոխանակման համար սերվեր և հաճախորդ միջև։

Տվյալների փոխանակման համար սերվերների և հաճախորդների միջև C# .NET-ում օգտագործվում են տարբեր պրոտոկոլներ, որոնց ընտրությունը կախված է հավելվածի պահանջներից՝ արագություն, հուսալիություն, անվտանգություն, տվյալների տիպ և ֆորմատ:

Հիմնական պրոտոկոլները:

1. HTTP/HTTPS: Ամենատարածված պրոտոկոլները վեբ-հավելվածների համար: HTTP (Hypertext Transfer Protocol) — հիպերտեքստային տեղեկատվության փոխանցման կիրառական մակարդակի պրոտոկոլ: HTTPS — դրա ընդլայնում է շифրմամբ (SSL/TLS) ապահովելու համար:

   • Առավելություններ: Շարունակական աջակցություն, պարզ օգտագործում, լավ է հարմար է "մեկ անգամ տվյալներ ստանալու" հարցում/պատասխաններում:
   • Կոմպրոմիսներ: Կենտրոնացած է հարցում-պատասխան, ոչ արդյունավետ հոսքային փոխանցման կամ մշտական երկկողմանի փոխանակման համար:

2. TCP/IP: Թրանսպորտային պրոտոկոլ (TCP - Transmission Control Protocol) և ցանցային պրոտոկոլ (IP - Internet Protocol): TCP-ն ապահովում է պակասի ապահովված առաքում և հոսքի կառավարում: Դա հիմքն է շատ բարձր մակարդակի պրոտոկոլների համար:

   • Առավելություններ: Հուսալիություն, հոսքի կառավարում, հարմար է ցանկացած տվյալների տիպի համար:
   • Կոմպրոմիսներ: Ավելի ցածր մակարդակ, պահանջում է ավելի շատ լոգիկայի մշակում հավելվածի կողմից:

3. UDP/IP: Ցանցային պրոտոկոլ (UDP - User Datagram Protocol): Բացառությամբ TCP-ից, UDP-ն չի երաշխավորում առաքում և կարգը, բայց ունի ավելի փոքր ծախսեր:

   • Առավելություններ: Բարձր արագություն, ցածր ուշացում, հարմար է հոսքային տվյալների փոխանցման համար (ձայն, տեսանյութ), որտեղ կորուստը թույլատրվում է:
   • Կոմպրոմիսներ: Հուսալի չէ, չի վերահսկում կարգը և կորուստները:

4. WebSocket: Պրոտոկոլ, որը ապահովում է ամբողջ երկկողմ կապ TCP միացման միջոցով: Позволяет ինչպես սերվերին, այնպես էլ հաճախորդին ուղարկել տվյալներ ցանկացած ժամանակ առանց մշտական հարցումների:

   • Առավելություններ: Երկկողմ կապ, ցածր ուշացում, արդյունավետ է իրական ժամանակի փոխանակման համար:
   • Կոմպրոմիսներ: Աջակցությունը կարող է տարբեր լինել հին բրաուզերներում կամ հաճախորդներում:

5. gRPC: Բարձր կատարողական RPC (Remote Procedure Call) համակարգ, որը մշակվել է Google-ի կողմից: Օգտագործում է HTTP/2 տրանսպորտի համար և Protocol Buffers սերիալիզացման համար:

   • Առավելություններ: Բարձր կատարողականություն, ուժեղ կոնտակտացիա, հոսքային փոխանցում, աջակցում է բազմաթիվ լեզուների:
   • Կոմպրոմիսներ: Կարող է ավելի բարդ լինել կարգավորել, քան RESTful HTTP:

6. .NET Remoting (հնացած): Հնացած տեխնոլոգիա .NET Framework-ի համար միջհամակարգային փոխազդեցության համար: Չի խորհուրդ տրվում նոր կոդի համար:

7. WCF (Windows Communication Foundation) (համակարգային .NET Framework): Մեկական մոդել Microsoft-ի համար տարածված հավելվածների կառուցման համար: Աջակցում է տարբեր պրոտոկոլների (TCP, HTTP, MSMQ) և հաղորդագրությունների ֆորմատների:

   • Առավելություններ: Գործնականություն, աջակցում է տարբեր պրոտոկոլների և ֆորմատների, անվտանգություն:
   • Կոմպրոմիսներ: Կարծրություն, հատուկ է միայն .NET-ի համար, քիչ արդիական է .NET Core+-ում:

8. ASP.NET Core SignalR: գրադարան ASP.NET Core-ի համար, որը հեշտացնում է իրական ժամանակի ֆունկցիոնալության ավելացումը հավելվածներում: Օգտագործում է WebSocket, Server-Sent Events կամ Long Polling որպես տրանսպորտ:

   • Առավելություններ: Հեշտ իրականացնել իրական ժամանակի ֆունկցիոնալություն, ավտոմատ ընտրություն լավագույն տրանսպորտի:
   • Կոմպրոմիսներ: Կենտրոնացած է վեբ-սցենարների վրա:

Օրինակ՝ HTTP-կլիենտ օգտագործելու համար C#-ում:

// using System.Net.Http;
// using System.Threading.Tasks;

public async Task<string> GetDataFromApiAsync(string url)
{
    using (HttpClient client = new HttpClient())
    {
        try
        {
            HttpResponseMessage response = await client.GetAsync(url);
            response.EnsureSuccessStatusCode(); // Թողարկում է բացառություն, եթե վիճակագրական կոդը չի հաջողված
            string responseBody = await response.Content.ReadAsStringAsync();
            return responseBody;
        }
        catch (HttpRequestException e)
        {
            Console.WriteLine($"HTTP սխալ: {e.Message}");
            return null;
        }
    }
}

Օրինակ՝ պարզ TCP սերվեր:

// using System.Net;
// using System.Net.Sockets;
// using System.Text;
// using System.Threading.Tasks;

public async Task StartTcpServerAsync(int port)
{
    TcpListener server = null;
    try
    {
        IPAddress localAddr = IPAddress.Loopback; // կամ IPAddress.Any
        server = new TcpListener(localAddr, port);

        server.Start();
        Console.WriteLine($"TCP սերվերը սկսվեց {localAddr}:{port}");

        while (true)
        {
            Console.WriteLine("Սպասում է միացում...");
            TcpClient client = await server.AcceptTcpClientAsync();
            Console.WriteLine("Միացում հաստատված!");

            // Իրական հավելվածում կապի մշակումը պետք է կատարվի առանձին թևում կամ Task-ում
            NetworkStream stream = client.GetStream();

            byte[] buffer = new byte[256]; // Բաֆեր տվյալների ընթերցման համար
            int bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length);
            string data = Encoding.UTF8.GetString(buffer, 0, bytesRead);
            Console.WriteLine($"Ստացված: {data}");

            // Ուղարկում պատասխան
            byte[] msg = Encoding.UTF8.GetBytes("Բարև, հաճախորդ!");
            await stream.WriteAsync(msg, 0, msg.Length);
            Console.WriteLine("Ուղարկված: Բարև, հաճախորդ!");

            client.Close();
        }
    }
    catch (SocketException e)
    {
        Console.WriteLine($"Socket սխալ: {e.Message}");
    }
    finally
    {
        server?.Stop();
    }
}

Ընտրությունը պրոտոկոլի կախված է կոնկրետ պահանջներից: Ստանդարտ API փոխանակումների համար հաճախ օգտագործվում է HTTP/HTTPS: Իրական ժամանակի հավելվածների համար, օրինակ՝ չատերի, WebSocket կամ SignalR ավելի նախընտրելի են: Բարձր կատարողական միջծառայողական հաղորդակցությունների համար կարող է հարմար լինել gRPC։