API de SMS em C# com código-fonte completo

Se você está procurando uma ferramenta poderosa para desenvolvedores C#.Net para adicionar capacidade de envio e recebimento de SMS a aplicações C#.Net, a API de SMS em C# fornecida pelo Ozeki SMS Gateway é a melhor opção. Esta é a melhor API de SMS em C# em 2025. Ela é excelente porque é muito eficiente em termos de recursos e oferece informações sobre suas mensagens enviadas na forma de relatórios de envio e relatórios de entrega muito mais rápido do que outras APIs de SMS. Esta API de SMS em C# também permite que você agende SMS para entrega futura e pode ser usada tanto para enviar quanto para receber SMS de telefones móveis sem atrasos. Leia este artigo para conhecer esta incrível solução de SMS em C# e descobrir como você pode aproveitá-la em seu ambiente.

O que é a API de SMS em C#?

A API de SMS em C# do Ozeki é uma interface de software fornecida pelo Ozeki SMS Gateway que permite enviar e receber SMS a partir de código C#.Net. Esta interface pode ser usada com a biblioteca cliente da API de SMS em C# de vários computadores simultaneamente. (Figura 1) Você pode baixar a biblioteca cliente da API de SMS em C# nesta página.

api de sms em c#
Figura 1 - API de SMS em C#

Download da biblioteca cliente da API de SMS em C#

Você pode baixar o cliente de SMS em C# (código-fonte) no link a seguir. O arquivo ZIP contém um projeto do Visual Studio com código-fonte completo. Você pode modificar, usar e redistribuir este código ou derivados livremente.

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

Como funciona a API de SMS em C#?

Com a API de SMS em C# do Ozeki, você pode enviar e receber mensagens SMS de forma muito mais eficiente do que usando soluções tradicionais de API SMP HTTP ou REST. Isso é possível porque a API de SMS em C# do Ozeki cria e mantém um link TCP/IP permanente para o gateway de SMS e se comunica por meio de um protocolo de SMS altamente otimizado chamado OZX. Este método de comunicação requer menos recursos em termos de CPU, memória e largura de banda de rede do que outros protocolos de SMS. Por exemplo, enviar uma mensagem SMS em uma solicitação de API REST HTTP consome pelo menos 10 vezes mais dados do que uma solicitação de envio OZX.

A vantagem mais importante vem do link TCP/IP permanente. Graças a este link permanente, sua aplicação de SMS em C# receberá relatórios de envio e entrega instantâneos na forma de eventos em C#. Você também receberá mensagens SMS recebidas sem atrasos. Sem esse link, você teria que consultar o gateway de SMS para obter relatórios de entrega ou baixar SMS recebidos, ou teria que configurar um listener TCP/IP ou serviço web e abrir uma porta no firewall para que suas mensagens chegassem.

Este link TCP/IP pode ser criptografado usando SSL/TLS e você pode facilmente adicionar validação de certificado de cliente e servidor para tornar este link da API de SMS em C# extremamente seguro.

Como usar a API de SMS em C#:

  1. Baixe o Ozeki SMS Gateway
  2. Instale uma conexão de teste de SMS
  3. Instale um usuário OZX
  4. Crie um nome de usuário e senha
  5. Ative o registro de comunicação
  6. Abra seu projeto de SMS em C# no Visual Studio
  7. Modifique o código em C# com o nome de usuário e senha
  8. Envie um SMS de teste a partir do C#
  9. Verifique os logs no gateway de SMS
  10. Simule um SMS recebido com a conexão de teste
  11. Faça um teste ao vivo com seu telefone Android

Tutorial em vídeo da API de SMS em C# (2 minutos)

Para ter uma ideia rápida de como configurar seu gateway de SMS para aceitar conexões da API de SMS em C# e como enviar seu primeiro SMS a partir de sua aplicação em C#, confira o vídeo a seguir. Este vídeo tem apenas 2 minutos e 21 segundos e vale a pena. O vídeo mostra como um usuário OZX pode ser criado no gateway de SMS para aceitar clientes da API de SMS em C# e como você pode iniciar e executar a biblioteca cliente da API de SMS em C# baixada no Visual Studio. A parte final mostra como você pode enviar um SMS de teste.

Vídeo 1 - Como configurar seu gateway de SMS para aceitar conexões da API de SMS em C# e enviar seu primeiro SMS a partir de sua aplicação em C# (Tutorial em vídeo)

Por que a API de SMS em C# do Ozeki é melhor?

A API de SMS em C# do Ozeki é ótima porque a quantidade de dados necessários para enviar um SMS é menor e a codificação e decodificação da Unidade de Dados de Protocolo (PDU) tem um custo de CPU significativamente menor. Se você usá-la, sua solução consumirá menos recursos nas três áreas principais: memória, CPU e largura de banda de rede. Como resultado, suas aplicações serão mais rápidas e mais responsivas.

Como posso usar a API de SMS em C#?

A API de SMS em C# do Ozeki é um conjunto de classes em C# que permitem enviar e receber mensagens SMS. Você pode usá-la abrindo o projeto baixado no Visual Studio. Ao abrir o projeto, você verá que o código completo está escrito em C#.Net. O envio de mensagens é feito usando chamadas de método em C#, e as mensagens recebidas chegam na forma de eventos em C#. Sua aplicação de SMS, que você construir com base na API de SMS, poderá enviar mensagens SMS diretamente para a rede móvel usando um telefone Android ou um PC com uma conexão de SMS IP. A conexão com a rede móvel será fornecida pelo Ozeki SMS Gateway, que você precisa Linux. (Figura 2)

O que é a api de sms em c#?
Figura 2 - Como funciona a API de SMS em C#

Quanto custa a API de SMS em C#?

A API é uma biblioteca, que é fornecida gratuitamente, com uma licença MIT. Você pode modificá-la e distribuí-la livremente como desejar. Quando você baixa a API, o pacote contém um aplicativo de console de exemplo e o código-fonte completo da dll Ozeki.Libs.OZX.

O único custo que você precisa pagar é a taxa de licença para o software Ozeki SMS Gateway. Um único gateway de SMS pode ser usado para servir várias centenas de clientes de SMS em C# pela rede. Você pode instalar o gateway de SMS em vários computadores para aumentar a capacidade ou para aproveitar as ofertas de SMS por redes locais.

Em relação aos custos de SMS, se você enviar mensagens de texto através de um celular conectado ao seu PC, o custo depende das tarifas de SMS do cartão SIM no seu telefone. Na maioria dos países, você pode enviar mensagens SMS gratuitamente se escolher esta opção. Há uma limitação, no entanto: um único celular não pode enviar mais de 12000 SMS por dia. Você só pode aumentar essa capacidade conectando vários celulares ao seu computador. Quando você envia um SMS através do seu celular (Figura 2), você precisa instalar o software Ozeki Android SMS Gateway no seu celular e precisa se conectar a ele via Wi-fi.

Se você instalar o Linux, você pode enviar SMS sem fio com um pool de modems GSM conectado ao PC. Nesses casos, as mesmas tarifas gratuitas de SMS se aplicam porque modems GSM e pools de modems GSM operam sem fio com cartões SIM.

Se você precisa de um sistema de gateway de SMS local de alto desempenho, onde vários milhares (ou milhões) de mensagens podem ser enviadas e recebidas, você precisa se conectar a um provedor de serviços de SMS online. Neste caso, as tarifas de SMS são definidas pelo serviço de SMS que você assina. Observe que é sempre uma boa ideia se conectar a dois ou mais serviços de SMS online para ser tolerante a falhas e para poder aproveitar as opções de roteamento de menor custo. Também é uma boa ideia configurar um link sem fio de backup.

Como me conecto ao gateway de SMS?

Quando você desenvolve seu aplicativo de SMS em C#, provavelmente usará seu laptop. O Visual Studio será instalado no seu laptop. Este laptop se conectará à sua rede local (LAN) do escritório através de Wi-fi ou de uma conexão Ethernet. Seu celular Android ou seu sistema de gateway de SMS Windows (Figura 3) também se conectará à LAN do escritório. Quando você se conectar ao gateway de SMS, você usará o endereço IP da LAN do computador do gateway de SMS.

Ozeki SMS Gateway instalado em um servidor
Figura 3 - Ozeki SMS Gateway instalado em um servidor

Para conectar seu aplicativo em C# ao gateway de SMS, você precisará saber o endereço IP e o número da porta do gateway de SMS, e precisará de um nome de usuário e senha. O endereço IP do gateway de SMS será seu endereço IP da LAN. Como na maioria das vezes o software do gateway de SMS será instalado em um computador diferente do seu laptop de desenvolvimento, esse endereço IP será diferente do endereço IP do seu laptop. O número da porta é fácil. Geralmente, é o número da porta padrão, que é 9580. Para obter um nome de usuário e senha, você precisa criar um usuário OZX (Figura 4). Quando você cria o usuário OZX, pode especificar qualquer nome de usuário ou senha que desejar.

Depois de descobrir o endereço IP, o número da porta e ter criado o nome de usuário e senha, você precisa inserir esses detalhes no método de conexão do seu aplicativo de SMS em C#.

