Oktatóanyag: Helyszíni WCF REST-szolgáltatás elérhetővé tétele külső ügyfél számára az Azure WCF Relay használatával

Cikk
08/11/2023

Ez az oktatóanyag bemutatja, hogyan hozhat létre WCF Relay-ügyfélalkalmazást és szolgáltatást az Azure Relay használatával. Az eredeti WCF-megfelelőikhez hasonlóan a szolgáltatás egy olyan szerkezet, amely egy vagy több végpontot tesz elérhetővé. Minden végpont egy vagy több szolgáltatásműveletet tesz elérhetővé. A szolgáltatás végpontja megadja azt a címet , ahol a szolgáltatás megtalálható, egy kötést , amely tartalmazza az ügyfélnek a szolgáltatással való kommunikációhoz szükséges információkat, valamint egy szerződést , amely meghatározza a szolgáltatás által az ügyfelek számára biztosított funkciókat. A WCF és a WCF Relay közötti fő különbség az, hogy a végpont a helyi számítógép helyett a felhőben van közzétéve.

Miután elvégezte az oktatóanyag szakaszainak sorrendjét, egy futó szolgáltatással fog rendelkezni. Egy ügyfél is rendelkezik, amely meghívja a szolgáltatás műveleteit.

Ebben az oktatóanyagban a következő feladatokat hajtja végre:

Az oktatóanyag előfeltételeinek telepítése.
Hozzon létre egy Relay-névteret.
Hozzon létre egy WCF-szolgáltatási szerződést.
Implementálja a WCF-szerződést.
Futtassa és futtassa a WCF szolgáltatást a Relay szolgáltatásban való regisztrációhoz.
Hozzon létre egy WCF-ügyfelet a szolgáltatási szerződéshez.
Konfigurálja a WCF-ügyfelet.
Implementálja a WCF-ügyfelet.
Futtassa az alkalmazásokat.

Előfeltételek

Az oktatóanyag teljesítéséhez a következő előfeltételekre lesz szüksége:

Azure-előfizetés. Ha még nem rendelkezik ilyen fiókkal, hozzon létre egy ingyenes fiókot a kezdés előtt.
Visual Studio 2015 vagy újabb verzió. Az oktatóanyagban szereplő példák a Visual Studio 2019-et használják.
Azure SDK for .NET. Telepítse az SDK letöltési oldaláról.

Relay-névtér létrehozása

Első lépésként hozzon létre egy névteret, és szerezze be a közös hozzáférésű jogosultságkód (SAS) kulcsát. A névtér alkalmazáshatárt biztosít a továbbító szolgáltatáson keresztül elérhető összes alkalmazáshoz. A rendszer automatikusan létrehoz egy SAS-kulcsot a szolgáltatásnévtér létrehozásakor. A szolgáltatásnévtér és az SAS-kulcs kombinációja biztosítja az Azure hitelesítő adatait az alkalmazásokhoz való hozzáférés hitelesítéséhez.

Jelentkezzen be az Azure Portalra.
A bal oldali menüben válassza a Minden szolgáltatás lehetőséget. Válassza az Integráció lehetőséget, keresse meg a Továbbítókat, vigye az egeret a Továbbítók fölé, majd válassza a Létrehozás lehetőséget.
A Névtér létrehozása lapon kövesse az alábbi lépéseket:
1. Válassza ki azt az Azure-előfizetést, amelyben létre szeretné hozni a névteret.
2. Az Erőforráscsoport mezőben válasszon ki egy meglévő erőforráscsoportot, amelyben elhelyezi a névteret, vagy hozzon létre egy újat.
3. Adja meg a Relay névtér nevét.
4. Válassza ki azt a régiót, amelyben a névteret üzemeltetni szeretné.
5. Válassza a Lap alján található Véleményezés + létrehozás lehetőséget.
6. A Véleményezés + létrehozás lapon válassza a Létrehozás lehetőséget.
7. Néhány perc elteltével megjelenik a névtér Relay lapja.

Felügyeleti hitelesítő adatok lekérése

A Továbbítás lapon válassza a megosztott hozzáférési szabályzatok lehetőséget a bal oldali menüben. `
A Megosztott hozzáférési szabályzatok lapon válassza a RootManageSharedAccessKey lehetőséget.
Az SAS-szabályzat: RootManageSharedAccessKey területen válassza az Elsődleges kapcsolati sztring melletti Másolás gombot. Ez a művelet a kapcsolati sztring a vágólapra másolja későbbi használatra. Illessze be ezt az értéket a Jegyzettömbbe vagy egy másik ideiglenes helyre.
A későbbi használat érdekében ismételje meg az előző lépést, és másolja ki és illessze be az Elsődleges kulcs értékét egy ideiglenes helyre.

WCF-szolgáltatási szerződés definiálása

A szolgáltatási szerződés határozza meg, hogy a szolgáltatás mely műveleteket támogatja. A műveletek webszolgáltatási módszerek vagy függvények. A szerződések a C++, a C# vagy a Visual Basic felület meghatározásával jönnek létre. A felület minden metódusa egy konkrét szolgáltatási műveletnek felel meg. A ServiceContractAttriibute attribútumot minden felületre, az OperationContractAttribaute attribútumot pedig minden műveletre alkalmazni kell. Ha egy ServiceContractAttribute attribútummal rendelkező felületen lévő metódus nem rendelkezik az OperationContractAttribute attribútummal, akkor a metódus nem lesz közzétéve. A feladatok kódja megtalálható az eljárást követő példában. A szerződésekről és szolgáltatásokról a Szolgáltatások tervezése és megvalósítása című témakörben olvashat bővebben.

Továbbítási szerződés létrehozása adapterrel

Indítsa el a Microsoft Visual Studiót rendszergazdaként. Ehhez kattintson a jobb gombbal a Visual Studio program ikonjára, és válassza a Futtatás rendszergazdaként parancsot.
A Visual Studióban válassza az Új projekt létrehozása lehetőséget.
Az Új projekt létrehozása területen válassza a Konzolalkalmazás (.NET-keretrendszer) lehetőséget a C# számára, és válassza a Tovább gombot.
Nevezze el a projektet EchoService néven , és válassza a Létrehozás lehetőséget.
A Megoldáskezelőben kattintson a jobb gombbal a projektre, és válassza a Manage NuGet Packages (NuGet-csomagok kezelése) lehetőséget. A NuGet-csomagkezelőben válassza a Tallózás lehetőséget, majd keresse meg és válassza a WindowsAzure.ServiceBus elemet. Válassza a Telepítés lehetőséget, és fogadja el a használati feltételeket.

Ez a csomag automatikusan hozzáad hivatkozásokat a Service Bus-kódtárakhoz és a WCF-hez System.ServiceModel. A System.ServiceModel az a névtér, amely lehetővé teszi a programozott hozzáférést a WCF alapszintű szolgáltatásaihoz. A Service Bus számos WCF-objektumot és -attribútumot használ a szolgáltatási szerződések meghatározására.
Adja hozzá a következő using utasításokat a Program.cs tetején:
```
using System.ServiceModel;
using Microsoft.ServiceBus;
```
Módosítsa a névtér alapértelmezett EchoService nevét a következőre: Microsoft.ServiceBus.Samples.

Fontos

Ez az oktatóanyag A WCF-ügyfél konfigurálása szakaszban található konfigurációs fájlban használt szerződésalapú felügyelt típus névterét használó C#-névteret Microsoft.ServiceBus.Samples használja. A minta létrehozásakor bármilyen névteret megadhat. Az oktatóanyag azonban csak akkor működik, ha a szerződés és a szolgáltatás névtereit ennek megfelelően módosítja az alkalmazás konfigurációs fájljában. A App.config fájlban megadott névtérnek meg kell egyeznie a C#-fájlokban megadott névtérrel.
Közvetlenül a Microsoft.ServiceBus.Samples névtér deklarációja után, de a névtéren belül definiáljon egy új nevű felületet IEchoContract , és alkalmazza az ServiceContractAttribute attribútumot a felületre a névtérértékkel https://samples.microsoft.com/ServiceModel/Relay/. Illessze be a következő kódot a névtér deklarációja után:
```
[ServiceContract(Name = "IEchoContract", Namespace = "https://samples.microsoft.com/ServiceModel/Relay/")]
public interface IEchoContract
{
}
```
A névtér értéke különbözik a kód tartományában használt névtértől. A névtér értéke ehelyett egyedi azonosítóként van használatban ehhez a szerződéshez. A névtér explicit meghatározásával megelőzhető az alapértelmezett névtér hozzáadása a szerződésnévhez.

Megjegyzés

A szolgáltatási szerződés névtere általában tartalmaz egy elnevezési sémát, amely tartalmazza a verzióinformációkat. Ha a verzióinformációk szerepelnek a szolgáltatási szerződés névterében, a szolgáltatások képesek elkülöníteni a nagyobb módosításokat egy új szolgáltatási szerződés új névtérrel való meghatározása, valamint egy új végponton való megjelenítése révén. Ily módon az ügyfelek továbbra is használhatják a régi szolgáltatási szerződést anélkül, hogy frissíteni kellene. A verzióinformációk dátumot vagy buildszámot tartalmazhatnak. További információ: Service Versioning (Szolgáltatás verziószámozása). Ebben az oktatóanyagban a szolgáltatási szerződés névterének elnevezési sémája nem tartalmaz verzióinformációkat.
IEchoContract Az interfészen belül deklaráljon egy metódust arra az egyetlen műveletre, amelyet a IEchoContract szerződés elérhetővé tesz a felületen, és alkalmazza az OperationContractAttribute attribútumot a nyilvános WCF Relay-szerződés részeként elérhetővé tenni kívánt metódusra az alábbiak szerint:
```
[OperationContract]
string Echo(string text);
```
Közvetlenül az IEchoContract felület deklarációja után deklaráljon egy csatornát, amely örökli az IEchoContract és az IClientChannel felületek tulajdonságait is, ahogy az itt látható:
```
public interface IEchoChannel : IEchoContract, IClientChannel { }
```
A csatorna egy olyan WCF-objektum, amelyen keresztül a gazda és az ügyfél információkat adnak át egymásnak. Később kódot fog írni a csatornára a két alkalmazás adatainak visszhangja érdekében.
Válassza aBuild Solution (Buildelési megoldáslétrehozása>) vagy a Ctrl+Shift+B billentyűkombinációt a munkája eddigi pontosságának megerősítéséhez.

Példa WCF-szerződésre

Az alábbi kód egy alapszintű felületet mutat be, amely egy WCF Relay-szerződést határoz meg.

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

Most, hogy létrejött a felület, megvalósíthatja azt.

A WCF-szerződés megvalósítása

Az Azure Relay létrehozásához először létre kell hoznia a szerződést egy interfész használatával. A felület létrehozásával kapcsolatos további információkért lásd az előző szakaszt. A következő eljárás implementálja az interfészt. Ehhez a feladathoz létre kell hozni egy nevű EchoService osztályt, amely implementálja a felhasználó által definiált IEchoContract felületet. Az illesztő implementálása után konfigurálja a felületet egy App.config konfigurációs fájllal. A konfigurációs fájl tartalmazza az alkalmazáshoz szükséges információkat. Ezek az információk tartalmazzák a szolgáltatás nevét, a szerződés nevét és a továbbító szolgáltatással való kommunikációhoz használt protokoll típusát. Az ezekhez a feladatokhoz használt kódot az eljárást követő példában adták meg. A szolgáltatási szerződések implementálásával kapcsolatos általánosabb információkért lásd: Szolgáltatásszerződések implementálása.

Hozzon létre egy új, EchoService nevű osztályt közvetlenül az IEchoContract felület meghatározása után. Az EchoService osztály megvalósítja az IEchoContract felületet.
```
class EchoService : IEchoContract
{
}
```
Hasonlóan az egyéb felületi megvalósításokhoz, a definíciót megvalósíthatja egy másik fájlban. Ebben az oktatóanyagban azonban a megvalósítás ugyanabban a fájlban található, mint a felületdefiníció és a Main() metódus.
Alkalmazza a ServiceBehaviorAttribute attribútumot az IEchoContract felületre. Az attribútum megadja a szolgáltatás nevét és névterét. Ezután az EchoService osztály a következőképp jelenik meg:
```
[ServiceBehavior(Name = "EchoService", Namespace = "https://samples.microsoft.com/ServiceModel/Relay/")]
class EchoService : IEchoContract
{
}
```

Valósítsa meg az IEchoContract felületen meghatározott Echo metódust az EchoService osztályban.

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

Válassza aBuild Solution (Buildelési megoldáslétrehozása>) vagy a Ctrl+Shift+B billentyűkombinációt.

A szolgáltatás gazdagépének konfigurációjának meghatározása

A konfigurációs fájl hasonló a WCF konfigurációs fájlhoz. Tartalmazza a szolgáltatásnevet, a végpontot és a kötést. A végpont az a hely, amelyet az Azure Relay elérhetővé tesz az ügyfelek és a gazdagépek számára, hogy kommunikáljanak egymással. A kötés a kommunikációhoz használt protokoll típusa. A fő különbség az, hogy ez a konfigurált szolgáltatásvégpont egy NetTcpRelayBinding kötésre hivatkozik, amely nem része a .NET-keretrendszer. A NetTcpRelayBinding a szolgáltatás által meghatározott kötések egyike.

A Megoldáskezelőben kattintson duplán aApp.config elemre a fájl Visual Studio-szerkesztőben való megnyitásához.
<appSettings> Az elemben cserélje le a helyőrzőket az Azure Relay-névtér nevére és a korábbi lépésben másolt SAS-kulcsra.
A <system.serviceModel> címkéken belül adjon hozzá egy <services> elemet. Egyetlen konfigurációs fájlban több továbbítóalkalmazást is definiálhat. Ez az oktatóanyag viszont csak egyet határoz meg.
```
<?xmlversion="1.0" encoding="utf-8"?>
<configuration>
  <system.serviceModel>
    <services>

    </services>
  </system.serviceModel>
