Tutorial: Expor um serviço REST do Windows Communication Foundation (WCF) local ao cliente externo usando o Azure WCF Relay

Artigo
12/11/2024

Este tutorial descreve como criar um aplicativo cliente WCF Relay e um serviço usando o Azure Relay. Como seus homólogos WCF originais, um serviço é uma construção 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 de um serviço especifica um endereço onde o serviço pode ser encontrado, uma associação que contém as informações que um cliente deve se comunicar com o serviço e um contrato que define a funcionalidade fornecida pelo serviço a seus clientes. A principal diferença entre o WCF e o WCF Relay é que o ponto de extremidade é exposto na nuvem em vez de localmente no seu computador.

Depois de trabalhar na sequência de seções neste 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ê executa as seguintes tarefas neste tutorial:

Instale os pré-requisitos para este tutorial.
Crie um namespace de retransmissão.
Crie um contrato de serviço WCF.
Implementar o contrato WCF.
Hospede e execute o serviço WCF para se registrar no serviço de retransmissão.
Crie um cliente WCF para o contrato de serviço.
Configure o cliente WCF.
Implemente o cliente WCF.
Execute os aplicativos.

Pré-requisitos

Para concluir este tutorial, precisa dos seguintes pré-requisitos:

Uma subscrição do Azure. Se não tiver uma, crie uma conta gratuita antes de começar.
Visual Studio 2015 ou posterior. Os exemplos neste 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 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 é gerada automaticamente pelo sistema quando um namespace de serviço é criado. A combinação de namespace de serviço e chave SAS fornece as credenciais para o Azure autenticar o acesso a um aplicativo.

Inicie sessão no portal do Azure.
Selecione Todos os serviços no menu à esquerda. Selecione Integração, procure Relés, mova o rato sobre Relés e, em seguida, selecione Criar.
Na página Criar namespace, siga estas etapas:
1. Escolha uma assinatura do Azure na qual criar o namespace.
2. Para Grupo de recursos, escolha um grupo de recursos existente no qual colocar o namespace ou crie um novo.
3. Insira um nome para o namespace Relay.
4. Selecione a região na qual seu namespace deve ser hospedado.
5. Selecione Rever + criar na parte inferior da página.
6. Na página Rever + criar, selecione Criar.
7. Depois de alguns minutos, você verá a página Retransmissão para o namespace.

Obter credenciais de gestão

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 SAS: RootManageSharedAccessKey, selecione o botão Copiar ao lado de Cadeia de Conexão Primária. Esta ação copia a cadeia de conexão para a área de transferência para uso posterior. Cole este valor no Bloco de Notas ou noutra localização temporária.
Repita o passo anterior para copiar e colar o valor da Chave primária para uma localização temporária para utilizar mais tarde.

Definir um contrato de serviço WCF

O contrato de serviço especifica quais operações o serviço suporta. As operações são métodos ou funções de serviço Web. Os contratos são criados através da definição de uma interface em C++, C# ou Visual Basic. Cada método da interface corresponde a uma operação de serviço específica. Todas as interfaces devem ter aplicado o atributo ServiceContractAttribute e todas as operações devem ter aplicado o atributo OperationContractAttribute. 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 utilizado nestas tarefas surge no exemplo que segue o procedimento. Para uma discussão mais ampla sobre contratos e serviços, consulte Projetando e implementando serviços.

Criar um contrato de retransmissão com uma interface

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

Este pacote adiciona automaticamente referências às bibliotecas do Service Bus e ao WCF System.ServiceModel. System.ServiceModel é o espaço de nomes que permite o acesso através de programação às funcionalidades básicas do WCF. O Service Bus utiliza muitos dos objetos e atributos de WCF para definir os contratos de serviço.
Adicione as seguintes using instruções na parte superior do Program.cs:
```
using System.ServiceModel;
using Microsoft.ServiceBus;
```
Altere o nome do espaço de nomes a partir do respetivo nome predefinido de EchoService para Microsoft.ServiceBus.Samples.

Importante