Figura 4 - Criar usuário OZX para API de SMS em C#

Se você não quiser usar dois computadores, pode instalar o gateway de SMS no seu laptop (o mesmo computador onde você desenvolve seu aplicativo em C#). Neste caso, você forneceria "127.0.0.1" como o endereço IP e a porta "9580" no método de conexão. (Sim, você também pode usar endereços IPv6 ou nomes de host, como 'localhost")

Benefícios de usar seu próprio gateway de SMS

Teste gratuito: É muito benéfico operar seu próprio gateway de SMS, porque você pode testar seu aplicativo de SMS gratuitamente. Você pode simular mensagens SMS recebidas, pode enviar mensagens de teste para a conexão de teste do gateway de SMS e pode simular relatórios de entrega de SMS indicando entrega bem-sucedida e falha. É uma boa ideia ler o guia do simulador SMPP para obter mais informações sobre testes.

Teste de desempenho ilimitado: Depois de desenvolver sua solução de SMS em C#, é provável que você queira fazer alguns testes de desempenho. Com o Ozeki SMS Gateway, é muito fácil testar seu sistema com um alto volume de mensagens SMS. Na maioria dos casos, você enviará apenas alguns milhares de SMS, mas se solicitado por um cliente, você pode até fazer um teste com vários milhões de mensagens. Confira os resultados de teste de desempenho de SMS que realizamos com o Ozeki SMS Gateway com 1.000.000 de SMS.

Mude facilmente de provedor: Se você desenvolver seu código em C# que funciona com o Ozeki SMS Gateway, não precisará se preocupar em ficar preso a uma rede de SMS ou a um provedor de serviços de SMS. Você pode usar o mesmo código em C# e simplesmente mudar para outro provedor de serviços de SMS se obter uma oferta melhor configurando a conexão do novo provedor no gateway de SMS.

O que é OZX?

OZX significa OZeki eXchange. É um protocolo de SMS altamente otimizado usado para comunicação entre sua aplicação de SMS em C# e o Ozeki SMS Gateway. É um protocolo baseado em TCP/IP que é significativamente mais eficiente do que os protocolos tradicionais de SMS, como os protocolos C# HTTP SMS API, protocolos C# REST SMS API ou o protocolo SMPP SMS. A eficiência vem de dois fatores principais: nenhum dado desnecessário é transmitido (note que existe uma grande sobrecarga de dados tanto no HTTP quanto no SMPP), e um processamento de protocolo mais fácil e eficiente é possível devido à estrutura PDU do protocolo.

O que está no zip da API de SMS em C#?

O arquivo zip contém dois projetos (como na Figura 5): uma aplicação de console que é um código muito fácil de entender para mostrar como usar a API de SMS em C#, e contém o código fonte da própria API de SMS em C#.

Conteúdo do pacote da API de SMS em C#:

  • Código de exemplo (código fonte completo)
  • Biblioteca cliente Ozeki (código fonte completo)

Figura 5 - Conteúdo do pacote da API de SMS em C#

Como abro a solução .sln da API de SMS em C#?

Para abrir a API de SMS Ozeki, você precisa localizar o arquivo OzekiConsole.sln após descompactar o pacote OzekiConsole.zip e abrir este arquivo no Visual Studio. (Figura 6) Você pode clicar duas vezes no arquivo de solução (.sln) ou navegar até ele no Visual Studio.

Figura 6 - Abrir o OzekiConsole.sln

Depois de abrir o .sln, você verá dois projetos em sua solução. O projeto OzekiConsole contém o código de exemplo que mostra como você pode usar a biblioteca cliente da API de SMS em C# para se conectar ao SMS Gateway. (Figura 7) O outro projeto é o projeto Ozeki.Libs.OZX dll. Este projeto contém o código fonte completo da biblioteca cliente da API de SMS em C#.

Figura 7 - Solução de SMS em C#

Como fazer login no SMS gateway com a API de SMS em C#

Para usar a API de SMS em C#, você precisa criar um nome de usuário e senha em seu SMS gateway. Se você instalou seu SMS gateway no seu telefone Android, você precisa fazer login no telefone usando um navegador web. Se você instalou seu SMS gateway no Windows ou Linux, basta se conectar a ele com seu navegador. Se você ainda não instalou seu SMS gateway, configure-o agora usando uma das seguintes instruções: Como configurar meu SMS Gateway no Windows, Como configurar meu SMS gateway no Linux. (Figura 8)

como usar a api de sms em c#
Figura 8 - Como usar a API de SMS em C#

Como enviar SMS a partir de C#

Para enviar SMS a partir de C#, você precisa adicionar o ozekisms.dll como uma referência em sua solução do Visual Studio. Você pode optar por adicionar o dll binário ou pode adicionar o projeto contendo o código fonte. Se você adicionar o dll binário, seu projeto será compilado mais rapidamente; se adicionar o código fonte, você terá melhores capacidades de depuração. (Figura 9)

Como enviar uma mensagem de SMS a partir de C#
Figura 9 - Como enviar uma mensagem de texto a partir de C#

Como enviar SMS a partir de C#:

  1. Baixe a biblioteca de SMS em C# da Ozeki (arquivo zip)
  2. Extraia o arquivo zip
  3. Abra o Microsoft Visual Studio
  4. Crie uma nova aplicação de console
  5. No explorador de soluções, clique em "Adicionar..."
  6. Selecione "Projeto existente"
  7. Procure pelo OzekiSMSLibrary.csproj
  8. Clique em Abrir
  9. Adicione o namespace "Ozeki" ao seu aplicativo de console
  10. Copie e cole o exemplo
  11. Envie seu primeiro SMS usando a função SendMessage
Como receber SMS em C#

Para receber SMS em C#, você precisa configurar seu projeto da mesma forma que faria para enviar uma mensagem de SMS. Resumindo, baixe o ozekisms.dll como binário ou como código fonte e adicione-o ao seu projeto como uma biblioteca de referência. Depois disso, você pode criar uma instância da classe em C# e se inscrever no evento que é chamado quando um SMS é recebido. (Figura 10)

Como receber uma mensagem de SMS usando C#
Figura 10 - Como receber um SMS usando C#

Como receber SMS em C#:

  1. Baixe a biblioteca de SMS em C# da Ozeki (arquivo zip)
  2. Abra o Microsoft Visual Studio
  3. Crie um novo aplicativo de console ou abra um de seus projetos existentes
  4. Adicione a biblioteca de SMS em C# à sua solução em C#
  5. Adicione o namespace "Ozeki" à sua classe
  6. Crie uma instância da classe de mensagem
  7. Inscreva-se no evento OnMessageReceived
  8. Escreva o código do manipulador de eventos
  9. Defina um ponto de interrupção no manipulador de eventos
  10. Envie uma mensagem de teste
  11. Aguarde o SMS atingir o ponto de interrupção

Entenda o código-fonte da API de SMS em C#

//*********************************************************************
// API de SMS em C# Ozeki - v1.0.0
// Documentação: 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);
            }
        }

        //*************************************************************
        // Ler próximo comando
        //*************************************************************
        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("Obrigado por usar o Ozeki Client!");
                    break;
                case "connect":
                    connect(parameters);
                    break;
                case "disconnect":
                    disconnect();
                    break;
                case "send":
                    send(parameters);
                    break;
            }
        }

        //*************************************************************
        // Comandos / Boas-vindas
        //*************************************************************

        static void printWelcome()
        {
            Console.WriteLine("**********************************");
            Console.WriteLine("* Bem-vindo ao Ozeki Client v1.0.0 *");
            Console.WriteLine("**********************************");
            Console.WriteLine("Digite 'help' para ver os comandos disponíveis");
        }

        //*************************************************************
        // Comandos / Ajuda
        //*************************************************************

        static void printHelp()
        {
            Console.WriteLine("**********************");
            Console.WriteLine("* Comandos disponíveis *");
            Console.WriteLine("**********************");
            Console.WriteLine("help");
            Console.WriteLine("connect [host:porta] [usuário] [senha]");
            Console.WriteLine("disconnect");
            Console.WriteLine("send [destinatário] [mensagem]");
            Console.WriteLine("exit");
        }

        //*************************************************************
        // Comandos / Conectar
        //*************************************************************

        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("Erro. "+errormessage);
                Console.WriteLine("Sintaxe: connect [host:porta] [usuário] [senha]");
                Console.WriteLine("Exemplo: connect 127.0.0.1:9580 testuser testpass");
            }
            Console.WriteLine("Conectando a "+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 = "O comando connect espera 3 parâmetros.";
                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 e porta inválidos.";
                host = null;
                port = 0;
                return false;                
            }

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

            if (!int.TryParse(portstring, out port))
            {
                errormessage = "Número de porta inválido.";
                port = 0;
                return false;
            }

            errormessage = null;
            return true;
        }

        //*************************************************************
        // Comandos / Desconectar
        //*************************************************************

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

        //*************************************************************
        // Comandos / Enviar
        //*************************************************************

        static void send(string parameters)
        {
            string[] parts = parameters.Split(new char[] { ' ' },2);
            if (parts.Length < 2)
            {
                Console.WriteLine("Erro. O comando send espera 2 parâmetros.");
                Console.WriteLine("Sintaxe: send [destinatário] [mensagem]");
                Console.WriteLine("Exemplo: send +441234567 Olá mundo");
                return;
            }

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

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

            Console.WriteLine("Enviando mensagem. ID: "+msg.ID);
            Client.Send(msg);
        }

        //*************************************************************
        // Criar cliente
        //*************************************************************
        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;
        }

        //*************************************************************
        // Eventos de mensagens
        //*************************************************************

        static void Client_OnConnected(object sender, EventArgs e)
        {
            Console.WriteLine("Conectado com sucesso.");
            printPrompt();
        }

        static void Client_OnDisconnected(object sender, OzxArgs< string > e)
        {
            Console.WriteLine("Conexão encerrada. Motivo: " + e.Item.ToString());
            printPrompt();
        }

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

        static void Client_OnMessageAcceptedForDelivery(object sender, OzxArgs< string > e)
        {
            Console.WriteLine("Mensagem aceita para entrega. ID: " + e.Item.ToString());
            printPrompt();
        }

        static void Client_OnMessageNotAcceptedForDelivery(object sender, OzxArgs< string, string > e)
        {
            Console.WriteLine("Mensagem rejeitada. ID: " + e.Item1.ToString()+" Motivo: "+e.Item2);
            printPrompt();
        }

        static void Client_OnMessageSubmitSuccess(object sender, OzxArgs< string, DateTime > e)
        {
            Console.WriteLine("Mensagem submetida. ID: "+e.Item1+" Data: "+e.Item2);
            printPrompt();
        }

        static void Client_OnMessageSubmitFailed(object sender, OzxArgs< string, DateTime, string > e)
        {
            Console.WriteLine("Falha ao submeter mensagem. ID: " + e.Item1 + " Data: " + e.Item2+" Motivo: "+e.Item3);
            printPrompt();
        }

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

        static void Client_OnMessageDeliveryFailed(object sender, OzxArgs< string, DateTime, string > e)
        {
            Console.WriteLine("Falha na entrega da mensagem. ID: " + e.Item1 + " Data: " + e.Item2 + " Motivo: " + e.Item3);
            printPrompt();
        }

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

