Kurz: Zveřejnění místní služby WCF REST externímu klientovi pomocí služby Azure WCF Relay

Článek
08/11/2023

Tento kurz popisuje, jak vytvořit klientskou aplikaci WCF Relay a službu pomocí Azure Relay. Stejně jako jejich původní protějšky WCF je služba konstruktor, který zveřejňuje jeden nebo více koncových bodů. Každý koncový bod zveřejňuje jednu nebo více operací služby. Koncový bod služby určuje adresu , kde lze službu najít, vazbu obsahující informace o tom, že klient musí se službou komunikovat, a kontrakt , který definuje funkce poskytované službou svým klientům. Hlavní rozdíl mezi WCF a WCF Relay spočívá v tom, že koncový bod je vystavený v cloudu, a ne místně na vašem počítači.

Až si projdete posloupnost částí v tomto kurzu, budete mít spuštěnou službu. Budete mít také klienta, který může vyvolat operace služby.

V tomto kurzu provedete následující úlohy:

Nainstalujte si požadavky pro tento kurz.
Vytvořte obor názvů služby Relay.
Vytvořte kontrakt služby WCF.
Implementujte kontrakt WCF.
Hostujte a spusťte službu WCF pro registraci ve službě Relay.
Vytvořte klienta WCF pro kontrakt služby.
Nakonfigurujte klienta WCF.
Implementujte klienta WCF.
Spusťte aplikace.

Požadavky

Pro absolvování tohoto kurzu musí být splněné následující požadavky:

Předplatné Azure. Pokud ho nemáte, vytvořte si bezplatný účet , než začnete.
Visual Studio 2015 nebo novější. Příklady v tomto kurzu používají Visual Studio 2019.
Azure SDK pro .NET. Nainstalujte ho ze stránky pro stažení sady SDK.

Vytvoření oboru názvů služby Relay

Prvním krokem je vytvoření oboru názvů a získání klíče sdíleného přístupového podpisu (SAS). Obor názvů poskytuje hranici aplikace pro každou aplikaci vystavenou prostřednictvím předávací služby. Při vytvoření oboru názvů služby se automaticky vygeneruje klíč SAS systémem. Kombinace oboru názvů služby a klíče SAS poskytuje přihlašovací údaje pro Azure k ověření přístupu k aplikaci.

Přihlaste se k webu Azure Portal.
V nabídce vlevo vyberte Všechny služby . Vyberte Integrace, vyhledejte Přenosy, najeďte myší na Relays a pak vyberte Vytvořit.
Na stránce Vytvořit obor názvů postupujte takto:
1. Zvolte předplatné Azure, ve kterém chcete obor názvů vytvořit.
2. V části Skupina prostředků zvolte existující skupinu prostředků, do které chcete obor názvů umístit, nebo vytvořte novou.
3. Zadejte název oboru názvů služby Relay.
4. Vyberte oblast, ve které má být váš obor názvů hostovaný.
5. V dolní části stránky vyberte Zkontrolovat a vytvořit .
6. Na stránce Zkontrolovat a vytvořit vyberte Vytvořit.
7. Po několika minutách se zobrazí stránka Relay pro obor názvů.

Získání přihlašovacích údajů pro správu

