Tutorial: Expor um serviço REST do WCF local para o cliente externo usando a Retransmissão do WCF do Azure

Artigo
08/11/2023

Este tutorial descreve como criar um aplicativo cliente e um serviço da Retransmissão do WCF usando a Retransmissão do Azure. Assim como os respectivos equivalentes do WCF originais, um serviço é um constructo que expõe um ou mais pontos de extremidade. Cada ponto de extremidade expõe uma ou mais operações de serviço. O ponto de extremidade do serviço especifica um endereço em que o serviço pode ser encontrado, uma associação que contém as informações que um cliente deve comunicar com o serviço e um contrato que define a funcionalidade fornecida pelo serviço aos seus clientes. A principal diferença entre um WCF e uma de Retransmissão de WCF é que o ponto de extremidade é exposto na nuvem, em vez de localmente em seu computador.

Depois de trabalhar na sequência de seções deste tutorial, você terá um serviço em execução. Você também terá um cliente que pode invocar as operações do serviço.

Você executará as seguintes tarefas neste tutorial:

Instalar os pré-requisitos para este tutorial.
Criar um namespace de Retransmissão
Criar um contrato de serviço WCF.
Implementar o contrato WCF.
Hospedar e executar o serviço WCF para registrar-se no serviço de Retransmissão.
Criar um cliente WCF para o contrato de serviço.
Configurar o cliente WCF.
Implementar o cliente WCF.
Executar os aplicativos.

Pré-requisitos

Para concluir este tutorial, você precisará dos seguintes pré-requisitos:

Uma assinatura do Azure. Se você não tiver uma conta gratuita, crie uma antes de começar.
Visual Studio 2015 ou posterior. Os exemplos deste tutorial usam o Visual Studio 2019.
SDK do Azure para .NET. Instale-o a partir da página de downloads do SDK.

Criar um namespace de Retransmissão

A primeira etapa é criar um namespace e obter uma chave de SAS (Assinatura de Acesso Compartilhado). Um namespace fornece um limite de aplicativo para cada aplicativo exposto por meio do serviço de retransmissão. Uma chave SAS é automaticamente gerada pelo sistema quando um namespace do serviço é criado. A combinação do namespace de serviço e a chave SAS fornece as credenciais para o Azure autenticar o acesso a um aplicativo.

Entre no portal do Azure.
Selecione Todos os serviços no menu esquerdo. Selecione Integração, procure por Retransmissões, passe o mouse sobre Retransmissões e clique em Criar.
Na página Criar namespace, siga estas etapas:
1. Escolha uma assinatura do Azure na qual criar o namespace.
2. Em Grupo de recursos, escolha um grupo de recursos existente no qual colocar o namespace ou crie um.
3. Insira um nome para o namespace de Retransmissão.
4. Selecione o país ou região no qual o namespace deve ser hospedado.
5. Selecione Revisar + criar na parte inferior da página.
6. Na página Examinar + criar escolha Criar.
7. Depois de alguns minutos, você verá a página de Retransmissão do namespace.

Obter credenciais de gerenciamento

