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
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 :
Välj en Azure-prenumeration där du vill skapa namnområdet.
För Resursgrupp väljer du en befintlig resursgrupp där du vill placera namnområdet eller skapar en ny.
Ange ett namn för Relay-namnområdet.
Välj den region där ditt namnområde ska finnas.
Välj Granska + skapa längst ned på sidan.
På sidan Granska + skapa väljer du Skapa.
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
tillMicrosoft.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 namnetIEchoContract
och tillämparServiceContractAttribute
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ärdIEchoContract
som kontraktet exponerar i gränssnittet och tillämparOperationContractAttribute
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ådaIEchoContract
och även från gränssnittetIClientChannel
, 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änssnittetIEchoContract
. KlassenEchoService
implementerar gränssnittetIEchoContract
.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 klassenEchoService
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änssnittetIEchoContract
i klassenEchoService
.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
AutoDetect
fö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 angeConnectivityMode.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
tillprivate
kan en klient fortfarande komma åt tjänsten. Tjänsten visas dock inte när den söker iRelay
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:
- Högerklicka på den aktuella lösningen (inte projektet) i Solution Explorer och välj Lägg till>nytt projekt.
- I Lägg till ett nytt projekt väljer du Konsolapp (.NET Framework) för C# och väljer Nästa.
- 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
tillMicrosoft.ServiceBus.Samples
.Installera Service Bus NuGet-paketet:
Högerklicka på EchoClient i Solution Explorer och välj sedan Hantera NuGet-paket.
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 iMain()
-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: