Samouczek: uwidacznianie lokalnej usługi REST programu Windows Communication Foundation (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 ich oryginalne odpowiedniki WCF, usługa jest konstrukcją, która uwidacznia jeden lub więcej punktów końcowych. 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 wykonaniu sekwencji 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 programu WCF.
• Hostuj i uruchom usługę WCF, aby zarejestrować się w usłudze Relay.
• Utwórz klienta programu WCF dla kontraktu usługi.
• Skonfiguruj klienta programu WCF.
• Zaimplementuj klienta programu WCF.
• Uruchom aplikacje.

Wymagania wstępne

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

• Subskrypcja Azure. Jeśli nie masz subskrypcji, 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 podczas tworzenia 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ś wskaźnik myszy 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 powinna 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źnika 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, jakie operacje obsługuje usługa. 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 szerszym omówieniem 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żer 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 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 jest używana przestrzeń Microsoft.ServiceBus.Samples nazw języka C#, która jest przestrzenią nazw typu zarządzanego opartego na kontrakcie, który jest używany w pliku konfiguracji w sekcji Konfigurowanie klienta programu WCF. Możesz określić dowolną przestrzeń nazw podczas kompilowania 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ą https://samples.microsoft.com/ServiceModel/Relay/przestrzeni nazw . 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 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, aby powtórzyć informacje między dwiema aplikacjami.

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

Przykład kontraktu 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 udostępniany 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 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, w którym usługa Azure Relay uwidacznia klientom i hostom komunikowanie 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 odnosi się do powiązania NetTcpRelayBinding , które nie jest częścią programu .NET Framework. NetTcpRelayBinding jest jednym z powiązań zdefiniowanych przez usługę.

1. W Eksplorator rozwiązań kliknij dwukrotnie plik 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 SAS 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ą przekaźnika.

6. Wybierz pozycję Kompiluj>rozwiązanie kompilacji lub naciśnij 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 używany później 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świadczeń 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 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()systemie , 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ą przekaźnika; 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ę dla 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 elementu 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 ustawiono wartość DiscoveryType private, 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. Na potrzeby tego samouczka 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. Wybierz 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 przypominają kroki używane do tworzenia usługi: definiowanie kontraktu, edytowanie pliku App.config przy użyciu poświadczeń w celu nawiązania połączenia z usługą przekaźnika 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 pozycję Dalej.
   3. Określ element EchoClient jako nazwę projektu i wybierz pozycję Utwórz.

2. W Eksplorator rozwiązań w projekcie EchoClient kliknij dwukrotnie Program.cs, aby otworzyć plik w edytorze, jeśli nie został 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 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 plik 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 programu 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, aby uzyskać dostęp 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ą przekaźnika. 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 zostać wyświetlony w następujący sposób. Ten kod pokazuje, jak utworzyć aplikację kliencką, jak 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 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ólny projekt startowy wł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 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 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 Enter.

   Oto przykładowe dane wyjściowe z okna konsoli. Oto 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ł w usłudze i wyświetli monit o wprowadzenie tekstu, jak pokazano w poniższym przykładzie danych wyjściowych konsoli.

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

    Wprowadź tekst, który ma być wysyłany do aplikacji usługi, a następnie wybierz 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ę Wprowadź w oknach konsoli klienta i usługi, aby zakończyć obie aplikacje.

Następny krok

Przejdź do następującego samouczka:

Uwidacznia lokalną usługę REST WCF klientowi spoza sieci