Samouczek: uwidacznia lokalną usługę REST WCF dla klienta zewnętrznego przy użyciu usługi Azure WCF Relay

W tym samouczku opisano sposób tworzenia aplikacji klienckiej usługi WCF Relay i usługi przy użyciu usługi Azure Relay. Podobnie jak w przypadku oryginalnych odpowiedników WCF, usługa jest konstrukcją, która uwidacznia co najmniej jeden punkt końcowy. Każdy punkt końcowy uwidacznia co najmniej jedną operację usługi. Punkt końcowy usługi określa adres , w którym można znaleźć usługę, powiązanie zawierające informacje, które klient musi komunikować się z usługą, oraz kontrakt definiujący funkcjonalność zapewnianą przez usługę klientom. Główną różnicą między usługami WCF i WCF Relay jest to, że punkt końcowy jest uwidoczniony w chmurze zamiast lokalnie na komputerze.

Po zapoznaniu się z sekwencją sekcji w tym samouczku będziesz mieć uruchomioną usługę. Będziesz również mieć klienta, który może wywoływać operacje usługi.

W tym samouczku wykonasz następujące zadania:

• Zainstaluj wymagania wstępne dotyczące tego samouczka.
• Utwórz przestrzeń nazw usługi Relay.
• Utwórz kontrakt usługi WCF.
• Zaimplementuj kontrakt WCF.
• Hostuj i uruchom usługę WCF, aby zarejestrować się w usłudze Relay.
• Utwórz klienta WCF dla kontraktu usługi.
• Skonfiguruj klienta programu WCF.
• Zaimplementuj klienta WCF.
• Uruchom aplikacje.

Wymagania wstępne

Do wykonania kroków tego samouczka niezbędne jest spełnienie następujących wymagań wstępnych:

• Subskrypcja platformy Azure. Jeśli go nie masz, przed rozpoczęciem utwórz bezpłatne konto .
• Program Visual Studio 2015 lub nowszy. Przykłady w tym samouczku używają programu Visual Studio 2019.
• Zestaw Azure SDK dla platformy .NET. Zainstaluj go ze strony pobierania zestawu SDK.

Tworzenie przestrzeni nazw usługi Relay

Pierwszym krokiem jest utworzenie przestrzeni nazw i uzyskanie klucza sygnatury dostępu współdzielonego (SAS, Shared Access Signature). Przestrzeń nazw wyznacza granice każdej aplikacji uwidacznianej za pośrednictwem usługi przekaźnika. Klucz sygnatury dostępu współdzielonego jest generowany automatycznie przez system po utworzeniu przestrzeni nazw usługi. Kombinacja przestrzeni nazw i klucza sygnatury dostępu współdzielonego usługi dostarcza poświadczenia dla platformy Azure w celu uwierzytelnienia dostępu do aplikacji.

1. Zaloguj się w witrynie Azure Portal.

2. Wybierz pozycję Wszystkie usługi w menu po lewej stronie. Wybierz pozycję Integracja, wyszukaj pozycję Przekaźniki, przenieś mysz nad przekaźnikami, a następnie wybierz pozycję Utwórz.

   

3. Na stronie Tworzenie przestrzeni nazw wykonaj następujące kroki:

   1. Wybierz subskrypcję platformy Azure, w której chcesz utworzyć przestrzeń nazw.

   2. W obszarze Grupa zasobów wybierz istniejącą grupę zasobów, w której chcesz umieścić przestrzeń nazw, lub utwórz nową.

   3. Wprowadź nazwę przestrzeni nazw usługi Relay.

   4. Wybierz region, w którym ma być hostowana przestrzeń nazw.

   5. Wybierz pozycję Przejrzyj i utwórz w dolnej części strony.

      

   6. Na stronie Przeglądanie i tworzenie wybierz pozycję Utwórz.

   7. Po kilku minutach zostanie wyświetlona strona Przekaźnik dla przestrzeni nazw.

      

Uzyskiwanie poświadczeń zarządzania

1. Na stronie Przekaźnik wybierz pozycję Zasady dostępu współdzielonego w menu po lewej stronie. `

2. Na stronie Zasady dostępu współdzielonego wybierz pozycję RootManageSharedAccessKey.

3. W obszarze Zasady sygnatury dostępu współdzielonego: RootManageSharedAccessKey wybierz przycisk Kopiuj obok pozycji Podstawowe parametry połączenia. Ta akcja kopiuje parametry połączenia do schowka do późniejszego użycia. Wklej tę wartość do Notatnika lub innej tymczasowej lokalizacji.

4. Powtórz poprzedni krok w celu skopiowania i wklejenia wartości pozycji Klucz podstawowy w lokalizacji tymczasowej do późniejszego użycia.

   

Definiowanie kontraktu usługi WCF

Kontrakt usługi określa operacje obsługiwane przez usługę. Operacje to metody lub funkcje usługi internetowej. Kontrakty są tworzone przez definiowanie interfejsu C++, C# lub Visual Basic. Każda metoda w interfejsie odpowiada określonej operacji usługi. W odniesieniu do każdego interfejsu należy zastosować atrybut ServiceContractAttribute, a w odniesieniu do każdej operacji należy zastosować atrybut OperationContractAttribute. Jeśli metoda w interfejsie z atrybutem ServiceContractAttribute nie ma atrybutu OperationContractAttribute , ta metoda nie jest uwidoczniona. Kod dla tych zadań podano w przykładzie zamieszczonym na końcu procedury. Aby zapoznać się z większą dyskusją na temat kontraktów i usług, zobacz Projektowanie i implementowanie usług.

Tworzenie kontraktu przekaźnika za pomocą interfejsu

1. Uruchom program Microsoft Visual Studio jako administrator. W tym celu kliknij prawym przyciskiem myszy ikonę programu Visual Studio i wybierz polecenie Uruchom jako administrator.

2. W programie Visual Studio wybierz pozycję Utwórz nowy projekt.

3. W obszarze Utwórz nowy projekt wybierz pozycję Aplikacja konsolowa (.NET Framework) dla języka C#, a następnie wybierz pozycję Dalej.

4. Nadaj projektowi nazwę EchoService i wybierz pozycję Utwórz.

   

5. W Eksplorator rozwiązań kliknij prawym przyciskiem myszy projekt i wybierz polecenie Zarządzaj pakietami NuGet. W Menedżerze pakietów NuGet wybierz pozycję Przeglądaj, a następnie wyszukaj i wybierz pozycję WindowsAzure.ServiceBus. Wybierz pozycję Zainstaluj i zaakceptuj warunki użytkowania.

   

   Ten pakiet automatycznie dodaje odwołania do bibliotek usługi Service Bus i programu WCF System.ServiceModel. System.ServiceModel jest przestrzenią nazw umożliwiającą programowy dostęp do podstawowych funkcji platformy WCF. Usługa Service Bus używa wielu obiektów i atrybutów usługi WCF do definiowania kontraktów usług.

6. Dodaj następujące using instrukcje w górnej części pliku Program.cs:

   using System.ServiceModel;
   using Microsoft.ServiceBus;
   

7. Zmień nazwę przestrzeni nazw z domyślnej nazwy EchoService na Microsoft.ServiceBus.Samples.

   Ważne

   W tym samouczku użyto przestrzeni nazw języka C#, która jest przestrzenią Microsoft.ServiceBus.Samples nazw typu zarządzanego opartego na kontrakcie, który jest używany w pliku konfiguracji w sekcji Konfigurowanie klienta WCF . Możesz określić dowolną przestrzeń nazw, którą chcesz utworzyć podczas tworzenia tego przykładu. Jednak samouczek nie będzie działać, chyba że następnie zmodyfikujesz przestrzenie nazw kontraktu i usługi odpowiednio w pliku konfiguracji aplikacji. Przestrzeń nazw określona w pliku App.config musi być taka sama jak przestrzeń nazw określona w plikach języka C#.

8. Bezpośrednio po Microsoft.ServiceBus.Samples deklaracji przestrzeni nazw, ale w przestrzeni nazw zdefiniuj nowy interfejs o nazwie IEchoContract i zastosuj ServiceContractAttribute atrybut do interfejsu z wartością przestrzeni nazw .https://samples.microsoft.com/ServiceModel/Relay/ Wklej następujący kod po deklaracji przestrzeni nazw:

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

   Wartość przestrzeni nazw różni się od przestrzeni nazw używanej w kodzie. Zamiast tego wartość przestrzeni nazw jest używana jako unikatowy identyfikator dla tego kontraktu. Jawne określenie przestrzeni nazw zapobiega dodawaniu domyślnej wartości przestrzeni nazw do nazwy kontraktu.

   Uwaga

   Zazwyczaj przestrzeń nazw kontraktu usługi zawiera schemat nazewnictwa uwzględniający informacje o wersji. Uwzględnienie informacji o wersji w przestrzeni nazw kontraktu usługi umożliwia usługom izolowanie istotnych zmian przez zdefiniowanie nowego kontraktu usługi z nową przestrzenią nazw i ujawnienie go w nowym punkcie końcowym. W ten sposób klienci mogą nadal korzystać ze starego kontraktu usługi bez konieczności aktualizowania. Informacje o wersji mogą zawierać datę lub numer kompilacji. Aby uzyskać więcej informacji, zobacz Service Versioning (Obsługa wersji usług). W tym samouczku schemat nazewnictwa przestrzeni nazw kontraktu usługi nie zawiera informacji o wersji.

9. W interfejsie IEchoContract zadeklaruj metodę dla pojedynczej operacji IEchoContract uwidacznianej przez kontrakt w interfejsie i zastosuj OperationContractAttribute atrybut do metody, którą chcesz uwidocznić w ramach publicznego kontraktu przekaźnika WCF, w następujący sposób:

   [OperationContract]
   string Echo(string text);
   

10. Bezpośrednio po definicji interfejsu IEchoContract zadeklaruj kanał dziedziczący zarówno po IEchoContract, jak i interfejsie IClientChannel, w sposób pokazany poniżej:

    public interface IEchoChannel : IEchoContract, IClientChannel { }
    

    Kanał jest obiektem platformy WCF, za pomocą którego host i klient przekazują do siebie informacje. Później napiszesz kod w kanale w celu echa informacji między obiema aplikacjami.

11. Wybierz pozycjęKompiluj rozwiązanie kompilacji> lub naciśnij klawisze Ctrl+Shift+B, aby potwierdzić dokładność pracy do tej pory.

Przykład kontraktu programu WCF

Poniższy kod przedstawia podstawowy interfejs, który definiuje kontrakt przekaźnika WCF.

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

Teraz, gdy interfejs został utworzony, możesz go zaimplementować.

Implementowanie kontraktu programu WCF

Utworzenie usługi Azure Relay wymaga, aby najpierw utworzyć kontrakt przy użyciu interfejsu. Aby uzyskać więcej informacji na temat tworzenia interfejsu, zobacz poprzednią sekcję. Następna procedura implementuje interfejs. To zadanie obejmuje utworzenie klasy o nazwie EchoService , która implementuje interfejs zdefiniowany przez IEchoContract użytkownika. Po zaimplementowaniu interfejsu należy skonfigurować interfejs przy użyciu pliku konfiguracji App.config . Plik konfiguracji zawiera niezbędne informacje dotyczące aplikacji. Te informacje obejmują nazwę usługi, nazwę kontraktu oraz typ protokołu używanego do komunikowania się z usługą przekazywania. Kod używany do tych zadań jest podany w przykładzie, który jest zgodny z procedurą. Aby zapoznać się z bardziej ogólnym omówieniem sposobu implementowania kontraktu usługi, zobacz Implementowanie kontraktów usług.

1. Utwórz nową klasę o nazwie EchoService bezpośrednio po definicji interfejsu IEchoContract. Klasa EchoService implementuje interfejs IEchoContract.

   class EchoService : IEchoContract
   {
   }
   

   Podobnie jak w przypadku innych implementacji interfejsów, można zaimplementować definicję w innym pliku. Jednak w przypadku tego samouczka implementację umieszczono w tym samym pliku, w którym znajduje się definicja interfejsu i metoda Main().

2. Zastosuj atrybut ServiceBehaviorAttribute do interfejsu IEchoContract. Ten atrybut określa nazwę usługi i przestrzeń nazw. Po wykonaniu tych czynności klasa EchoService wygląda następująco:

   [ServiceBehavior(Name = "EchoService", Namespace = "https://samples.microsoft.com/ServiceModel/Relay/")]
   class EchoService : IEchoContract
   {
   }
   

3. Zaimplementuj metodę Echo zdefiniowaną w interfejsie IEchoContract w klasie EchoService.

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

4. Wybierz pozycjęKompiluj rozwiązanie kompilacji> lub naciśnij klawisze Ctrl+Shift+B.

Definiowanie konfiguracji hosta usługi

Plik konfiguracji jest podobny do pliku konfiguracji programu WCF. Zawiera ona nazwę usługi, punkt końcowy i powiązanie. Punkt końcowy to lokalizacja uwidacznianą przez usługę Azure Relay dla klientów i hostów w celu komunikowania się ze sobą. Powiązanie jest typem protokołu używanego do komunikacji. Główną różnicą jest to, że ten skonfigurowany punkt końcowy usługi odwołuje się do powiązania NetTcpRelayBinding, które nie jest częścią .NET Framework. NetTcpRelayBinding jest jednym z powiązań zdefiniowanych przez usługę.

1. W Eksplorator rozwiązań kliknij dwukrotnie App.config, aby otworzyć plik w edytorze programu Visual Studio.

2. W elemencie <appSettings> zastąp symbole zastępcze nazwą przestrzeni nazw usługi Azure Relay i kluczem SYGNATURy dostępu współdzielonego skopiowanym we wcześniejszym kroku.

3. W tagach <system.serviceModel> dodaj element <services>. W jednym pliku konfiguracji można zdefiniować wiele aplikacji przekaźnika. W tym samouczku zdefiniowano jednak tylko jedną.

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

4. W elemencie <services> dodaj element <service>, aby zdefiniować nazwę usługi.

   <service name="Microsoft.ServiceBus.Samples.EchoService">
   </service>
   

5. W elemencie <service> zdefiniuj lokalizację kontraktu punktu końcowego i wpisz powiązanie dla punktu końcowego.

   <endpoint contract="Microsoft.ServiceBus.Samples.IEchoContract" binding="netTcpRelayBinding"/>
   

   Punkt końcowy określa, gdzie klient będzie szukać aplikacji hosta. Później samouczek używa tego kroku do utworzenia identyfikatora URI, który w pełni uwidacznia hosta za pośrednictwem usługi Azure Relay. Powiązanie deklaruje, że używamy protokołu TCP jako protokołu do komunikowania się z usługą przekazywania.

6. Wybierz pozycjęKompiluj rozwiązanie kompilacji> lub naciśnij klawisze Ctrl+Shift+B, aby potwierdzić dokładność pracy do tej pory.

Przykład implementacji kontraktu usługi

Poniższy kod przedstawia implementację kontraktu usługi.

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

Poniższy kod przedstawia podstawowy format pliku App.config skojarzonego z hostem usługi.

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

Hostowanie i uruchamianie usługi WCF w celu zarejestrowania się w usłudze przekaźnika

W tym kroku opisano sposób uruchamiania usługi Azure Relay.

Tworzenie poświadczeń przekaźnika

1. W procedurze Main() utwórz dwie zmienne do przechowywania przestrzeni nazw i klucza sygnatury dostępu współdzielonego odczytanego z okna konsoli.

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

   Klucz sygnatury dostępu współdzielonego będzie później używany do uzyskiwania dostępu do projektu. Przestrzeń nazw jest przekazywana jako parametr do procedury CreateServiceUri w celu utworzenia identyfikatora URI.

2. Za pomocą obiektu TransportClientEndpointBehavior zadeklaruj, że jako typ poświadczenia użyjesz klucza SYGNATURy dostępu współdzielonego. Dodaj poniższy kod bezpośrednio po kodzie dodanym w ostatnim kroku.

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

Tworzenie adresu podstawowego dla usługi

Po kodzie dodanym w poprzedniej sekcji utwórz Uri wystąpienie dla podstawowego adresu usługi. Ten identyfikator URI określa schemat magistrali usług, przestrzeń nazw i ścieżkę interfejsu usługi.

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

Wartość "sb" jest skrótem schematu usługi Service Bus. Oznacza to, że używamy protokołu TCP jako protokołu. Ten schemat został również wcześniej wskazany w pliku konfiguracji, gdy parametr NetTcpRelayBinding został określony jako powiązanie.

W tym samouczku użyto identyfikatora URI sb://putServiceNamespaceHere.windows.net/EchoService.

Tworzenie i konfigurowanie hosta usługi

1. Nadal działa w Main()programie , ustaw tryb łączności na AutoDetectwartość .

   ServiceBusEnvironment.SystemConnectivity.Mode = ConnectivityMode.AutoDetect;
   

   Tryb łączności opisuje protokół używany przez usługę do komunikowania się z usługą przekazywania; HTTP lub TCP. Przy użyciu ustawienia AutoDetectdomyślnego usługa próbuje nawiązać połączenie z usługą Azure Relay za pośrednictwem protokołu TCP, jeśli jest dostępna, a protokół HTTP, jeśli protokół TCP jest niedostępny. Ten wynik różni się od protokołu określonego przez usługę na potrzeby komunikacji klienta. Ten protokół jest ustalany na podstawie używanego powiązania. Na przykład usługa może używać powiązania BasicHttpRelayBinding , które określa, że jego punkt końcowy komunikuje się z klientami za pośrednictwem protokołu HTTP. Ta sama usługa może określić ConnectivityMode.AutoDetect , aby usługa komunikowała się z usługą Azure Relay za pośrednictwem protokołu TCP.

2. Utwórz hosta usługi przy użyciu identyfikatora URI utworzonego wcześniej w tej sekcji.

   ServiceHost host = new ServiceHost(typeof(EchoService), address);
   

   Host usługi jest obiektem platformy WCF tworzącym wystąpienie usługi. W tym miejscu przekażesz typ usługi, którą chcesz utworzyć, EchoService typ, a także adres, pod którym chcesz uwidocznić usługę.

3. W górnej części pliku Program.cs dodaj odwołania do elementów System.ServiceModel.Description i Microsoft.ServiceBus.Description.

   using System.ServiceModel.Description;
   using Microsoft.ServiceBus.Description;
   

4. Ponownie w procedurze Main() skonfiguruj punkt końcowy do obsługi dostępu publicznego.

   IEndpointBehavior serviceRegistrySettings = new ServiceRegistrySettings(DiscoveryType.Public);
   

   Ten krok informuje usługę przekazywania, że aplikację można znaleźć publicznie, sprawdzając źródło danych Atom dla projektu. Jeśli ustawisz wartość DiscoveryTypeprivate, klient nadal będzie mógł uzyskać dostęp do usługi. Jednak usługa nie będzie wyświetlana podczas wyszukiwania Relay przestrzeni nazw. Zamiast tego klient musiałby wcześniej znać ścieżkę punktu końcowego.

5. Zastosuj poświadczenia usługi do punktów końcowych usługi zdefiniowanych w pliku App.config :

   foreach (ServiceEndpoint endpoint in host.Description.Endpoints)
   {
       endpoint.Behaviors.Add(serviceRegistrySettings);
       endpoint.Behaviors.Add(sasCredential);
   }
   

   Jak wspomniano wcześniej, w pliku konfiguracji można zadeklarować wiele usług i punktów końcowych. W takim przypadku ten kod pomijałby plik konfiguracji i wyszukiwałby każdy punkt końcowy, do którego powinien zastosować Twoje poświadczenia. W tym samouczku plik konfiguracji ma tylko jeden punkt końcowy.

Otwieranie hosta usługi

1. Nadal w Main()pliku dodaj następujący wiersz, aby otworzyć usługę.

   host.Open();
   

2. Poinformuj użytkownika, że usługa jest uruchomiona, i wyjaśnij, jak zamknąć usługę.

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

3. Po zakończeniu zamknij hosta usługi.

   host.Close();
   

4. Naciśnij klawisze Ctrl+Shift+B, aby skompilować projekt.

Przykład hostujący usługę w aplikacji konsolowej

Ukończony kod usługi powinien zostać wyświetlony w następujący sposób. Kod zawiera kontrakt usługi i implementację z poprzednich kroków w samouczku oraz hostuje usługę w aplikacji konsolowej.

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

Tworzenie klienta platformy WCF dla kontraktu usługi

Następnym zadaniem jest utworzenie aplikacji klienckiej i zdefiniowanie kontraktu usługi, który zostanie zaimplementowany później. Te kroki są podobne do kroków używanych do tworzenia usługi: definiowanie kontraktu, edytowanie pliku App.config , używanie poświadczeń w celu nawiązania połączenia z usługą przekazywania itd. Kod używany do wykonywania tych zadań podano w przykładzie zamieszczonym po procedurze.

1. Utwórz nowy projekt w bieżącym rozwiązaniu programu Visual Studio dla klienta:

   1. W Eksplorator rozwiązań kliknij prawym przyciskiem myszy bieżące rozwiązanie (a nie projekt), a następnie wybierz polecenie Dodaj>nowy projekt.
   2. W obszarze Dodaj nowy projekt wybierz pozycję Aplikacja konsolowa (.NET Framework) dla języka C#, a następnie wybierz przycisk Dalej.
   3. Nadaj projektowi nazwę EchoClient i wybierz pozycję Utwórz.

2. W Eksplorator rozwiązań w projekcie EchoClient kliknij dwukrotnie plik Program.cs, aby otworzyć plik w edytorze, jeśli nie jest jeszcze otwarty.

3. Zmień nazwę przestrzeni nazw z domyślnej nazwy EchoClient na Microsoft.ServiceBus.Samples.

4. Zainstaluj pakiet NuGet usługi Service Bus:

   1. W Eksplorator rozwiązań kliknij prawym przyciskiem myszy pozycję EchoClient, a następnie wybierz polecenie Zarządzaj pakietami NuGet.

   2. Wybierz pozycję Przeglądaj, a następnie wyszukaj i wybierz pozycję WindowsAzure.ServiceBus. Wybierz pozycję Zainstaluj i zaakceptuj warunki użytkowania.

      

5. Dodaj instrukcję using dla przestrzeni nazw System.ServiceModel w pliku Program.cs .

   using System.ServiceModel;
   

6. Dodaj definicję kontraktu usługi do przestrzeni nazw jak pokazano w poniższym przykładzie. Ta definicja jest identyczna z definicją używaną w projekcie usługi . Dodaj ten kod w górnej Microsoft.ServiceBus.Samples części przestrzeni nazw.

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

7. Naciśnij klawisze Ctrl+Shift+B, aby skompilować klienta.

Przykład projektu EchoClient

Poniższy kod przedstawia bieżący stan pliku Program.cs w projekcie EchoClient .

using System;
using Microsoft.ServiceBus;
using System.ServiceModel;

namespace Microsoft.ServiceBus.Samples
{

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

    public interface IEchoChannel : IEchoContract, IClientChannel { }


    class Program
    {
        static void Main(string[] args)
        {
        }
    }
}

Konfigurowanie klienta platformy WCF

W tym kroku utworzysz plik App.config dla podstawowej aplikacji klienckiej, która uzyskuje dostęp do usługi utworzonej wcześniej w tym samouczku. Ten plik App.config definiuje kontrakt, powiązanie i nazwę punktu końcowego. Kod używany do wykonywania tych zadań podano w przykładzie zamieszczonym po procedurze.

1. W Eksplorator rozwiązań w projekcie EchoClient kliknij dwukrotnie App.config, aby otworzyć plik w edytorze programu Visual Studio.

2. W elemencie <appSettings> zastąp symbole zastępcze nazwą przestrzeni nazw usługi i kluczem sygnatury dostępu współdzielonego skopiowanym we wcześniejszym kroku.

3. W elemecie system.serviceModel dodaj <client> element .

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

   Ten kod deklaruje, że definiujesz aplikację kliencką w stylu WCF.

4. W elemencie client zdefiniuj nazwę, kontrakt i typ powiązania punktu końcowego.

   <endpoint name="RelayEndpoint"
                   contract="Microsoft.ServiceBus.Samples.IEchoContract"
                   binding="netTcpRelayBinding"/>
   

   Ten kod definiuje nazwę punktu końcowego. Definiuje również kontrakt zdefiniowany w usłudze oraz fakt, że aplikacja kliencka używa protokołu TCP do komunikowania się z usługą Azure Relay. Nazwa punktu końcowego jest używana w następnym kroku do powiązania tej konfiguracji pliku końcowego z identyfikatorem URI usługi.

5. Wybierz pozycję Plik>Zapisz wszystko.

Przykład pliku App.config

Poniższy kod przedstawia plik App.config dla klienta Echo.

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.serviceModel>
    <client>
      <endpoint name="RelayEndpoint"
                      contract="Microsoft.ServiceBus.Samples.IEchoContract"
                      binding="netTcpRelayBinding"/>
    </client>
    <extensions>
      <bindingExtensions>
        <add name="netTcpRelayBinding"
                    type="Microsoft.ServiceBus.Configuration.NetTcpRelayBindingCollectionElement, Microsoft.ServiceBus, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
      </bindingExtensions>
    </extensions>
  </system.serviceModel>
</configuration>

Implementowanie klienta WCF

W tej sekcji zaimplementujesz podstawową aplikację kliencką, która uzyskuje dostęp do usługi utworzonej wcześniej w tym samouczku. Podobnie jak w przypadku usługi, klient wykonuje wiele tych samych operacji w celu uzyskania dostępu do usługi Azure Relay:

• Ustawienie trybu łączności.
• Utworzenie identyfikatora URI, który lokalizuje usługę hosta.
• Uzyskanie poświadczeń zabezpieczeń.
• Zastosowanie poświadczeń do połączenia.
• Otwarcie połączenia.
• Wykonanie zadań specyficznych dla aplikacji.
• Zamknięcie połączenia.

Jednak jedną z głównych różnic jest to, że aplikacja kliencka używa kanału do łączenia się z usługą przekazywania. Usługa używa wywołania elementu ServiceHost. Kod używany do wykonywania tych zadań podano w przykładzie zamieszczonym po procedurze.

Implementowanie aplikacji klienckiej

1. Ustaw tryb łączności AutoDetect. Dodaj następujący kod w metodzie Main() aplikacji EchoClient.

   ServiceBusEnvironment.SystemConnectivity.Mode = ConnectivityMode.AutoDetect;
   

2. Zdefiniuj zmienne do przechowywania wartości przestrzeni nazw i klucza sygnatury dostępu współdzielonego odczytanego z okna konsoli.

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

3. Utwórz identyfikator URI definiujący lokalizację hosta w projekcie usługi Relay.

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

4. Utwórz obiekt poświadczeń dla punktu końcowego przestrzeni nazw Twojej usługi.

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

5. Utwórz fabrykę kanałów, która ładuje konfigurację opisaną w pliku App.config .

   ChannelFactory<IEchoChannel> channelFactory = new ChannelFactory<IEchoChannel>("RelayEndpoint", new EndpointAddress(serviceUri));
   

   Fabryka kanałów jest obiektem platformy WCF tworzącym kanał komunikacyjny dla usługi i aplikacji klienckich.

6. Zastosuj poświadczenia.

   channelFactory.Endpoint.Behaviors.Add(sasCredential);
   

7. Utwórz i otwórz kanał dla usługi.

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

8. Zapisz podstawowy interfejs użytkownika i funkcje dla echa.

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

   Kod używa wystąpienia obiektu kanału jako serwera proxy dla usługi.

9. Zamknij kanał i fabrykę.

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

Przykładowy kod dla tego samouczka

Ukończony kod powinien pojawić się w następujący sposób. Ten kod pokazuje, jak utworzyć aplikację kliencką, wywołać operacje usługi i jak zamknąć klienta po zakończeniu wywołania operacji.

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

        }
    }
}

Uruchamianie aplikacji

1. Naciśnij klawisze Ctrl+Shift+B, aby skompilować rozwiązanie. Ta akcja kompiluje zarówno projekt klienta, jak i projekt usługi utworzony w poprzednich krokach.

2. Przed uruchomieniem aplikacji klienckiej musisz upewnić się, że aplikacja usługi jest uruchomiona. W Eksplorator rozwiązań kliknij prawym przyciskiem myszy rozwiązanie EchoService, a następnie wybierz pozycję Właściwości.

3. Na stronach właściwości wspólnyprojekt startowywłaściwości>, a następnie wybierz pozycję Wiele projektów startowych. Upewnij się, że pozycja EchoService jest wyświetlana na początku listy.

4. Ustaw w polu Akcja zarówno dla projektu EchoService, jak i projektu EchoClient ustawienie Uruchom.

   

5. Wybierz pozycję Zależności projektu. W obszarze Projekty wybierz pozycję EchoClient. W obszarze Zależy od upewnij się, że wybrano opcję EchoService .

   

6. Wybierz przycisk OK , aby zamknąć strony właściwości.

7. Wybierz klawisz F5, aby uruchomić oba projekty.

8. Oba okna konsoli zostaną otwarte z monitami o podanie nazwy przestrzeni nazw. Najpierw należy uruchomić usługę, więc w oknie konsoli EchoService wprowadź przestrzeń nazw, a następnie wybierz klawisz Enter.

9. Następnie konsola wyświetli monit o podanie klucza sygnatury dostępu współdzielonego. Wprowadź klucz SYGNATURy dostępu współdzielonego i wybierz klawisz Enter.

   Oto przykładowe dane wyjściowe z okna konsoli. Poniżej przedstawiono tylko przykłady.

   Your Service Namespace: myNamespace

   Your SAS Key: <SAS key value>

   Aplikacja usługi wyświetla w oknie konsoli adres, na którym nasłuchuje, jak w poniższym przykładzie.

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

   Press [Enter] to exit

10. W oknie konsoli EchoClient wprowadź te same informacje, które zostały wprowadzone uprzednio dla aplikacji usługi. Wprowadź te same wartości przestrzeni nazw usługi i klucza sygnatury dostępu współdzielonego dla aplikacji klienckiej.

11. Po wprowadzeniu tych wartości klient otworzy kanał do usługi i będzie monitować o wprowadzenie tekstu, jak w poniższym przykładzie danych wyjściowych konsoli.

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

    Wprowadź tekst do wysłania do aplikacji usługi i wybierz klawisz Enter. Ten tekst jest wysyłany do usługi za pośrednictwem operacji usługi Echo i pojawia się w oknie konsoli usługi, jak w poniższym przykładzie danych wyjściowych.

    Echoing: My sample text

    Aplikacja kliencka odbiera wartość zwracaną przez operację Echo, która jest oryginalnym tekstem, i wyświetla go w oknie swojej konsoli. Poniższy tekst to przykładowe dane wyjściowe z okna konsoli klienta.

    Server echoed: My sample text

12. Możesz kontynuować wysyłanie wiadomości tekstowych z klienta do usługi w ten sposób. Po zakończeniu wybierz pozycję Enter w oknach konsoli klienta i usługi, aby zakończyć obie aplikacje.

Następne kroki

Przejdź do następującego samouczka:

Uwidacznianie lokalnej usługi WCF dla klienta WCF spoza sieci