Na stránce Relay v nabídce vlevo vyberte Zásady sdíleného přístupu . `
Na stránce Zásady sdíleného přístupu vyberte RootManageSharedAccessKey.
V části Zásady SAS: RootManageSharedAccessKey vyberte tlačítko Kopírovat vedle položky Primární připojovací řetězec. Tato akce zkopíruje připojovací řetězec do schránky pro pozdější použití. Vložte tuto hodnotu do Poznámkového bloku nebo jiného dočasného umístění.
Zopakujte předchozí krok, zkopírujte si hodnotu primárního klíče a vložte ji do dočasného umístění pro pozdější použití.

Definování kontraktu služby WCF

Kontrakt služby určuje, jaké operace služba podporuje. Operace jsou metody nebo funkce webové služby. Kontrakty se vytvoří definováním základního rozhraní C++, C# nebo Visual Basic. Každá metoda v rozhraní odpovídá konkrétní operaci služby. Na každé rozhraní musí mít aplikovaný atribut ServiceContractAttribute a na každou operace musí byt aplikovaný atribut OperationContractAttribute. Pokud metoda v rozhraní, které má atribut ServiceContractAttribute , nemá atribut OperationContractAttribute , tato metoda se nezobrazí. Kód k těmto úlohám najdete v příkladu za postupem. Podrobnější informace o kontraktech a službách najdete v tématu Návrh a implementace služeb.

Vytvoření kontraktu přenosu s rozhraním

Spusťte Microsoft Visual Studio jako správce. Uděláte to tak, že kliknete pravým tlačítkem na ikonu programu Sady Visual Studio a vyberete Spustit jako správce.
V sadě Visual Studio vyberte Vytvořit nový projekt.
V části Vytvořit nový projekt zvolte Konzolová aplikace (.NET Framework) pro C# a vyberte Další.
Pojmenujte projekt EchoService a vyberte Vytvořit.
V Průzkumník řešení klikněte pravým tlačítkem na projekt a vyberte Spravovat balíčky NuGet. Ve Správci balíčků NuGet vyberte Procházet a pak vyhledejte a zvolte WindowsAzure.ServiceBus. Vyberte Nainstalovat a přijměte podmínky použití.

Tento balíček automaticky přidá odkazy na knihovny služby Service Bus a WCF System.ServiceModel. System.ServiceModel je obor názvů, který vám umožňuje programový přístup k základním funkcím WCF. Service Bus používá mnoho objektů a atributů WCF k definování kontraktů služby.
Na začátek souboru Program.cs přidejte následující using příkazy:
```
using System.ServiceModel;
using Microsoft.ServiceBus;
```
Změňte název oboru názvů z výchozího názvu EchoService na Microsoft.ServiceBus.Samples.

Důležité

Tento kurz používá obor názvů jazyka Microsoft.ServiceBus.Samples C#, což je obor názvů spravovaného typu založeného na kontraktu, který se používá v konfiguračním souboru v části Konfigurace klienta WCF . Při vytváření této ukázky můžete zadat libovolný obor názvů. Kurz však nebude fungovat, pokud pak odpovídajícím způsobem nezměníte obory názvů kontraktu a služby v konfiguračním souboru aplikace. Obor názvů zadaný v souboruApp.config musí být stejný jako obor názvů zadaný v souborech jazyka C#.
Přímo po Microsoft.ServiceBus.Samples deklaraci oboru názvů, ale v rámci oboru názvů, definujte nové rozhraní s názvem IEchoContract a použijte ServiceContractAttribute atribut na rozhraní s hodnotou https://samples.microsoft.com/ServiceModel/Relay/oboru názvů . Za deklaraci oboru názvů vložte následující kód:
```
[ServiceContract(Name = "IEchoContract", Namespace = "https://samples.microsoft.com/ServiceModel/Relay/")]
public interface IEchoContract
{
}
```
Hodnota oboru názvů se liší od oboru názvů, které používáte v celém svém kódu. Místo toho se obor názvů používá jako jedinečný identifikátor pro tento kontrakt. Když explicitně zadáte obor názvů, zabráníte tím přidání výchozí hodnoty oboru názvů do názvu kontraktu.

Poznámka

Obor názvů kontraktu služby obvykle obsahuje schéma pojmenování s informacemi o verzi. Informace o verzi, které jsou v oboru názvů kontraktu služby, službám umožňuje službám izolovat výrazné změny pomocí definice nové služby s novým oborem názvů, která bude vystavená na novém koncovém bodu. Klienti tak můžou dál používat starý kontrakt služby, aniž by bylo nutné ho aktualizovat. Informace o verzi může mít podobu data nebo čísla sestavení. Další informace najdete v článku o Správa verzí služeb. Pro účely tohoto kurzu schéma pojmenování oboru názvů kontraktu služby neobsahuje informace o verzi.
IEchoContract V rozhraní deklarujte metodu pro jednu operaciIEchoContract, kterou kontrakt zveřejňuje v rozhraní, a použijte OperationContractAttribute atribut na metodu, kterou chcete vystavit jako součást veřejného kontraktu WCF Relay, následujícím způsobem:
```
[OperationContract]
string Echo(string text);
```
Přímo po definici rozhraní IEchoContract deklarujte kanál, který zdědí vlastnosti z obou IEchoContract a také do rozhraní IClientChannel, jak je vidět tady:
```
public interface IEchoChannel : IEchoContract, IClientChannel { }
```
Kanál je objekt WCF, kterým si hostitel a klient navzájem posílají informace. Později napíšete kód proti kanálu, který bude reagovat na informace mezi těmito dvěma aplikacemi.
Vyberte Sestavit>řešení sestavení nebo stisknutím kombinace kláves Ctrl+Shift+B a potvrďte přesnost vaší dosavadní práce.

Příklad kontraktu WCF

Následující kód ukazuje základní rozhraní, které definuje kontrakt WCF Relay.

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)
        {
        }
    }
}

Když je teď vytvořené rozhraní, můžete ho implementovat.

Implementace kontraktu WCF

Vytvoření služby Azure Relay vyžaduje, abyste nejprve vytvořili kontrakt pomocí rozhraní. Další informace o vytvoření rozhraní najdete v předchozí části. Další postup implementuje rozhraní. Tato úloha zahrnuje vytvoření třídy s názvem EchoService , která implementuje uživatelsky definované IEchoContract rozhraní. Po implementaci rozhraní nakonfigurujete rozhraní pomocí konfiguračního souboruApp.config . Konfigurační soubor obsahuje potřebné informace pro aplikaci. Tyto informace zahrnují název služby, název smlouvy a typ protokolu, který se používá ke komunikaci se službou relay. Kód použitý pro tyto úlohy je uveden v příkladu, který následuje po postupu. Obecnější diskuzi o tom, jak implementovat kontrakt služby, najdete v tématu Implementace kontraktů služeb.

Vytvořte novou třídu s názvem EchoService přímo po definování rozhraní IEchoContract. Třída EchoService implementuje rozhraní IEchoContract.
```
class EchoService : IEchoContract
{
}
```
Podobně jako u implementace jiných rozhraní můžete definici implementovat v jiném souboru. V tomto kurzu je ale implementace ve stejném souboru jako definice rozhraní a metoda Main().
Na rozhraní IEchoContract aplikujte atribut ServiceBehaviorAttribute. Atribut specifikuje název služby a obor názvů. Když to dokončíte, třída EchoService bude vypadat takto:
```
[ServiceBehavior(Name = "EchoService", Namespace = "https://samples.microsoft.com/ServiceModel/Relay/")]
class EchoService : IEchoContract
{
}
```

Implementujte metodu Echo definovanou v rozhraní IEchoContract ve třídě EchoService.

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

Vyberte Sestavit>řešení sestavení nebo vyberte Ctrl+Shift+B.

Definování konfigurace pro hostitele služby

Konfigurační soubor je podobný konfiguračnímu souboru WCF. Zahrnuje název služby, koncový bod a vazbu. Koncový bod je umístění, ve které služba Azure Relay zpřístupňuje klientům a hostitelům vzájemnou komunikaci. Vazba je typ protokolu, který se používá ke komunikaci. Hlavní rozdíl spočívá v tom, že tento nakonfigurovaný koncový bod služby odkazuje na vazbu NetTcpRelayBinding , která není součástí rozhraní .NET Framework. NetTcpRelayBinding je jednou z vazeb definovaných službou.

V Průzkumník řešení poklikáním na App.config otevřete soubor v editoru sady Visual Studio.
V elementu <appSettings> nahraďte zástupné symboly názvem vašeho oboru názvů Služby Azure Relay a klíčem SAS, který jste zkopírovali v předchozím kroku.
Ve značkách <system.serviceModel> přidejte element <services>. V jednom konfiguračním souboru můžete definovat více aplikací přenosu. V tomto kurzu se ale definuje jen jedna.
```
<?xmlversion="1.0" encoding="utf-8"?>
<configuration>
  <system.serviceModel>
    <services>

    </services>
  </system.serviceModel>
