Självstudie: Exponera en lokal Rest-tjänst för Windows Communication Foundation (WCF) för en extern klient med hjälp av Azure WCF Relay

Artikel
12/11/2024

I den här självstudien beskrivs hur du skapar ett WCF Relay-klientprogram och en tjänst med hjälp av Azure Relay. Precis som de ursprungliga WCF-motsvarigheterna är en tjänst en konstruktion som exponerar en eller flera slutpunkter. Varje slutpunkt exponerar en eller flera tjänståtgärder. Slutpunkten för en tjänst anger en adress där tjänsten kan hittas, en bindning som innehåller den information som en klient måste kommunicera med tjänsten och ett kontrakt som definierar de funktioner som tillhandahålls av tjänsten till sina klienter. Den största skillnaden mellan WCF och WCF Relay är att slutpunkten exponeras i molnet i stället för lokalt på datorn.

När du har gått igenom sekvensen med avsnitt i den här självstudien har du en tjänst som körs. Du har också en klient som kan anropa tjänstens åtgärder.

Du utför följande uppgifter i den här självstudien:

Installera förutsättningar för den här självstudien.
Skapa ett Relay-namnområde.
Skapa ett WCF-tjänstkontrakt.
Implementera WCF-kontraktet.
Värd och kör WCF-tjänsten för att registrera dig för Relay-tjänsten.
Skapa en WCF-klient för tjänstkontraktet.
Konfigurera WCF-klienten.
Implementera WCF-klienten.
Kör programmen.

Förutsättningar

För att slutföra den här självstudien, finns följande förhandskrav:

En Azure-prenumeration Om du inte har ett konto kan du skapa ett kostnadsfritt konto innan du börjar.
Visual Studio 2015 eller senare. Exemplen i den här självstudien använder Visual Studio 2019.
Azure SDK för .NET. Installera det från den nedladdningssidan för SDK.

Skapa ett Relay-namnområde

Det första steget är att skapa ett namnområde och hämta en SAS-nyckel (signatur för delad åtkomst). Ett namnområde ger en appgräns för varje app som exponeras via Relay-tjänsten. En SAS-nyckel genereras automatiskt av systemet när ett tjänstnamnområde skapas. Kombinationen av tjänstens namnområde och SAS-nyckeln ger referensen för Azure som används för att tillåta åtkomst till ett program.

Logga in på Azure-portalen.
Välj Alla tjänster på den vänstra menyn. Välj Integrering, sök efter Reläer, flytta musen över Reläer och välj sedan Skapa.
Följ dessa steg på sidan Skapa namnområde :
1. Välj en Azure-prenumeration där du vill skapa namnområdet.
2. För Resursgrupp väljer du en befintlig resursgrupp där du vill placera namnområdet eller skapar en ny.
3. Ange ett namn för Relay-namnområdet.
4. Välj den region där ditt namnområde ska finnas.
5. Välj Granska + skapa längst ned på sidan.
6. På sidan Granska + skapa väljer du Skapa.
7. Efter några minuter visas sidan Relay för namnområdet.

Få autentiseringsuppgifter för hantering

På sidan Relay väljer du Principer för delad åtkomst på den vänstra menyn.
På sidan Principer för delad åtkomst väljer du RootManageSharedAccessKey.
Under SAS-princip: RootManageSharedAccessKey väljer du knappen Kopiera bredvid Primär anslutningssträng. Den här åtgärden kopierar anslutningssträng till Urklipp för senare användning. Klistra in det här värdet i Anteckningar eller på en tillfällig plats.
Upprepa föregående steg för att kopiera och klistra in värdet för primärnyckeln till en tillfällig plats för senare användning.

Definiera ett WCF-tjänstkontrakt

Tjänstkontraktet anger vilka åtgärder tjänsten stöder. Åtgärder är webbtjänstmetoder eller funktioner. Kontrakt skapas genom att definiera ett gränssnitt för C++, C# eller Visual Basic. Varje metod i gränssnittet motsvarar en viss tjänsteåtgärd. Attributet ServiceContractAttribute måste tillämpas på varje gränssnitt och attributet OperationContractAttribute måste tillämpas på varje åtgärd. Om en metod i ett gränssnitt som har attributet ServiceContractAttribute inte har attributet OperationContractAttribute exponeras inte den metoden. Koden för dessa arbetsuppgifter visas in exemplet som följer efter proceduren. En större diskussion om kontrakt och tjänster finns i Designa och implementera tjänster.

