C# SMS API mit vollständigem Quellcode
Wenn Sie nach einem leistungsstarken Tool für C#.Net-Entwickler suchen, um die SMS-Sende- und Empfangsfunktionalität in C#.Net-Anwendungen zu integrieren, ist die C# SMS API von Ozeki SMS Gateway die beste Option. Dies ist die beste C# SMS API im Jahr 2025. Sie ist hervorragend, weil sie sehr ressourceneffizient ist und Informationen über Ihre gesendeten Nachrichten in Form von Submit Reports und Delivery Reports viel schneller liefert als andere SMS APIs. Diese C# SMS API ermöglicht es Ihnen auch, SMS für eine spätere Zustellung zu planen, und Sie können sie sowohl zum Senden als auch zum Empfangen von SMS von Mobiltelefonen ohne Verzögerungen nutzen. Lesen Sie diesen Artikel, um mehr über diese erstaunliche C# SMS-Lösung zu erfahren und herauszufinden, wie Sie sie in Ihrer Umgebung nutzen können.
Was ist die C# SMS API?
Die Ozeki C# SMS API ist eine Software-Schnittstelle, die von Ozeki SMS Gateway bereitgestellt wird und es Ihnen ermöglicht, SMS von C#.Net-Code aus zu senden und zu empfangen. Diese Schnittstelle kann mit der C# SMS API-Client-Bibliothek von mehreren Computern gleichzeitig verwendet werden. (Abbildung 1) Sie können die C# SMS API-Client-Bibliothek von dieser Webseite herunterladen.
C# SMS API-Client-Bibliothek herunterladen
Sie können den C# SMS-Client (Quellcode) über den folgenden Link herunterladen. Die ZIP-Datei enthält ein Visual Studio-Projekt mit vollständigem Quellcode. Sie können diesen Code oder abgeleitete Versionen frei modifizieren, nutzen und weiterverbreiten.
Download: OzekiConsole.zip (51 Kb)
URL: https://ozeki-sms-gateway.com/attachments/5755/OzekiConsole.zip
Wie funktioniert die C# SMS API?
Mit der Ozeki C# SMS API können Sie SMS-Nachrichten senden und empfangen, viel effizienter als mit traditionellen HTTP- oder REST-SMP-API-Lösungen. Dies ist möglich, weil die Ozeki C# SMS API eine permanente TCP/IP-Verbindung zum SMS-Gateway herstellt und über ein hochoptimiertes SMS-Protokoll namens OZX kommuniziert. Diese Kommunikationsmethode benötigt weniger Ressourcen in Bezug auf CPU, Speicher und Netzwerkbandbreite als andere SMS-Protokolle. Beispielsweise erfordert das Senden einer SMS-Nachricht über eine HTTP-REST-API-Anfrage mindestens 10-mal so viele Daten wie eine OZX-Submit-Anfrage.
Der wichtigste Vorteil ergibt sich aus der permanenten TCP/IP-Verbindung. Dank dieser permanenten Verbindung erhält Ihre C# SMS-Anwendung sofortige Submit Reports und Delivery Reports in Form von C#-Events. Sie erhalten auch eingehende SMS-Nachrichten ohne Verzögerungen. Ohne eine solche Verbindung müssten Sie entweder das SMS-Gateway abfragen, um Delivery Reports oder eingehende SMS zu erhalten, oder Sie müssten einen TCP/IP-Listener oder Webdienst einrichten und eine Firewall-Port für eingehende Nachrichten öffnen.
Diese TCP/IP-Verbindung kann mit SSL/TLS verschlüsselt werden, und Sie können leicht eine Client- und Server-Zertifikatsvalidierung hinzufügen, um diese C# SMS API-Verbindung extrem sicher zu machen.
So verwenden Sie die C# SMS API:
- Laden Sie das Ozeki SMS Gateway herunter
- Installieren Sie eine SMS-Tester-Verbindung
- Installieren Sie einen OZX-Benutzer
- Erstellen Sie einen Benutzernamen und ein Passwort
- Aktivieren Sie die Kommunikationsprotokollierung
- Öffnen Sie Ihr C# SMS-Projekt in Visual Studio
- Passen Sie den C#-Code mit dem Benutzernamen und Passwort an
- Senden Sie eine Test-SMS aus C#
- Überprüfen Sie die Protokolle im SMS-Gateway
- Simulieren Sie eine eingehende SMS mit der Testverbindung
- Führen Sie einen Live-Test mit Ihrem Android-Handy durch
C# SMS API-Videotutorial (2 Minuten)
Um schnell zu verstehen, wie Sie Ihr SMS-Gateway für C# SMS API-Verbindungen einrichten und Ihre erste SMS aus Ihrer C#-Anwendung senden können, sehen Sie sich das folgende Video an. Dieses Video ist nur 2 Minuten und 21 Sekunden lang und lohnt sich. Das Video zeigt, wie ein OZX-Benutzer im SMS-Gateway erstellt wird, um C# SMS API-Clients zu akzeptieren, und wie Sie die heruntergeladene C# SMS API-Client-Bibliothek in Visual Studio starten und ausführen können. Der letzte Teil zeigt Ihnen, wie Sie eine Test-SMS senden können.
Warum ist die Ozeki C# SMS API besser?
Die Ozeki C# SMS API ist großartig, weil die Menge der benötigten Daten zum Senden einer SMS geringer ist und die PDU-Kodierung und -Dekodierung deutlich weniger CPU-Aufwand erfordert. Wenn Sie sie verwenden, verbraucht Ihre Lösung weniger Ressourcen in allen drei Hauptbereichen: Speicher, CPU und Netzwerkbandbreite. Dadurch werden Ihre Anwendungen schneller und reagieren besser.
Wie kann ich die C# SMS API verwenden?
Die Ozeki C# SMS API ist eine Sammlung von C#-Klassen, die es Ihnen ermöglichen, SMS-Nachrichten zu senden und zu empfangen. Sie können sie verwenden, indem Sie das heruntergeladene Projekt in Visual Studio öffnen. Sobald Sie das Projekt öffnen, werden Sie sehen, dass der vollständige Code in C#.Net geschrieben ist. Das Senden von Nachrichten erfolgt über C#-Methodenaufrufe, und eingehende Nachrichten werden in Form von C#-Events empfangen. Ihre SMS-Anwendung, die Sie auf Basis der SMS API erstellen, kann SMS-Nachrichten direkt über ein Android-Mobiltelefon oder einen PC mit einer IP-SMS-Verbindung an das Mobilfunknetz senden. Die Verbindung zum Mobilfunknetz wird von Ozeki SMS Gateway bereitgestellt, das Sie Linux-Computer installieren müssen. (Abbildung 2)
Die API ist eine Bibliothek, die Ihnen kostenlos mit einer MIT-Lizenz zur Verfügung gestellt wird. Sie können sie frei modifizieren und nach Belieben verteilen. Wenn Sie die API herunterladen, enthält das Paket eine Beispiel-Konsolenanwendung und den vollständigen Quellcode der Ozeki.Libs.OZX dll.
Die einzigen Kosten, die Sie tragen müssen, sind die Lizenzgebühr für die Ozeki SMS Gateway-Software. Ein einzelnes SMS-Gateway kann verwendet werden, um mehrere hundert C# SMS-Clients über das Netzwerk zu bedienen. Sie können das SMS-Gateway auf mehreren Computern installieren, um die Kapazität zu erhöhen oder von SMS-Angeboten lokaler Netzwerke zu profitieren.
Was die SMS-Kosten betrifft: Wenn Sie Textnachrichten über ein an Ihren PC angeschlossenes Mobiltelefon senden, hängen die Kosten von den SMS-Tarifen der SIM-Karte in Ihrem Telefon ab. In den meisten Ländern können Sie SMS-Nachrichten kostenlos versenden, wenn Sie diese Option wählen. Es gibt jedoch eine Einschränkung: Ein einzelnes Mobiltelefon kann nicht mehr als 12000 SMS pro Tag versenden. Sie können diese Kapazität nur erhöhen, indem Sie mehrere Mobiltelefone an Ihren Computer anschließen. Wenn Sie eine SMS über Ihr Mobiltelefon senden (Abbildung 2), müssen Sie die Ozeki Android SMS Gateway-Software auf Ihrem Telefon installieren und sich über Wifi damit verbinden.
Wenn Sie Linux-Computer installieren, können Sie SMS drahtlos mit einem GSM-Modem-Pool senden, der an den PC angeschlossen ist. In diesen Fällen gelten die gleichen kostenlosen SMS-Tarife, da GSM-Modems und GSM-Modem-Pools drahtlos mit SIM-Karten betrieben werden.
Wenn Sie ein hochleistungsfähiges On-Premises-SMS-Gateway-System benötigen, mit dem mehrere tausend (oder Millionen) Nachrichten gesendet und empfangen werden können, müssen Sie sich mit einem Online-SMS-Dienstanbieter verbinden. In diesem Fall werden die SMS-Tarife von dem SMS-Dienst festgelegt, den Sie abonnieren. Beachten Sie, dass es immer eine gute Idee ist, sich mit zwei oder mehr Online-SMS-Diensten zu verbinden, um fehlertolerant zu sein und von Least-Cost-Routing-Optionen profitieren zu können. Es ist auch ratsam, einen drahtlosen Backup-Link einzurichten.
Wie verbinde ich mich mit dem SMS-Gateway?
Wenn Sie Ihre C# SMS-Anwendung entwickeln, werden Sie wahrscheinlich Ihren Laptop verwenden. Visual Studio wird auf Ihrem Laptop installiert sein. Dieser Laptop wird sich entweder über Wi-Fi oder über eine Ethernet- Verbindung mit Ihrem lokalen Büronetzwerk (LAN) verbinden. Ihr Android-Mobiltelefon oder Ihr Windows-SMS-Gateway-System (Abbildung 3) wird sich ebenfalls mit dem Büro-LAN verbinden. Wenn Sie sich mit dem SMS-Gateway verbinden, verwenden Sie die LAN-IP-Adresse des SMS-Gateway-Computers.
Um Ihre C#-Anwendung mit dem SMS-Gateway zu verbinden, müssen Sie die IP-Adresse und die Portnummer des SMS-Gateways kennen sowie einen Benutzernamen und ein Passwort. Die IP-Adresse des SMS-Gateways ist dessen LAN-IP-Adresse. Da die SMS-Gateway-Software meist auf einem anderen Computer als Ihrem Entwicklungs- Laptop installiert ist, wird diese IP-Adresse von der IP-Adresse Ihres Laptops abweichen. Die Portnummer ist einfach. In der Regel ist es die Standard-Portnummer, also 9580. Um einen Benutzernamen und ein Passwort zu erhalten, müssen Sie einen OZX-Benutzer anlegen (Abbildung 4). Wenn Sie den OZX-Benutzer anlegen, können Sie einen beliebigen Benutzernamen oder ein beliebiges Passwort festlegen.
Sobald Sie die IP-Adresse und die Portnummer herausgefunden und den Benutzernamen und das Passwort erstellt haben, müssen Sie diese Angaben in die Connect-Methode Ihrer C# SMS-Anwendung eingeben.
Wenn Sie nicht zwei Computer verwenden möchten, können Sie das SMS-Gateway auf Ihrem Laptop installieren (demselben Computer, auf dem Sie Ihre C#-Anwendung entwickeln). In diesem Fall würden Sie "127.0.0.1" als IP-Adresse und Port "9580" in der Connect-Methode angeben. (Ja, Sie können auch IPv6-Adressen oder Hostnamen wie 'localhost' verwenden.)
Vorteile der Verwendung Ihres eigenen SMS-Gateways
Kostenloses Testen: Es ist sehr vorteilhaft, ein eigenes SMS-Gateway zu betreiben, da Sie Ihre SMS-Anwendung kostenlos testen können. Sie können eingehende SMS-Nachrichten simulieren, Testnachrichten an die Testverbindung des SMS-Gateways senden und SMS-Zustellberichte simulieren, die eine erfolgreiche oder fehlgeschlagene Zustellung anzeigen. Es ist ratsam, die Anleitung zum SMPP-Simulator zu lesen, um mehr über Tests zu erfahren.
Unbegrenzte Leistungstests: Sobald Sie Ihre SMS-Lösung in C# entwickelt haben, möchten Sie wahrscheinlich einige Leistungstests durchführen. Mit dem Ozeki SMS- Gateway ist es sehr einfach, Ihr System mit einer großen Anzahl von SMS-Nachrichten zu testen. In den meisten Fällen werden Sie nur einige tausend SMS versenden, aber auf Kundenwunsch können Sie sogar einen Test mit mehreren Millionen Nachrichten durchführen. Sehen Sie sich die SMS-Leistungstest- ergebnisse an, die wir mit dem Ozeki SMS-Gateway mit 1 000 000 SMS durchgeführt haben.
Einfacher Anbieterwechsel: Wenn Sie Ihren C#-Code entwickeln, der mit dem Ozeki SMS-Gateway funktioniert, müssen Sie sich keine Sorgen machen, an ein bestimmtes SMS-Netzwerk oder einen bestimmten SMS-Dienstanbieter gebunden zu sein. Sie können den gleichen C#-Code verwenden und einfach zu einem anderen SMS-Dienstanbieter wechseln, wenn Sie ein besseres Angebot erhalten, indem Sie die Verbindung des neuen Anbieters im SMS- Gateway konfigurieren.
Was ist OZX?OZX steht für OZeki eXchange. Es ist ein hochoptimiertes SMS-Protokoll, das zur Kommunikation zwischen Ihrer C#-SMS-Anwendung und dem Ozeki SMS Gateway verwendet wird. Es ist ein TCP/IP-basiertes Protokoll, das deutlich effizienter ist als traditionelle SMS-Protokolle, wie z.B. C# HTTP SMS API-Protokolle, C# REST SMS API-Protokolle oder das SMPP SMS-Protokoll. Die Effizienz ergibt sich aus zwei Hauptfaktoren: Es werden keine unnötigen Daten übertragen (beachten Sie, dass sowohl HTTP als auch SMPP einen enormen Daten-Overhead haben), und eine einfachere, effizientere Protokollverarbeitung ist aufgrund der Protokoll-PDU-Struktur möglich.
Was befindet sich im C# SMS API-Zip?
Die Zip-Datei enthält zwei Projekte (wie in Abbildung 5): eine Konsolenanwendung, die einen sehr leicht verständlichen Code enthält, um Ihnen die Verwendung der C# SMS API zu zeigen, und den Quellcode der C# SMS API selbst.
Inhalt des C# SMS API-Pakets:
- Beispielcode (vollständiger Quellcode)
- Ozeki-Client-Bibliothek (vollständiger Quellcode)
Wie öffne ich die C# SMS API .sln-Lösung?
Um die Ozeki SMS API zu öffnen, müssen Sie nach dem Entpacken des OzekiConsole.zip-Pakets die Datei OzekiConsole.sln finden und diese in Visual Studio öffnen. (Abbildung 6) Sie können doppelt auf die Lösungsdatei (.sln) klicken oder sie in Visual Studio auswählen.
Nachdem Sie die .sln-Datei geöffnet haben, sehen Sie zwei Projekte in Ihrer Lösung. Das OzekiConsole-Projekt enthält den Beispielcode, der Ihnen zeigt, wie Sie die C# SMS API-Client-Bibliothek verwenden können, um eine Verbindung zum SMS Gateway herzustellen. (Abbildung 7) Das andere Projekt ist das Ozeki.Libs.OZX-DLL-Projekt. Dieses Projekt enthält den vollständigen Quellcode der C# SMS API-Client-Bibliothek.
Wie melde ich mich beim SMS-Gateway mit der C# SMS API an?
Um die C# SMS API zu verwenden, müssen Sie einen Benutzernamen und ein Passwort in Ihrem SMS-Gateway erstellen. Wenn Sie Ihr SMS-Gateway auf Ihrem Android-Handy installiert haben, müssen Sie sich über einen Webbrowser auf dem Handy anmelden. Wenn Sie Ihr SMS-Gateway unter Windows oder Linux installiert haben, verbinden Sie sich einfach mit Ihrem Browser damit. Wenn Sie Ihr SMS-Gateway noch nicht installiert haben, richten Sie es jetzt mit einer der folgenden Anleitungen ein: Wie richte ich mein SMS-Gateway unter Windows ein, Wie richte ich mein SMS-Gateway unter Linux ein. (Abbildung 8)
//*********************************************************************
// Ozeki C# SMS API - v1.0.0
// Dokumentation: 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);
}
}
//*************************************************************
// Read next command
//*************************************************************
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("Vielen Dank für die Nutzung des Ozeki Clients!");
break;
case "connect":
connect(parameters);
break;
case "disconnect":
disconnect();
break;
case "send":
send(parameters);
break;
}
}
//*************************************************************
// Commands / Welcome
//*************************************************************
static void printWelcome()
{
Console.WriteLine("**********************************");
Console.WriteLine("* Willkommen bei Ozeki Client v1.0.0 *");
Console.WriteLine("**********************************");
Console.WriteLine("Geben Sie 'help' für verfügbare Befehle ein");
}
//*************************************************************
// Commands / Help
//*************************************************************
static void printHelp()
{
Console.WriteLine("**********************");
Console.WriteLine("* Verfügbare Befehle *");
Console.WriteLine("**********************");
Console.WriteLine("help");
Console.WriteLine("connect [host:port] [Benutzername] [Passwort]");
Console.WriteLine("disconnect");
Console.WriteLine("send [Empfänger] [Nachricht]");
Console.WriteLine("exit");
}
//*************************************************************
// Commands / Connect
//*************************************************************
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("Fehler. "+errormessage);
Console.WriteLine("Syntax: connect [host:port] [Benutzername] [Passwort]");
Console.WriteLine("Beispiel: connect 127.0.0.1:9580 testuser testpass");
}
Console.WriteLine("Verbinde mit "+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 = "Connect erwartet 3 Parameter.";
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 = "Ungültiger Host und Port.";
host = null;
port = 0;
return false;
}
host = hostandportparts[0];
string portstring = hostandportparts[1];
if (!int.TryParse(portstring, out port))
{
errormessage = "Ungültige Portnummer.";
port = 0;
return false;
}
errormessage = null;
return true;
}
//*************************************************************
// Commands / Disconnect
//*************************************************************
static void disconnect()
{
Client.Disconnect();
}
//*************************************************************
// Commands / Send
//*************************************************************
static void send(string parameters)
{
string[] parts = parameters.Split(new char[] { ' ' },2);
if (parts.Length < 2)
{
Console.WriteLine("Fehler. Send erwartet 2 Parameter.");
Console.WriteLine("Syntax: send [Empfänger] [Nachricht]");
Console.WriteLine("Beispiel: send +441234567 Hallo Welt");
return;
}
string recipient = parts[0];
string message = parts[1];
var msg = new OzxMessage();
msg.ToAddress = recipient;
msg.Text = message;
Console.WriteLine("Nachricht wird gesendet. ID: "+msg.ID);
Client.Send(msg);
}
//*************************************************************
// Create 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;
}
//*************************************************************
// Messaging events
//*************************************************************
static void Client_OnConnected(object sender, EventArgs e)
{
Console.WriteLine("Erfolgreich verbunden.");
printPrompt();
}
static void Client_OnDisconnected(object sender, OzxArgs< string > e)
{
Console.WriteLine("Verbindung geschlossen. Grund: " + e.Item.ToString());
printPrompt();
}
static void Client_OnMessageReceived(object sender, OzxArgs< IOzxMessage > e)
{
Console.WriteLine("Nachricht empfangen: " + e.Item.ToString());
printPrompt();
}
static void Client_OnMessageAcceptedForDelivery(object sender, OzxArgs< string > e)
{
Console.WriteLine("Nachricht für Zustellung akzeptiert. ID: " + e.Item.ToString());
printPrompt();
}
static void Client_OnMessageNotAcceptedForDelivery(object sender, OzxArgs< string, string > e)
{
Console.WriteLine("Nachricht abgelehnt. ID: " + e.Item1.ToString()+" Grund: "+e.Item2);
printPrompt();
}
static void Client_OnMessageSubmitSuccess(object sender, OzxArgs< string, DateTime > e)
{
Console.WriteLine("Nachricht übermittelt. ID: "+e.Item1+" Datum: "+e.Item2);
printPrompt();
}
static void Client_OnMessageSubmitFailed(object sender, OzxArgs< string, DateTime, string > e)
{
Console.WriteLine("Nachrichtenübermittlung fehlgeschlagen. ID: " + e.Item1 + " Datum: " + e.Item2+" Grund: "+e.Item3);
printPrompt();
}
static void Client_OnMessageDeliverySuccess(object sender, OzxArgs< string, DateTime > e)
{
Console.WriteLine("Nachricht zugestellt. ID: " + e.Item1 + " Datum: " + e.Item2);
printPrompt();
}
static void Client_OnMessageDeliveryFailed(object sender, OzxArgs< string, DateTime, string > e)
{
Console.WriteLine("Nachrichtenzustellung fehlgeschlagen. ID: " + e.Item1 + " Datum: " + e.Item2 + " Grund: " + e.Item3);
printPrompt();
}
static void Client_OnMessageViewed(object sender, OzxArgs< string, DateTime > e)
{
Console.WriteLine("Nachricht gelesen. ID: " + e.Item1 + " Datum: " + e.Item2);
printPrompt();
}
}
}
Was tun, wenn ich keine Verbindung herstellen kann?
Wenn Ihre SMS-Anwendung keine Verbindung zum SMS-Gateway herstellen kann, ist es möglich, dass Sie die falsche IP-Adresse oder Portnummer in den SMS-Client eingegeben haben. Es könnte auch sein, dass die Firewall auf dem SMS-Gateway die Verbindung blockiert.
Um zu überprüfen, ob Sie die richtige IP-Adresse und den richtigen Port verwenden, öffnen Sie die Benutzeroberfläche des SMS-Gateways. Klicken Sie in der Symbolleiste der SMS-Gateway-App auf die Schaltfläche "Erweitert". Dadurch wird die Services-Seite des SMS-Gateways angezeigt. Sie müssen den OZX-Service in der Liste finden und auf "Details" klicken (Abbildung 11).
Nachdem die Seite geöffnet wurde, können Sie die IP-Adresse in der Titelleiste des Fensters finden (Abbildung 12) und die Portnummer auf der linken Seite des Konfigurationsformulars. (Hinweis: Sie können diese Portnummer ändern, indem Sie das Konfigurationsformular des OZX-Services öffnen.)
Nachdem Sie die IP-Adresse und den Port gefunden haben, sollten Sie sicherstellen, dass Sie diese Angaben in Ihrer C#-SMS-Anwendung verwenden. Wenn die IP-Adresse beispielsweise 192.168.93.192 und der Port 9580 war, sollten Sie diese Parameter in die Connect-Funktion eingeben. (Abbildung 13)
Sie können diese Angaben direkt in Ihren C#-Code schreiben. Beispielsweise können Sie die folgende Funktion verwenden, um eine Verbindung zum SMS-Gateway unter 192.168.93.192:9580 mit einem OZX-Benutzernamen "tester" und dem Passwort "testpass" herzustellen:
static void createClient()
{
Client = new OzxClient();
Client.AutoReconnect = true;
Client.Connect("192.168.93.192", 9580, "testuser", "testpass");
}
Abschließende Gedanken
Zusammenfassend lässt sich sagen, dass die C# SMS API Ihnen ermöglicht, eine Verbindung zu Ihrem SMS-Gateway über das OZX-Protokoll herzustellen. Dieses SMS-Protokoll bietet hervorragende Leistung und Zwei-Wege- SMS-Kommunikation. Die Tatsache, dass die kostenlose C# SMS API-Bibliothek von Ozeki es Ihnen ermöglicht, SMS-Nachrichten mit einfachen Methodenaufrufen zu senden und SMS-Sende- und Zustellberichte in Form von C#-Ereignissen zu empfangen, macht diese Option zur besten Wahl, wenn Sie im Jahr 2025 eine C#-SMS-Anwendung erstellen möchten.
More information