</configuration>
```
V elementu <services> přidejte element <service>, který definuje název služby.
```
<service name="Microsoft.ServiceBus.Samples.EchoService">
</service>
```
V elementu <service> definujte umístění koncového bodu kontraktu a také vazbu koncového bodu.
```
<endpoint contract="Microsoft.ServiceBus.Samples.IEchoContract" binding="netTcpRelayBinding"/>
```
Koncový bod definuje, kde bude klient hledat hostitelskou aplikaci. Později kurz použije tento krok k vytvoření identifikátoru URI, který plně zpřístupní hostitele prostřednictvím služby Azure Relay. Vazba deklaruje, že ke komunikaci se službou relay používáme protokol TCP.
Vyberte Sestavit>řešení sestavení nebo stisknutím kombinace kláves Ctrl+Shift+B a potvrďte přesnost vaší dosavadní práce.

Příklad implementace smlouvy o poskytování služeb

Následující kód ukazuje implementaci kontraktu služby.

[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;
        }
    }

Následující kód ukazuje základní formát souboruApp.config přidruženého k hostiteli služby.

<?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>

Hostování a spuštění služby WCF pro registraci ve službě relay

Tento krok popisuje, jak spustit službu Azure Relay.

Vytvoření přihlašovacích údajů pro přenos

V Main() vytvořte dvě proměnné, do kterých se uloží obor názvů a klíč SAS načtené z okna konzoly.
```
Console.Write("Your Service Namespace: ");
string serviceNamespace = Console.ReadLine();
Console.Write("Your SAS key: ");
string sasKey = Console.ReadLine();
```
Klíč SAS se použije později pro přístup k projektu. Obor názvů se předá do CreateServiceUri jako parametr a vytvoří se URI služby.
Pomocí objektu TransportClientEndpointBehavior deklarujte, že jako typ přihlašovacích údajů budete používat klíč SAS. Následující kód přidejte přímo za kód, který jste přidali v předchozím kroku.
```
TransportClientEndpointBehavior sasCredential = new TransportClientEndpointBehavior();
sasCredential.TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider("RootManageSharedAccessKey", sasKey);
```

Vytvoření základní adresy pro službu

Po kódu, který jste přidali v předchozí části, vytvořte Uri instanci pro základní adresu služby. Toto URI specifikuje schéma Service Bus, obor názvů a cestu rozhraní služby.

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

Hodnota "sb" je zkratka pro schéma služby Service Bus. Označuje, že jako protokol používáme protokol TCP. Toto schéma bylo také dříve uvedeno v konfiguračním souboru, když netTcpRelayBinding byl zadán jako vazba.

V tomto kurzu je URI sb://putServiceNamespaceHere.windows.net/EchoService.

Vytvoření a konfigurace hostitele služby

Stále pracujete v Main()a nastavte režim připojení na AutoDetect.
```
ServiceBusEnvironment.SystemConnectivity.Mode = ConnectivityMode.AutoDetect;
```
Režim připojení popisuje protokol, který služba používá ke komunikaci se službou relay. http nebo TCP. Pomocí výchozího nastavení AutoDetectse služba pokusí připojit ke službě Azure Relay přes protokol TCP, pokud je k dispozici, a http, pokud tcp není dostupný. Tento výsledek se liší od protokolu, který služba určuje pro komunikaci klienta. Jeho protokol se určuje podle požité vazby. Služba může například použít vazbu BasicHttpRelayBinding , která určuje, že její koncový bod komunikuje s klienty přes PROTOKOL HTTP. Stejná služba by mohla zadat ConnectivityMode.AutoDetect , aby služba komunikuje se službou Azure Relay přes protokol TCP.
Vytvořte hostitele služby pomocí URI, které jste předtím vytvořili v této části.
```
ServiceHost host = new ServiceHost(typeof(EchoService), address);
```
Hostitel služby je objekt WCF, který instancuje službu. Tady mu předáte typ služby, kterou chcete vytvořit, EchoService typ a také adresu, na které chcete službu zveřejnit.
V horní části souboru Program.cs přidejte odkazy na System.ServiceModel.Description a Microsoft.ServiceBus.Description.
```
using System.ServiceModel.Description;
using Microsoft.ServiceBus.Description;
```
Zpátky v Main() nakonfigurujte koncový bod, a povolte tak veřejný přístup.
```
IEndpointBehavior serviceRegistrySettings = new ServiceRegistrySettings(DiscoveryType.Public);
```
Tento krok informuje předávací službu, že vaši aplikaci lze najít veřejně, a to prozkoumáním informačního kanálu Atom pro váš projekt. Pokud nastavíte DiscoveryType hodnotu private, klient bude mít stále přístup ke službě. Služba se ale při hledání Relay oboru názvů nezobrazí. Místo toho by klient musel předem znát cestu ke koncovému bodu.
Použijte přihlašovací údaje služby na koncové body služby definované v souboruApp.config :
```
foreach (ServiceEndpoint endpoint in host.Description.Endpoints)
{
    endpoint.Behaviors.Add(serviceRegistrySettings);
    endpoint.Behaviors.Add(sasCredential);
}
```
Jak bylo uvedeno výše, mohli jste v konfiguračním souboru deklarovat více služeb a koncových bodů. Pokud byste to udělali, tento kód by prošel konfigurační soubor a vyhledal by všechny koncové body, na které by měl vaše pověření použít. Pro účely tohoto kurzu má konfigurační soubor jenom jeden koncový bod.

Otevření hostitele služby

Stále v Main()souboru přidejte následující řádek, aby se služba otevřela.
```
host.Open();
```

Informujte uživatele, že zpráva běží, a vysvětlete mu, jak službu ukončit.

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

Po dokončení zavřete hostitele služby.
```
host.Close();
```
Vyberte Ctrl+Shift+B a sestavte projekt.

Příklad hostí službu v konzolové aplikaci

Dokončený kód služby by se měl zobrazit následujícím způsobem. Kód zahrnuje kontrakt služby a implementaci z předchozích kroků kurzu a hostuje službu v konzolové aplikaci.

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();
        }
    }
}

Vytvoření klienta WCF pro kontrakt služby

Dalším úkolem je vytvořit klientskou aplikaci a definovat kontrakt služby, který budete implementovat později. Tyto kroky se podobají krokům použitým k vytvoření služby: definování kontraktu, úprava souboruApp.config , použití přihlašovacích údajů pro připojení ke službě relay atd. Kód použitý k těmto úlohám najdete v příkladu za postupem.

Vytvořte nový projekt v aktuálním řešení sady Visual Studio pro klienta:
1. V Průzkumník řešení klikněte pravým tlačítkem na aktuální řešení (ne na projekt) a vyberte Přidat>nový projekt.
2. V části Přidat nový projekt vyberte Konzolová aplikace (.NET Framework) pro C# a vyberte Další.
3. Pojmenujte projekt EchoClient a vyberte Vytvořit.
V Průzkumník řešení v projektu EchoClient poklikáním otevřete soubor Program.cs v editoru, pokud ještě není otevřený.
Změňte název oboru názvů z výchozího názvu EchoClient na Microsoft.ServiceBus.Samples.
Nainstalujte balíček NuGet služby Service Bus:
1. V Průzkumník řešení klikněte pravým tlačítkem na EchoClient a pak vyberte Spravovat balíčky NuGet.
2. Vyberte Procházet a pak vyhledejte a vyberte WindowsAzure.ServiceBus. Vyberte Nainstalovat a přijměte podmínky použití.
using Přidejte příkaz pro obor názvů System.ServiceModel v souboru Program.cs.
```
using System.ServiceModel;
```

Přidejte definici kontraktu služby do oboru názvů, jak je vidět v následujícím příkladu. Tato definice je identická s definicí použitou v projektu Service . Přidejte tento kód do horní části Microsoft.ServiceBus.Samples oboru názvů.

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

public interface IEchoChannel : IEchoContract, IClientChannel { }

Stisknutím kombinace kláves Ctrl+Shift+B sestavte klienta.

Příklad projektu EchoClient

Následující kód ukazuje aktuální stav souboru Program.cs v projektu 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)
        {
        }
    }
}

Konfigurace klienta WCF

V tomto kroku vytvoříte souborApp.config pro základní klientskou aplikaci, která přistupuje ke službě vytvořené dříve v tomto kurzu. Tento App.config soubor definuje kontrakt, vazbu a název koncového bodu. Kód použitý k těmto úlohám najdete v příkladu za postupem.

V Průzkumník řešení v projektu EchoClient poklikáním na App.config otevřete soubor v editoru sady Visual Studio.
V elementu <appSettings> nahraďte zástupné texty názvem svého oboru názvů a klíčem SAS, který jste zkopírovali v jednom z předchozích kroků.

Do elementu system.serviceModel přidejte <client> element.

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

Tento kód deklaruje, že definujete klientskou aplikaci ve stylu WCF.

V elementu client definujte název, kontrakt a typ vazby koncového bodu.
```
<endpoint name="RelayEndpoint"
                contract="Microsoft.ServiceBus.Samples.IEchoContract"
                binding="netTcpRelayBinding"/>