Skapa ett reläkontrakt med ett gränssnitt

Starta Microsoft Visual Studio som administratör. Det gör du genom att högerklicka på Visual Studio-programikonen och välja Kör som administratör.
I Visual Studio väljer du Skapa ett nytt projekt.
I Skapa ett nytt projekt väljer du Konsolapp (.NET Framework) för C# och väljer Nästa.
Ge projektet namnet EchoService och välj Skapa.
Högerklicka på projektet i Solution Explorer och välj Hantera NuGet-paket. I NuGet Package Manager väljer du Bläddra, söker sedan efter och väljer WindowsAzure.ServiceBus. Välj Installera och godkänn användningsvillkoren.

Det här paketet lägger automatiskt till referenser till Service Bus-biblioteken och WCF System.ServiceModel. System.ServiceModel är det namnområde som ger dig programmatisk åtkomst till de grundläggande funktionerna i WCF. Service Bus använder många av WFC:s objekt och attribut för att definiera tjänstekontrakt.
Lägg till följande using instruktioner överst i Program.cs:
```
using System.ServiceModel;
using Microsoft.ServiceBus;
```
Ändra namnet på namnområdet från standardnamnet EchoService till Microsoft.ServiceBus.Samples.

Viktigt!

I den här självstudien används C#-namnområdet Microsoft.ServiceBus.Samples som är namnområdet för den kontraktsbaserade hanterade typen som används i konfigurationsfilen i avsnittet Konfigurera WCF-klienten . Du kan ange valfritt namnområde när du skapar det här exemplet. Självstudien fungerar dock inte om du inte ändrar namnrymderna för kontraktet och tjänsten i enlighet med detta i programkonfigurationsfilen. Namnområdet som anges i filen App.config måste vara samma som det namnområde som anges i C#-filerna.
Direkt efter namnområdesdeklarationen Microsoft.ServiceBus.Samples , men inom namnområdet, definierar du ett nytt gränssnitt med namnet IEchoContract och tillämpar ServiceContractAttribute attributet på gränssnittet med ett namnområdesvärde på https://samples.microsoft.com/ServiceModel/Relay/. Klistra in följande kod efter namnområdesdeklarationen:
```
[ServiceContract(Name = "IEchoContract", Namespace = "https://samples.microsoft.com/ServiceModel/Relay/")]
public interface IEchoContract
{
}
```
Namnområdesvärdet skiljer sig från det namnområde som du använder under hela intervallet för din kod. Istället används namnområdesvärdet som en unik identifierare för det här kontraktet. Genom att ange namnområdet uttryckligen förhindrar du att det förvalda namnområdesvärdet läggs till i kontraktnamnet.

Kommentar

Namnområdet för tjänstekontraktet innehåller vanligtvis ett namngivningsschema som inkluderar information om versionen. Om du tar med versionsinformation i namnområdet för tjänstekontraktet kan tjänsterna isolera större ändringar genom att definiera ett nytt tjänstkontrakt med ett nytt namnområde och sedan exponera det på en ny slutpunkt. På så sätt kan klienter fortsätta att använda det gamla tjänstkontraktet utan att behöva uppdateras. Versionsinformation kan bestå av ett datum eller ett build-nummer. Mer information finns i Versionshantering för tjänster. I den här självstudien innehåller namngivningsschemat för namnområdet för tjänstkontraktet inte versionsinformation.
IEchoContract I gränssnittet deklarerar du en metod för den enda åtgärd IEchoContract som kontraktet exponerar i gränssnittet och tillämpar OperationContractAttribute attributet på den metod som du vill exponera som en del av det offentliga WCF Relay-kontraktet enligt följande:
```
[OperationContract]
string Echo(string text);
```
Direkt efter gränssnittsdefinitionen IEchoContract deklarerar du en kanal som ärver egenskaper från båda IEchoContract och även från gränssnittet IClientChannel, som visas här:
```
public interface IEchoChannel : IEchoContract, IClientChannel { }
```
En kanal är det WCF-objekt via vilken värden och klienten skickar information till varandra. Senare skriver du kod mot kanalen för att upprepa information mellan de två programmen.
Välj Skapa>bygglösning eller välj Ctrl+Skift+B för att bekräfta noggrannheten i ditt arbete hittills.

Exempel på ett WCF-kontrakt

Följande kod visar ett grundläggande gränssnitt som definierar ett WCF Relay-kontrakt.

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

Nu när gränssnittet har skapats kan du implementera det.

