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.