Na página Retransmissão, selecione Políticas de acesso compartilhado no menu à esquerda. `
Na página Políticas de acesso compartilhado, selecione RootManageSharedAccessKey.
Em Política de SAS: RootManageSharedAccessKey, clique no botão Copiar ao lado da opção Cadeia de Conexão Primária. Isso copiará a cadeia de conexão para a área de transferência para uso posterior. Cole esse valor no Bloco de notas ou em outro local temporário.
Repita a etapa anterior para copiar e colar o valor de Chave primária para um local temporário para uso posterior.

Definir um contrato de serviço do WCF

O contrato de serviço especifica a quais operações o serviço dá suporte. As operações são métodos ou funções de serviço Web. Os contratos são criados pela definição de uma interface C++, C# ou Visual Basic. Cada método na interface corresponde a uma operação de serviço específica. O atributo ServiceContractAttribute deve ser aplicado a cada interface e o atributo OperationContractAttribute deve ser aplicado a cada operação. Se um método em uma interface que tem o atributo ServiceContractAttribute não tiver o atributo OperationContractAttribute, esse método não será exposto. O código para essas tarefas é fornecido no exemplo logo após o procedimento. Para obter uma discussão mais ampla de contratos e serviços, confira Como projetar e implementar serviços.

Criar um contrato de retransmissão com uma interface

Inicie o Microsoft Visual Studio como um administrador. Para fazer isso, clique com o botão direito do mouse no ícone de programa do Visual Studio e selecione Executar como administrador.
No Visual Studio, selecione Criar um projeto.
Em Criar um novo projeto, escolha Aplicativo de Console (.NET Framework) para C# e, em seguida, selecione Avançar.
Nomeie o projeto EchoService e selecione Criar.
No Gerenciador de Soluções, clique com o botão direito no projeto e escolha Gerenciar Pacotes NuGet. No Gerenciador de Pacotes NuGet, selecione Procurar e, em seguida, pesquise e escolha WindowsAzure.ServiceBus. Selecione Instalar e aceite os termos de uso.

Esse pacote adiciona referências automaticamente às bibliotecas do Barramento de Serviço e ao System.ServiceModel do WCF. System.ServiceModel é o namespace que permite o acesso programático aos recursos básicos do WCF. O Barramento de Serviço usa vários dos objetos e atributos do WCF para definir contratos de serviço.
Adicione as seguintes instruções using na parte superior de Program.cs:
```
using System.ServiceModel;
using Microsoft.ServiceBus;
```
Altere o nome do namespace de seu padrão EchoService para Microsoft.ServiceBus.Samples.

Importante

Este tutorial usa o namespace Microsoft.ServiceBus.Samples do C#, que é o namespace do tipo gerenciado baseado em contrato usado no arquivo de configuração na seção Configurar o cliente WCF. Você pode especificar qualquer namespace desejado ao criar essa amostra. No entanto, o tutorial não funcionará, a menos que você modifique os namespaces do contrato e do serviço de acordo, no arquivo de configuração de aplicativo. O namespace especificado no arquivo App.config precisa ser o mesmo namespace especificado nos arquivos C#.
Imediatamente após a declaração do namespace Microsoft.ServiceBus.Samples, mas ainda dentro do namespace, defina uma nova interface chamada IEchoContract e aplique o atributo ServiceContractAttribute à interface com um valor de namespace de https://samples.microsoft.com/ServiceModel/Relay/. Cole o trecho de código a seguir após a declaração de namespace:
```
[ServiceContract(Name = "IEchoContract", Namespace = "https://samples.microsoft.com/ServiceModel/Relay/")]
public interface IEchoContract
{
}
```
O valor do namespace é diferente do namespace que você usa em todo o escopo do seu código. Em vez disso, o valor do namespace é usado como um identificador exclusivo para este contrato. Especificar o namespace de forma explícita impede a adição do valor de namespace padrão ao nome do contrato.

Observação

Normalmente, o namespace de contrato de serviço contém um esquema de nomenclatura que inclui informações de versão. A inclusão de informações de versão no namespace de contrato de serviço permite que os serviços isolem as alterações principais, definindo um novo contrato de serviço com um novo namespace e expondo-o em um novo ponto de extremidade. Dessa maneira, os clientes podem continuar a usar o antigo contrato de serviço sem que ele precise ser atualizado. Informações de versão podem consistir de uma data ou um número da versão. Para saber mais, veja Controle de Versão do Serviço. Para este tutorial, o esquema de nomenclatura do namespace do contrato de serviço não contém informações de versão.
Dentro da interface IEchoContract, declare um método para a operação individual exposta pelo contrato IEchoContract na interface e aplique o atributo OperationContractAttribute ao método que você deseja expor como parte do contrato de retransmissão de WCF público, conforme descrito a seguir:
```
[OperationContract]
string Echo(string text);
```
Logo após a definição da interface IEchoContract, declare um canal que herde de IEchoContract e também a interface IClientChannel, como mostrado aqui:
```
public interface IEchoChannel : IEchoContract, IClientChannel { }
```
Um canal é o objeto WCF por meio do qual o host e o cliente trocam informações. Posteriormente, você escreverá o código no canal para ecoar as informações entre os dois aplicativos.
Selecione Compilar>Compilar Solução ou selecione Ctrl+Shift+B para confirmar a precisão do trabalho até o momento.

Exemplo de um contrato WCF

O código a seguir mostra uma interface básica que define um contrato de Retransmissão de WCF.

using System;
using System.ServiceModel;

namespace Microsoft.ServiceBus.Samples
{
    [ServiceContract(Name = "IEchoContract", Namespace = "https://samples.microsoft.com/ServiceModel/Relay/")]
    public interface IEchoContract
    {
        [OperationContract]
        String Echo(string text);
    }

    public interface IEchoChannel : IEchoContract, IClientChannel { }

    class Program
    {
        static void Main(string[] args)
        {
        }
    }
}

Agora que a interface está criada, você pode implementar a interface.

Implementar o contrato WCF

A criação de uma retransmissão do Azure exige que você primeiro crie o contrato usando uma interface. Para obter mais informações sobre como criar a interface, confira a seção anterior. O próximo procedimento implementa a interface. Essa tarefa envolve a criação de uma classe chamada EchoService que implementa a interface IEchoContract definida pelo usuário. Depois de implementar a interface, você a configurará usando um arquivo de configuração App.config. O arquivo de configuração contém as informações necessárias para o aplicativo. Essas informações incluem o nome do serviço, o nome do contrato e o tipo de protocolo usado para se comunicar com o serviço de retransmissão. O código usado para essas tarefas é fornecido no exemplo logo após o procedimento. Para obter uma discussão mais geral sobre como implementar um contrato de serviço, confira Como implementar contratos de serviço.

Crie uma nova classe chamada EchoService diretamente após a definição da interface IEchoContract. A classe EchoService implementa a interface IEchoContract.
```
class EchoService : IEchoContract
{
}
```
Assim como outras implementações de interface, você pode implementar a definição em um arquivo diferente. No entanto, para este tutorial, a implementação está localizada no mesmo arquivo que a definição de interface e o método Main().
Aplique o atributo ServiceBehaviorAttribute na interface IEchoContract. O atributo especifica o nome do serviço e o namespace. Depois de fazer isso, a classe EchoService aparecerá da seguinte maneira:
```
[ServiceBehavior(Name = "EchoService", Namespace = "https://samples.microsoft.com/ServiceModel/Relay/")]
class EchoService : IEchoContract
{
}
```

Implemente o método Echo definido na interface IEchoContract na classe EchoService.

public string Echo(string text)
{
    Console.WriteLine("Echoing: {0}", text);
    return text;
}

Selecione Compilar>Compilar Solução ou selecione Ctrl+Shift+B.

Definir a configuração do host de serviço

O arquivo de configuração é semelhante a um arquivo de configuração do WCF. Ele inclui o nome do serviço, o ponto de extremidade e a associação. O ponto de extremidade é a localização que a Retransmissão do Azure expõe para clientes e hosts se comunicarem entre si. A associação é o tipo de protocolo usado para a comunicação. A principal diferença é que esse ponto de extremidade de serviço configurado refere-se a uma associação NetTcpRelayBinding, que não faz parte do .NET Framework. NetTcpRelayBinding é uma das associações definidas pelo serviço.

No Gerenciador de Soluções, clique duas vezes em App.config para abrir o arquivo no editor do Visual Studio.
No elemento <appSettings>, substitua os espaços reservados pelo nome do namespace da Retransmissão do Azure e pela chave SAS que você copiou em uma etapa anterior.
Dentro das marcas <system.serviceModel>, adicione um elemento <services>. Assim como nas associações, você pode definir vários aplicativos de retransmissão em um único arquivo de configuração. Este tutorial, porém, define apenas um.
```
<?xmlversion="1.0" encoding="utf-8"?>
<configuration>
  <system.serviceModel>
    <services>

    </services>
  </system.serviceModel>
</configuration>
```
Dentro do elemento <services>, adicione um elemento <service> para definir o nome do serviço.
```
<service name="Microsoft.ServiceBus.Samples.EchoService">
</service>
```
Dentro do elemento <service>, defina o local do contrato do ponto de extremidade e também o tipo de associação para o ponto de extremidade.
```
<endpoint contract="Microsoft.ServiceBus.Samples.IEchoContract" binding="netTcpRelayBinding"/>
```
O ponto de extremidade define no qual o cliente procurará o aplicativo host. Posteriormente, o tutorial usa esta etapa para criar um URI que expõe totalmente o host através da Retransmissão do Azure. A associação declara que estamos usando o TCP como o protocolo para se comunicar com o serviço de retransmissão.
Selecione Compilar>Compilar Solução ou selecione Ctrl+Shift+B para confirmar a precisão do trabalho até o momento.

Exemplo de implementação de um contrato de serviço

O código a seguir mostra a implementação do contrato de serviço.

[ServiceBehavior(Name = "EchoService", Namespace = "https://samples.microsoft.com/ServiceModel/Relay/")]

    class EchoService : IEchoContract
    {
        public string Echo(string text)
        {
            Console.WriteLine("Echoing: {0}", text);
            return text;
        }
    }

O código a seguir mostra o formato básico do arquivo App.config associado ao host de serviço.

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.serviceModel>
    <services>
      <service name="Microsoft.ServiceBus.Samples.EchoService">
        <endpoint contract="Microsoft.ServiceBus.Samples.IEchoContract" binding="netTcpRelayBinding" />
      </service>
    </services>
    <extensions>
      <bindingExtensions>
        <add name="netTcpRelayBinding"
                    type="Microsoft.ServiceBus.Configuration.NetTcpRelayBindingCollectionElement, Microsoft.ServiceBus, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
      </bindingExtensions>
    </extensions>
  </system.serviceModel>
</configuration>

Hospedar e executar o serviço WCF para registrar-se no serviço de retransmissão

Esta etapa descreve como executar um serviço de Retransmissão do Azure.

Criar as credenciais de retransmissão

Em Main(), crie duas variáveis nas quais armazenar o namespace e a chave de SAS que são lidos da janela do console.
```
Console.Write("Your Service Namespace: ");
string serviceNamespace = Console.ReadLine();
Console.Write("Your SAS key: ");
string sasKey = Console.ReadLine();
```
A chave de SAS será usada posteriormente para acessar seu projeto. O namespace é passado como um parâmetro para CreateServiceUri para criar um URI de serviço.

Usando um objeto TransportClientEndpointBehavior, declare que você usará uma chave SAS como o tipo de credencial. Adicione o código a seguir diretamente após o código adicionado na última etapa.

TransportClientEndpointBehavior sasCredential = new TransportClientEndpointBehavior();
sasCredential.TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider("RootManageSharedAccessKey", sasKey);

Criar um endereço básico para o serviço

Após o código adicionado na etapa anterior, crie uma instância de Uri para o endereço básico do serviço. Esse URI especifica o esquema de Barramento de Serviço, o namespace e o caminho da interface do serviço.

Uri address = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, "EchoService");

O valor "sb" é uma abreviação do esquema do Barramento de Serviço. Isso indica que estamos usando o TCP como o protocolo. Esse esquema também foi indicado anteriormente no arquivo de configuração, quando NetTcpRelayBinding foi especificado como a associação.

Para este tutorial, o URI é sb://putServiceNamespaceHere.windows.net/EchoService.

Criar e configurar o host de serviço

Ainda trabalhando em Main(), defina o modo de conectividade como AutoDetect.
```
ServiceBusEnvironment.SystemConnectivity.Mode = ConnectivityMode.AutoDetect;
```
O modo de conectividade descreve o protocolo que o serviço usa para comunicar-se com o serviço de retransmissão, HTTP ou TCP. Usando a configuração padrão AutoDetect, o serviço tentará se conectar à Retransmissão do Azure via TCP se ele estiver disponível e via HTTP se o TCP não estiver disponível. Esse resultado difere do protocolo que o serviço especifica para a comunicação do cliente. Esse protocolo é determinado pela associação usada. Por exemplo, um serviço pode usar a associação BasicHttpRelayBinding, que especifica que o ponto de extremidade comunica-se com clientes por HTTP. Esse mesmo serviço pode especificar ConnectivityMode.AutoDetect, de modo que o serviço se comunique com a Retransmissão do Azure via TCP.
Crie o host de serviço, usando o endereço URI criado anteriormente nesta seção.
```
ServiceHost host = new ServiceHost(typeof(EchoService), address);
```
O host de serviço é o objeto WCF que instancia o serviço. Aqui, você passará a ele o tipo de serviço que deseja criar, um tipo EchoService e também o endereço no qual deseja expor o serviço.
Na parte superior do arquivo Program.cs, adicione referências a System.ServiceModel.Description e Microsoft.ServiceBus.Description.
```
using System.ServiceModel.Description;
using Microsoft.ServiceBus.Description;
```
De volta em Main(), configure o ponto de extremidade para habilitar o acesso público.
```
IEndpointBehavior serviceRegistrySettings = new ServiceRegistrySettings(DiscoveryType.Public);
```
Essa etapa informa o serviço de retransmissão que o aplicativo pode ser encontrado publicamente examinando o feed Atom do projeto. Se você definir DiscoveryType como private, um cliente ainda poderá acessar o serviço. No entanto, o serviço não será exibido quando ele pesquisar o namespace Relay. Em vez disso, o cliente precisaria saber o caminho do ponto de extremidade com antecedência.
Aplique as credenciais de serviço aos pontos de extremidade de serviço definidos no arquivo App.config:
```
foreach (ServiceEndpoint endpoint in host.Description.Endpoints)
{
    endpoint.Behaviors.Add(serviceRegistrySettings);
    endpoint.Behaviors.Add(sasCredential);
}
```
Conforme mencionado anteriormente, você poderia ter declarado vários serviços e pontos de extremidade no arquivo de configuração. Se você tivesse feito isso, esse código percorreria o arquivo de configuração e procuraria por cada ponto de extremidade ao qual ele devesse aplicar suas credenciais. Para este tutorial, o arquivo de configuração só tem um ponto de extremidade.

Abrir o host de serviço

Ainda em Main(), adicione a linha a seguir para abrir o serviço.
```
host.Open();
```

Informe ao usuário que o serviço está em execução e explique como desligá-lo.

Console.WriteLine("Service address: " + address);
Console.WriteLine("Press [Enter] to exit");
Console.ReadLine();

Quando terminar, feche o host do serviço.
```
host.Close();
```
Selecione Ctrl+Shift+B para compilar o projeto.

Exemplo que hospeda um serviço em um aplicativo de console

O código de serviço concluído deve aparecer conforme demonstrado a seguir. O código inclui o contrato e a implementação de serviço das etapas anteriores no tutorial e hospeda o serviço em um aplicativo de console.

using System;
using System.ServiceModel;
using System.ServiceModel.Description;
using Microsoft.ServiceBus;
using Microsoft.ServiceBus.Description;

namespace Microsoft.ServiceBus.Samples
{
    [ServiceContract(Name = "IEchoContract", Namespace = "https://samples.microsoft.com/ServiceModel/Relay/")]
    public interface IEchoContract
    {
        [OperationContract]
        String Echo(string text);
    }

    public interface IEchoChannel : IEchoContract, IClientChannel { };

    [ServiceBehavior(Name = "EchoService", Namespace = "https://samples.microsoft.com/ServiceModel/Relay/")]
    class EchoService : IEchoContract
    {
        public string Echo(string text)
        {
            Console.WriteLine("Echoing: {0}", text);
            return text;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {

            ServiceBusEnvironment.SystemConnectivity.Mode = ConnectivityMode.AutoDetect;         

            Console.Write("Your Service Namespace: ");
            string serviceNamespace = Console.ReadLine();
            Console.Write("Your SAS key: ");
            string sasKey = Console.ReadLine();

           // Create the credentials object for the endpoint.
            TransportClientEndpointBehavior sasCredential = new TransportClientEndpointBehavior();
            sasCredential.TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider("RootManageSharedAccessKey", sasKey);

            // Create the service URI based on the service namespace.
            Uri address = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, "EchoService");

            // Create the service host reading the configuration.
            ServiceHost host = new ServiceHost(typeof(EchoService), address);

            // Create the ServiceRegistrySettings behavior for the endpoint.
            IEndpointBehavior serviceRegistrySettings = new ServiceRegistrySettings(DiscoveryType.Public);

            // Add the Relay credentials to all endpoints specified in configuration.
            foreach (ServiceEndpoint endpoint in host.Description.Endpoints)
            {
                endpoint.Behaviors.Add(serviceRegistrySettings);
                endpoint.Behaviors.Add(sasCredential);
            }

            // Open the service.
            host.Open();

            Console.WriteLine("Service address: " + address);
            Console.WriteLine("Press [Enter] to exit");
            Console.ReadLine();

            // Close the service.
            host.Close();
        }
    }
}

Criar um cliente WCF para o contrato de serviço

A próxima tarefa é criar um aplicativo cliente e definir o contrato de serviço que você implementará mais adiante. Essas etapas se assemelham àquelas usadas para criar um serviço: definir um contrato, editar um arquivo App.config, usar as credenciais para se conectar ao serviço de retransmissão etc. O código usado para essas tarefas é fornecido no exemplo logo após o procedimento.

Crie um projeto na solução atual do Visual Studio para o cliente:
1. No Gerenciador de Soluções, clique com o botão direito do mouse na solução atual (não no projeto) e selecione Adicionar>Novo Projeto.
2. Em Adicionar um novo projeto, selecione Aplicativo de Console (.NET Framework) para C# e Avançar.
3. Nomeie o projeto EchoClient e selecione Criar.
No Gerenciador de Soluções, no projeto EchoClient, clique duas vezes em Program.cs para abrir o arquivo no editor, caso ele já não esteja aberto.
Altere o nome do namespace de seu padrão EchoClient para Microsoft.ServiceBus.Samples.
Instale o pacote NuGet do Barramento de Serviço:
1. No Gerenciador de Soluções, clique com o botão direito do mouse em EchoClient e, em seguida, selecione Gerenciar Pacotes NuGet.
2. Selecione Procurar e, em seguida, pesquise e selecione WindowsAzure.ServiceBus. Selecione Instalar e aceite os termos de uso.
Adicione uma instrução using ao namespace System.ServiceModel no arquivo Program.cs.
```
using System.ServiceModel;
```

Adicione a definição de contrato de serviço ao namespace, conforme mostrado no exemplo a seguir. Essa definição é idêntica à definição usada no projeto Service. Adicione esse código à parte superior do namespace Microsoft.ServiceBus.Samples.

[ServiceContract(Name = "IEchoContract", Namespace = "https://samples.microsoft.com/ServiceModel/Relay/")]
public interface IEchoContract
{
    [OperationContract]
    string Echo(string text);
}

public interface IEchoChannel : IEchoContract, IClientChannel { }

Selecione Ctrl+Shift+B para compilar o cliente.

Exemplo do projeto EchoClient

O código a seguir mostra o status atual do arquivo Program.cs no projeto EchoClient.

using System;
using Microsoft.ServiceBus;
using System.ServiceModel;

namespace Microsoft.ServiceBus.Samples
{

    [ServiceContract(Name = "IEchoContract", Namespace = "https://samples.microsoft.com/ServiceModel/Relay/")]
    public interface IEchoContract
    {
        [OperationContract]
        string Echo(string text);
    }

    public interface IEchoChannel : IEchoContract, IClientChannel { }


    class Program
    {
        static void Main(string[] args)
        {
        }
    }
}

Configurar o cliente WCF

Nesta etapa, você criará um arquivo App.config para um aplicativo cliente básico que acessa o serviço criado anteriormente neste tutorial. Esse arquivo App.config define o contrato, a associação e o nome do ponto de extremidade. O código usado para essas tarefas é fornecido no exemplo logo após o procedimento.

No Gerenciador de Soluções, no projeto EchoClient, clique duas vezes em App.config para abrir o arquivo no editor do Visual Studio.
No elemento <appSettings>, substitua os espaços reservados pelo nome do seu namespace de serviço e a chave SAS copiada em uma etapa anterior.
Dentro do elemento system.serviceModel, adicione um elemento <client>.
```
<?xmlversion="1.0" encoding="utf-8"?>
<configuration>
  <system.serviceModel>
    <client>
    </client>
  </system.serviceModel>