Implementera WCF-kontraktet

När du skapar ett Azure Relay måste du först skapa kontraktet med hjälp av ett gränssnitt. Mer information om hur du skapar gränssnittet finns i föregående avsnitt. Nästa procedur implementerar gränssnittet. Den här uppgiften innebär att skapa en klass med namnet EchoService som implementerar det användardefinierade IEchoContract gränssnittet. När du har implementerat gränssnittet konfigurerar du sedan gränssnittet med hjälp av en App.config-konfigurationsfil . Konfigurationsfilen innehåller nödvändig information för programmet. Den här informationen omfattar namnet på tjänsten, namnet på kontraktet och vilken typ av protokoll som används för att kommunicera med relätjänsten. Koden som används för dessa uppgifter finns i exemplet som följer proceduren. En mer allmän diskussion om hur du implementerar ett tjänstkontrakt finns i Implementera tjänstkontrakt.

Skapa en ny klass med namnet EchoService direkt efter definitionen av gränssnittet IEchoContract. Klassen EchoService implementerar gränssnittet IEchoContract.
```
class EchoService : IEchoContract
{
}
```
Precis som med andra gränssnittsimplementeringar kan du implementera definitionen i en annan fil. Men i den här självstudiekursen ligger implementeringen i samma fil som gränssnittsdefinitionen och Main()-metoden.
Tillämpa attributet ServiceBehaviorAttribute på gränssnittet IEchoContract. Attributet anger namnet på tjänsten och på namnområdet. När du har gjort det, visas klassen EchoService på följande sätt:
```
[ServiceBehavior(Name = "EchoService", Namespace = "https://samples.microsoft.com/ServiceModel/Relay/")]
class EchoService : IEchoContract
{
}
```

Implementera metoden Echo som definierats i gränssnittet IEchoContract i klassen EchoService.

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

Välj Skapa>bygglösning eller välj Ctrl+Skift+B.

Definiera konfigurationen för tjänstvärden

Konfigurationsfilen liknar en WCF-konfigurationsfil. Den innehåller tjänstnamn, slutpunkt och bindning. Slutpunkten är den plats som Azure Relay exponerar för klienter och värdar att kommunicera med varandra. Bindningen är den typ av protokoll som används för att kommunicera. Den största skillnaden är att den här konfigurerade tjänstslutpunkten refererar till en NetTcpRelayBinding-bindning , som inte ingår i .NET Framework. NetTcpRelayBinding är en av bindningarna som definieras av tjänsten.

Dubbelklicka på App.config i Solution Explorer för att öppna filen i Visual Studio-redigeraren.
I -elementet <appSettings> ersätter du platshållarna med namnet på ditt Azure Relay-namnområde och DEN SAS-nyckel som du kopierade i ett tidigare steg.
Lägg till ett <services>-element inom taggarna <system.serviceModel>. Du kan definiera flera reläprogram i en enda konfigurationsfil. I den här självstudiekursen definieras dock bara en.
```
<?xmlversion="1.0" encoding="utf-8"?>
<configuration>
  <system.serviceModel>
    <services>

    </services>
  </system.serviceModel>
</configuration>
```
Inne i elementet <services> element lägger du till ett <service>-element för att definiera namnet på tjänsten.
```
<service name="Microsoft.ServiceBus.Samples.EchoService">
</service>
```
Definiera platsen för slutpunktskontraktet inne i elementet <service> och även typen av bindning för slutpunkten.
```
<endpoint contract="Microsoft.ServiceBus.Samples.IEchoContract" binding="netTcpRelayBinding"/>
```
Slutpunkten definierar var klienten ska söka efter värdprogrammet. Senare använder självstudien det här steget för att skapa en URI som helt exponerar värden via Azure Relay. Bindningen deklarerar att vi använder TCP som protokoll för att kommunicera med relätjänsten.
Välj Skapa>bygglösning eller välj Ctrl+Skift+B för att bekräfta noggrannheten i ditt arbete hittills.

Exempel på implementering av ett tjänstkontrakt

Följande kod visar implementeringen av tjänstekontraktet.

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

Följande kod visar det grundläggande formatet för filen App.config som är associerad med tjänstvärden.

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

Värd och kör WCF-tjänsten för att registrera med relay-tjänsten

Det här steget beskriver hur du kör en Azure Relay-tjänst.

Skapa autentiseringsuppgifterna för reläet