O que fazer se não conseguir conectar?

Se o seu aplicativo de SMS não conseguir se conectar ao gateway de SMS, é possível que você tenha inserido o endereço IP ou número da porta incorretos no cliente de SMS. Também pode ser que o firewall no gateway de SMS esteja bloqueando a conexão.

Para verificar se você está usando o endereço IP e a porta corretos, abra a interface do usuário do gateway de SMS. Na barra de ferramentas do aplicativo SMS Gateway, clique no botão Avançado. Isso abrirá a página de serviços do gateway de SMS. Você precisa encontrar o serviço OZX na lista e clicar em "Detalhes" (Figura 11).

Detalhes do serviço OZX
Figura 11 - Detalhes do serviço OZX

Depois que a página for aberta, você pode encontrar o endereço IP na barra de título da janela (Figura 12) e o número da porta no lado esquerdo do formulário de configuração. (Observe que você pode alterar este número da porta abrindo o formulário de configuração do serviço OZX.)

Encontrar o host e a porta da API de SMS em C#
Figura 12 - Encontrar o host e a porta da API de SMS em C#

Depois de encontrar o endereço IP e a porta, você deve garantir que usa esses detalhes no seu aplicativo de SMS em C#. Por exemplo, se o endereço IP fosse 192.168.93.192 e a porta fosse 9580, você deve inserir esses parâmetros na função de conexão. (Figura 13)

Figura 13 - IP e porta do cliente de SMS em C#

Você pode escrever esses detalhes diretamente no seu código em C#. Por exemplo, você pode usar a seguinte função para configurar uma conexão com o gateway de SMS em 192.168.93.192:9580 com um nome de usuário OZX "tester" e senha "testpass":

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

Considerações finais

Para resumir, a API de SMS em C# permite que você se conecte ao seu Gateway de SMS usando o protocolo OZX. Este protocolo de SMS oferece excelente desempenho e comunicação bidirecional de SMS. O fato de a biblioteca da API de SMS em C# gratuita fornecida pela Ozeki permitir que você envie mensagens SMS com chamadas de método simples e receba relatórios de envio e entrega de SMS na forma de eventos em C# torna esta a melhor opção se você deseja construir um aplicativo de SMS em C# em 2025.

More information