C# SMS API z pełnym kodem źródłowym

Jeśli szukasz potężnego narzędzia dla programistów C#.Net, aby dodać możliwość wysyłania i odbierania SMS-ów do aplikacji C#.Net, C# SMS API dostarczane przez Ozeki SMS Gateway jest najlepszą opcją. To najlepsze C# SMS API w 2025 roku. Jest doskonałe, ponieważ jest bardzo wydajne pod względem zasobów i oferuje informacje o wysłanych wiadomościach w postaci raportów wysłania i raportów dostarczenia znacznie szybciej niż inne API SMS. To C# SMS API pozwala również na planowanie wysyłki SMS-ów na później i może być używane zarówno do wysyłania, jak i odbierania SMS-ów z telefonów komórkowych bez opóźnień. Przeczytaj ten artykuł, aby dowiedzieć się więcej o tym niesamowitym rozwiązaniu C# SMS i jak możesz wykorzystać je w swoim środowisku.

Co to jest C# SMS API?

Ozeki C# SMS API to interfejs programistyczny dostarczany przez Ozeki SMS Gateway, który umożliwia wysyłanie i odbieranie SMS-ów z kodu C#.Net. Ten interfejs może być używany z biblioteką kliencką C# SMS API z wielu komputerów jednocześnie. (Rysunek 1) Bibliotekę kliencką C# SMS API możesz pobrać z tej strony internetowej.

c# sms api
Rysunek 1 - C# SMS API

Pobieranie biblioteki klienckiej C# SMS API

Bibliotekę kliencką C# SMS (kod źródłowy) możesz pobrać z poniższego linku. Plik ZIP zawiera projekt Visual Studio z pełnym kodem źródłowym. Możesz swobodnie modyfikować, używać i rozpowszechniać ten kod lub jego pochodne.

Pobierz: OzekiConsole.zip (51 Kb)
URL: https://ozeki-sms-gateway.com/attachments/5755/OzekiConsole.zip

Jak działa C# SMS API?

Z Ozeki C# SMS API możesz wysyłać i odbierać SMS-y znacznie wydajniej niż przy użyciu tradycyjnych rozwiązań HTTP lub REST SMP API. Możesz to zrobić, ponieważ Ozeki C# SMS API tworzy i utrzymuje stałe połączenie TCP/IP z bramką SMS i komunikuje się za pomocą wysoko zoptymalizowanego protokołu SMS zwanego OZX. Ta metoda komunikacji wymaga mniej zasobów pod względem CPU, pamięci i przepustowości sieci niż inne protokoły SMS. Na przykład, wysłanie wiadomości SMS w żądaniu HTTP REST API wymaga co najmniej 10x więcej danych niż żądanie OZX.

Najważniejszą zaletą jest stałe połączenie TCP/IP. Dzięki temu połączeniu Twoja aplikacja C# SMS będzie otrzymywać natychmiastowe raporty wysłania i dostarczenia w formie zdarzeń C#. Będziesz również otrzymywać przychodzące SMS-y bez żadnych opóźnień. Bez takiego połączenia musiałbyś albo pytać bramkę SMS o raporty dostarczenia lub pobierać przychodzące SMS-y, albo musiałbyś skonfigurować nasłuchiwanie TCP/IP lub usługę sieciową i otworzyć port w zaporze ogniowej, aby wiadomości mogły docierać.

To połączenie TCP/IP może być zaszyfrowane za pomocą SSL/TLS i możesz łatwo dodać walidację certyfikatów klienta i serwera, aby uczynić to połączenie C# SMS API bardzo bezpiecznym.

Jak używać C# SMS API:

  1. Pobierz Ozeki SMS Gateway
  2. Zainstaluj połączenie testowe SMS
  3. Zainstaluj użytkownika OZX
  4. Utwórz nazwę użytkownika i hasło
  5. Włącz logowanie komunikacji
  6. Otwórz swój projekt C# SMS w Visual Studio
  7. Zmodyfikuj kod C# z nazwą użytkownika i hasłem
  8. Wyślij testowego SMS-a z C#
  9. Sprawdź logi w bramce SMS
  10. Zasymuluj przychodzącego SMS-a z połączeniem testowym
  11. Przeprowadź test na żywo z telefonem Android

Samouczek wideo C# SMS API (2 minuty)

Aby szybko zrozumieć, jak skonfigurować swoją bramkę SMS do akceptowania połączeń C# SMS API i jak wysłać pierwszego SMS-a z aplikacji C#, obejrzyj poniższy film. Ten film trwa tylko 2 minuty i 21 sekund i warto poświęcić ten czas. Film pokazuje, jak można utworzyć użytkownika OZX w bramce SMS do akceptowania klientów C# SMS API i jak można uruchomić pobraną bibliotekę kliencką C# SMS API w Visual Studio. Ostatnia część pokazuje, jak można wysłać testowego SMS-a.

Wideo 1 - Jak skonfigurować bramkę SMS do akceptowania połączeń C# SMS API i wysłać pierwszego SMS-a z aplikacji C# (Samouczek wideo)

Dlaczego Ozeki C# SMS API jest lepsze?

Ozeki C# SMS API jest świetne, ponieważ ilość danych potrzebnych do wysłania SMS-a jest mniejsza, a kodowanie i dekodowanie jednostek danych protokołu (PDU) wymaga znacznie mniej obciążenia CPU. Jeśli go użyjesz, Twoje rozwiązanie będzie zużywać mniej zasobów we wszystkich trzech głównych obszarach: pamięci, CPU i przepustowości sieci. W rezultacie Twoje aplikacje będą działać szybciej i będą bardziej responsywne.

Jak mogę używać C# SMS API?

Ozeki C# SMS API to zestaw klas C#, które umożliwiają wysyłanie i odbieranie wiadomości SMS. Możesz go użyć, otwierając pobrany projekt w Visual Studio. Po otwarciu projektu zobaczysz, że pełny kod jest napisany w C#.Net. Wysyłanie wiadomości odbywa się za pomocą wywołań metod C#, a przychodzące wiadomości docierają w formie zdarzeń C#. Twoja aplikacja SMS, którą zbudujesz na podstawie SMS API, będzie mogła wysyłać wiadomości SMS bezpośrednio do sieci komórkowej za pomocą telefonu Android lub komputera z połączeniem IP SMS. Połączenie z siecią komórkową będzie zapewnione przez Ozeki SMS gateway, które musisz Linux. (Rysunek 2)

Co to jest c# sms api?
Rysunek 2 - Jak działa C# SMS API

API to biblioteka, która jest dostarczana bezpłatnie, z licencją MIT. Możesz swobodnie ją modyfikować i rozpowszechniać według własnego uznania. Po pobraniu API, pakiet zawiera przykładową aplikację konsolową oraz pełny kod źródłowy biblioteki Ozeki.Libs.OZX dll.

Jedyny koszt, który musisz ponieść, to opłata licencyjna za oprogramowanie Ozeki SMS Gateway. Pojedyncza bramka SMS może obsługiwać kilkaset klientów SMS w języku C# przez sieć. Możesz zainstalować bramkę SMS na wielu komputerach, aby zwiększyć jej wydajność lub skorzystać z ofert SMS lokalnych sieci.

Jeśli chodzi o koszty SMS, jeśli wysyłasz wiadomości tekstowe przez telefon komórkowy podłączony do komputera, koszt zależy od taryfy SMS karty SIM w telefonie. W większości krajów możesz wysyłać wiadomości SMS za darmo, jeśli wybierzesz tę opcję. Istnieje jednak ograniczenie: pojedynczy telefon komórkowy nie może wysłać więcej niż 12000 SMS dziennie. Możesz zwiększyć tę pojemność tylko przez podłączenie wielu telefonów komórkowych do komputera. Aby wysłać SMS przez telefon komórkowy (Rysunek 2), musisz zainstalować oprogramowanie Ozeki Android SMS gateway na swoim telefonie i połączyć się z nim przez Wi-fi.

Jeśli zainstalujesz Linux, możesz wysyłać SMS bezprzewodowo za pomocą puli modemów GSM podłączonych do komputera. W tych przypadkach obowiązują te same darmowe taryfy SMS, ponieważ modemy GSM i pule modemów GSM działają bezprzewodowo z kartami SIM.

Jeśli potrzebujesz wysokowydajnego systemu bramki SMS na miejscu, który może wysyłać i odbierać kilka tysięcy (lub milionów) wiadomości, musisz połączyć się z dostawcą usług SMS online. W tym przypadku taryfy SMS ustala wybrany przez Ciebie dostawca usług SMS. Warto zauważyć, że zawsze dobrym pomysłem jest połączenie się z dwoma lub więcej dostawcami usług SMS online, aby zapewnić odporność na awarie i móc skorzystać z opcji routingu o najniższym koszcie. Dobrym pomysłem jest również skonfigurowanie bezprzewodowego łącza zapasowego.

Jak połączyć się z bramką SMS?

Podczas tworzenia aplikacji SMS w języku C# prawdopodobnie będziesz używać laptopa. Na laptopie będzie zainstalowane Visual Studio. Ten laptop będzie podłączony do lokalnej sieci biurowej (LAN) przez Wi-fi lub przez połączenie Ethernet. Twój telefon z Androidem lub system Windows SMS Gateway (Rysunek 3) również będzie podłączony do sieci LAN w biurze. Podczas łączenia się z bramką SMS będziesz używać adresu IP LAN komputera z bramką SMS.

Ozeki SMS Gateway zainstalowany na serwerze
Rysunek 3 - Ozeki SMS Gateway zainstalowany na serwerze

Aby połączyć aplikację w języku C# z bramką SMS, musisz znać adres IP i numer portu bramki SMS oraz potrzebujesz nazwy użytkownika i hasła. Adres IP bramki SMS będzie jej lokalnym adresem IP w sieci LAN. Ponieważ w większości przypadków oprogramowanie bramki SMS będzie zainstalowane na innym komputerze niż laptop deweloperski, ten adres IP będzie inny niż adres IP Twojego laptopa. Numer portu jest prosty. Zwykle jest to domyślny numer portu, czyli 9580. Aby uzyskać nazwę użytkownika i hasło, musisz utworzyć użytkownika OZX (Rysunek 4). Podczas tworzenia użytkownika OZX możesz podać dowolną nazwę użytkownika i hasło.

Gdy już znasz adres IP, numer portu i utworzyłeś nazwę użytkownika oraz hasło, musisz wprowadzić te dane do metody connect w swojej aplikacji SMS w języku C#.

Rysunek 4 - Tworzenie użytkownika OZX dla C# SMS API

Jeśli nie chcesz używać dwóch komputerów, możesz zainstalować bramkę SMS na swoim laptopie (tym samym komputerze, na którym tworzysz aplikację w języku C#). W tym przypadku podasz "127.0.0.1" jako adres IP i port "9580" w metodzie connect. (Tak, możesz również używać adresów IPv6 lub nazw hostów, takich jak 'localhost")

Korzyści z używania własnej bramki SMS

Darmowe testowanie: Bardzo korzystne jest posiadanie własnej bramki SMS, ponieważ możesz testować swoją aplikację SMS bezpłatnie. Możesz symulować przychodzące wiadomości SMS, wysyłać wiadomości testowe do testowego połączenia bramki SMS oraz symulować raporty dostarczenia SMS wskazujące na udane lub nieudane dostarczenie. Warto zapoznać się z przewodnikiem symulatora SMPP, aby uzyskać więcej informacji na temat testowania.

Nieograniczone testowanie wydajności: Po opracowaniu rozwiązania SMS w języku C# prawdopodobnie będziesz chciał przeprowadzić testy wydajnościowe. Z bramką SMS Ozeki bardzo łatwo jest przetestować system pod kątem dużej liczby wiadomości SMS. W większości przypadków będziesz wysyłać tylko kilka tysięcy SMS, ale na życzenie klienta możesz nawet przeprowadzić test z kilkoma milionami wiadomości. Sprawdź wyniki testów wydajnościowych SMS, które przeprowadziliśmy z bramką SMS Ozeki z 1 000 000 SMS.

Łatwe przełączanie dostawców: Jeśli opracujesz kod w języku C#, który działa z bramką SMS Ozeki, nie musisz się martwić o uzależnienie od jednej sieci SMS lub jednego dostawcy usług SMS. Możesz używać tego samego kodu w języku C# i po prostu przełączyć się na innego dostawcę usług SMS, jeśli uzyskasz lepszą ofertę, konfigurując połączenie nowego dostawcy w bramce SMS.

Czym jest OZX?

OZX oznacza OZeki eXchange. Jest to wysoko zoptymalizowany protokół SMS używany do komunikacji między aplikacją SMS w C# a bramką SMS Ozeki. Jest to protokół oparty na TCP/IP, który jest znacznie bardziej wydajny niż tradycyjne protokoły SMS, takie jak C# HTTP SMS API, protokoły C# REST SMS API lub protokół SMPP SMS. Wydajność wynika z dwóch głównych faktów: nie są przesyłane zbędne dane (zauważ, że zarówno http, jak i smpp mają duży narzut danych) oraz możliwe jest łatwiejsze i bardziej wydajne przetwarzanie protokołu dzięki strukturze PDU protokołu.

Co zawiera zip z C# SMS API?

Plik zip zawiera dwa projekty (jak na Rysunku 5): aplikację konsolową, która jest bardzo łatwym do zrozumienia kodem pokazującym, jak używać C# SMS API, oraz zawiera kod źródłowy samego C# SMS API.

Zawartość pakietu C# SMS API:

  • Przykładowy kod (pełny kod źródłowy)
  • Biblioteka klienta Ozeki (pełny kod źródłowy)

Rysunek 5 - Zawartość pakietu C# SMS API

Jak otworzyć rozwiązanie .sln C# SMS API?

Aby otworzyć Ozeki SMS API, należy zlokalizować plik OzekiConsole.sln po wypakowaniu pakietu OzekiConsole.zip i otworzyć ten plik w Visual Studio. (Rysunek 6) Możesz dwukrotnie kliknąć plik rozwiązania (.sln) lub znaleźć go w Visual Studio.

Rysunek 6 - Otwórz OzekiConsole.sln

Po otwarciu pliku .sln zobaczysz dwa projekty w swoim rozwiązaniu. Projekt OzekiConsole zawiera przykładowy kod, który pokazuje, jak można użyć biblioteki klienta C# SMS API do połączenia z Bramką SMS. (Rysunek 7) Drugi projekt to projekt Ozeki.Libs.OZX dll. Ten projekt zawiera pełny kod źródłowy biblioteki klienta C# SMS API.

Rysunek 7 - Rozwiązanie C# SMS

Jak zalogować się do bramki SMS za pomocą C# SMS API

Aby użyć C# SMS API, musisz utworzyć nazwę użytkownika i hasło w swojej bramce SMS. Jeśli zainstalowałeś swoją bramkę SMS na telefonie z Androidem, musisz zalogować się do telefonu za pomocą przeglądarki internetowej. Jeśli zainstalowałeś bramkę SMS na Windows lub Linux, po prostu połącz się z nią za pomocą przeglądarki. Jeśli jeszcze nie zainstalowałeś swojej bramki SMS, skonfiguruj ją teraz, korzystając z jednej z poniższych instrukcji: Jak skonfigurować bramkę SMS na Windows, Jak skonfigurować bramkę SMS na Linux. (Rysunek 8)

jak używać c# sms api
Rysunek 8 - Jak używać C# SMS API

Jak wysłać SMS z C#

Aby wysłać SMS z C#, musisz dodać ozekisms.dll jako referencję do swojego rozwiązania w Visual Studio. Możesz zdecydować się na dodanie binarnego dll lub możesz dodać projekt zawierający kod źródłowy. Jeśli dodasz binarne dll, Twój projekt będzie kompilował się szybciej, jeśli dodasz kod źródłowy, będziesz miał lepsze możliwości debugowania. (Rysunek 9)

Jak wysłać wiadomość SMS z C#
Rysunek 9 - Jak wysłać wiadomość tekstową z C#

Jak wysłać SMS z C#:

  1. Pobierz bibliotekę Ozeki C# SMS (plik zip)
  2. Wypakuj plik zip
  3. Otwórz Microsoft Visual Studio
  4. Utwórz nową aplikację konsolową
  5. W Eksploratorze rozwiązań kliknij "Dodaj..."
  6. Wybierz "Istniejący projekt"
  7. Wyszukaj OzekiSMSLibrary.csproj
  8. Kliknij Otwórz
  9. Dodaj przestrzeń nazw "Ozeki" do swojej aplikacji konsolowej
  10. Skopiuj i wklej przykład
  11. Wyślij swój pierwszy SMS za pomocą funkcji SendMessage

Jak odbierać SMS w C#

Aby odbierać SMS w C#, musisz skonfigurować swój projekt w taki sam sposób, jak konfiguruje się go do wysyłania wiadomości SMS. W skrócie, pobierz ozekisms.dll jako plik binarny lub jako źródło i dodaj go do swojego projektu jako bibliotekę referencyjną. Następnie możesz utworzyć instancję klasy C# i zasubskrybować zdarzenie, które jest wywoływane po odebraniu SMS. (Rysunek 10)

Jak odebrać wiadomość SMS za pomocą C#
Rysunek 10 - Jak odebrać SMS za pomocą C#

Jak odbierać SMS w C#:

  1. Pobierz bibliotekę Ozeki C# SMS (plik zip)
  2. Otwórz Microsoft Visual Studio
  3. Utwórz nową aplikację konsolową lub otwórz jeden z istniejących projektów
  4. Dodaj bibliotekę C# SMS do swojego rozwiązania w C#
  5. Dodaj przestrzeń nazw "Ozeki" do swojej klasy
  6. Utwórz instancję klasy wiadomości
  7. Zarejestruj się w zdarzeniu OnMessageReceived
  8. Napisz kod obsługi zdarzenia
  9. Ustaw punkt przerwania w obsłudze zdarzenia
  10. Wyślij wiadomość testową
  11. Czekaj, aż SMS dotrze do punktu przerwania
Zrozum kod źródłowy C# SMS API
//*********************************************************************
// Ozeki C# SMS API - v1.0.0
// Dokumentacja: 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);
            }
        }

        //*************************************************************
        // Odczytaj następne polecenie
        //*************************************************************
        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("Dziękujemy za korzystanie z Ozeki Client!");
                    break;
                case "connect":
                    connect(parameters);
                    break;
                case "disconnect":
                    disconnect();
                    break;
                case "send":
                    send(parameters);
                    break;
            }
        }

        //*************************************************************
        // Polecenia / Powitanie
        //*************************************************************

        static void printWelcome()
        {
            Console.WriteLine("**********************************");
            Console.WriteLine("* Witamy w Ozeki Client v1.0.0 *");
            Console.WriteLine("**********************************");
            Console.WriteLine("Wpisz 'help' aby zobaczyć dostępne polecenia");
        }

        //*************************************************************
        // Polecenia / Pomoc
        //*************************************************************

        static void printHelp()
        {
            Console.WriteLine("**********************");
            Console.WriteLine("* Dostępne polecenia *");
            Console.WriteLine("**********************");
            Console.WriteLine("help");
            Console.WriteLine("connect [host:port] [username] [password]");
            Console.WriteLine("disconnect");
            Console.WriteLine("send [odbiorca] [wiadomość]");
            Console.WriteLine("exit");
        }

        //*************************************************************
        // Polecenia / Połącz
        //*************************************************************

        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("Błąd. "+errormessage);
                Console.WriteLine("Składnia: connect [host:port] [username] [password]");
                Console.WriteLine("Przykład: connect 127.0.0.1:9580 testuser testpass");
            }
            Console.WriteLine("Łączenie z "+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 = "Polecenie connect wymaga 3 parametrów.";
                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 = "Nieprawidłowy host i port.";
                host = null;
                port = 0;
                return false;                
            }

            host = hostandportparts[0];
            string portstring = hostandportparts[1];

            if (!int.TryParse(portstring, out port))
            {
                errormessage = "Nieprawidłowy numer portu.";
                port = 0;
                return false;
            }

            errormessage = null;
            return true;
        }

        //*************************************************************
        // Polecenia / Rozłącz
        //*************************************************************

        static void disconnect()
        {
            Client.Disconnect();
        }

        //*************************************************************
        // Polecenia / Wyślij
        //*************************************************************

        static void send(string parameters)
        {
            string[] parts = parameters.Split(new char[] { ' ' },2);
            if (parts.Length < 2)
            {
                Console.WriteLine("Błąd. Polecenie send wymaga 2 parametrów.");
                Console.WriteLine("Składnia: send [odbiorca] [wiadomość]");
                Console.WriteLine("Przykład: send +441234567 Witaj świecie");
                return;
            }

            string recipient = parts[0];
            string message = parts[1];

            var msg = new OzxMessage();
            msg.ToAddress = recipient;
            msg.Text = message;

            Console.WriteLine("Wysyłanie wiadomości. ID: "+msg.ID);
            Client.Send(msg);
        }

        //*************************************************************
        // Utwórz klienta
        //*************************************************************
        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;
        }

        //*************************************************************
        // Zdarzenia związane z wiadomościami
        //*************************************************************

        static void Client_OnConnected(object sender, EventArgs e)
        {
            Console.WriteLine("Pomyślnie połączono.");
            printPrompt();
        }

        static void Client_OnDisconnected(object sender, OzxArgs< string > e)
        {
            Console.WriteLine("Połączenie zamknięte. Powód: " + e.Item.ToString());
            printPrompt();
        }

        static void Client_OnMessageReceived(object sender, OzxArgs< IOzxMessage > e)
        {
            Console.WriteLine("Odebrano wiadomość: " + e.Item.ToString());
            printPrompt();
        }

        static void Client_OnMessageAcceptedForDelivery(object sender, OzxArgs< string > e)
        {
            Console.WriteLine("Wiadomość zaakceptowana do dostarczenia. ID: " + e.Item.ToString());
            printPrompt();
        }

        static void Client_OnMessageNotAcceptedForDelivery(object sender, OzxArgs< string, string > e)
        {
            Console.WriteLine("Wiadomość odrzucona. ID: " + e.Item1.ToString()+" Powód: "+e.Item2);
            printPrompt();
        }

        static void Client_OnMessageSubmitSuccess(object sender, OzxArgs< string, DateTime > e)
        {
            Console.WriteLine("Wiadomość wysłana. ID: "+e.Item1+" Data: "+e.Item2);
            printPrompt();
        }

        static void Client_OnMessageSubmitFailed(object sender, OzxArgs< string, DateTime, string > e)
        {
            Console.WriteLine("Wysłanie wiadomości nie powiodło się. ID: " + e.Item1 + " Data: " + e.Item2+" Powód: "+e.Item3);
            printPrompt();
        }

        static void Client_OnMessageDeliverySuccess(object sender, OzxArgs< string, DateTime > e)
        {
            Console.WriteLine("Wiadomość dostarczona. ID: " + e.Item1 + " Data: " + e.Item2);
            printPrompt();
        }

        static void Client_OnMessageDeliveryFailed(object sender, OzxArgs< string, DateTime, string > e)
        {
            Console.WriteLine("Dostarczenie wiadomości nie powiodło się. ID: " + e.Item1 + " Data: " + e.Item2 + " Powód: " + e.Item3);
            printPrompt();
        }

        static void Client_OnMessageViewed(object sender, OzxArgs< string, DateTime > e)
        {
            Console.WriteLine("Wiadomość wyświetlona. ID: " + e.Item1 + " Data: " + e.Item2);
            printPrompt();
        }
    }
}

Co zrobić, jeśli nie mogę się połączyć?

Jeśli Twoja aplikacja SMS nie może połączyć się z bramką SMS, możliwe, że wprowadziłeś nieprawidłowy adres IP lub numer portu w kliencie SMS. Może się również zdarzyć, że zapora ogniowa na bramce SMS blokuje połączenie.

Aby sprawdzić, czy używasz prawidłowego adresu IP i portu, otwórz interfejs użytkownika bramki SMS. Na pasku narzędzi aplikacji Bramka SMS kliknij przycisk Zaawansowane. Spowoduje to wyświetlenie strony usług bramki SMS. Musisz znaleźć usługę OZX na liście i kliknąć „Szczegóły” (Rysunek 11).

Szczegóły usługi OZX
Rysunek 11 - Szczegóły usługi OZX

Po otwarciu strony możesz znaleźć adres IP w pasku tytułowym okna (Rysunek 12), a numer portu po lewej stronie formularza konfiguracyjnego. (Uwaga: możesz zmienić ten numer portu, otwierając formularz konfiguracyjny usługi OZX.)

Znajdź hosta i port API SMS C#
Rysunek 12 - Znajdź hosta i port API SMS C#

Po znalezieniu adresu IP i portu upewnij się, że używasz tych danych w swojej aplikacji SMS w C#. Na przykład, jeśli adres IP to 192.168.93.192, a port to 9580, należy wprowadzić te parametry w funkcji połączenia. (Rysunek 13)

Rysunek 13 - IP i port klienta SMS w C#

Możesz wpisać te dane bezpośrednio w kodzie C#. Na przykład możesz użyć następującej funkcji, aby nawiązać połączenie z bramką SMS na 192.168.93.192:9580 z nazwą użytkownika OZX tester i hasłem test:

static void createClient()
{
    Client = new OzxClient();
    Client.AutoReconnect = true;
    Client.Connect("192.168.93.192", 9580, "testuser", "testpass");
}

Podsumowanie

Podsumowując, API SMS w C# pozwala na połączenie z Twoją Bramką SMS przy użyciu protokołu OZX. Ten protokół SMS oferuje doskonałą wydajność i dwukierunkową komunikację SMS. Fakt, że darmowa biblioteka API SMS w C# dostarczona przez Ozeki pozwala na wysyłanie wiadomości SMS za pomocą prostych wywołań metod oraz odbieranie raportów dostarczenia SMS w postaci zdarzeń C#, czyni tę opcję najlepszym wyborem, jeśli chcesz zbudować aplikację SMS w C# w 2025 roku.

More information