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

Článek
12/11/2024

Tento kurz popisuje, jak vytvořit klientskou aplikaci WCF Relay a službu pomocí služby Azure Relay. Stejně jako jejich původní protějšky WCF je služba konstruktorem, 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, které 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 místo místně na vašem počítači.

Po procházení posloupnosti oddílů 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 požadavky pro tento kurz.
Vytvořte obor názvů služby Relay.
Vytvořte kontrakt služby WCF.
Implementujte kontrakt WCF.
Hostování a spuštění služby 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 před tím, než začnete.
Sada 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. Když se vytvoří obor názvů služby, systém automaticky vygeneruje klíč SAS. Kombinace oboru názvů služeb a klíče SAS poskytuje přihlašovací údaje pro Azure k ověření přístupu k aplikaci.

Přihlaste se k portálu Azure.
V nabídce vlevo vyberte Všechny služby . Vyberte Možnost Integrace, vyhledejte Relays, přesuň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 vytvořit obor názvů.
2. Pro skupinu 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. Vyberte Zkontrolovat a vytvořit v dolní části stránky.
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 vyberte v nabídce vlevo 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 primárního připojovacího řetězce. 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á ServiceContractAttribute atribut nemá OperationContractAttribute atribut, tato metoda není vystavena. Kód k těmto úlohám najdete v příkladu za postupem. Větší diskuzi o kontraktech a službách najdete v tématu Návrh a implementace služeb.

Vytvoření přenosového kontraktu pomocí rozhraní

Spusťte Microsoft Visual Studio jako správce. Uděláte to tak, že kliknete pravým tlačítkem myši 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. V Správce balíčků NuGet vyberte Procházet, vyhledejte a zvolte WindowsAzure.ServiceBus. Vyberte Instalovat a přijměte podmínky použití.

Tento balíček automaticky přidá odkazy na knihovny 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 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 C#, což je obor názvů Microsoft.ServiceBus.Samples spravovaného typu založeného na kontraktu, který se používá v konfiguračním souboru v části Konfigurace klienta WCF. Při sestavování této ukázky můžete zadat libovolný obor názvů, který chcete použít. Tento kurz však nebude fungovat, pokud pak v konfiguračním souboru aplikace nezměníte obory názvů kontraktu a služby. Obor názvů zadaný v souboru App.config musí být stejný jako obor názvů zadaný v souborech 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 nadále používat starý kontrakt služby, aniž by museli být aktualizováni. 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 jedinou 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 na kanál, který bude vypisovat informace mezi těmito dvěma aplikacemi.
Vyberte Sestavit>řešení nebo stisknutím kombinace kláves Ctrl+Shift+B potvrďte přesnost své 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í pak nakonfigurujete rozhraní pomocí konfiguračního souboru App.config . Konfigurační soubor obsahuje nezbytné 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 za postupem. Obecnější diskuzi o tom, jak implementovat kontrakt služby, naleznete 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í nebo stiskněte 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í, které Azure Relay zveřejňuje klientům a hostitelům, aby mezi sebou komunikovali. Vazba je typ protokolu, který se používá ke komunikaci. Hlavním rozdílem je, ž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 tento krok použije tento krok k vytvoření identifikátoru URI, který plně zveřejňuje hostitele prostřednictvím služby Azure Relay. Vazba deklaruje, že jako protokol pro komunikaci se službou relay používáme protokol TCP.
Vyberte Sestavit>řešení nebo stisknutím kombinace kláves Ctrl+Shift+B potvrďte přesnost své dosavadní práce.

Příklad implementace kontraktu služby

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 souboru App.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 v předávací službě

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í TransportClientEndpointBehavior objektu deklarujte, že jako typ přihlašovacích údajů použijete 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 přidání kódu 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 označeno v konfiguračním souboru, kdy byl jako vazba zadán NetTcpRelayBinding .

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

Vytvoření a konfigurace hostitele služby

Stále pracujete Main(), 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í k dispozici. Tento výsledek se liší od protokolu, který služba určuje pro komunikaci klienta. Jeho protokol se určuje podle požité vazby. Například služba může použít vazbu BasicHttpRelayBinding , která určuje, že jeho koncový bod komunikuje s klienty přes HTTP. Stejná služba může určit 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 předáte typ služby, kterou chcete vytvořit, EchoService typ a také adresu, na kterou 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 službu relay, že aplikaci lze veřejně najít 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 nezobrazí, když prohledá Relay obor názvů. 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 souboru App.config :
```
foreach (ServiceEndpoint endpoint in host.Description.Endpoints)
{
    endpoint.Behaviors.Add(serviceRegistrySettings);
    endpoint.Behaviors.Add(sasCredential);
}
```
Jak jsme uvedli dříve, 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 pouze jeden koncový bod.

Otevření hostitele služby

Stále v Main(), přidejte následující řádek pro otevření služby.
```
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, který hostuje 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ů v 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, úpravě souboru App.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.

V aktuálním řešení sady Visual Studio pro klienta vytvořte nový projekt:
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. Jako název projektu zadejte EchoClient a vyberte Vytvořit.
V Průzkumník řešení poklikáním na Program.cs v projektu EchoClient otevřete soubor 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 Instalovat a přijměte podmínky použití.
using Do souboru Program.cs přidejte příkaz pro obor názvů System.ServiceModel.
```
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 stejná jako definice použitá v projektu služby . 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 { }

Vyberte Ctrl+Shift+B a 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 soubor App.config pro základní klientskou aplikaci, která přistupuje ke službě vytvořené dříve v tomto kurzu. Tento soubor App.config 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 <client> přidejte prvek.

<?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 používá ke komunikaci se službou Azure Relay 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 Uložit>soubor vše.

Příklad souboru App.config

Následující kód ukazuje soubor App.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 služba má klient mnoho stejných operací pro přístup ke službě Azure Relay:

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í k předávací službě. 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 souboru App.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();
```

Ukázkový kód 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 sestaví 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.
Na stránkách vlastností, Společné vlastnosti>Spouštěný projekt a 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 projektech vyberte EchoClient. V případě závislosti se ujistěte, že je vybraná služba EchoService .
Výběrem tlačítka OK zavřete stránky vlastností.
Výběrem klávesy F5 spusťte oba projekty.
Obě okna konzoly se otevřou a požádají vás o zadání oboru názvů. Služba musí běžet 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. Tady jsou jen 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ý obor názvů služby a hodnoty klíče SAS pro klientskou aplikaci.
Po zadání těchto hodnot klient otevře kanál pro službu a vyzve vás, abyste zadali nějaký text, jak je vidět v následujícím příkladu výstupu konzoly.

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

Zadejte nějaký text, který chcete 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říkladem výstupu z okna konzoly klienta.

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 Enter v oknech konzoly klienta a služeb a ukončete obě aplikace.

Další krok

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

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

Sdílet prostřednictvím