Skapa två variabler i Main() där du ska lagra namnområdet och SAS-nyckeln som läses från konsolfönstret.
```
Console.Write("Your Service Namespace: ");
string serviceNamespace = Console.ReadLine();
Console.Write("Your SAS key: ");
string sasKey = Console.ReadLine();
```
SAS-nyckeln används senare för att komma åt projektet. Namnområdet skickas som en parameter till CreateServiceUri för att skapa en URI för tjänsten.
Med hjälp av ett TransportClientEndpointBehavior-objekt deklarerar du att du ska använda en SAS-nyckel som typ av autentiseringsuppgifter. Lägg till följande kod direkt efter den som lades till i det senaste steget.
```
TransportClientEndpointBehavior sasCredential = new TransportClientEndpointBehavior();
sasCredential.TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider("RootManageSharedAccessKey", sasKey);
```

Skapa en basadress för tjänsten

Efter koden som du lade till i föregående avsnitt skapar du en Uri instans för tjänstens basadress. Den här URI anger Service Bus-schemat, namnområdet och sökvägen för tjänstegränssnittet.

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

Värdet "sb" är en förkortning för Service Bus-schemat. Det anger att vi använder TCP som protokoll. Det här schemat angavs också tidigare i konfigurationsfilen när NetTcpRelayBinding angavs som bindning .

URI är sb://putServiceNamespaceHere.windows.net/EchoService för den här självstudiekursen.

Skapa och konfigurera tjänstvärden

Arbetar fortfarande i Main()och ställer in anslutningsläget på AutoDetect.
```
ServiceBusEnvironment.SystemConnectivity.Mode = ConnectivityMode.AutoDetect;
```
Anslutningsläget beskriver det protokoll som tjänsten använder för att kommunicera med relätjänsten. antingen HTTP eller TCP. Med standardinställningen AutoDetectförsöker tjänsten ansluta till Azure Relay via TCP om den är tillgänglig och HTTP om TCP inte är tillgängligt. Det här resultatet skiljer sig från protokollet som tjänsten anger för klientkommunikation. Det här protokollet bestäms av den bindning som används. En tjänst kan till exempel använda bindningen BasicHttpRelayBinding , som anger att dess slutpunkt kommunicerar med klienter via HTTP. Samma tjänst kan ange ConnectivityMode.AutoDetect så att tjänsten kommunicerar med Azure Relay via TCP.
Skapa tjänstevärden med hjälp av den URI som du skapade tidigare i det här avsnittet.
```
ServiceHost host = new ServiceHost(typeof(EchoService), address);
```
Tjänstevärden är det WCF-objekt som instantierar tjänsten. Här skickar du den typ av tjänst som du vill skapa, en EchoService typ och även till den adress där du vill exponera tjänsten.
Överst i filen Program.cs lägger du till referenser till System.ServiceModel.Description och Microsoft.ServiceBus.Description.
```
using System.ServiceModel.Description;
using Microsoft.ServiceBus.Description;
```
När du är tillbaka i Main(), konfigurerar du slutpunkten för att ge allmän åtkomst till den.
```
IEndpointBehavior serviceRegistrySettings = new ServiceRegistrySettings(DiscoveryType.Public);
```
Det här steget informerar relätjänsten om att ditt program kan hittas offentligt genom att undersöka Atom-flödet för projektet. Om du anger DiscoveryType till privatekan en klient fortfarande komma åt tjänsten. Tjänsten visas dock inte när den söker i Relay namnområdet. Klienten måste då i stället känna till sökvägen för slutpunkten på förhand.
Tillämpa autentiseringsuppgifterna för tjänsten på tjänstslutpunkterna som definierats i App.config-filen :
```
foreach (ServiceEndpoint endpoint in host.Description.Endpoints)
{
    endpoint.Behaviors.Add(serviceRegistrySettings);
    endpoint.Behaviors.Add(sasCredential);
}
```
Som tidigare nämnts kunde du ha deklarerat flera tjänster och slutpunkter i konfigurationsfilen. Om du hade gjort detta skulle den här koden ha bläddrat igenom hela konfigurationsfilen och ha sökt efter varje slutpunkt som den skulle ha tillämpat på dina autentiseringsuppgifter. I den här självstudien har konfigurationsfilen bara en slutpunkt.

Öppna tjänstvärden

Fortfarande i Main()lägger du till följande rad för att öppna tjänsten.
```
host.Open();
```

Informera användaren om att tjänsten körs och förklara hur tjänsten stängs av.

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

Stäng tjänstevärden när du är klar.
```
host.Close();
```
Välj Ctrl+Skift+B för att skapa projektet.

Exempel som är värd för en tjänst i ett konsolprogram

Den färdiga tjänstkoden bör visas på följande sätt. Koden innehåller tjänstkontraktet och implementeringen från föregående steg i självstudien och är värd för tjänsten i ett konsolprogram.

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

Skapa en WCF-klient för tjänstekontraktet

Nästa uppgift är att skapa ett klientprogram och definiera det tjänstkontrakt som du ska implementera senare. De här stegen liknar de steg som används för att skapa en tjänst: definiera ett kontrakt, redigera en App.config-fil , använda autentiseringsuppgifter för att ansluta till relätjänsten och så vidare. Den kod som används för dessa arbetsuppgifter visas in exemplet som följer efter proceduren.

Skapa ett nytt projekt i den aktuella Visual Studio-lösningen för klienten:
1. Högerklicka på den aktuella lösningen (inte projektet) i Solution Explorer och välj Lägg till>nytt projekt.
2. I Lägg till ett nytt projekt väljer du Konsolapp (.NET Framework) för C# och väljer Nästa.
3. Ange EchoClient som namnet på projektet och välj Skapa.
Dubbelklicka på Program.cs i Projektet EchoClient i Solution Explorer för att öppna filen i redigeraren om den inte redan är öppen.
Ändra namnet på namnområdet från standardnamnet EchoClient till Microsoft.ServiceBus.Samples.
Installera Service Bus NuGet-paketet:
1. Högerklicka på EchoClient i Solution Explorer och välj sedan Hantera NuGet-paket.
2. Välj Bläddra och sök sedan efter och välj WindowsAzure.ServiceBus. Välj Installera och godkänn användningsvillkoren.
Lägg till en using instruktion för namnområdet System.ServiceModel i filen Program.cs .
```
using System.ServiceModel;
```

Lägga till en definition för tjänstekontraktet i namnområdet, som visas i följande exempel. Den här definitionen är identisk med den definition som används i serviceprojektet . Lägg till den här koden överst i Microsoft.ServiceBus.Samples namnområdet.

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

public interface IEchoChannel : IEchoContract, IClientChannel { }

Välj Ctrl+Skift+B för att skapa klienten.

Exempel på EchoClient-projektet

Följande kod visar aktuell status för Program.cs-filen i EchoClient-projektet.

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

Konfigurera WCF-klienten

I det här steget skapar du en App.config-fil för ett grundläggande klientprogram som kommer åt tjänsten som skapades tidigare i den här självstudien. Den här App.config-filen definierar kontrakt, bindning och namnet på slutpunkten. Den kod som används för dessa arbetsuppgifter visas in exemplet som följer efter proceduren.

Dubbelklicka på App.config i Projektet EchoClient i Solution Explorer för att öppna filen i Visual Studio-redigeraren.
I elementet <appSettings> ersätter du platshållarna med namnet på ditt namnområde för tjänsten och den SAS-nyckel som du kopierade i ett av de föregående stegen.

Lägg till ett <client> element i elementetsystem.serviceModel.

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

Den här koden deklarerar att du definierar ett klientprogram i WCF-stil.

Definiera namnet, kontraktet och bindningstypen för slutpunkten inom elementet client.
```
<endpoint name="RelayEndpoint"
                contract="Microsoft.ServiceBus.Samples.IEchoContract"
                binding="netTcpRelayBinding"/>
```
Den här koden definierar namnet på slutpunkten. Det definierar också kontraktet som definierats i tjänsten och det faktum att klientprogrammet använder TCP för att kommunicera med Azure Relay. Namnet på slutpunkten används i nästa steg för att länka samman denna slutpunktskonfiguration med URI:n för tjänsten.
Välj Spara>alla.

Exempel på app.config-filen

Följande kod visar Filen App.config för Echo-klienten.

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

Implementera WCF-klienten

I det här avsnittet implementerar du ett grundläggande klientprogram som kommer åt tjänsten som du skapade tidigare i den här självstudien. På samma sätt som med tjänsten utför klienten många av samma åtgärder för att få åtkomst till Azure Relay:

Ställer in anslutningsläget.
Skapar den URI som lokaliserar värdtjänsten.
Definierar säkerhetsautentiseringen.
Tillämpar autentiseringsuppgifterna på anslutningen.
Öppnar anslutningen.
Utför de programspecifika uppgifterna.
Stänger ned anslutningen.

En av de största skillnaderna är dock att klientprogrammet använder en kanal för att ansluta till relätjänsten. Tjänsten använder ett anrop till ServiceHost. Den kod som används för dessa arbetsuppgifter visas in exemplet som följer efter proceduren.

Implementera ett klientprogram

Ställ in anslutningsläget på AutoDetect. Lägg till följande kod inne i Main()-metoden för EchoClient-programmet.
```
ServiceBusEnvironment.SystemConnectivity.Mode = ConnectivityMode.AutoDetect;
```

Definiera variabler för att lagra värdena för tjänstens namnområde och den SAS-nyckel som läses från konsolen.

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

Skapa den URI som definierar platsen för värden i ditt Relay-projekt.

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

Skapa autentiseringsobjektet för slutpunkten för tjänstens namnområde.

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

Skapa kanalfabriken som läser in konfigurationen som beskrivs i App.config-filen .
```
ChannelFactory<IEchoChannel> channelFactory = new ChannelFactory<IEchoChannel>("RelayEndpoint", new EndpointAddress(serviceUri));
```
En kanalfabriken är ett WCF-objekt som skapar en kanal via vilken tjänsten och klientprogrammet kan kommunicera.

Använd autentiseringsuppgifterna.

channelFactory.Endpoint.Behaviors.Add(sasCredential);

Skapa och öppna kanalen till tjänsten.

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

Skriv det grundläggande gränssnittet och funktionerna för ekot.

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

Koden använder instansen av kanalobjektet som proxy för tjänsten.

Stäng kanalen och stäng fabriken.

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

Exempelkod för den här självstudien

Den färdiga koden bör visas på följande sätt. Den här koden visar hur du skapar ett klientprogram, hur du anropar tjänstens åtgärder och hur du stänger klienten när åtgärdsanropet är klart.

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

        }
    }
}

Kör programmen

Välj Ctrl+Skift+B för att skapa lösningen. Den här åtgärden bygger både klientprojektet och tjänstprojektet som du skapade i föregående steg.
Du måste se till att tjänsteprogrammet körs innan du startar klientprogrammet. Högerklicka på EchoService-lösningen i Solution Explorer och välj sedan Egenskaper.
I Egenskapssidor väljer du Startprojekt för vanliga egenskaper>och sedan Flera startprojekt. Kontrollera att EchoService visas först i listan.
Ställ in rutan Åtgärd för både EchoService- och EchoClient-projektet på Starta.
Välj Projektberoenden. I Projekt väljer du EchoClient. För Beror på kontrollerar du att EchoService är valt.
Välj OK för att stänga egenskapssidor.
Välj F5 för att köra båda projekten.
Båda konsolfönstren öppnas och uppmanar dig att ange namnet på namnområdet. Tjänsten måste köras först, så i EchoService-konsolfönstret anger du namnområdet och väljer sedan Retur.
Därefter uppmanas du att ange din SAS-nyckel i konsolen. Ange SAS-nyckeln och välj Retur.

Här är exempel på utdata från konsolfönstret. Värdena här är bara exempel.

Your Service Namespace: myNamespace

Your SAS Key: <SAS key value>

Tjänsteprogrammet skriver till konsolfönstret, till adressen som den lyssnar på, som visas i följande exempel.

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

Press [Enter] to exit
Ange samma information som du angav tidigare för tjänsteprogrammet i konsolfönstret för EchoClient. Ange samma tjänstnamnområde och SAS-nyckelvärden för klientprogrammet.
När du har angett dessa värden öppnar klienten en kanal till tjänsten och uppmanar dig att ange text som visas i följande konsolutdataexempel.

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

Ange text som ska skickas till tjänstprogrammet och välj Retur. Texten skickas till tjänsten via tjänsteåtgärden Echo och visas i tjänstekonsolfönstret, som i följande exempelutmatning.

Echoing: My sample text

Klientprogrammet får returvärdet för Echo-åtgärden, som är den ursprungliga texten, och skriver ut denna i sitt konsolfönster. Följande text är exempelutdata från klientkonsolfönstret.

Server echoed: My sample text
Du kan fortsätta att skicka textmeddelanden från klienten till tjänsten på detta sätt. När du är klar väljer du Retur i klient- och tjänstkonsolens fönster för att avsluta båda programmen.

Gå vidare

Fortsätt till följande självstudie:

Exponera en lokal WCF REST-tjänst för en klient utanför nätverket

Dela via