</configuration>
```
Esse código declara que você está definindo um aplicativo cliente no estilo WCF.
Dentro do elemento client, defina o nome, o contrato e o tipo de associação para o ponto de extremidade.
```
<endpoint name="RelayEndpoint"
                contract="Microsoft.ServiceBus.Samples.IEchoContract"
                binding="netTcpRelayBinding"/>
```
Esse código define o nome do ponto de extremidade. Ele também define o contrato definido no serviço e o fato de que o aplicativo cliente usa o TCP para se comunicar com a Retransmissão do Azure. O nome do ponto de extremidade é usado na próxima etapa para vincular esta configuração de ponto de extremidade com o URI do serviço.
Selecione Arquivo>Salvar Todos.

Exemplo do arquivo App.config

O código a seguir mostra o arquivo App.config para o cliente Echo.

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.serviceModel>
    <client>
      <endpoint name="RelayEndpoint"
                      contract="Microsoft.ServiceBus.Samples.IEchoContract"
                      binding="netTcpRelayBinding"/>
    </client>
    <extensions>
      <bindingExtensions>
        <add name="netTcpRelayBinding"
                    type="Microsoft.ServiceBus.Configuration.NetTcpRelayBindingCollectionElement, Microsoft.ServiceBus, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
      </bindingExtensions>
    </extensions>
  </system.serviceModel>
</configuration>

Implementar o cliente WCF

Nesta seção, você implementará um aplicativo cliente básico que acessa o serviço criado anteriormente neste tutorial. Semelhante ao serviço, o cliente executa muitas das mesmas operações para acessar a Retransmissão do Azure:

Define o modo de conectividade.
Cria o URI que localiza o serviço de host.
Define as credenciais de segurança.
Aplica as credenciais à conexão.
Abre a conexão.
Executa as tarefas específicas do aplicativo.
Encerra a conexão.

No entanto, uma das principais diferenças é que o aplicativo cliente usa um canal para se conectar ao serviço de retransmissão. O serviço usa uma chamada a ServiceHost. O código usado para essas tarefas é fornecido no exemplo logo após o procedimento.

Implementar um aplicativo cliente

Defina o modo de conectividade para AutoDetect. Adicione o código a seguir dentro do método Main() do aplicativo EchoClient.
```
ServiceBusEnvironment.SystemConnectivity.Mode = ConnectivityMode.AutoDetect;
```

Defina variáveis para conter os valores para o namespace de serviço e a chave SAS que são lidos do console.

Console.Write("Your Service Namespace: ");
string serviceNamespace = Console.ReadLine();
Console.Write("Your SAS Key: ");
string sasKey = Console.ReadLine();

Crie o URI que define o local do host em seu projeto de Retransmissão.

Uri serviceUri = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, "EchoService");

Crie o objeto de credencial para o ponto de extremidade do namespace de serviço.

TransportClientEndpointBehavior sasCredential = new TransportClientEndpointBehavior();
sasCredential.TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider("RootManageSharedAccessKey", sasKey);

Crie a fábrica de canais que carrega a configuração descrita no arquivo App.config.
```
ChannelFactory<IEchoChannel> channelFactory = new ChannelFactory<IEchoChannel>("RelayEndpoint", new EndpointAddress(serviceUri));
```
Uma fábrica de canais é um objeto WCF que cria um canal por meio do qual o os aplicativos cliente e de serviço se comunicam.

Aplique as credenciais.

channelFactory.Endpoint.Behaviors.Add(sasCredential);

Crie e abra o canal para o serviço.

IEchoChannel channel = channelFactory.CreateChannel();
channel.Open();

Escreva a interface do usuário básico e a funcionalidade para o eco.

Console.WriteLine("Enter text to echo (or [Enter] to exit):");
string input = Console.ReadLine();
while (input != String.Empty)
{
    try
    {
        Console.WriteLine("Server echoed: {0}", channel.Echo(input));
    }
    catch (Exception e)
    {
        Console.WriteLine("Error: " + e.Message);
    }
    input = Console.ReadLine();
}

O código usa a instância do objeto do canal como um proxy para o serviço.

Feche o canal e a fábrica.

channel.Close();
channelFactory.Close();

Exemplo de código para este tutorial

O código concluído deve ser exibido conforme mostrado a seguir. Esse código mostra como criar um aplicativo cliente, como chamar as operações do serviço e como fechar o cliente após a conclusão da chamada da operação.

using System;
using Microsoft.ServiceBus;
using System.ServiceModel;

namespace Microsoft.ServiceBus.Samples
{
    [ServiceContract(Name = "IEchoContract", Namespace = "https://samples.microsoft.com/ServiceModel/Relay/")]
    public interface IEchoContract
    {
        [OperationContract]
        String Echo(string text);
    }

    public interface IEchoChannel : IEchoContract, IClientChannel { }

    class Program
    {
        static void Main(string[] args)
        {
            ServiceBusEnvironment.SystemConnectivity.Mode = ConnectivityMode.AutoDetect;


            Console.Write("Your Service Namespace: ");
            string serviceNamespace = Console.ReadLine();
            Console.Write("Your SAS Key: ");
            string sasKey = Console.ReadLine();



            Uri serviceUri = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, "EchoService");

            TransportClientEndpointBehavior sasCredential = new TransportClientEndpointBehavior();
            sasCredential.TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider("RootManageSharedAccessKey", sasKey);

            ChannelFactory<IEchoChannel> channelFactory = new ChannelFactory<IEchoChannel>("RelayEndpoint", new EndpointAddress(serviceUri));

            channelFactory.Endpoint.Behaviors.Add(sasCredential);

            IEchoChannel channel = channelFactory.CreateChannel();
            channel.Open();

            Console.WriteLine("Enter text to echo (or [Enter] to exit):");
            string input = Console.ReadLine();
            while (input != String.Empty)
            {
                try
                {
                    Console.WriteLine("Server echoed: {0}", channel.Echo(input));
                }
                catch (Exception e)
                {
                    Console.WriteLine("Error: " + e.Message);
                }
                input = Console.ReadLine();
            }

            channel.Close();
            channelFactory.Close();

        }
    }
}

Executar os aplicativos

Selecione Ctrl+Shift+B para compilar a solução. Essa ação compila o projeto de cliente e o projeto de serviço criados nas etapas anteriores.
Antes de executar o aplicativo cliente, verifique se o aplicativo de serviço está em execução. Em Gerenciador de Soluções, clique com o botão direito do mouse na solução EchoService e, em seguida, selecione Propriedades.
Em Páginas de Propriedades, Propriedades Comuns>Projeto de Inicialização, escolha Vários projetos de inicialização. Verifique se EchoService aparece primeiro na lista.
Defina a caixa Ação dos projetos EchoService e EchoClient para Iniciar.
Selecione Dependências do Projeto. Em Projetos, selecione EchoClient. Em Depende de, verifique se EchoService está selecionado.
Selecione OK para fechar as Páginas de Propriedades.
Selecione F5 para executar os dois projetos.
Ambas as janelas do console serão abertas e o nome do namespace será solicitado. O serviço precisa ser executado primeiro, portanto, na janela do console de EchoService, insira o namespace e, em seguida, selecione Enter.
Em seguida, o console solicitará sua chave SAS. Insira a chave SAS e selecione Enter.

Eis um exemplo de saída da janela do console. Os valores aqui são apenas exemplos.

Your Service Namespace: myNamespace

Your SAS Key: <SAS key value>

O aplicativo de serviço imprime na janela do console o endereço no qual ele está escutando, como visto no exemplo a seguir.

Service address: sb://mynamespace.servicebus.windows.net/EchoService/

Press [Enter] to exit
Na janela do console EchoClient, digite as mesmas informações inseridas anteriormente para o aplicativo de serviço. Insira os mesmos valores do namespace de serviço e da chave SAS para o aplicativo cliente.
Depois de inserir esses valores, o cliente abre um canal para o serviço e solicita que você digite algum texto, como visto no exemplo de saída do console a seguir.

Enter text to echo (or [Enter] to exit):

Insira um texto para ser enviado ao aplicativo de serviço e selecione Enter. Esse texto é enviado para o serviço por meio da operação de serviço Echo e aparece na janela do console de serviço como a saída de exemplo a seguir.

Echoing: My sample text

O aplicativo cliente recebe o valor retornado da operação Echo, que é o texto original, e o exibe na janela do console. O texto a seguir é uma saída de exemplo da janela do console do cliente.

Server echoed: My sample text
Você pode continuar a enviar mensagens de texto do cliente para o serviço dessa maneira. Quando terminar, selecione Enter nas janelas do console de cliente e de serviço para encerrar os dois aplicativos.

Próximas etapas

Vá para o tutorial a seguir:

Expor um serviço REST WCF local a um cliente fora da rede

Compartilhar via