Tutorial: Expor um serviço REST de WCF no local a um cliente externo com o Reencaminhamento do WCF do Azure

Artigo
08/11/2023

Este tutorial descreve como criar uma aplicação cliente de Reencaminhamento de WCF e um serviço com o Reencaminhamento do Azure. Tal como os seus homólogos originais do WCF, um serviço é uma construção que expõe um ou mais pontos finais. Cada ponto final expõe uma ou mais operações de serviço. O ponto final de um serviço especifica um endereço onde o serviço pode ser encontrado, um enlace que contém as informações que um cliente tem de comunicar com o serviço e um contrato que define a funcionalidade fornecida pelo serviço aos seus clientes. A principal diferença entre o Reencaminhamento de WCF e WCF é que o ponto final é exposto na cloud em vez de localmente no seu computador.

Depois de trabalhar na sequência de secções neste tutorial, terá um serviço em execução. Também terá um cliente que pode invocar as operações do serviço.

Efetue as seguintes tarefas neste tutorial:

Instale os pré-requisitos deste tutorial.
Criar um espaço de nomes de Reencaminhamento.
Crie um contrato de serviço WCF.
Implemente o contrato do WCF.
Aloje e execute o serviço WCF para se registar no serviço reencaminhamento.
Crie um cliente WCF para o contrato de serviço.
Configure o cliente WCF.
Implemente o cliente WCF.
Execute as aplicações.

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 utilizam o Visual Studio 2019.
SDK do Azure para .NET. Instale-o a partir da página de transferências do SDK.

Criar um espaço de nomes de Reencaminhamento

O primeiro passo é criar um espaço de nomes e obter uma chave de Assinatura de Acesso Partilhado (SAS). Um espaço de nomes fornece um limite de aplicação para cada aplicação exposta através do serviço de reencaminhamento. Uma chave SAS é gerada automaticamente pelo sistema quando é criado um espaço de nomes de serviço. A combinação de espaço de nomes de serviço e chave SAS fornece as credenciais para o Azure autenticar o acesso a uma aplicação.

Inicie sessão no portal do Azure.
Selecione Todos os serviços no menu esquerdo. Selecione Integração, procure Reencaminhamentos, mova o rato sobre Reencaminhamentos e, em seguida, selecione Criar.
Na página Criar espaço de nomes , siga estes passos:
1. Escolha uma subscrição do Azure na qual pretende criar o espaço de nomes.
2. Em Grupo de recursos, escolha um grupo de recursos existente no qual colocar o espaço de nomes ou crie um novo.
3. Introduza um nome para o espaço de nomes reencaminhamento.
4. Selecione a região na qual o espaço de nomes deve ser alojado.
5. Selecione Rever + criar na parte inferior da página.
6. Na página Rever + criar , selecione Criar.
7. Após alguns minutos, verá a página Reencaminhamento do espaço de nomes.

Obter credenciais de gestão

Na página Reencaminhamento , selecione Políticas de acesso partilhado no menu esquerdo. `
Na página Políticas de acesso partilhado , selecione RootManageSharedAccessKey.
Em Política SAS: RootManageSharedAccessKey, selecione o botão Copiar junto a Cadeia de Ligação Primária. Esta ação copia a cadeia de ligação para a área de transferência para utilização 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 as operações suportadas pelo serviço. As operações são métodos ou funções do 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 numa interface com 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 alargada sobre contratos e serviços, veja Designing and Implementing Services (Estruturar e Implementar Serviços).

Criar um contrato de reencaminhamento com uma interface

Inicie o Microsoft Visual Studio como administrador. Para tal, clique com o botão direito do rato no ícone do programa do Visual Studio e selecione Executar como administrador.
No Visual Studio, selecione Criar um novo projeto.
Em Criar um novo projeto, selecione Aplicação de Consola (.NET Framework) para C# e selecione Seguinte.
Atribua um nome ao projeto EchoService e selecione Criar.
No Explorador de Soluções, clique com o botão direito do rato no projeto e selecione Gerir Pacotes NuGet. No Gestor de Pacotes NuGet, selecione Procurar e, em seguida, procure e escolha WindowsAzure.ServiceBus. Selecione Instalar e aceite os termos de utilização.

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 de 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 utiliza o espaço de nomes Microsoft.ServiceBus.Samples C# que é o espaço de nomes do tipo gerido baseado no contrato que é utilizado no ficheiro de configuração na secção Configurar o cliente WCF . Pode especificar qualquer espaço de nomes que pretenda quando criar este exemplo. No entanto, o tutorial não funcionará, a menos que modifique os espaços de nomes do contrato e do serviço em conformidade, no ficheiro de configuração da aplicação. O espaço de nomes especificado no ficheiro App.config tem de ser o mesmo que o espaço de nomes especificado nos seus ficheiros C#.
Diretamente após a declaração do Microsoft.ServiceBus.Samples espaço de nomes, mas no espaço de nomes, defina uma nova interface com o nome IEchoContract e aplique o ServiceContractAttribute atributo à interface com um valor de espaço de nomes de https://samples.microsoft.com/ServiceModel/Relay/. Cole o seguinte código após a declaração de espaço de nomes:
```
[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 contrato de serviço antigo 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 espaço de nomes do contrato de serviço não contém informações de versão.
IEchoContract Na interface, declare um método para a operação única que o IEchoContract contrato expõe na interface e aplique o OperationContractAttribute atributo ao método que pretende expor como parte do contrato de Reencaminhamento do WCF público, da seguinte forma:
```
[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, irá escrever código no canal para ecoar informações entre as duas aplicações.
Selecione Compilar>Solução de Compilação ou selecione Ctrl+Shift+B para confirmar a precisão do seu trabalho até agora.

Exemplo de um contrato de WCF

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

Implementar o contrato do WCF

Criar um reencaminhamento do Azure requer que crie primeiro o contrato com uma interface. Para obter mais informações sobre como criar a interface, consulte a secção anterior. O procedimento seguinte implementa a interface. Esta tarefa envolve a criação de uma classe com o nome EchoService que implementa a interface definida pelo IEchoContract utilizador. Depois de implementar a interface, configure a interface com um ficheiro de configuração App.config . O ficheiro de configuração contém as informações necessárias para a aplicação. Estas informações incluem o nome do serviço, o nome do contrato e o tipo de protocolo utilizado para comunicar com o serviço de reencaminhamento. O código utilizado para estas tarefas é fornecido no exemplo que segue o procedimento. Para uma discussão mais geral sobre como implementar um contrato de serviço, veja Implementar 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 Compilar>Solução de Compilação ou selecione Ctrl+Shift+B.

Definir a configuração para o anfitrião de serviços

O ficheiro de configuração é semelhante a um ficheiro de configuração wcF. Inclui o nome do serviço, o ponto final e o enlace. O ponto final é a localização que o Azure Relay expõe para os clientes e anfitriões comunicarem entre si. O enlace é o tipo de protocolo utilizado para comunicar. A principal diferença é que este ponto final de serviço configurado se refere a um enlace NetTcpRelayBinding, que não faz parte do .NET Framework. NetTcpRelayBinding é um dos enlaces definidos pelo serviço.

No Explorador de Soluções, faça duplo clique App.config para abrir o ficheiro no editor do Visual Studio.
<appSettings> No elemento , substitua os marcadores de posição pelo nome do espaço de nomes do Reencaminhamento do Azure e a chave SAS que copiou num passo anterior.
Dentro das etiquetas <system.serviceModel>, adicione um elemento <services>. Pode definir várias aplicações de reencaminhamento num único ficheiro 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 utiliza este passo para criar um URI que expõe totalmente o anfitrião através do Reencaminhamento do Azure. O enlace declara que estamos a utilizar o TCP como protocolo para comunicar com o serviço de reencaminhamento.
Selecione Compilar>Solução de Compilação ou selecione Ctrl+Shift+B para confirmar a precisão do seu trabalho até agora.

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

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 seguinte mostra o formato básico do ficheiro App.config associado ao anfitrião do 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>

Alojar e executar o serviço WCF para se registar no serviço de reencaminhamento

Este passo descreve como executar um serviço de Reencaminhamento do Azure.

Criar as credenciais de reencaminhamento

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á utilizada mais tarde para aceder ao seu projeto. O espaço de nomes é passado como parâmetro em CreateServiceUri para criar um URI de serviço.

Com um objeto TransportClientEndpointBehavior , declare que vai utilizar 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

Depois do código que adicionou na secçã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 do esquema do Service Bus. Indica que estamos a utilizar o TCP como protocolo. Este esquema também foi indicado anteriormente no ficheiro de configuração, quando NetTcpRelayBinding foi especificado como o enlace.

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

Criar e configurar o anfitrião do serviço

Ainda a trabalhar 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 utiliza para comunicar com o serviço de reencaminhamento; HTTP ou TCP. Com a predefinição AutoDetect, o serviço tenta ligar ao Reencaminhamento do Azure através de TCP se estiver disponível e HTTP se o TCP não estiver disponível. Este resultado difere do protocolo especificado pelo serviço para a comunicação do cliente. Esse protocolo é determinado pelo enlace utilizado. Por exemplo, um serviço pode utilizar o enlace BasicHttpRelayBinding , que especifica que o ponto final comunica com os clientes através de HTTP. Esse mesmo serviço pode especificar ConnectivityMode.AutoDetect para que o serviço comunique com o Reencaminhamento do Azure através de 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, transmite-lhe o tipo de serviço que pretende criar, um EchoService tipo e também o endereço no qual pretende expor o serviço.
Na parte superior do ficheiro 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);
```
Este passo informa o serviço de reencaminhamento de que a sua aplicação pode ser encontrada publicamente ao examinar o feed Atom do projeto. Se definir DiscoveryType como private, um cliente ainda poderá aceder ao serviço. No entanto, o serviço não apareceria quando pesquisasse o Relay espaço de nomes. Em vez disso, o cliente terá de conhecer de antemão o percurso do ponto final.
Aplique as credenciais de serviço aos pontos finais de serviço definidos no ficheiro deApp.config :
```
foreach (ServiceEndpoint endpoint in host.Description.Endpoints)
{
    endpoint.Behaviors.Add(serviceRegistrySettings);
    endpoint.Behaviors.Add(sasCredential);
}
```
Conforme indicado anteriormente, poderia ter declarado vários serviços e pontos finais no ficheiro 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. Neste tutorial, o ficheiro de configuração tem apenas um ponto final.

Abrir o anfitrião do 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 aloja um serviço numa aplicação de consola

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 dos passos anteriores no tutorial e aloja o serviço numa aplicação de consola.

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 consiste em criar uma aplicação cliente e definir o contrato de serviço que irá implementar mais tarde. Estes passos assemelham-se aos passos utilizados para criar um serviço: definir um contrato, editar um ficheiro deApp.config , utilizar credenciais para ligar ao serviço de reencaminhamento, etc. 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 Explorador de Soluções, clique com o botão direito do rato na solução atual (não no projeto) e selecione Adicionar>Novo Projeto.
2. Em Adicionar um novo projeto, selecione Aplicação de Consola (.NET Framework) para C#e selecione Seguinte.
3. Dê um nome ao projeto EchoClient e selecione Criar.
No Explorador de Soluções, no projeto EchoClient , faça duplo clique em Program.cs para abrir o ficheiro no editor, se 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 Explorador de Soluções, clique com o botão direito do rato em EchoClient e, em seguida, selecione Gerir Pacotes NuGet.
2. Selecione Procurar e, em seguida, procure e selecione WindowsAzure.ServiceBus. Selecione Instalar e aceite os termos de utilização.
Adicione uma using instrução para o espaço de nomes System.ServiceModel no ficheiro 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 utilizada no projeto Serviço . Adicione este código na parte superior do Microsoft.ServiceBus.Samples espaço de nomes.
```
[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 seguinte mostra o estado atual do ficheiro 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

Neste passo, vai criar um ficheiro App.config para uma aplicação cliente básica que acede ao serviço criado anteriormente neste tutorial. Este ficheiroApp.config define o contrato, o enlace e o nome do ponto final. O código utilizado para estas tarefas surge no exemplo que segue o procedimento.

No Explorador de Soluções, no projeto EchoClient , faça duplo clique App.config para abrir o ficheiro 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.

system.serviceModel No elemento , adicione um <client> elemento.

<?xmlversion="1.0" encoding="utf-8"?>
<configuration>
  <system.serviceModel>
    <client>
    </client>
  </system.serviceModel>
</configuration>

Este código declara que está a definir uma aplicação cliente de 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"/>
```
Este código define o nome do ponto final. Também define o contrato definido no serviço e o facto de a aplicação cliente utilizar TCP para comunicar com o Reencaminhamento do Azure. O nome do ponto final é utilizado no próximo passo para ligar esta configuração de ponto final com o URI do serviço.
SelecioneGuardar Todos os Ficheiros>.

Exemplo do ficheiro de App.config

O código seguinte mostra o ficheiro deApp.config do 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 secção, vai implementar uma aplicação cliente básica que acede ao serviço que criou anteriormente neste tutorial. Semelhante ao serviço, o cliente faz muitas das mesmas operações para aceder ao 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 a aplicação cliente utiliza um canal para ligar ao serviço de reencaminhamento. O serviço utiliza uma chamada para ServiceHost. O código utilizado para estas tarefas surge no exemplo que segue o procedimento.

Implementar uma aplicação 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 a localização do anfitrião no projeto reencaminhamento.

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 ficheiro 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 utiliza 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 concluído deverá ser apresentado da seguinte forma. Este código mostra como criar uma aplicação 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 de cliente e o projeto de serviço que criou nos passos 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 Explorador de Soluções, clique com o botão direito do rato na solução EchoService e, em seguida, selecione Propriedades.
Em Páginas de Propriedades,Projeto de Arranque de Propriedades> Comuns e, em seguida, selecione Vários projetos de arranque. 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. Em Depende de, certifique-se de que EchoService está selecionado.
Selecione OK para fechar 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 tem de ser executado primeiro, por isso, na janela da consola EchoService , introduza o espaço de nomes e, em seguida, selecione Enter.
Em seguida, a consola pede-lhe a sua chave SAS. Introduza a chave SAS e selecione Enter.

Eis o resultado de exemplo da janela da consola. 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. Introduza o mesmo espaço de nomes de serviço e valores de chave SAS para a aplicação cliente.
Depois de introduzir estes valores, o cliente abrirá um canal para o serviço e pede-lhe que introduza algum texto, conforme se verifica no seguinte exemplo de saída de consola.

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

Introduza algum texto para enviar para a aplicação 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 seguinte texto é o resultado de exemplo da janela da consola do cliente.

Server echoed: My sample text
Pode continuar a enviar mensagens de texto do cliente para o serviço desta forma. Quando tiver terminado, selecione Enter nas janelas do cliente e da consola de serviços para terminar ambas as aplicações.

Passos seguintes

Avançar para o tutorial seguinte:

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