API SMS pentru C# cu cod sursă complet
Dacă cauți un instrument puternic pentru dezvoltatorii C#.Net pentru a adăuga capacitatea de trimitere și primire SMS în aplicațiile C#.Net, API-ul SMS pentru C# oferit de Ozeki SMS Gateway este cea mai bună opțiune. Acesta este cel mai bun API SMS pentru C# în 2025. Este excelent, deoarece este foarte eficient din punct de vedere al resurselor și oferă informații despre mesajele trimise sub formă de rapoarte de trimitere și rapoarte de livrare mult mai rapid decât alte API-uri SMS. Acest API SMS pentru C# vă permite, de asemenea, să programați SMS-uri pentru livrare viitoare și îl puteți utiliza atât pentru trimiterea, cât și pentru primirea SMS-urilor de la telefoanele mobile fără întârzieri. Citiți acest articol pentru a afla mai multe despre această soluție uimitoare de SMS pentru C# și pentru a descoperi cum o puteți folosi în mediul dumneavoastră.
Ce este API-ul SMS pentru C#?API-ul SMS pentru C# Ozeki este o interfață software oferită de Ozeki SMS Gateway care vă permite să trimiteți și să primiți SMS din codul C#.Net. Această interfață poate fi utilizată cu biblioteca client API SMS pentru C# de la mai multe calculatoare simultan. (Figura 1) Puteți descărca biblioteca client API SMS pentru C# de pe această pagină web.
Puteți descărca clientul SMS pentru C# (cod sursă) de la următorul link. Fișierul ZIP conține un proiect Visual Studio cu cod sursă complet. Puteți modifica, utiliza și redistribui liber acest cod sau derivate ale acestuia.
Descărcare: OzekiConsole.zip (51 Kb)
URL: https://ozeki-sms-gateway.com/attachments/5755/OzekiConsole.zip
Cu API-ul SMS pentru C# Ozeki puteți trimite și primi mesaje SMS mult mai eficient decât folosind soluții tradiționale HTTP sau REST SMP API. Puteți face acest lucru deoarece API-ul SMS pentru C# Ozeki creează și menține o legătură permanentă TCP/IP cu gateway-ul SMS și comunică prin intermediul unui protocol SMS optimizat numit OZX. Această metodă de comunicare necesită mai puține resurse în ceea ce privește CPU, memorie și lățime de bandă de rețea decât alte protocoale SMS. De exemplu, trimiterea unui mesaj SMS printr-o cerere HTTP REST API necesită cel puțin de 10 ori mai multe date decât o cerere OZX de trimitere.
Cel mai important avantaj provine din legătura permanentă TCP/IP. Datorită acestei legături permanente, aplicația dumneavoastră C# SMS va primi rapoarte de trimitere și rapoarte de livrare instantanee sub formă de evenimente C#. De asemenea, veți primi mesaje SMS fără nicio întârziere. Fără o astfel de legătură, ar trebui fie să interogați gateway-ul SMS pentru a obține rapoarte de livrare sau pentru a descărca SMS-uri primite, fie să configurați un listener TCP/IP sau un serviciu web și să deschideți un port de firewall pentru a primi mesaje.
Această legătură TCP/IP poate fi criptată folosind SSL/TLS și puteți adăuga cu ușurință validarea certificatelor de client și server pentru a face această legătură API SMS pentru C# extrem de sigură.
Cum se utilizează API-ul SMS pentru C#:
- Descărcați Ozeki SMS Gateway
- Instalați o conexiune de testare SMS
- Instalați un utilizator OZX
- Creați un nume de utilizator și o parolă
- Activați jurnalizarea comunicării
- Deschideți proiectul C# SMS în Visual Studio
- Modificați codul C# cu numele de utilizator și parola
- Trimiteți un SMS de test din C#
- Verificați jurnalele din gateway-ul SMS
- Simulați un SMS primit cu conexiunea de test
- Efectuați un test live cu telefonul dumneavoastră Android
Pentru a vă face rapid o idee despre cum să configurați gateway-ul SMS pentru a accepta conexiuni API SMS pentru C# și cum să trimiteți primul SMS din aplicația dumneavoastră C#, vizionați următorul videoclip. Acest videoclip durează doar 2 minute și 21 de secunde și merită timpul investit. Videoclipul arată cum poate fi creat un utilizator OZX în gateway-ul SMS pentru a accepta clienți API SMS pentru C# și cum puteți porni și rula biblioteca client API SMS pentru C# descărcată în Visual Studio. Partea finală vă arată cum puteți trimite un SMS de test.
De ce este API-ul SMS pentru C# Ozeki mai bun?
API-ul SMS pentru C# Ozeki este excelent deoarece cantitatea de date necesară pentru a trimite un SMS este mai mică, iar codificarea și decodificarea Unității de Date Protocol (PDU) implică o utilizare semnificativ mai mică a CPU. Dacă îl utilizați, soluția dumneavoastră va consuma mai puține resurse în toate cele trei domenii majore: memorie, CPU și lățime de bandă de rețea. Ca urmare, aplicațiile dumneavoastră vor acționa mai rapid și vor deveni mai reactive.
Cum pot folosi API-ul SMS pentru C#?API-ul SMS pentru C# Ozeki este un set de clase C# care vă permit să trimiteți și să primiți mesaje SMS. Puteți să-l utilizați deschizând proiectul descărcat în Visual Studio. Odată ce deschideți proiectul, veți vedea că codul complet este scris în C#.Net. Trimiterea mesajelor se face folosind apeluri de metode C#, iar mesajele primite ajung sub formă de evenimente C#. Aplicația dumneavoastră SMS, pe care o construiți pe baza API-ului SMS, va putea trimite mesaje SMS direct în rețeaua mobilă folosind un telefon mobil Android sau un PC cu o conexiune IP SMS. Conexiunea cu rețeaua mobilă va fi asigurată de Ozeki SMS gateway, pe care trebuie să Linux. (Figura 2)
Cât costă API-ul SMS pentru C#?
API-ul este o bibliotecă, care vă este oferită gratuit, cu o licență MIT. Puteți să o modificați și să o distribuiți liber după cum doriți. Când descărcați API-ul, pachetul conține o aplicație de consolă exemplu și codul sursă complet al DLL-ului Ozeki.Libs.OZX.
Singurul cost pe care trebuie să-l plătiți este taxa de licență pentru software-ul Ozeki SMS Gateway. Un singur gateway SMS poate fi folosit pentru a servi sute de clienți SMS C# pe rețea. Puteți instala gateway-ul SMS pe mai multe calculatoare pentru a crește capacitatea sau pentru a beneficia de ofertele SMS ale rețelelor locale.
În ceea ce privește costurile SMS, dacă trimiteți mesaje text prin intermediul unui telefon mobil conectat la PC, costul depinde de tarifele SMS ale cardului SIM din telefonul dvs. În majoritatea țărilor, puteți trimite mesaje SMS gratuit dacă alegeți această opțiune. Există însă o limitare: un singur telefon mobil nu poate trimite mai mult de 12000 de SMS pe zi. Puteți crește această capacitate doar prin conectarea mai multor telefoane mobile la computer. Când trimiteți un SMS prin telefonul mobil (Figura 2), trebuie să instalați software-ul Ozeki Android SMS gateway pe telefonul dvs. și trebuie să vă conectați la el prin Wi-fi.
Dacă instalați Linux, puteți trimite SMS fără fir cu un pool de modem GSM conectat la PC. În aceste cazuri, se aplică aceleași tarife gratuite pentru SMS deoarece modemele GSM și pool-urile de modem GSM funcționează fără fir cu carduri SIM.
Dacă aveți nevoie de un sistem de gateway SMS local de înaltă performanță, unde pot fi trimise și primite câteva mii (sau milioane) de mesaje, trebuie să vă conectați la un furnizor de servicii SMS online. În acest caz, tarifele SMS sunt stabilite de serviciul SMS la care vă abonați. Rețineți că este întotdeauna o idee bună să vă conectați la două sau mai multe servicii SMS online pentru a fi toleranți la defecțiuni și pentru a putea beneficia de opțiunile de rutare la cel mai mic cost. De asemenea, este o idee bună să configurați o legătură de rezervă fără fir.
Cum mă conectez la gateway-ul SMS?Când dezvoltați aplicația dvs. SMS în C#, probabil veți folosi laptopul. Visual Studio va fi instalat pe laptop. Acest laptop se va conecta la rețeaua locală (LAN) a biroului fie prin Wi-fi, fie prin conexiune Ethernet. Telefonul dvs. Android sau sistemul Windows SMS Gateway (Figura 3) se vor conecta, de asemenea, la rețeaua locală a biroului. Când vă conectați la gateway-ul SMS, veți folosi adresa IP LAN a calculatorului pe care este instalat gateway-ul SMS.
Pentru a conecta aplicația dvs. C# la gateway-ul SMS, va trebui să cunoașteți adresa IP și numărul portului gateway-ului SMS și veți avea nevoie de un nume de utilizator și o parolă. Adresa IP a gateway-ului SMS va fi adresa sa IP LAN. Deoarece majoritatea timpului, software-ul gateway SMS va fi instalat pe un alt calculator decât laptopul de dezvoltare, această adresă IP va fi diferită de adresa IP a laptopului dvs. Numărul portului este simplu. De obicei, este numărul portului implicit, care este 9580. Pentru a obține un nume de utilizator și o parolă, trebuie să creați un utilizator OZX (Figura 4). Când creați utilizatorul OZX, puteți specifica orice nume de utilizator sau parolă doriți.
Odată ce ați aflat adresa IP, numărul portului și ați creat numele de utilizator și parola, trebuie să introduceți aceste detalii în metoda de conectare a aplicației dvs. SMS în C#.
Dacă nu doriți să folosiți două calculatoare, puteți instala gateway-ul SMS pe laptopul dvs. (același calculator pe care dezvoltați aplicația în C#). În acest caz, veți furniza "127.0.0.1" ca adresă IP și portul "9580" în metoda de conectare. (Da, puteți folosi și adrese IPv6 sau nume de gazdă, cum ar fi 'localhost")
Beneficii ale utilizării propriului Gateway SMSTestare gratuită: Este foarte benefic să operați propriul gateway SMS, deoarece puteți testa aplicația dvs. SMS gratuit. Puteți simula mesaje SMS primite, puteți trimite mesaje de test la conexiunea de test a gateway-ului SMS și puteți simula rapoarte de livrare SMS care indică livrarea reușită sau eșuată. Este o idee bună să citiți ghidul simulator SMPP pentru a obține mai multe informații despre testare.
Testare de performanță nelimitată: După ce ați dezvoltat soluția dvs. SMS în C#, este probabil să doriți să faceți câteva teste de performanță. Cu Ozeki SMS Gateway este foarte ușor să testați sistemul cu un volum mare de mesaje SMS. În majoritatea cazurilor, veți trimite doar câteva mii de SMS, dar dacă un client vă solicită, puteți face chiar un test cu câteva milioane de mesaje. Consultați rezultatele testului de performanță SMS pe care le-am realizat cu Ozeki SMS Gateway cu 1 000 000 de SMS.
Comutare ușoară între furnizori: Dacă dezvoltați codul dvs. C# care funcționează cu Ozeki SMS Gateway, nu va trebui să vă faceți griji că veți fi blocat într-o rețea SMS sau la un singur furnizor de servicii SMS. Puteți folosi același cod C# și pur și simplu să treceți la un alt furnizor de servicii SMS dacă obțineți o ofertă mai bună prin configurarea conexiunii noului furnizor în gateway-ul SMS.
Ce este OZX?
OZX reprezintă OZeki eXchange. Este un protocol SMS foarte optimizat folosit pentru comunicarea dintre aplicația ta SMS în C# și Ozeki SMS Gateway. Este un protocol bazat pe TCP/IP care este semnificativ mai eficient decât protocoalele SMS tradiționale, cum ar fi C# HTTP SMS API, protocoalele C# REST SMS API sau protocolul SMPP SMS. Eficiența provine din două motive majore: nu se transmit date inutile (rețineți că există o suprasarcină mare de date atât în HTTP cât și în SMPP), iar procesarea protocolului este mai ușoară și mai eficientă datorită structurii PDU a protocolului.
Ce conține arhiva C# SMS API?Arhiva conține două proiecte (ca în Figura 5): o aplicație consolă care este un cod foarte ușor de înțeles pentru a-ți arăta cum să folosești C# SMS API și conține codul sursă al C# SMS API în sine.
Conținutul pachetului C# SMS API:
- Cod exemplu (cod sursă complet)
- Biblioteca client Ozeki (cod sursă complet)
Pentru a deschide Ozeki SMS API, trebuie să localizezi fișierul OzekiConsole.sln după dezarhivarea pachetului OzekiConsole.zip și să-l deschizi în Visual Studio. (Figura 6) Poți face dublu clic pe fișierul soluție (.sln) sau să navighezi la el în Visual Studio.
După ce ai deschis .sln, vei vedea două proiecte în soluția ta. Proiectul OzekiConsole conține codul exemplu care îți arată cum poți folosi biblioteca client C# SMS API pentru a te conecta la SMS Gateway. (Figura 7) Celălalt proiect este Ozeki.Libs.OZX dll. Acest proiect conține codul sursă complet al bibliotecii client C# SMS API.
Pentru a folosi C# SMS API, trebuie să creezi un nume de utilizator și o parolă în SMS gateway. Dacă ai instalat SMS gateway pe telefonul tău Android, trebuie să te autentifici pe telefon folosind un browser web. Dacă ai instalat SMS gateway pe Windows sau Linux, conectează-te pur și simplu la el cu browserul tău. Dacă nu ai instalat încă SMS gateway, configurează-l acum folosind una dintre următoarele instrucțiuni: Cum să configurez SMS Gateway pe Windows, Cum să configurez SMS gateway pe Linux. (Figura 8)
Pentru a trimite SMS din C#, trebuie să adaugi ozekisms.dll ca referință în soluția ta Visual Studio. Poți alege să adaugi dll-ul binar sau să adaugi proiectul care conține codul sursă. Dacă adaugi dll-ul binar, proiectul tău se va compila mai repede, iar dacă adaugi codul sursă, vei avea mai bune capabilități de depanare. (Figura 9)
Cum să trimiți SMS din C#:
- Descarcă biblioteca Ozeki C# SMS (fișier zip)
- Extrage fișierul zip
- Deschide Microsoft Visual Studio
- Creează o nouă aplicație consolă
- În Solution Explorer, click "Adaugă..."
- Selectează "Proiect existent"
- Caută OzekiSMSLibrary.csproj
- Click Deschide
- Adaugă namespace-ul "Ozeki" în aplicația ta consolă
- Copiază și lipește exemplul
- Trimite primul tău SMS folosind funcția SendMessage
Pentru a primi SMS în C#, trebuie să configurezi proiectul tău în același mod în care l-ai configura pentru a trimite un mesaj SMS. Pe scurt, descarcă ozekisms.dll ca binar sau ca sursă și adaugă-l în proiectul tău ca bibliotecă de referință. După aceasta, poți crea o instanță a clasei C# și poți să te abonezi la evenimentul care este apelat când un SMS este primit. (Figura 10)
Cum să primești SMS în C#:
- Descarcă biblioteca Ozeki C# SMS (fișier zip)
- Deschide Microsoft Visual Studio
- Creează o nouă aplicație consolă sau deschide unul din proiectele tale existente
- Adaugă biblioteca C# SMS în soluția ta C#
- Adaugă namespace-ul "Ozeki" în clasa ta
- Creează o instanță a clasei de mesaje
- Înscrie-te la evenimentul OnMessageReceived
- Scrie codul pentru gestionarea evenimentului
- Setează un punct de întrerupere în gestionarul de evenimente
- Trimite un mesaj de test
- Așteaptă ca SMS-ul să ajungă la punctul de întrerupere
Înțelegeți codul sursă al API-ului SMS C#
//*********************************************************************
// Ozeki C# SMS API - v1.0.0
// Documentație: https://ozeki-sms-gateway.com/p_5755-c-sharp-sms-api.html
//*********************************************************************
using System;
using OZX;
namespace OzekiConsoleClient
{
class Program
{
static OzxClient Client;
//*************************************************************
// Principal
//*************************************************************
static void Main(string[] args)
{
createClient();
printWelcome();
string command = null;
string parameters;
while (command != "exit")
{
if (!_promptAvailable) printPrompt();
readCommand(out command, out parameters);
_promptAvailable = false;
dispatchCommand(command, parameters);
}
}
//*************************************************************
// Citește următoarea comandă
//*************************************************************
static bool _promptAvailable;
static void printPrompt()
{
Console.Write("> ");
_promptAvailable = true;
}
static void readCommand(out string command, out string parameters)
{
command = Console.ReadLine();
parameters = null;
int paramSep = command.IndexOf(' ');
if (paramSep > -1)
{
parameters = command.Substring(paramSep + 1);
command = command.Substring(0, paramSep);
}
}
static void dispatchCommand(string command, string parameters)
{
switch (command)
{
case "help":
printHelp();
break;
case "exit":
Console.WriteLine("Vă mulțumim pentru utilizarea Ozeki Client!");
break;
case "connect":
connect(parameters);
break;
case "disconnect":
disconnect();
break;
case "send":
send(parameters);
break;
}
}
//*************************************************************
// Comenzi / Bun venit
//*************************************************************
static void printWelcome()
{
Console.WriteLine("**********************************");
Console.WriteLine("* Bun venit la Ozeki Client v1.0.0 *");
Console.WriteLine("**********************************");
Console.WriteLine("Tastați 'help' pentru comenzi disponibile");
}
//*************************************************************
// Comenzi / Ajutor
//*************************************************************
static void printHelp()
{
Console.WriteLine("**********************");
Console.WriteLine("* Comenzi disponibile *");
Console.WriteLine("**********************");
Console.WriteLine("help");
Console.WriteLine("connect [host:port] [username] [password]");
Console.WriteLine("disconnect");
Console.WriteLine("send [destinatar] [mesaj]");
Console.WriteLine("exit");
}
//*************************************************************
// Comenzi / Conectare
//*************************************************************
static void connect(string parameters)
{
if (!parseConnectParameters(parameters, out string host, out int port, out string username, out string password, out string errormessage))
{
Console.WriteLine("Eroare. "+errormessage);
Console.WriteLine("Sintaxă: connect [host:port] [username] [password]");
Console.WriteLine("Exemplu: connect 127.0.0.1:9580 testuser testpass");
}
Console.WriteLine("Se conectează la "+parameters+"...");
Client.Connect(host, port, username, password);
}
static bool parseConnectParameters(string parameters, out string host, out int port, out string username, out string password, out string errormessage)
{
string[] parts = parameters.Split(' ');
if (parts.Length < 3)
{
errormessage = "Conectarea așteaptă 3 parametri.";
username = null;
password = null;
host = null;
port = 0;
return false;
}
string hostandport = parts[0];
username = parts[1];
password = parts[2];
string[] hostandportparts = hostandport.Split(':');
if (hostandportparts.Length < 2)
{
errormessage = "Host și port invalid.";
host = null;
port = 0;
return false;
}
host = hostandportparts[0];
string portstring = hostandportparts[1];
if (!int.TryParse(portstring, out port))
{
errormessage = "Număr de port invalid.";
port = 0;
return false;
}
errormessage = null;
return true;
}
//*************************************************************
// Comenzi / Deconectare
//*************************************************************
static void disconnect()
{
Client.Disconnect();
}
//*************************************************************
// Comenzi / Trimite
//*************************************************************
static void send(string parameters)
{
string[] parts = parameters.Split(new char[] { ' ' },2);
if (parts.Length < 2)
{
Console.WriteLine("Eroare. Trimite așteaptă 2 parametri.");
Console.WriteLine("Sintaxă: send [destinatar] [mesaj]");
Console.WriteLine("Exemplu: send +441234567 Salut lume");
return;
}
string recipient = parts[0];
string message = parts[1];
var msg = new OzxMessage();
msg.ToAddress = recipient;
msg.Text = message;
Console.WriteLine("Se trimite mesajul. ID: "+msg.ID);
Client.Send(msg);
}
//*************************************************************
// Creează client
//*************************************************************
static void createClient()
{
Client = new OzxClient();
Client.AutoReconnect = true;
Client.OnMessageReceived += Client_OnMessageReceived;
Client.OnMessageAcceptedForDelivery += Client_OnMessageAcceptedForDelivery;
Client.OnMessageNotAcceptedForDelivery += Client_OnMessageNotAcceptedForDelivery;
Client.OnMessageSubmitSuccess += Client_OnMessageSubmitSuccess;
Client.OnMessageSubmitFailed += Client_OnMessageSubmitFailed;
Client.OnMessageDeliverySuccess += Client_OnMessageDeliverySuccess;
Client.OnMessageDeliveryFailed += Client_OnMessageDeliveryFailed;
Client.OnMessageViewed += Client_OnMessageViewed;
Client.OnConnected += Client_OnConnected;
Client.OnDisconnected += Client_OnDisconnected;
}
//*************************************************************
// Evenimente de mesagerie
//*************************************************************
static void Client_OnConnected(object sender, EventArgs e)
{
Console.WriteLine("Conectat cu succes.");
printPrompt();
}
static void Client_OnDisconnected(object sender, OzxArgs< string > e)
{
Console.WriteLine("Conexiune închisă. Motiv: " + e.Item.ToString());
printPrompt();
}
static void Client_OnMessageReceived(object sender, OzxArgs< IOzxMessage > e)
{
Console.WriteLine("Mesaj primit: " + e.Item.ToString());
printPrompt();
}
static void Client_OnMessageAcceptedForDelivery(object sender, OzxArgs< string > e)
{
Console.WriteLine("Mesaj acceptat pentru livrare. ID: " + e.Item.ToString());
printPrompt();
}
static void Client_OnMessageNotAcceptedForDelivery(object sender, OzxArgs< string, string > e)
{
Console.WriteLine("Mesaj respins. ID: " + e.Item1.ToString()+" Motiv: "+e.Item2);
printPrompt();
}
static void Client_OnMessageSubmitSuccess(object sender, OzxArgs< string, DateTime > e)
{
Console.WriteLine("Mesaj trimis. ID: "+e.Item1+" Data: "+e.Item2);
printPrompt();
}
static void Client_OnMessageSubmitFailed(object sender, OzxArgs< string, DateTime, string > e)
{
Console.WriteLine("Trimiterea mesajului a eșuat. ID: " + e.Item1 + " Data: " + e.Item2+" Motiv: "+e.Item3);
printPrompt();
}
static void Client_OnMessageDeliverySuccess(object sender, OzxArgs< string, DateTime > e)
{
Console.WriteLine("Mesaj livrat. ID: " + e.Item1 + " Data: " + e.Item2);
printPrompt();
}
static void Client_OnMessageDeliveryFailed(object sender, OzxArgs< string, DateTime, string > e)
{
Console.WriteLine("Livrarea mesajului a eșuat. ID: " + e.Item1 + " Data: " + e.Item2 + " Motiv: " + e.Item3);
printPrompt();
}
static void Client_OnMessageViewed(object sender, OzxArgs< string, DateTime > e)
{
Console.WriteLine("Mesaj vizualizat. ID: " + e.Item1 + " Data: " + e.Item2);
printPrompt();
}
}
}
Ce să fac dacă nu mă pot conecta?
Dacă aplicația ta SMS nu se poate conecta la gateway-ul SMS, este posibil să fi introdus adresa IP sau numărul de port greșit în clientul SMS. De asemenea, este posibil ca firewall-ul de pe gateway-ul SMS să blocheze conexiunea.
Pentru a verifica dacă folosești adresa IP și portul corect, deschide interfața de utilizator a gateway-ului SMS. În bara de instrumente a aplicației SMS Gateway, dă clic pe butonul Avansat. Aceasta va deschide pagina de servicii a gateway-ului SMS. Trebuie să găsești serviciul OZX în listă și să dai clic pe "Detalii" (Figura 11)
După ce pagina s-a deschis, poți găsi adresa IP în bara de titlu a ferestrei (Figura 12), iar numărul de port în partea stângă a formularului de configurare. (Reține că poți modifica acest număr de port deschizând formularul de configurare al serviciului OZX.)
Poți scrie aceste detalii direct în codul tău C#. De exemplu, poți folosi următoarea funcție pentru a stabili o conexiune la gateway-ul SMS la 192.168.93.192:9580 cu un nume de utilizator OZX tester și parola test:
static void createClient()
{
Client = new OzxClient();
Client.AutoReconnect = true;
Client.Connect("192.168.93.192", 9580, "testuser", "testpass");
}
În concluzie, API-ul SMS C# îți permite să te conectezi la Gateway-ul tău SMS folosind protocolul OZX. Acest protocol SMS oferă performanță excelentă și comunicare SMS bidirecțională. Faptul că biblioteca gratuită API SMS C# oferită de Ozeki îți permite să trimiți mesaje SMS cu apeluri simple de metode și să primești rapoarte de trimitere și livrare SMS sub forma de evenimente C# face această opțiune cea mai bună dacă dorești să construiești o aplicație SMS C# în 2025.
More information