Este tutorial usa o namespace Microsoft.ServiceBus.Samples 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 este exemplo. 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 do aplicativo. O namespace especificado no arquivo App.config deve ser o mesmo que o namespace especificado em seus arquivos C#.
Diretamente após a declaração de Microsoft.ServiceBus.Samples namespace, mas dentro do namespace, defina uma nova interface chamada IEchoContract e aplique o ServiceContractAttribute atributo à interface com um valor de namespace de https://samples.microsoft.com/ServiceModel/Relay/. Cole o seguinte código após a declaração de namespace:
```
[ServiceContract(Name = "IEchoContract", Namespace = "https://samples.microsoft.com/ServiceModel/Relay/")]
public interface IEchoContract
{
}
```
O valor do espaço de nomes difere do espaço de nomes que utiliza em todo o âmbito do seu código. Em vez disso, o valor do espaço de nomes utiliza-se como identificador exclusivo para este contrato. A especificação explícita do espaço de nomes impede que o valor de espaço de nomes predefinido seja adicionado ao nome do contrato.

Nota

Normalmente, o espaço de nomes do contrato de serviço contém um esquema de nomenclatura que inclui a informação da versão. Ao incluir a informação de versão no espaço de nomes de contrato de serviço, tal permite que os serviços possam isolar as alterações mais importantes, através da definição de um novo contrato de serviço com um novo espaço de nomes e a sua exposição num novo ponto final. Desta forma, os clientes podem continuar a utilizar o antigo contrato de serviço sem terem de ser atualizados. A informação de versão pode consistir numa data ou número de compilação. Para obter mais informações, consulte o artigo Controlo de Versões 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 IEchoContract interface, declare um método para a única operação que o IEchoContract contrato expõe na interface e aplique o OperationContractAttribute atributo ao método que você deseja expor como parte do contrato público WCF Relay, da seguinte maneira:
```
[OperationContract]
string Echo(string text);
```
Imediatamente depois da definição de interface IEchoContract, declare um canal que herda de IEchoContract e também da interface IClientChannel, conforme se mostra aqui:
```
public interface IEchoChannel : IEchoContract, IClientChannel { }
```
Um canal é o objeto de WCF através do qual o anfitrião e o cliente passam informações entre si. Mais tarde, você escreverá código no canal para ecoar informações entre os dois aplicativos.
Selecione Build>Build Solution ou selecione Ctrl+Shift+B para confirmar a precisão do seu trabalho até agora.

Exemplo de um contrato WCF

O código a seguir mostra uma interface básica que define um contrato de retransmissão 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, pode implementá-la.

Implementar o contrato WCF

Criar uma retransmissão do Azure requer que você primeiro crie o contrato usando uma interface. Para obter mais informações sobre como criar a interface, consulte a seção anterior. O próximo procedimento implementa a interface. Esta tarefa envolve a criação de uma classe chamada EchoService que implementa a interface definida IEchoContract pelo usuário. Depois de implementar a interface, configure a interface 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 que segue o procedimento. Para obter uma discussão mais geral sobre como implementar um contrato de serviço, consulte Implementando contratos de serviço.