```
Tento kód definuje název koncového bodu. Definuje také kontrakt definovaný ve službě a skutečnost, že klientská aplikace ke komunikaci se službou Azure Relay používá protokol TCP. Název koncového bodu se použije v následujícím kroku k propojení této konfigurace koncového bodu s URI služby.
Vyberte Soubor>Uložit vše.

Příklad souboru App.config

Následující kód ukazuje souborApp.config pro klienta 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>

Implementace klienta WCF

V této části implementujete základní klientskou aplikaci, která přistupuje ke službě, kterou jste vytvořili dříve v tomto kurzu. Podobně jako u této služby klient pro přístup ke službě Azure Relay provede mnoho stejných operací:

Nastaví režim připojení.
Vytvoří URI, které vyhledá hostitelskou službu.
Definuje bezpečnostní pověření.
Aplikuje pověření na připojení.
Otevře připojení.
Provádí úlohy specifické pro aplikace.
Ukončí připojení.

Jedním z hlavních rozdílů je ale to, že klientská aplikace používá kanál pro připojení ke službě relay. Služba používá volání ServiceHost. Kód použitý k těmto úlohám najdete v příkladu za postupem.

Implementace klientské aplikace

Nastavte režim připojení na AutoDetect. Do metody Main() aplikace EchoClient přidejte následující kód.
```
ServiceBusEnvironment.SystemConnectivity.Mode = ConnectivityMode.AutoDetect;
```

Definujte proměnné, do kterých se uloží hodnoty obor názvů služby a klíče SAS načtené z konzoly.

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

Vytvořte identifikátor URI, který definuje umístění hostitele v projektu Relay.

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

Vytvořte objekt pověření pro koncový bod vašeho oboru názvů.

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

Vytvořte objekt pro vytváření kanálů, který načte konfiguraci popsanou v souboruApp.config .
```
ChannelFactory<IEchoChannel> channelFactory = new ChannelFactory<IEchoChannel>("RelayEndpoint", new EndpointAddress(serviceUri));
```
Objekt kanálu pro vytváření je objekt WCF, který vytvoří kanál, přes který může služba komunikovat s klientskými aplikacemi.

Použijte přihlašovací údaje.

channelFactory.Endpoint.Behaviors.Add(sasCredential);

Vytvořte a otevřete kanál pro službu.

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

Napište základní uživatelské prostředí a funkci pro echo.

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();
}

Kód používá instanci objektu kanálu jako proxy pro službu.

Zavřete kanál a zavřete objekt pro vytváření.
```
channel.Close();
channelFactory.Close();
```

Příklad kódu pro tento kurz

Dokončený kód by se měl zobrazit následujícím způsobem. Tento kód ukazuje, jak vytvořit klientskou aplikaci, jak volat operace služby a jak zavřít klienta po dokončení volání operace.

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();

        }
    }
}

Spuštění aplikací

Vyberte Ctrl+Shift+B a sestavte řešení. Tato akce vytvoří projekt klienta i projekt služby, který jste vytvořili v předchozích krocích.
Než spustíte klientskou aplikaci, musíte se ujistit, že aplikace služby běží. V Průzkumník řešení klikněte pravým tlačítkem na řešení EchoService a pak vyberte Vlastnosti.
V části Stránky vlastností, Společné vlastnosti>Spouštěný projekt, pak zvolte Více projektů po spuštění. Ujistěte se, že se EchoService v seznamu objeví jako první.
V poli Akce u projektů EchoService i EchoClient nastavte Start.
Vyberte Závislosti projektu. V části Projekty vyberte EchoClient. V části Závisí na se ujistěte, že je vybraná možnost EchoService .
Výběrem OKzavřete stránky vlastností.
Pokud chcete spustit oba projekty, vyberte F5.
Obě okna konzoly se otevřou a požádají vás o zadání oboru názvů. Služba se musí spustit jako první, takže v okně konzoly EchoService zadejte obor názvů a pak vyberte Enter.
V dalším kroku vás konzola vyzve k zadání klíče SAS. Zadejte klíč SAS a vyberte Enter.

Tady je příklad výstupu z okna konzoly. Hodnoty tady jsou jenom příklady.

Your Service Namespace: myNamespace

Your SAS Key: <SAS key value>

Aplikace služby do okna konzoly vypíše adresu, na které naslouchá, jak je vidět na následujícím příkladu.

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

Press [Enter] to exit
V okně konzoly EchoClient zadejte stejný údaj, který jste zadali pro aplikaci služby. Zadejte stejné hodnoty oboru názvů služby a klíče SAS pro klientskou aplikaci.
Po zadání těchto hodnot klient otevře kanál ke službě a zobrazí se výzva k zadání nějakého textu, jak je vidět v následujícím příkladu výstupu konzoly.

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

Zadejte text, který se má odeslat do aplikace služby, a vyberte Enter. Tento text se odešle do služby pomocí operace služby Echo a objeví se v okně konzoly služby, jak je vidět v následujícím příkladu výstupu.

Echoing: My sample text

Klientská aplikace obdrží hodnotu vrácenou z operace Echo. Tou je původní text, který se vypíše do okna konzoly. Následující text je příklad výstupu z okna klientské konzoly.

Server echoed: My sample text
Tímto způsobem můžete dál posílat textové zprávy z klienta do služby. Až budete hotovi, vyberte v oknech klienta a konzoly služby enter a ukončete obě aplikace.

Další kroky

Přejděte k následujícímu kurzu:

Zveřejnění místní služby WCF REST pro klienta mimo vaši síť