</configuration>
```
A <services> elemen belül adjon hozzá egy <service> elemet a szolgáltatás nevének meghatározásához.
```
<service name="Microsoft.ServiceBus.Samples.EchoService">
</service>
```
A <service> elemen belül határozza meg a végpont szerződés helyét, valamint a végpont kötésének típusát.
```
<endpoint contract="Microsoft.ServiceBus.Samples.IEchoContract" binding="netTcpRelayBinding"/>
```
A végpont meghatározza, hogy az ügyfél hol keresi majd a gazdaalkalmazást. Később az oktatóanyag ezzel a lépéssel létrehoz egy URI-t, amely teljes mértékben elérhetővé teszi a gazdagépet az Azure Relayen keresztül. A kötés deklarálja, hogy TCP protokollt használunk a továbbító szolgáltatással való kommunikációhoz.
Válassza aBuild Solution (Buildelési megoldáslétrehozása>) vagy a Ctrl+Shift+B billentyűkombinációt a munkája eddigi pontosságának megerősítéséhez.

Példa egy szolgáltatási szerződés megvalósítására

A következő kód a szolgáltatási szerződés megvalósítását mutatja be.

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

Az alábbi kód a szolgáltatás gazdagépéhez társított App.config fájl alapformátumát mutatja be.

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

A WCF szolgáltatás üzemeltetéséhez és futtatásához regisztráljon a relay szolgáltatásban

Ez a lépés az Azure Relay szolgáltatás futtatását ismerteti.

A továbbító hitelesítő adatainak létrehozása

A Main() metódusban hozzon létre két változót, amelyben a konzolablakból beolvasott névtér és SAS-kulcs tárolható.
```
Console.Write("Your Service Namespace: ");
string serviceNamespace = Console.ReadLine();
Console.Write("Your SAS key: ");
string sasKey = Console.ReadLine();
```
Az SAS-kulcsot később a rendszer a projekt eléréséhez fogja használni. A névteret a rendszer paraméterként átadja a CreateServiceUri számára szolgáltatás URI létrehozásához.

TransportClientEndpointBehavior objektummal deklarálja, hogy SAS-kulcsot fog használni hitelesítőadat-típusként. Vegye fel a következő kódot közvetlenül az előző lépésben felvett kód után.

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

Alapcím létrehozása a szolgáltatáshoz

Az előző szakaszban hozzáadott kód után hozzon létre egy példányt Uri a szolgáltatás alapcíméhez. Ez az URI megadja a Service Bus-sémát, a névteret és a szolgáltatási felület útvonalát.

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

Az "sb" érték a Service Bus-séma rövidítése. Azt jelzi, hogy protokollként TCP-t használunk. Ezt a sémát korábban a konfigurációs fájlban is jelezték, amikor a NetTcpRelayBinding lett megadva kötésként.

Az oktatóanyaghoz az URI sb://putServiceNamespaceHere.windows.net/EchoService.

A szolgáltatás gazdagépének létrehozása és konfigurálása

Továbbra is működik a rendszerben Main(), állítsa a kapcsolati módot értékre AutoDetect.
```
ServiceBusEnvironment.SystemConnectivity.Mode = ConnectivityMode.AutoDetect;
```
A kapcsolati mód azt a protokollt írja le, amelyet a szolgáltatás a továbbító szolgáltatással való kommunikációhoz használ; HTTP-t vagy TCP-t. Az alapértelmezett beállítással AutoDetecta szolgáltatás TCP-kapcsolaton keresztül próbál csatlakozni az Azure Relayhez, ha az elérhető, és HTTP-t, ha a TCP nem érhető el. Ez az eredmény eltér a szolgáltatás által az ügyfélkommunikációhoz megadott protokolltól. Azt a protokollt az alkalmazott kötés határozza meg. Egy szolgáltatás például használhatja az AlapszintűHttpRelayBinding kötést, amely azt határozza meg, hogy végpontja HTTP-kapcsolaton keresztül kommunikáljon az ügyfelekkel. Ugyanez a szolgáltatás megadhatja ConnectivityMode.AutoDetect , hogy a szolgáltatás TCP-kapcsolaton keresztül kommunikáljon az Azure Relayrel.
Hozza létre a szolgáltatás gazdáját a szakaszban korábban létrehozott URI segítségével.
```
ServiceHost host = new ServiceHost(typeof(EchoService), address);
```
A szolgáltatásgazda a WCF-objektum, amely a szolgáltatást példányosítja. Itt adja át a létrehozni kívánt szolgáltatástípust, egy típust EchoService , valamint azt a címet is, ahol elérhetővé szeretné tenni a szolgáltatást.
A Program.cs fájl tetején adja hozzá a System.ServiceModel.Description és a Microsoft.ServiceBus.Description hivatkozásokat.
```
using System.ServiceModel.Description;
using Microsoft.ServiceBus.Description;
```
Újra a Main() metódusban konfigurálja a végpontot a nyilvános hozzáférés engedélyezésére.
```
IEndpointBehavior serviceRegistrySettings = new ServiceRegistrySettings(DiscoveryType.Public);
```
Ez a lépés tájékoztatja a továbbítószolgáltatást arról, hogy az alkalmazás nyilvánosan megtalálható a projekt Atom-hírcsatornájának vizsgálatával. Ha a értékre privatevan állítvaDiscoveryType, az ügyfél továbbra is hozzáférhet a szolgáltatáshoz. A szolgáltatás azonban nem jelenik meg, amikor a névtérben Relay keres. Az ügyfélnek ehhez már ismernie kell a végpont elérési útját.
Alkalmazza a szolgáltatás hitelesítő adatait a App.config fájlban meghatározott szolgáltatásvégpontokra:
```
foreach (ServiceEndpoint endpoint in host.Description.Endpoints)
{
    endpoint.Behaviors.Add(serviceRegistrySettings);
    endpoint.Behaviors.Add(sasCredential);
}
```
Ahogy korábban említettük, több szolgáltatást és végpontot is deklarálhatott volna a konfigurációs fájlban. Ha így tett, ez a kód végighalad a konfigurációs fájlon, és megkeres minden végpontot, amelyre alkalmaznia kell a hitelesítő adatokat. Ebben az oktatóanyagban a konfigurációs fájlnak csak egy végpontja van.

A szolgáltatás gazdagépének megnyitása

A fájlban Main()továbbra is adja hozzá a következő sort a szolgáltatás megnyitásához.
```
host.Open();
```

Tájékoztassa a felhasználót arról, hogy a szolgáltatás fut, és magyarázza el, hogyan lehet leállítani.

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

Ha kész, zárja be a szolgáltatásgazdát.
```
host.Close();
```
A projekt létrehozásához válassza a Ctrl+Shift+B billentyűkombinációt.

Példa egy szolgáltatás konzolalkalmazásban való üzemeltetésére

A befejezett szolgáltatáskódnak a következőképpen kell megjelennie. A kód tartalmazza az oktatóanyag korábbi lépéseiből származó szolgáltatási szerződést és implementációt, és a szolgáltatást egy konzolalkalmazásban üzemelteti.

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

WCF-ügyfél létrehozása a szolgáltatási szerződéshez

A következő feladat egy ügyfélalkalmazás létrehozása és a később megvalósítandó szolgáltatási szerződés meghatározása. Ezek a lépések hasonlóak a szolgáltatás létrehozásához használt lépésekhez: szerződés definiálása, App.config fájl szerkesztése, hitelesítő adatok használata a továbbító szolgáltatáshoz való csatlakozáshoz stb. A feladatokhoz használt kód megtalálható az eljárást követő példában.

Hozzon létre egy új projektet az aktuális Visual Studio-megoldásban az ügyfél számára:
1. A Megoldáskezelőben kattintson a jobb gombbal az aktuális megoldásra (nem a projektre), és válassza azÚj projekthozzáadása> lehetőséget.
2. Az Új projekt hozzáadása területen válassza a C# konzolalkalmazás (.NET-keretrendszer) elemét, majd válassza a Tovább lehetőséget.
3. Nevezze el az EchoClient projektet, és válassza a Létrehozás lehetőséget.
A MegoldáskezelőEchoClient projektjében kattintson duplán a Program.cs fájlra a fájl szerkesztőben való megnyitásához, ha még nincs megnyitva.
Módosítsa a névtér alapértelmezett EchoClient nevét a következőre: Microsoft.ServiceBus.Samples.
Telepítse a Service Bus NuGet-csomagot:
1. A Megoldáskezelőben kattintson a jobb gombbal az EchoClient elemre , majd válassza a Manage NuGet Packages (NuGet-csomagok kezelése) lehetőséget.
2. Válassza a Tallózás lehetőséget, majd keresse meg és válassza a WindowsAzure.ServiceBus lehetőséget. Válassza a Telepítés lehetőséget, és fogadja el a használati feltételeket.
Adjon hozzá egy utasítást using a System.ServiceModel névtérhez a Program.cs fájlban.
```
using System.ServiceModel;
```

Adja hozzá a szolgáltatási szerződés meghatározását a névtérhez, ahogyan az az alábbi példában látható. Ez a definíció megegyezik a Service projektben használt definícióval. Adja hozzá ezt a kódot a Microsoft.ServiceBus.Samples névtér tetején.

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

public interface IEchoChannel : IEchoContract, IClientChannel { }

Az ügyfél létrehozásához válassza a Ctrl+Shift+B billentyűkombinációt.

Példa az EchoClient-projektre

Az alábbi kód a Program.cs fájl aktuális állapotát mutatja az EchoClient projektben.

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

A WCF-ügyfél konfigurálása

Ebben a lépésben létrehoz egy App.config fájlt egy alapszintű ügyfélalkalmazáshoz, amely hozzáfér az oktatóanyagban korábban létrehozott szolgáltatáshoz. Ez aApp.config fájl határozza meg a végpont szerződését, kötését és nevét. A feladatokhoz használt kód megtalálható az eljárást követő példában.

A MegoldáskezelőEchoClient projektjében kattintson duplán a App.config elemre a fájl Visual Studio-szerkesztőben való megnyitásához.
Az <appSettings> elemben cserélje le a helyőrzőket a szolgáltatási névtér nevére, valamint a korábbi lépésben másolt SAS-kulcsra.

Az elemen system.serviceModel belül adjon hozzá egy <client> elemet.

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

Ez a kód azt deklarálja, hogy WCF-stílusú ügyfélalkalmazást definiál.

A client elemen belül határozza meg a nevet, a szerződést és a kötéstípust a végponthoz.
```
<endpoint name="RelayEndpoint"
                contract="Microsoft.ServiceBus.Samples.IEchoContract"
                binding="netTcpRelayBinding"/>