Criar uma nova classe com o nome EchoService imediatamente depois da definição da interface IEchoContract. A classe EchoService implementa a interface IEchoContract.
```
class EchoService : IEchoContract
{
}
```
Tal como noutras implementações de interface, pode implementar a definição num ficheiro diferente. No entanto, neste tutorial, a implementação aparece no mesmo ficheiro que a definição de interface e o método Main().
Aplique o atributo ServiceBehaviorAttribute à interface IEchoContract. O atributo especifica o nome de serviço e o espaço de nomes. Depois de fazê-lo, aparecerá a classe EchoService da seguinte forma:
```
[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 Build>Build Solution ou selecione Ctrl+Shift+B.

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

O arquivo de configuração é semelhante a um arquivo de configuração WCF. Inclui o nome do serviço, o ponto de extremidade e a ligação. O ponto de extremidade é o local que o Azure Relay expõe para que clientes e hosts se comuniquem entre si. A ligação é o tipo de protocolo usado para se comunicar. 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 ligaçõ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 , substitua <appSettings> os espaços reservados pelo nome do seu namespace de Retransmissão do Azure e a chave SAS que você copiou em uma etapa anterior.
Dentro das etiquetas <system.serviceModel>, adicione um elemento <services>. Você pode definir vários aplicativos de retransmissão em um único arquivo de configuração. No entanto, este tutorial 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 a localização do contrato de ponto final, bem como o tipo de enlace para o ponto final.
```
<endpoint contract="Microsoft.ServiceBus.Samples.IEchoContract" binding="netTcpRelayBinding"/>
```
O ponto final define onde o cliente procurará a aplicação anfitriã. Mais tarde, o tutorial usa esta etapa para criar um URI que expõe totalmente o host por meio do Azure Relay. A associação declara que estamos usando TCP como o protocolo para nos comunicarmos com o serviço de retransmissão.
Selecione Build>Build Solution ou selecione Ctrl+Shift+B para confirmar a precisão do seu trabalho até agora.

Exemplo de execução de um contrato de prestação de serviços

O código seguinte 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>

Hospede e execute o serviço WCF para se registrar 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 para armazenar o espaço de nomes e a chave SAS que são lidos a partir da janela da consola.
```
Console.Write("Your Service Namespace: ");
string serviceNamespace = Console.ReadLine();
Console.Write("Your SAS key: ");
string sasKey = Console.ReadLine();
```
A chave SAS será usada posteriormente para acessar seu projeto. O espaço de nomes é passado como parâmetro em 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 seguinte código imediatamente depois do código adicionado no último passo.

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

Criar um endereço base para o serviço

Após o código adicionado na seção anterior, crie uma Uri instância para o endereço base do serviço. Este URI especifica o esquema de Service Bus, o espaço de nomes e o percurso da interface de serviço.

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

O valor "sb" é uma abreviatura para o esquema do Service Bus. Isso indica que estamos usando TCP como protocolo. Esse esquema também foi indicado anteriormente no arquivo de configuração, quando NetTcpRelayBinding foi especificado como a ligação.

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

Criar e configurar o host de serviço

Ainda a funcionar no 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 se comunicar com o serviço de retransmissão; HTTP ou TCP. Usando a configuração AutoDetectpadrão , o serviço tenta se conectar ao Azure Relay over TCP se estiver disponível e HTTP se o TCP não estiver disponível. Esse resultado difere do protocolo especificado pelo serviço para a comunicação com o cliente. Esse protocolo é determinado pelo enlace utilizado. Por exemplo, um serviço pode usar a ligação BasicHttpRelayBinding , que especifica que seu ponto de extremidade se comunica com clientes por HTTP. Esse mesmo serviço pode especificar ConnectivityMode.AutoDetect para que o serviço se comunique com o Azure Relay over TCP.
Crie o anfitrião do serviço, utilizando o URI criado anteriormente nesta secção.
```
ServiceHost host = new ServiceHost(typeof(EchoService), address);
```
O anfitrião do serviço é o objeto de WCF que cria uma instância no serviço. Aqui, você passa o tipo de serviço que deseja criar, um EchoService tipo e também para 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 novo em Main(), configure o ponto final para ativar o acesso público.
```
IEndpointBehavior serviceRegistrySettings = new ServiceRegistrySettings(DiscoveryType.Public);
```
Esta etapa informa ao serviço de retransmissão que seu aplicativo pode ser encontrado publicamente examinando o feed Atom para seu projeto. Se você definir DiscoveryType como private, um cliente ainda poderá acessar o serviço. No entanto, o serviço não aparece quando pesquisa o Relay namespace. Em vez disso, o cliente terá de conhecer de antemão o percurso do ponto final.
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);
}
```
Como dito anteriormente, você poderia ter declarado vários serviços e pontos de extremidade no arquivo de configuração. Se o tiver feito, este código percorreria o ficheiro de configuração e pesquisaria cada ponto final para o qual se devem aplicar as credenciais. Para este tutorial, o arquivo de configuração tem apenas um ponto de extremidade.

Abra o host de serviço

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

Informe o utilizador que o serviço está em execução e explique-lhe como encerrá-lo.

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

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

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

O código de serviço concluído deve aparecer da seguinte forma. O código inclui o contrato de serviço e a implementaçã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 tarde. Essas etapas se assemelham às etapas usadas para criar um serviço: definir um contrato, editar um arquivo App.config , usar credenciais para se conectar ao serviço de retransmissão e assim por diante. O código utilizado para estas tarefas surge no exemplo que segue o procedimento.

Crie um novo 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 selecione Avançar.
3. Especifique EchoClient como o nome do proejct e selecione Criar.
No Gerenciador de Soluções, no projeto EchoClient , clique duas vezes em Program.cs para abrir o arquivo no editor, se ele ainda não estiver aberto.
Altere o nome do espaço de nomes a partir do respetivo nome predefinido de EchoClient para Microsoft.ServiceBus.Samples.
Instale o pacote NuGet do Service Bus:
1. No Gerenciador de Soluções, clique com o botão direito do mouse em EchoClient e selecione Gerenciar Pacotes NuGet.
2. Selecione Procurar, procure e selecione WindowsAzure.ServiceBus. Selecione Instalar e aceite os termos de uso.
Adicione uma using instrução para o namespace System.ServiceModel no arquivo Program.cs .
```
using System.ServiceModel;
```

Adicione a definição do contrato de serviço ao espaço de nomes, conforme se mostra no exemplo seguinte. Esta definição é idêntica à definição usada no projeto Service . Adicione esse código na parte superior do Microsoft.ServiceBus.Samples namespace.

[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 criar 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 de WCF

Nesta etapa, você cria 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 utilizado para estas tarefas surge no exemplo que segue 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 marcadores de posição pelo nome do seu espaço de nomes do serviço e a chave SAS que copiou num passo anterior.
Dentro do system.serviceModel elemento , adicione um <client> elemento .
```
<?xmlversion="1.0" encoding="utf-8"?>
<configuration>
  <system.serviceModel>
    <client>
    </client>
  </system.serviceModel>
</configuration>
```
Este 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 enlace para o ponto final.
```
<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 TCP para se comunicar com o Azure Relay. O nome do ponto final é utilizado no próximo passo para ligar esta configuração de ponto final com o URI do serviço.
Selecione Arquivo>Salvar tudo.

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ê implementa um aplicativo cliente básico que acessa o serviço criado anteriormente neste tutorial. Semelhante ao serviço, o cliente faz muitas das mesmas operações para acessar o Azure Relay:

Define o modo de conectividade.
Cria o URI que localiza o serviço anfitrião.
Define as credenciais de segurança.
Aplica as credenciais para a ligação.
Abre a ligação.
Efetua as tarefas específicas da aplicação.
Fecha a ligaçã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 para ServiceHost. O código utilizado para estas tarefas surge no exemplo que segue o procedimento.

Implementar um aplicativo cliente

Defina o modo de conectividade como AutoDetect. Adicione o seguinte código dentro do método Main() da aplicação EchoClient.
```
ServiceBusEnvironment.SystemConnectivity.Mode = ConnectivityMode.AutoDetect;
```

Defina variáveis para conter os valores para o espaço de nomes do serviço e a chave SAS que são lidos desde a consola.

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 final do espaço de nomes do 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 de WCF que cria um canal através do qual comunicam as aplicações cliente e de serviço.

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 utilizador 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 de canal como um proxy para o serviço.

Feche o canal e feche a fábrica.

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

Código de exemplo para este tutorial

O código preenchido deve aparecer da seguinte forma. Este 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 de 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 as aplicações

Selecione Ctrl+Shift+B para criar a solução. Esta ação cria o projeto cliente e o projeto de serviço que você criou nas etapas anteriores.
Antes de executar a aplicação cliente, tem de se certificar de que a aplicação de serviço está em execução. No Gerenciador de Soluções, clique com o botão direito do mouse na solução EchoService e selecione Propriedades.
Em Property Pages, Common Properties Startup Project (Projeto de inicialização de propriedades>comuns) e escolha Vários projetos de inicialização. Certifique-se EchoService aparece em primeiro lugar na lista.
Defina a caixa Ação para os projetos EchoService e EchoClient para Iniciar.
Selecione Dependências do projeto. Em Projetos, selecione EchoClient. Para Depende de, verifique se EchoService está selecionado.
Selecione OK para fechar as Páginas de propriedades.
Selecione F5 para executar ambos os projetos.
Ambas as janelas de consola abrem-se e solicitam-lhe o nome do espaço de nomes. O serviço deve ser executado primeiro, portanto, na janela do console EchoService , insira o namespace e selecione Enter.
Em seguida, o console solicita a chave SAS. Digite a chave SAS e selecione Enter.

Aqui está 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>

A aplicação de serviço imprime na janela de consola o endereço no qual está a escutar, como se vê no exemplo a seguir.

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

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

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

Insira algum texto para enviar ao aplicativo de serviço e selecione Enter. Este texto é enviado para o serviço através da operação de serviço Eco e é apresentado na janela da consola de serviço, como se mostra na saída no exemplo seguinte.

Echoing: My sample text

A aplicação cliente recebe o valor devolvido da operação Echo, que é o texto original, e imprime-o para a janela de consola. O texto a seguir é uma saída de exemplo da janela do console do cliente.

Server echoed: My sample text
Pode continuar a enviar mensagens de texto do cliente para o serviço desta forma. Quando terminar, selecione Enter nas janelas do cliente e do console de serviço para encerrar ambos os aplicativos.

Próximo passo

Avançar para o tutorial seguinte:

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

Partilhar via