API SMS C# avec code source complet
Si vous recherchez un outil puissant pour les développeurs C#.Net afin d'ajouter la capacité d'envoi et de réception de SMS aux applications C#.Net, l'API SMS C# fournie par Ozeki SMS Gateway est la meilleure option. C'est la meilleure API SMS C# en 2025. Elle est excellente, car elle est très économe en ressources et offre des informations sur vos messages soumis sous forme de rapports d'envoi et de rapports de livraison beaucoup plus rapidement que les autres API SMS. Cette API SMS C# vous permet également de programmer des SMS pour une livraison future, et vous pouvez l'utiliser pour envoyer et recevoir des SMS depuis des téléphones portables sans délai. Lisez cet article pour en savoir plus sur cette solution SMS C# incroyable et découvrir comment vous pouvez en tirer parti dans votre environnement.
Qu'est-ce que l'API SMS C# ?
L'API SMS C# Ozeki est une interface logicielle fournie par Ozeki SMS Gateway qui vous permet d'envoyer et de recevoir des SMS depuis du code C#.Net. Cette interface peut être utilisée avec la bibliothèque cliente de l'API SMS C# depuis plusieurs ordinateurs simultanément. (Figure 1) Vous pouvez télécharger la bibliothèque cliente de l'API SMS C# depuis cette page web.
Téléchargement de la bibliothèque cliente de l'API SMS C#
Vous pouvez télécharger le client SMS C# (code source) à partir du lien suivant. Le fichier ZIP contient un projet Visual Studio avec le code source complet. Vous pouvez librement modifier, utiliser et redistribuer ce code ou ses dérivés.
Téléchargement : OzekiConsole.zip (51 Kb)
URL : https://ozeki-sms-gateway.com/attachments/5755/OzekiConsole.zip
Comment fonctionne l'API SMS C# ?
Avec l'API SMS C# Ozeki, vous pouvez envoyer et recevoir des messages SMS beaucoup plus efficacement qu'avec les solutions traditionnelles d'API SMS HTTP ou REST. Cela est possible car l'API SMS C# Ozeki crée et maintient une liaison TCP/IP permanente vers la passerelle SMS et communique via un protocole SMS hautement optimisé appelé OZX. Cette méthode de communication nécessite moins de ressources en termes de CPU, mémoire et bande passante réseau que les autres protocoles SMS. Par exemple, soumettre un message SMS via une requête API REST HTTP prend au moins 10 fois plus de données qu'une requête de soumission OZX.
L'avantage le plus important provient de la liaison TCP/IP permanente. Grâce à cette liaison permanente, votre application SMS C# recevra instantanément des rapports d'envoi et de livraison sous forme d'événements C#. Vous recevrez également les SMS entrants sans aucun délai. Sans une telle liaison, vous seriez obligé d'interroger la passerelle SMS pour obtenir des rapports de livraison ou de télécharger les SMS entrants, ou vous devriez configurer un écouteur TCP/IP ou un service web et ouvrir un port de pare-feu pour que vos messages arrivent.
Cette liaison TCP/IP peut être chiffrée à l'aide de SSL/TLS et vous pouvez facilement ajouter une validation de certificat client et serveur pour rendre cette liaison API SMS C# extrêmement sécurisée.
Comment utiliser l'API SMS C# :
- Téléchargez Ozeki SMS Gateway
- Installez une connexion de test SMS
- Installez un utilisateur OZX
- Créez un nom d'utilisateur et un mot de passe
- Activez la journalisation des communications
- Ouvrez votre projet SMS C# dans Visual Studio
- Modifiez le code C# avec le nom d'utilisateur et le mot de passe
- Envoyez un SMS test depuis C#
- Vérifiez les journaux dans la passerelle SMS
- Simulez un SMS entrant avec la connexion de test
- Effectuez un test en direct avec votre téléphone Android
Tutoriel vidéo de l'API SMS C# (2 minutes)
Pour avoir une idée rapide de comment configurer votre passerelle SMS pour accepter les connexions de l'API SMS C# et envoyer votre premier SMS depuis votre application C#, regardez la vidéo suivante. Cette vidéo ne dure que 2 minutes et 21 secondes, et elle en vaut la peine. La vidéo montre comment un utilisateur OZX peut être créé dans la passerelle SMS pour accepter les clients de l'API SMS C#, et comment vous pouvez démarrer et exécuter la bibliothèque cliente de l'API SMS C# téléchargée dans Visual Studio. La dernière partie vous montre comment envoyer un SMS test.
Pourquoi l'API SMS C# Ozeki est-elle meilleure ?
L'API SMS C# Ozeki est excellente car la quantité de données nécessaires pour envoyer un SMS est plus faible, et l'encodage et le décodage des unités de données de protocole (PDU) nécessitent beaucoup moins de charge CPU. Si vous l'utilisez, votre solution consommera moins de ressources dans les trois domaines principaux : mémoire, CPU et bande passante réseau. En conséquence, vos applications seront plus rapides et plus réactives.
Comment puis-je utiliser l'API SMS C# ?
L'API SMS C# Ozeki est un ensemble de classes C# qui vous permettent d'envoyer et de recevoir des messages SMS. Vous pouvez l'utiliser en ouvrant le projet téléchargé dans Visual Studio. Une fois le projet ouvert, vous verrez que le code complet est écrit en C#.Net. L'envoi de messages se fait via des appels de méthodes C#, et les messages entrants arrivent sous forme d'événements C#. Votre application SMS, que vous construirez à partir de l'API SMS, pourra envoyer des messages SMS directement vers le réseau mobile en utilisant un téléphone portable Android ou un PC avec une connexion SMS IP. La connexion au réseau mobile sera fournie par Ozeki SMS Gateway, que vous devez Linux. (Figure 2)
Combien coûte l'API SMS C# ?
L'API est une bibliothèque, qui vous est fournie gratuitement, avec une licence MIT. Vous pouvez la modifier et la distribuer librement comme vous le souhaitez. Lorsque vous téléchargez l'API, le package contient une application console exemple et le code source complet de la DLL Ozeki.Libs.OZX.
Le seul coût que vous devez payer est la licence pour le logiciel Ozeki SMS Gateway. Un seul SMS Gateway peut être utilisé pour servir plusieurs centaines de clients SMS C# sur le réseau. Vous pouvez installer le SMS Gateway sur plusieurs ordinateurs pour augmenter la capacité ou pour profiter des offres SMS des réseaux locaux.
Concernant les coûts des SMS, si vous envoyez des messages texte via un téléphone portable connecté à votre PC, le coût dépend des tarifs SMS de la carte SIM dans votre téléphone. Dans la plupart des pays, vous pouvez envoyer des SMS gratuitement si vous choisissez cette option. Il y a cependant une limitation : un seul téléphone portable ne peut pas envoyer plus de 12 000 SMS par jour. Vous ne pouvez augmenter cette capacité qu'en connectant plusieurs téléphones portables à votre ordinateur. Lorsque vous envoyez un SMS via votre téléphone portable (Figure 2), vous devez installer le logiciel Ozeki Android SMS Gateway sur votre téléphone et vous devez vous y connecter via le Wi-Fi.
Si vous installez Linux, vous pouvez envoyer des SMS sans fil avec un pool de modems GSM connecté au PC. Dans ces cas, les mêmes tarifs SMS gratuits s'appliquent car les modems GSM et les pools de modems GSM fonctionnent sans fil avec des cartes SIM.
Si vous avez besoin d'un système SMS Gateway sur site haute performance, où plusieurs milliers (ou millions) de messages peuvent être envoyés et reçus, vous devez vous connecter à un fournisseur de services SMS en ligne. Dans ce cas, les tarifs SMS sont fixés par le service SMS auquel vous souscrivez. Notez qu'il est toujours judicieux de se connecter à deux ou plusieurs services SMS en ligne pour être tolérant aux pannes et pour pouvoir profiter des options de routage au moindre coût. Il est également conseillé de configurer une liaison sans fil de secours.
Comment se connecter au SMS Gateway ?
Lorsque vous développez votre application SMS en C#, vous utiliserez probablement votre ordinateur portable. Visual Studio sera installé sur votre ordinateur portable. Cet ordinateur portable se connectera à votre réseau local (LAN) de bureau soit via le Wi-Fi, soit via une connexion Ethernet. Votre mobile Android ou votre système Windows SMS Gateway (Figure 3) se connectera également au réseau local du bureau. Lorsque vous vous connectez au SMS Gateway, vous utiliserez l'adresse IP locale de l'ordinateur du SMS Gateway.
Pour connecter votre application C# au SMS Gateway, vous devrez connaître l'adresse IP et le numéro de port du SMS Gateway, ainsi qu'un nom d'utilisateur et un mot de passe. L'adresse IP du SMS Gateway sera son adresse IP locale. Comme la plupart du temps le logiciel SMS Gateway sera installé sur un ordinateur différent de votre ordinateur portable de développement, cette adresse IP sera différente de celle de votre ordinateur portable. Le numéro de port est facile. Généralement, c'est le numéro de port par défaut, qui est 9580. Pour obtenir un nom d'utilisateur et un mot de passe, vous devez créer un utilisateur OZX (Figure 4). Lorsque vous créez l'utilisateur OZX, vous pouvez spécifier n'importe quel nom d'utilisateur ou mot de passe que vous souhaitez.
Une fois que vous avez trouvé l'adresse IP, le numéro de port et que vous avez créé le nom d'utilisateur et le mot de passe, vous devez entrer ces détails dans la méthode de connexion de votre application SMS C#.
Si vous ne souhaitez pas utiliser deux ordinateurs, vous pouvez installer le SMS Gateway sur votre ordinateur portable (le même ordinateur où vous développez votre application C#). Dans ce cas, vous devez fournir "127.0.0.1" comme adresse IP et le port "9580" dans la méthode de connexion. (Oui, vous pouvez également utiliser des adresses IPv6 ou des noms d'hôte, comme 'localhost")
Avantages d'utiliser votre propre SMS Gateway
Tests gratuits : Il est très bénéfique d'utiliser votre propre SMS Gateway, car vous pouvez tester votre application SMS gratuitement. Vous pouvez simuler des SMS entrants, vous pouvez envoyer des messages de test à la connexion de test du SMS Gateway, et vous pouvez simuler des rapports de livraison SMS indiquant une livraison réussie ou échouée. Il est judicieux de lire le guide du simulateur SMPP pour obtenir plus d'informations sur les tests.
Tests de performance illimités : Une fois que vous avez développé votre solution SMS en C#, il est probable que vous souhaitiez effectuer des tests de performance. Avec Ozeki SMS Gateway, il est très facile de tester votre système avec un volume élevé de SMS. Dans la plupart des cas, vous n'enverrez que quelques milliers de SMS, mais si un client le demande, vous pouvez même effectuer un test avec plusieurs millions de messages. Consultez les résultats des tests de performance SMS que nous avons réalisés avec Ozeki SMS Gateway avec 1 000 000 de SMS.
Changer facilement de fournisseur : Si vous développez votre code C# qui fonctionne avec Ozeki SMS Gateway, vous n'aurez pas à vous soucier d'être lié à un seul réseau SMS ou à un seul fournisseur de services SMS. Vous pouvez utiliser le même code C# et simplement passer à un autre fournisseur de services SMS si vous obtenez une meilleure offre en configurant la connexion du nouveau fournisseur dans le SMS Gateway.
Qu'est-ce que OZX ?
OZX signifie OZeki eXchange. C'est un protocole SMS hautement optimisé utilisé pour communiquer entre votre application SMS en C# et la passerelle SMS Ozeki. C'est un protocole basé sur TCP/IP qui est nettement plus efficace que les protocoles SMS traditionnels, tels que les protocoles API SMS HTTP en C#, les protocoles API SMS REST en C# ou le protocole SMS SMPP. L'efficacité provient de deux faits majeurs : aucune donnée inutile n'est transmise (notez que il y a une énorme surcharge de données dans http et smpp), et un traitement du protocole plus facile et plus efficace est possible grâce à la structure PDU du protocole.
Que contient le zip de l'API SMS en C# ?
Le fichier zip contient deux projets (comme sur la Figure 5) : une application console qui est un code très facile à comprendre pour vous montrer comment utiliser l'API SMS en C#, et il contient le code source de l'API SMS en C# elle-même.
Contenu du package API SMS en C# :
- Exemple de code (code source complet)
- Bibliothèque cliente Ozeki (code source complet)
Comment ouvrir la solution .sln de l'API SMS en C# ?
Pour ouvrir l'API SMS Ozeki, vous devez localiser le fichier OzekiConsole.sln après avoir décompressé le package OzekiConsole.zip, et vous devez ouvrir ce fichier dans Visual Studio. (Figure 6) Vous pouvez double-cliquer sur le fichier solution (.sln), ou vous pouvez le naviguer dans Visual Studio.
Une fois que vous avez ouvert le .sln, vous verrez deux projets dans votre solution. Le projet OzekiConsole contient le code exemple qui vous montre comment vous pouvez utiliser la bibliothèque cliente de l'API SMS en C# pour vous connecter à la Passerelle SMS. (Figure 7) L'autre projet est le projet de dll Ozeki.Libs.OZX. Ce projet contient le code source complet de la bibliothèque cliente de l'API SMS en C#.
Comment se connecter à la passerelle SMS avec l'API SMS en C#
Pour utiliser l'API SMS en C#, vous devez créer un nom d'utilisateur et un mot de passe dans votre passerelle SMS. Si vous avez installé votre passerelle SMS sur votre téléphone Android, vous devez vous connecter au téléphone via un navigateur web. Si vous avez installé votre passerelle SMS sur Windows ou Linux, connectez-vous simplement à elle avec votre navigateur. Si vous n'avez pas encore installé votre passerelle SMS, configurez-la maintenant en utilisant l'une des instructions suivantes : Comment configurer ma passerelle SMS sur Windows, Comment configurer ma passerelle SMS sur Linux. (Figure 8)
Comment envoyer un SMS depuis C#
Pour envoyer un SMS depuis C#, vous devez ajouter le ozekisms.dll comme référence à votre solution Visual Studio. Vous pouvez choisir d'ajouter la dll binaire ou vous pouvez ajouter le projet contenant le code source. Si vous ajoutez la dll binaire, votre projet compilera plus rapidement, si vous ajoutez le code source, vous aurez de meilleures capacités de débogage. (Figure 9)
Comment envoyer un SMS depuis C# :
- Téléchargez la bibliothèque SMS Ozeki en C# (fichier zip)
- Extrayez le fichier zip
- Ouvrez Microsoft Visual Studio
- Créez une nouvelle application console
- Dans l'explorateur de solutions, cliquez sur "Ajouter..."
- Sélectionnez "Projet existant"
- Recherchez le OzekiSMSLibrary.csproj
- Cliquez sur Ouvrir
- Ajoutez l'espace de noms "Ozeki" à votre application console
- Copiez et collez l'exemple
- Envoyez votre premier SMS en utilisant la fonction SendMessage
Comment recevoir un SMS en C#
Pour recevoir un SMS depuis C#, vous devez configurer votre projet de la même manière que vous le feriez pour envoyer un message SMS. En bref, téléchargez le ozekisms.dll en tant que binaire ou en tant que source et ajoutez-le à votre projet en tant que bibliothèque de référence. Après cela, vous pouvez créer une instance de classe C# et vous pouvez vous abonner à l'événement qui est appelé lorsqu'un SMS est reçu. (Figure 10)
Comment recevoir un SMS en C# :
- Téléchargez la bibliothèque SMS Ozeki en C# (fichier zip)
- Ouvrez Microsoft Visual Studio
- Créez une nouvelle application console ou ouvrez l'un de vos projets existants
- Ajoutez la bibliothèque SMS en C# à votre solution C#
- Ajoutez l'espace de noms "Ozeki" à votre classe
- Créez une instance de la classe de message
- Inscrivez-vous à l'événement OnMessageReceived
- Écrivez le code du gestionnaire d'événements
- Définissez un point d'arrêt dans le gestionnaire d'événements
- Envoyez un message test
- Attendez que le SMS atteigne le point d'arrêt
//*********************************************************************
// API SMS C# Ozeki - v1.0.0
// Documentation : https://ozeki-sms-gateway.com/p_5755-c-sharp-sms-api.html
//*********************************************************************
using System;
using OZX;
namespace OzekiConsoleClient
{
class Program
{
static OzxClient Client;
//*************************************************************
// Main
//*************************************************************
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);
}
}
//*************************************************************
// Lire la commande suivante
//*************************************************************
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("Merci d'avoir utilisé Ozeki Client !");
break;
case "connect":
connect(parameters);
break;
case "disconnect":
disconnect();
break;
case "send":
send(parameters);
break;
}
}
//*************************************************************
// Commandes / Bienvenue
//*************************************************************
static void printWelcome()
{
Console.WriteLine("**********************************");
Console.WriteLine("* Bienvenue dans Ozeki Client v1.0.0 *");
Console.WriteLine("**********************************");
Console.WriteLine("Tapez 'help' pour les commandes disponibles");
}
//*************************************************************
// Commandes / Aide
//*************************************************************
static void printHelp()
{
Console.WriteLine("**********************");
Console.WriteLine("* Commandes disponibles *");
Console.WriteLine("**********************");
Console.WriteLine("help");
Console.WriteLine("connect [hôte:port] [nom d'utilisateur] [mot de passe]");
Console.WriteLine("disconnect");
Console.WriteLine("send [destinataire] [message]");
Console.WriteLine("exit");
}
//*************************************************************
// Commandes / Connexion
//*************************************************************
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("Erreur. "+errormessage);
Console.WriteLine("Syntaxe : connect [hôte:port] [nom d'utilisateur] [mot de passe]");
Console.WriteLine("Exemple : connect 127.0.0.1:9580 testuser testpass");
}
Console.WriteLine("Connexion à "+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 = "La commande connect attend 3 paramètres.";
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 = "Hôte et port invalides.";
host = null;
port = 0;
return false;
}
host = hostandportparts[0];
string portstring = hostandportparts[1];
if (!int.TryParse(portstring, out port))
{
errormessage = "Numéro de port invalide.";
port = 0;
return false;
}
errormessage = null;
return true;
}
//*************************************************************
// Commandes / Déconnexion
//*************************************************************
static void disconnect()
{
Client.Disconnect();
}
//*************************************************************
// Commandes / Envoi
//*************************************************************
static void send(string parameters)
{
string[] parts = parameters.Split(new char[] { ' ' },2);
if (parts.Length < 2)
{
Console.WriteLine("Erreur. La commande send attend 2 paramètres.");
Console.WriteLine("Syntaxe : send [destinataire] [message]");
Console.WriteLine("Exemple : send +441234567 Bonjour le monde");
return;
}
string recipient = parts[0];
string message = parts[1];
var msg = new OzxMessage();
msg.ToAddress = recipient;
msg.Text = message;
Console.WriteLine("Envoi du message. ID : "+msg.ID);
Client.Send(msg);
}
//*************************************************************
// Créer le 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;
}
//*************************************************************
// Événements de messagerie
//*************************************************************
static void Client_OnConnected(object sender, EventArgs e)
{
Console.WriteLine("Connexion réussie.");
printPrompt();
}
static void Client_OnDisconnected(object sender, OzxArgs< string > e)
{
Console.WriteLine("Connexion fermée. Raison : " + e.Item.ToString());
printPrompt();
}
static void Client_OnMessageReceived(object sender, OzxArgs< IOzxMessage > e)
{
Console.WriteLine("Message reçu : " + e.Item.ToString());
printPrompt();
}
static void Client_OnMessageAcceptedForDelivery(object sender, OzxArgs< string > e)
{
Console.WriteLine("Message accepté pour livraison. ID : " + e.Item.ToString());
printPrompt();
}
static void Client_OnMessageNotAcceptedForDelivery(object sender, OzxArgs< string, string > e)
{
Console.WriteLine("Message rejeté. ID : " + e.Item1.ToString()+" Raison : "+e.Item2);
printPrompt();
}
static void Client_OnMessageSubmitSuccess(object sender, OzxArgs< string, DateTime > e)
{
Console.WriteLine("Message soumis. ID : "+e.Item1+" Date : "+e.Item2);
printPrompt();
}
static void Client_OnMessageSubmitFailed(object sender, OzxArgs< string, DateTime, string > e)
{
Console.WriteLine("Échec de la soumission du message. ID : " + e.Item1 + " Date : " + e.Item2+" Raison : "+e.Item3);
printPrompt();
}
static void Client_OnMessageDeliverySuccess(object sender, OzxArgs< string, DateTime > e)
{
Console.WriteLine("Message livré. ID : " + e.Item1 + " Date : " + e.Item2);
printPrompt();
}
static void Client_OnMessageDeliveryFailed(object sender, OzxArgs< string, DateTime, string > e)
{
Console.WriteLine("Échec de la livraison du message. ID : " + e.Item1 + " Date : " + e.Item2 + " Raison : " + e.Item3);
printPrompt();
}
static void Client_OnMessageViewed(object sender, OzxArgs< string, DateTime > e)
{
Console.WriteLine("Message consulté. ID : " + e.Item1 + " Date : " + e.Item2);
printPrompt();
}
}
}
Que faire si je ne peux pas me connecter ?
Si votre application SMS ne peut pas se connecter à la passerelle SMS, il est possible que vous ayez saisi une mauvaise adresse IP ou un mauvais numéro de port dans le client SMS. Il est également possible que le pare-feu de la passerelle SMS bloque la connexion.
Pour vérifier que vous utilisez la bonne adresse IP et le bon port, ouvrez l'interface utilisateur de la passerelle SMS. Dans la barre d'outils de l'application Passerelle SMS, cliquez sur le bouton Avancé. Cela affichera la page des services de la passerelle SMS. Vous devez trouver le service OZX dans la liste et cliquer sur "Détails" (Figure 11).
Une fois la page ouverte, vous pouvez trouver l'adresse IP dans la barre de titre de la fenêtre (Figure 12), et le numéro de port sur le côté gauche du formulaire de configuration. (Notez que vous pouvez modifier ce numéro de port en ouvrant le formulaire de configuration du service OZX.)
Vous pouvez écrire ces détails directement dans votre code C#. Par exemple, vous pouvez utiliser la fonction suivante pour établir une connexion à la passerelle SMS à 192.168.93.192:9580 avec un nom d'utilisateur OZX "tester" et un mot de passe "testpass" :
static void createClient()
{
Client = new OzxClient();
Client.AutoReconnect = true;
Client.Connect("192.168.93.192", 9580, "testuser", "testpass");
}
Réflexions finales
Pour résumer, l'API SMS C# vous permet de vous connecter à votre Passerelle SMS en utilisant le protocole OZX. Ce protocole SMS offre des performances excellentes et une communication SMS bidirectionnelle. Le fait que la bibliothèque d'API SMS C# gratuite fournie par Ozeki vous permette d'envoyer des SMS avec des appels de méthode simples, et de recevoir des rapports d'envoi et de livraison de SMS sous la forme d'événements C#, fait de cette option la meilleure si vous souhaitez développer une application SMS C# en 2025.
More information