```
Ez a kód határozza meg a végpont nevét. Emellett meghatározza a szolgáltatásban definiált szerződést, valamint azt a tényt, hogy az ügyfélalkalmazás TCP-t használ az Azure Relaynel való kommunikációhoz. A következő lépés a végpont neve használatával ezt a végpont-konfigurációt összekapcsolja a szolgáltatás URI-jával.
Válassza azÖsszes fájl> mentése lehetőséget.

Példa a App.config fájlra

Az alábbi kód az Echo-ügyfélApp.config fájlját mutatja.

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

A WCF-ügyfél implementálása

Ebben a szakaszban egy alapszintű ügyfélalkalmazást implementál, amely hozzáfér az oktatóanyagban korábban létrehozott szolgáltatáshoz. A szolgáltatáshoz hasonlóan az ügyfél számos műveletet hajt végre az Azure Relay eléréséhez:

Beállítja a csatlakozási módot.
Létrehozza a gazdaszolgáltatás helyét megadó URI-t.
Megadja a biztonsági hitelesítő adatokat.
Alkalmazza a hitelesítő adatokat a kapcsolatra.
Megnyitja a kapcsolatot.
Végrehajtja az alkalmazásspecifikus feladatokat.
Bezárja a kapcsolatot.

Az egyik fő különbség azonban az, hogy az ügyfélalkalmazás egy csatornát használ a továbbítási szolgáltatáshoz való csatlakozáshoz. A szolgáltatás a ServiceHost hívását használja. A feladatokhoz használt kód megtalálható az eljárást követő példában.

Ügyfélalkalmazás implementálása

A csatlakozási mód beállítása legyen AutoDetect. Adja hozzá a következő kódot az EchoClient alkalmazás Main() metódusában.
```
ServiceBusEnvironment.SystemConnectivity.Mode = ConnectivityMode.AutoDetect;
```

Határozzon meg változókat, amelyek a konzolról beolvasott szolgáltatásnévtér és SAS-kulcs értékeit tárolják.

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

Hozza létre azt az URI-t, amely meghatározza a gazdagép helyét a Relay-projektben.

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

Hozza létre a hitelesítő objektumot a szolgáltatásnévtér végpontjához.

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

Hozza létre a csatorna-előállítót, amely betölti a App.config fájlban leírt konfigurációt.
```
ChannelFactory<IEchoChannel> channelFactory = new ChannelFactory<IEchoChannel>("RelayEndpoint", new EndpointAddress(serviceUri));
```
A csatornagyár egy WCF-objektum, amely létrehoz egy csatornát, amelyen keresztül a szolgáltatás és az ügyfélalkalmazások kommunikálnak.

Alkalmazza a hitelesítő adatokat.

channelFactory.Endpoint.Behaviors.Add(sasCredential);

Hozza létre és nyissa meg a csatornát a szolgáltatás felé.

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

Írja meg az Echo alapszintű felhasználói felületét és funkcióit.

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

A kód a csatornaobjektum példányát használja a szolgáltatás proxyjaként.

Zárja be a csatornát, és zárja be a gyárat.
```
channel.Close();
channelFactory.Close();
```

Példakód ehhez az oktatóanyaghoz

A kitöltött kódnak a következőképpen kell megjelennie. Ez a kód bemutatja, hogyan hozhat létre ügyfélalkalmazást, hogyan hívhatja meg a szolgáltatás műveleteit, és hogyan zárhatja be az ügyfelet a műveleti hívás befejezése után.

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

        }
    }
}

Az alkalmazások futtatása

A megoldás létrehozásához válassza a Ctrl+Shift+B billentyűkombinációt. Ez a művelet az előző lépésekben létrehozott ügyfélprojektet és szolgáltatásprojektet is létrehozza.
Az ügyfélalkalmazás futtatása előtt győződjön meg arról, hogy a szolgáltatásalkalmazás fut. A Megoldáskezelőben kattintson a jobb gombbal az EchoService megoldásra, majd válassza a Tulajdonságok lehetőséget.
A Tulajdonságlapok területen válassza a Common Properties Startup Project ( Közös tulajdonságok>indítási projektje) elemet, majd válassza a Több indítási projekt lehetőséget. Győződjön meg arról, hogy a lista első eleme az EchoService.
Az Action (Művelet) mezőt állítsa az EchoService és az EchoClient projekt esetén is Start (Indítás) értékűre.
Válassza a Projektfüggőségek lehetőséget. A Projektek területen válassza az EchoClient lehetőséget. A Függők beállításnál győződjön meg arról, hogy az EchoService ki van jelölve.
A Tulajdonságlapok bezárásához kattintson az OK gombra.
Mindkét projekt futtatásához válassza az F5 lehetőséget.
Mindkét konzolablak megnyílik, és a rendszer a névtér nevének megadását kéri. Először a szolgáltatásnak kell futnia, ezért az EchoService konzolablakban adja meg a névteret, majd válassza az Enter lehetőséget.
Ezután a konzol rákérdez az SAS-kulcsra. Írja be az SAS-kulcsot, és válassza az Enter lehetőséget.

Íme egy példa a konzolablak kimenetére. Az itt szereplő értékek csak példák.

Your Service Namespace: myNamespace

Your SAS Key: <SAS key value>

A szolgáltatásalkalmazás a konzolablakba írja a címet, amelyen figyel, ahogyan az az előbbi példában is látható.

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

Press [Enter] to exit
Az EchoClient konzolablakában adja meg a korábban a szolgáltatásalkalmazáshoz megadott adatokat. Adja meg ugyanazokat a szolgáltatásnévtereket és SAS-kulcsértékeket az ügyfélalkalmazáshoz.
Az értékek megadása után az ügyfél megnyit egy csatornát a szolgáltatás felé, és szövegbevitelre kéri, ahogyan az az alábbi példa konzolkimenetben látható.

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

Írjon be egy szöveget, és küldje el a szolgáltatásalkalmazásnak, majd válassza az Enter lehetőséget. Ezt a szöveget az Echo szolgáltatásműveleten keresztül küldi el a rendszer a szolgáltatásnak, és megjelenik a szolgáltatás konzolablakában, ahogyan az az alábbi példa kimenetben látható.

Echoing: My sample text

Az ügyfélalkalmazás fogadja az Echo művelet visszaadott értékét, amely az eredeti szöveg, és a konzolablakba írja. Az alábbi szöveg az ügyfélkonzol ablakának kimenete.

Server echoed: My sample text
Ezzel a módszerrel folytathatja szöveges üzenetek küldését az ügyfélről a szolgáltatásba. Ha végzett, válassza az Enter lehetőséget az ügyfél- és szolgáltatáskonzol ablakaiban mindkét alkalmazás befejezéséhez.

Következő lépések

Folytassa a következő oktatóanyaggal:

Helyszíni WCF REST-szolgáltatás közzététele egy saját hálózaton kívüli ügyfélen

Megosztás a következőn keresztül: