A programação do NSB é bem simples. Você começa criando uma interface de contrato e sua implementação, bem ao estilo WCF:

    [ServiceContract(Name = "EchoContract", Namespace = "nmsp")]
    public interface IEchoContract
    {       
        [OperationContract]
        string Echo(string text);
    }
    [ServiceBehavior(Name = "EchoService", Namespace = "nmsp")]
    public class EchoService : IEchoContract
    {
        public string Echo(string text)
        {
            Console.WriteLine("Echoing: {0}", text);
            return text;
        }
    }

Configura o app.config com os endpoints corretos no servidor (nesse caso é uma aplicação console):

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.serviceModel>
    <behaviors>
      <endpointBehaviors>
        <behavior name="cardSpaceClientCredentials">
          <transportClientEndpointBehavior credentialType="CardSpace" />
        </behavior>
      </endpointBehaviors>
    </behaviors>
    <bindings>
      <netTcpRelayBinding>
        <binding name="default" />
      </netTcpRelayBinding>
    </bindings>
    <services>
      <service name="Service.EchoService">
        <endpoint name="RelayEndpoint"
          contract="Service.IEchoContract"
          binding="netTcpRelayBinding"
          bindingConfiguration="default"
          behaviorConfiguration="cardSpaceClientCredentials"
          address="" />
      </service>
    </services>
  </system.serviceModel>
</configuration>

Neste caso o protocolo é via TCP (vejam o binding netTcpRelayBinding).

Aí você abre o serviço e espera, como qualquer serviço WCF:

        static void Main(string[] args)
        {
            string account = GetAccount();
            Uri address = new Uri(String.Format("sb://{0}/services/{1}/EchoService/", ServiceBusEnvironment.DefaultRelayHostName, account));
            ServiceHost host = new ServiceHost(typeof(EchoService), address);
            host.Open();
            Console.WriteLine("Service address: " + address);
            Console.WriteLine("Press [Enter] to exit");
            Console.ReadLine();
            host.Close();
        }

Perceberam que não há nada de diferente de um serviço comum WCF? A única diferença notável é o protocolo “sb:”, que na prática é uma abstração que vira um “tcp:”, ou um “http:”. O resultado é isso aqui (clique para ampliar):

Vocês já devem ter percebido que a aplicação somente ecoa o que ela recebeu na mensagem, e escreve isso na janela do console. Nesse caso o servidor já havia ecoado duas mensagens.

No cliente é um pouco mais complicado que uma configuração WCF comum. Não tem “Add Service Reference…”. É tudo na mão. Mas também é simples. Você reimplementa o contrato:

    [ServiceContract(Name = "EchoContract", Namespace = "nmsp")]
    public interface IEchoContract
    {
        [OperationContract]
        string Echo(string text);
    }
    public interface IEchoChannel : IEchoContract, IClientChannel { }

E abre e chama o serviço. O chato é ter que fazer na mão, abrindo ChannelFactory<T>, criando endereço, etc. Isso é um claro ponto para dar um monte de erros. Vamos ver se isso melhora um pouco até a versão final.

        static void Main(string[] args)
        {
            Console.Write("[Client] Enter the name of the user you want to connect with: ");
            string serviceUserName = Console.ReadLine();
            Uri serviceUri = new Uri(String.Format("sb://{0}/services/{1}/EchoService/", ServiceBusEnvironment.DefaultRelayHostName, serviceUserName));
            EndpointAddress address = new EndpointAddress(serviceUri);
            ChannelFactory<IEchoChannel> channelFactory = new ChannelFactory<IEchoChannel>("RelayEndpoint", address);
            IEchoChannel channel = channelFactory.CreateChannel();
            channel.Open();
            Console.WriteLine("Enter text to echo (or [Enter] to exit):");
            string input = Console.ReadLine();
            while (!String.IsNullOrEmpty(input))
            {
                try
                {
                    Console.WriteLine("Server echoed: {0}", channel.Echo(input));
                }
                catch (Exception e)
                {
                    Console.WriteLine("Error: " + e.Message);
                }
                input = Console.ReadLine();
            }
            channel.Close();
            channelFactory.Close();
        }

O resultado deve ser parecido com o que está abaixo (clique para ampliar). A cada vez que você manda uma mensagem, ela aparece na console do servidor e é ecoada de volta na janela do cliente:

Toda essa comunicação passa pelo servidor da Microsoft.

Vocês notaram uma menção ao cardspaces no arquivo de configuração? O cartão do cardspaces com acesso ao serviço é configurado online, como vocês podem ver abaixo. Além disso dá para usar certificado X.509 ou usuário e senha (basic auth).

Interessante, certo? E o legal é que você não precisa registrar nenhum serviço online no portal, como é feito para usar o Table Storage, por exemplo, ou até no Workflow Services. Se você está autenticado, você pode abrir um ponto de conexão no NSB e tudo vai funcionar. A página do NSB mostra isso tudo. No caso, meu projeto se chama “GiggioDotNet”, e no portal do Azure você pode ver como configurar seus endpoints:

Em resumo, bem fácil de usar. Dá para melhorar aqui e ali, mas o que estou vendo já está bem legal.

Giovanni Bassi

Arquiteto e desenvolvedor, agilista, escalador, provocador. É fundador e CSA da Lambda3. Programa porque gosta. Acredita que pessoas autogerenciadas funcionam melhor e por acreditar que heterarquia é mais eficiente que hierarquia. Foi reconhecido Microsoft MVP há mais de dez anos, dos mais de vinte que atua no mercado. Já palestrou sobre .NET, Rust, microsserviços, JavaScript, TypeScript, Ruby, Node.js, Frontend e Backend, Agile, etc, no Brasil, e no exterior. Liderou grupos de usuários em assuntos como arquitetura de software, Docker, e .NET.