Esercitazione sull'inoltro WCF di AzureAzure WCF Relay tutorial

Questa esercitazione descrive come compilare una semplice applicazione e servizio client di inoltro WCF usando Inoltro di Azure.This tutorial describes how to build a simple WCF Relay client application and service using Azure Relay. Per un'esercitazione simile che usa la messaggistica del bus di servizio, vedere Introduzione alle code del bus di servizio.For a similar tutorial that uses Service Bus messaging, see Get started with Service Bus queues.

L'esecuzione di questa esercitazione consente di acquisire una comprensione dei passaggi necessari per creare un'applicazione client e di servizio di inoltro WCF.Working through this tutorial gives you an understanding of the steps that are required to create a WCF Relay client and service application. Come per le rispettive controparti WCF originali, un servizio è un costrutto che espone uno o più endpoint, ognuno dei quali espone a sua volta una o più operazioni del servizio.Like their original WCF counterparts, a service is a construct that exposes one or more endpoints, each of which exposes one or more service operations. L'endpoint di un servizio specifica un indirizzo in cui è disponibile il servizio, un binding che contiene le informazioni che un client deve comunicare al servizio e un contratto che definisce la funzionalità fornita dal servizio ai propri client.The endpoint of a service specifies an address where the service can be found, a binding that contains the information that a client must communicate with the service, and a contract that defines the functionality provided by the service to its clients. La differenza principale tra WCF e l'inoltro WCF riguarda l'esposizione dell'endpoint nel cloud invece che localmente nel computer.The main difference between WCF and WCF Relay is that the endpoint is exposed in the cloud instead of locally on your computer.

Dopo aver eseguito la sequenza di argomenti in questa esercitazione, saranno disponibili un servizio in esecuzione e un client che potrà richiamare le operazioni del servizio.After you work through the sequence of topics in this tutorial, you will have a running service, and a client that can invoke the operations of the service. Il primo argomento descrive come configurare un account.The first topic describes how to set up an account. I passaggi successivi descrivono come definire un servizio che usa un contratto, come implementare il servizio e come configurarlo nel codice.The next steps describe how to define a service that uses a contract, how to implement the service, and how to configure the service in code. Descrivono anche come ospitare ed eseguire il servizio.They also describe how to host and run the service. Il servizio creato è self-hosted e il client e il servizio vengono eseguiti nello stesso computer.The service that is created is self-hosted and the client and service run on the same computer. È possibile configurare il servizio usando il codice o un file di configurazione.You can configure the service by using either code or a configuration file.

I tre passaggi finali descrivono come creare un'applicazione client, configurare l'applicazione client e creare e usare un client in grado di accedere alla funzionalità dell'host.The final three steps describe how to create a client application, configure the client application, and create and use a client that can access the functionality of the host.

PrerequisitiPrerequisites

Per completare l'esercitazione sono necessari gli elementi seguenti:To complete this tutorial, you'll need the following:

Creare uno spazio dei nomi del servizioCreate a service namespace

Il primo passaggio consiste nel creare uno spazio dei nomi e nell'ottenere una chiave di firma di accesso condiviso.The first step is to create a namespace, and to obtain a Shared Access Signature (SAS) key. Uno spazio dei nomi fornisce un limite per ogni applicazione esposta tramite il servizio di inoltro.A namespace provides an application boundary for each application exposed through the relay service. Una chiave di firma di accesso condiviso viene generata dal sistema quando viene creato uno spazio dei nomi del servizio.A SAS key is automatically generated by the system when a service namespace is created. La combinazione di spazio dei nomi servizio e chiave di firma di accesso condiviso fornisce le credenziali che consentono ad Azure di autenticare l'accesso a un'applicazione.The combination of service namespace and SAS key provides the credentials for Azure to authenticate access to an application. Seguire queste istruzioni per creare uno spazio dei nomi di inoltro.Follow the instructions here to create a Relay namespace.

Definire un contratto del servizio WCFDefine a WCF service contract

Il contratto di servizio specifica le operazioni (terminologia dei servizi Web per indicare metodi o funzioni) supportate dal servizio.The service contract specifies what operations (the web service terminology for methods or functions) the service supports. I contratti vengono creati definendo un'interfaccia C++, C# o Visual Basic.Contracts are created by defining a C++, C#, or Visual Basic interface. Ogni metodo dell'interfaccia corrisponde a un'operazione di servizio specifico.Each method in the interface corresponds to a specific service operation. A ogni interfaccia deve essere applicato l'attributo ServiceContractAttribute e a ogni operazione deve essere applicato l'attributo OperationContractAttribute.Each interface must have the ServiceContractAttribute attribute applied to it, and each operation must have the OperationContractAttribute attribute applied to it. Se un metodo di un'interfaccia con l'attributo ServiceContractAttribute non ha l'attributo OperationContractAttribute, il metodo non viene esposto.If a method in an interface that has the ServiceContractAttribute attribute does not have the OperationContractAttribute attribute, that method is not exposed. Il codice per eseguire queste attività viene fornito nell'esempio che segue la procedura.The code for these tasks is provided in the example following the procedure. Per una descrizione più ampia dei contratti e dei servizi, vedere Progettazione e implementazione di servizi nella documentazione di WCF.For a larger discussion of contracts and services, see Designing and Implementing Services in the WCF documentation.

Creare un contratto di inoltro con un'interfacciaCreate a relay contract with an interface

  1. Aprire Visual Studio con ruolo di amministratore. Fare clic con il pulsante destro del mouse sul programma nel menu Start e scegliere Esegui come amministratore.Open Visual Studio as an administrator by right-clicking the program in the Start menu and selecting Run as administrator.
  2. Creare un nuovo progetto di applicazione console.Create a new console application project. Fare clic sul menuFile, selezionare Nuovo e fare clic su Progetto.Click the File menu and select New, then click Project. Nella finestra di dialogo Nuovo progetto fare clic su Visual C#. Se Visual C# non è visualizzato, vedere in Altri linguaggi.In the New Project dialog, click Visual C# (if Visual C# does not appear, look under Other Languages). Fare clic sul modello App console (.NET Framework) e denominarlo EchoService.Click the Console App (.NET Framework) template, and name it EchoService. Fare clic su OK per creare il progetto.Click OK to create the project.

  3. Installare il pacchetto NuGet del bus di servizio.Install the Service Bus NuGet package. Questo pacchetto aggiunge automaticamente i riferimenti alle librerie del bus di servizio, oltre all'oggetto System.ServiceModel di WCF.This package automatically adds references to the Service Bus libraries, as well as the WCF System.ServiceModel. System.ServiceModel è lo spazio dei nomi che consente l'accesso a livello di codice alle funzionalità di base di WCF.System.ServiceModel is the namespace that enables you to programmatically access the basic features of WCF. Il bus di servizio utilizza molti degli oggetti e degli attributi di WCF per definire i contratti di servizio.Service Bus uses many of the objects and attributes of WCF to define service contracts.

    In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto e quindi scegliere Gestisci pacchetti NuGet.... Fare clic sulla scheda Sfoglia e quindi cercare WindowsAzure.ServiceBus.In Solution Explorer, right-click the project, and then click Manage NuGet Packages.... Click the Browse tab, then search for WindowsAzure.ServiceBus. Assicurarsi che il nome del progetto sia selezionato nella casella Versione.Ensure that the project name is selected in the Version(s) box. Fare clic su Installae accettare le condizioni per l'utilizzo.Click Install, and accept the terms of use.

  4. In Esplora soluzioni fare doppio clic sul file Program.cs per aprirlo nell'editor, se non è già aperto.In Solution Explorer, double-click the Program.cs file to open it in the editor, if it is not already open.
  5. Aggiungere le istruzioni using seguenti all'inizio del file:Add the following using statements at the top of the file:

    using System.ServiceModel;
    using Microsoft.ServiceBus;
    
  6. Modificare il nome predefinito dello spazio dei nomi da EchoService a Microsoft.ServiceBus.Samples.Change the namespace name from its default name of EchoService to Microsoft.ServiceBus.Samples.

    Importante

    Questa esercitazione usa lo spazio dei nomi C# Microsoft.ServiceBus.Samples, ovvero lo spazio dei nomi del tipo gestito in base al contratto usato nel file di configurazione nel passaggio Configurare il client WCF.This tutorial uses the C# namespace Microsoft.ServiceBus.Samples, which is the namespace of the contract-based managed type that is used in the configuration file in the Configure the WCF client step. È possibile specificare qualsiasi spazio dei nomi quando si crea questo esempio. L'esercitazione tuttavia non funzionerà a meno che gli spazi dei nomi del contratto e del servizio non vengano modificati di conseguenza nel file di configurazione dell'applicazione.You can specify any namespace you want when you build this sample; however, the tutorial will not work unless you then modify the namespaces of the contract and service accordingly, in the application configuration file. Lo spazio dei nomi specificato nel file App.config deve essere lo stesso specificato nei file C#.The namespace specified in the App.config file must be the same as the namespace specified in your C# files.

  7. Subito dopo la dichiarazione dello spazio dei nomi Microsoft.ServiceBus.Samples, ma sempre nello spazio dei nomi, definire una nuova interfaccia denominata IEchoContract e applicare l'attributo ServiceContractAttribute all'interfaccia con un valore dello spazio dei nomi http://samples.microsoft.com/ServiceModel/Relay/.Directly after the Microsoft.ServiceBus.Samples namespace declaration, but within the namespace, define a new interface named IEchoContract and apply the ServiceContractAttribute attribute to the interface with a namespace value of http://samples.microsoft.com/ServiceModel/Relay/. Il valore dello spazio dei nomi è diverso dallo spazio dei nomi usato nell'ambito del codice.The namespace value differs from the namespace that you use throughout the scope of your code. Il valore dello spazio dei nomi viene invece usato come identificatore univoco per questo contratto.Instead, the namespace value is used as a unique identifier for this contract. Specificando lo spazio dei nomi in modo esplicito si impedisce che il valore predefinito dello spazio dei nomi venga aggiunto al nome del contratto.Specifying the namespace explicitly prevents the default namespace value from being added to the contract name. Incollare il codice seguente dopo la dichiarazione dello spazio dei nomi:Paste the following code after the namespace declaration:

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

    Nota

    Lo spazio dei nomi del contratto del servizio include in genere uno schema di denominazione che contiene informazioni sulla versione.Typically, the service contract namespace contains a naming scheme that includes version information. Se si includono le informazioni sulla versione nello spazio dei nomi del contratto di servizio, si consente ai servizi di isolare le modifiche principali definendo un nuovo contratto di servizio con un nuovo spazio dei nomi ed esponendolo in un nuovo endpoint.Including version information in the service contract namespace enables services to isolate major changes by defining a new service contract with a new namespace and exposing it on a new endpoint. In questo modo i client possono continuare a usare il contratto del servizio precedente senza dover essere aggiornati.In this manner, clients can continue to use the old service contract without having to be updated. Le informazioni sulla versione possono essere costituite da una data o da un numero di build.Version information can consist of a date or a build number. Per altre informazioni, vedere Controllo delle versioni del servizio.For more information, see Service Versioning. Ai fini di questa esercitazione, lo schema di denominazione dello spazio dei nomi del contratto del servizio non include informazioni sulla versione.For the purposes of this tutorial, the naming scheme of the service contract namespace does not contain version information.

  8. Nell'interfaccia IEchoContract dichiarare un metodo per la singola operazione esposta dal contratto IEchoContract nell'interfaccia e applicare l'attributo OperationContractAttribute al metodo da esporre come parte del contratto pubblico di inoltro WCF, come segue:Within the IEchoContract interface, declare a method for the single operation the IEchoContract contract exposes in the interface and apply the OperationContractAttribute attribute to the method that you want to expose as part of the public WCF Relay contract, as follows:

    [OperationContract]
    string Echo(string text);
    
  9. Direttamente dopo la definizione dell'interfaccia IEchoContract dichiarare un canale che eredita dalle interfacce IEchoContract e IClientChannel, come illustrato di seguito:Directly after the IEchoContract interface definition, declare a channel that inherits from both IEchoContract and also to the IClientChannel interface, as shown here:

    public interface IEchoChannel : IEchoContract, IClientChannel { }
    

    Un canale è l'oggetto WCF attraverso il quale l'host e il client si scambiano informazioni.A channel is the WCF object through which the host and client pass information to each other. Successivamente si scriverà il codice per il canale per ripetere le informazioni tra le due applicazioni.Later, you will write code against the channel to echo information between the two applications.

  10. Scegliere Compila soluzione dal menu Compila o premere CTRL+MAIUSC+B per confermare la correttezza di quanto fatto finora.From the Build menu, click Build Solution or press Ctrl+Shift+B to confirm the accuracy of your work so far.

EsempioExample

L'esempio di codice seguente illustra un'interfaccia di base che definisce un contratto dell'inoltro WCF.The following code shows a basic interface that defines a WCF Relay contract.

using System;
using System.ServiceModel;

namespace Microsoft.ServiceBus.Samples
{
    [ServiceContract(Name = "IEchoContract", Namespace = "http://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)
        {
        }
    }
}

Dopo aver creato l'interfaccia, è possibile implementarla.Now that the interface is created, you can implement the interface.

Implementare il contratto WCFImplement the WCF contract

La creazione di un inoltro di Azure deve essere preceduta dalla creazione del contratto, che viene definito usando un'interfaccia.Creating an Azure relay requires that you first create the contract, which is defined by using an interface. Per altre informazioni sulla creazione dell'interfaccia, vedere il passaggio precedente.For more information about creating the interface, see the previous step. Il passaggio successivo consiste nell'implementazione dell'interfaccia.The next step is to implement the interface. Questa operazione richiede la creazione di una classe denominata EchoService t che implementa l'interfaccia IEchoContract definita dall'utente.This involves creating a class named EchoService that implements the user-defined IEchoContract interface. Dopo l'implementazione dell'interfaccia, si procede alla sua configurazione usando un file di configurazione App.config.After you implement the interface, you then configure the interface using an App.config configuration file. Il file di configurazione contiene le informazioni necessarie per l'applicazione, ad esempio il nome del servizio, il nome del contratto e il tipo di protocollo usato per comunicare con il servizio di inoltro.The configuration file contains necessary information for the application, such as the name of the service, the name of the contract, and the type of protocol that is used to communicate with the relay service. Il codice usato per eseguire queste attività viene fornito nell'esempio che segue la procedura.The code used for these tasks is provided in the example following the procedure. Per una descrizione di carattere generale sull'implementazione di un contratto di servizio, vedere Implementazione dei contratti di servizio nella documentazione di WCF.For a more general discussion about how to implement a service contract, see Implementing Service Contracts in the WCF documentation.

  1. Creare una nuova classe denominata EchoService direttamente dopo la definizione dell’interfaccia IEchoContract.Create a new class named EchoService directly after the definition of the IEchoContract interface. La classe EchoService implementa l'interfaccia IEchoContract.The EchoService class implements the IEchoContract interface.

    class EchoService : IEchoContract
    {
    }
    

    Analogamente ad altre implementazioni di interfaccia, è possibile implementare la definizione in un altro file.Similar to other interface implementations, you can implement the definition in a different file. Tuttavia, per questa esercitazione l'implementazione si trova nello stesso file che contiene la definizione di interfaccia e il metodo Main.However, for this tutorial, the implementation is located in the same file as the interface definition and the Main method.

  2. Applicare l'attributo ServiceBehaviorAttribute all'interfaccia IEchoContract.Apply the ServiceBehaviorAttribute attribute to the IEchoContract interface. L'attributo specifica lo spazio dei nomi e il nome del servizio.The attribute specifies the service name and namespace. Al termine dell'operazione, la classe EchoService ha un aspetto simile al seguente:After doing so, the EchoService class appears as follows:

    [ServiceBehavior(Name = "EchoService", Namespace = "http://samples.microsoft.com/ServiceModel/Relay/")]
    class EchoService : IEchoContract
    {
    }
    
  3. Implementare il metodo Echo definito nell'interfaccia IEchoContract nella classe EchoService.Implement the Echo method defined in the IEchoContract interface in the EchoService class.

    public string Echo(string text)
    {
        Console.WriteLine("Echoing: {0}", text);
        return text;
    }
    
  4. Scegliere Compila soluzione dal menu Compila per verificare la correttezza del lavoro.Click Build, then click Build Solution to confirm the accuracy of your work.

Definire la configurazione dell'host del servizioDefine the configuration for the service host

  1. Il file di configurazione è molto simile a un file di configurazione WCF.The configuration file is very similar to a WCF configuration file. Include il nome del servizio, l'endpoint (ovvero il percorso esposto dall'inoltro di Azure per le comunicazioni tra client e host) e l'associazione (ossia il tipo di protocollo usato per la comunicazione).It includes the service name, endpoint (that is, the location that Azure Relay exposes for clients and hosts to communicate with each other), and the binding (the type of protocol that is used to communicate). La differenza principale consiste nel fatto che l'endpoint di servizio configurato fa riferimento a un’associazione NetTcpRelayBinding che non fa parte di .NET Framework.The main difference is that this configured service endpoint refers to a NetTcpRelayBinding binding, which is not part of the .NET Framework. NetTcpRelayBinding è una delle associazioni definite dal servizio.NetTcpRelayBinding is one of the bindings defined by the service.
  2. In Esplora soluzioni fare doppio clic sul file App.config per aprirlo nell'editor di Visual Studio.In Solution Explorer, double-click the App.config file to open it in the Visual Studio editor.
  3. Nell'elemento <appSettings> sostituire i segnaposto con il nome dello spazio dei nomi del servizio e la chiave di firma di accesso condiviso copiata nel passaggio precedente.In the <appSettings> element, replace the placeholders with the name of your service namespace, and the SAS key that you copied in an earlier step.
  4. All'interno dei tag <system.serviceModel> aggiungere un elemento <services>.Within the <system.serviceModel> tags, add a <services> element. È possibile definire più applicazioni di inoltro in un singolo file di configurazione.You can define multiple relay applications in a single configuration file. In questa esercitazione ne viene tuttavia definita solo una.However, this tutorial defines only one.

    <?xmlversion="1.0"encoding="utf-8"?>
    <configuration>
      <system.serviceModel>
        <services>
    
        </services>
      </system.serviceModel>
    </configuration>
    
  5. Nell'elemento <services> aggiungere un elemento <service> per definire il nome del servizio.Within the <services> element, add a <service> element to define the name of the service.

    <service name="Microsoft.ServiceBus.Samples.EchoService">
    </service>
    
  6. Nell'elemento <service> definire la posizione del contratto, nonché il tipo di binding per l'endpoint.Within the <service> element, define the location of the endpoint contract, and also the type of binding for the endpoint.

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

    L'endpoint definisce la posizione in cui il client cercherà l'applicazione host.The endpoint defines where the client will look for the host application. Successivamente nell'esercitazione si userà questo passaggio per creare un URI che espone completamente l'host tramite l'inoltro di Azure.Later, the tutorial uses this step to create a URI that fully exposes the host through Azure Relay. L'associazione dichiara che come protocollo per le comunicazioni con il servizio di inoltro viene usato TCP.The binding declares that we are using TCP as the protocol to communicate with the relay service.

  7. Scegliere Compila soluzione dal menu Compila per verificare la correttezza del lavoro.From the Build menu, click Build Solution to confirm the accuracy of your work.

EsempioExample

Il codice seguente illustra l'implementazione del contratto di servizio.The following code shows the implementation of the service contract.

[ServiceBehavior(Name = "EchoService", Namespace = "http://samples.microsoft.com/ServiceModel/Relay/")]

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

Il codice seguente illustra il formato di base del file App.config associato all'host del servizio.The following code shows the basic format of the App.config file associated with the service host.

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

Ospitare ed eseguire un servizio Web di base per la registrazione con il servizio di inoltroHost and run a basic web service to register with the relay service

Questo passaggio descrive come eseguire un servizio di inoltro di Azure.This step describes how to run an Azure Relay service.

Creare le credenziali di inoltroCreate the relay credentials

  1. In Main() creare due variabili in cui archiviare lo spazio dei nomi e la chiave di firma di accesso condiviso letti dalla finestra della console.In Main(), create two variables in which to store the namespace and the SAS key that are read from the console window.

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

    La chiave di firma di accesso condiviso verrà usata in seguito per accedere al progetto.The SAS key will be used later to access your project. Lo spazio dei nomi viene passato come parametro a CreateServiceUri per creare un URI del servizio.The namespace is passed as a parameter to CreateServiceUri to create a service URI.

  2. Tramite un oggetto TransportClientEndpointBehavior dichiarare che come tipo di credenziali si userà una chiave di firma di accesso condiviso.Using a TransportClientEndpointBehavior object, declare that you will be using a SAS key as the credential type. Aggiungere il codice seguente direttamente dopo il codice aggiunto nel passaggio precedente.Add the following code directly after the code added in the last step.

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

Creare un indirizzo di base per il servizioCreate a base address for the service

Dopo il codice aggiunto nel passaggio precedente, creare un'istanza di Uri per l'indirizzo di base del servizio.After the code you added in the last step, create a Uri instance for the base address of the service. L'URI specifica lo schema del bus di servizio, lo spazio dei nomi e il percorso dell'interfaccia del servizio.This URI specifies the Service Bus scheme, the namespace, and the path of the service interface.

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

"sb" è l'abbreviazione dello schema del bus di servizio e indica che si usa il protocollo TCP."sb" is an abbreviation for the Service Bus scheme, and indicates that we are using TCP as the protocol. Il protocollo è stato indicato anche in precedenza nel file di configurazione, quando come associazione si è specificato NetTcpRelayBinding.This was also previously indicated in the configuration file, when NetTcpRelayBinding was specified as the binding.

Per questa esercitazione l'URI è sb://putServiceNamespaceHere.windows.net/EchoService.For this tutorial, the URI is sb://putServiceNamespaceHere.windows.net/EchoService.

Creare e configurare l'host del servizioCreate and configure the service host

  1. Impostare la modalità di connessione su AutoDetect.Set the connectivity mode to AutoDetect.

    ServiceBusEnvironment.SystemConnectivity.Mode = ConnectivityMode.AutoDetect;
    

    La modalità di connessione descrive il protocollo usato dal servizio per comunicare con il servizio di inoltro, ovvero HTTP o TCP.The connectivity mode describes the protocol the service uses to communicate with the relay service; either HTTP or TCP. Quando si usa l'impostazione predefinita AutoDetect, il servizio prova a connettersi all'inoltro di Azure tramite TCP, se disponibile, e tramite HTTP se TCP non è disponibile.Using the default setting AutoDetect, the service attempts to connect to Azure Relay over TCP if it is available, and HTTP if TCP is not available. Si noti che questo protocollo è diverso da quello specificato dal servizio per la comunicazione client.Note that this differs from the protocol the service specifies for client communication. Il protocollo dipende dal binding usato.That protocol is determined by the binding used. Ad esempio, un servizio può usare l'associazione BasicHttpRelayBinding che specifica che l'endpoint comunica con i client tramite HTTP.For example, a service can use the BasicHttpRelayBinding binding, which specifies that its endpoint communicates with clients over HTTP. Lo stesso servizio può specificare ConnectivityMode.AutoDetect per indicare che il servizio comunica con l'inoltro di Azure tramite TCP.That same service could specify ConnectivityMode.AutoDetect so that the service communicates with Azure Relay over TCP.

  2. Creare l'host del servizio usando l'URI creato precedentemente in questa sezione.Create the service host, using the URI created earlier in this section.

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

    L'host del servizio è l'oggetto WCF che crea un'istanza del servizio.The service host is the WCF object that instantiates the service. In questo caso, viene passato il tipo di servizio che si vuole creare (EchoService), insieme all'indirizzo in cui si vuole esporre il servizio.Here, you pass it the type of service you want to create (an EchoService type), and also to the address at which you want to expose the service.

  3. All'inizio del file Program.cs aggiungere riferimenti a System.ServiceModel.Description e Microsoft.ServiceBus.Description.At the top of the Program.cs file, add references to System.ServiceModel.Description and Microsoft.ServiceBus.Description.

    using System.ServiceModel.Description;
    using Microsoft.ServiceBus.Description;
    
  4. Tornando a Main(), configurare l'endpoint per abilitare l'accesso pubblico.Back in Main(), configure the endpoint to enable public access.

    IEndpointBehavior serviceRegistrySettings = new ServiceRegistrySettings(DiscoveryType.Public);
    

    Questo passaggio segnala al servizio di inoltro che l'applicazione può essere trovata pubblicamente esaminando il feed ATOM per il progetto.This step informs the relay service that your application can be found publicly by examining the ATOM feed for your project. Se si imposta DiscoveryType su private, un client sarà comunque in grado di accedere al servizio.If you set DiscoveryType to private, a client would still be able to access the service. Quest'ultimo non sarà tuttavia visibile durante la ricerca nello spazio dei nomi Relay.However, the service would not appear when it searches the Relay namespace. Il client dovrà invece conoscere in anticipo il percorso dell'endpoint.Instead, the client would have to know the endpoint path beforehand.

  5. Applicare le credenziali del servizio agli endpoint di servizio definiti nel file App.config:Apply the service credentials to the service endpoints defined in the App.config file:

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

    Come spiegato nel passaggio precedente, nel file di configurazione potrebbero essere stati dichiarati più servizi e più endpoint.As stated in the previous step, you could have declared multiple services and endpoints in the configuration file. In tal caso, questo codice scorrerebbe il file di configurazione per cercare tutti gli endpoint a cui applicare le credenziali.If you had, this code would traverse the configuration file and search for every endpoint to which it should apply your credentials. Per questa esercitazione, nel file di configurazione è tuttavia contenuto un solo endpoint.However, for this tutorial, the configuration file has only one endpoint.

Aprire l'host del servizioOpen the service host

  1. Aprire il servizio.Open the service.

    host.Open();
    
  2. Informare l'utente che il servizio è in esecuzione e spiegargli come arrestarlo.Inform the user that the service is running, and explain how to shut down the service.

    Console.WriteLine("Service address: " + address);
    Console.WriteLine("Press [Enter] to exit");
    Console.ReadLine();
    
  3. Al termine, chiudere l'host del servizio.When finished, close the service host.

    host.Close();
    
  4. Premere CTRL+MAIUSC+B per compilare il progetto.Press Ctrl+Shift+B to build the project.

EsempioExample

Il codice del servizio completato comparirà come indicato di seguito.Your completed service code should appear as follows. Il codice include il contratto di servizio e l'implementazione dei passaggi precedenti nell'esercitazione e ospita il servizio in un'applicazione console.The code includes the service contract and implementation from previous steps in the tutorial, and hosts the service in a console application.

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

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

    public interface IEchoChannel : IEchoContract, IClientChannel { };

    [ServiceBehavior(Name = "EchoService", Namespace = "http://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();
        }
    }
}

Creare un client WCF per il contratto di servizioCreate a WCF client for the service contract

Il passaggio successivo consiste nel creare un'applicazione client e nel definire il contratto di servizio che sarà implementato nei passaggi successivi.The next step is to create a client application and define the service contract you will implement in later steps. Si noti che molti di questi passaggi sono simili ai passaggi usati per la creazione di un servizio: ovvero definizione di un contratto, modifica di un file App.config, uso delle credenziali per la connessione al servizio di inoltro e così via.Note that many of these steps resemble the steps used to create a service: defining a contract, editing an App.config file, using credentials to connect to the relay service, and so on. Il codice usato per eseguire queste attività viene fornito nell'esempio che segue la procedura.The code used for these tasks is provided in the example following the procedure.

  1. Creare un nuovo progetto nella soluzione Visual Studio attuale per il client eseguendo le operazioni seguenti:Create a new project in the current Visual Studio solution for the client by doing the following:

    1. Nella stessa soluzione che include il servizio in Esplora soluzioni fare clic con il pulsante destro del mouse sulla soluzione attuale, non sul progetto, e scegliere Aggiungi.In Solution Explorer, in the same solution that contains the service, right-click the current solution (not the project), and click Add. Fare clic su Nuovo progetto.Then click New Project.
    2. Nella finestra di dialogo Aggiungi nuovo progetto fare clic su Visual C#. Se Visual C# non è visibile, cercare in Other Languages (Altri linguaggi), selezionare il modello App console (.NET Framework) e denominarlo EchoClient.In the Add New Project dialog box, click Visual C# (if Visual C# does not appear, look under Other Languages), select the Console App (.NET Framework) template, and name it EchoClient.
    3. Fare clic su OK.Click OK.
  2. In Esplora soluzioni fare doppio clic sul file Program.cs nel progetto EchoClient per aprirlo nell'editor, se non è già aperto.In Solution Explorer, double-click the Program.cs file in the EchoClient project to open it in the editor, if it is not already open.
  3. Modificare il nome dello spazio dei nomi da nome predefinito di EchoClient a Microsoft.ServiceBus.Samples.Change the namespace name from its default name of EchoClient to Microsoft.ServiceBus.Samples.
  4. Installare il pacchetto NuGet del bus di servizio: in Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto EchoClient e scegliere Gestisci pacchetti NuGet.Install the Service Bus NuGet package: in Solution Explorer, right-click the EchoClient project, and then click Manage NuGet Packages. Fare clic sulla scheda Sfoglia e cercare Microsoft Azure Service Bus.Click the Browse tab, then search for Microsoft Azure Service Bus. Fare clic su Installae accettare le condizioni per l'utilizzo.Click Install, and accept the terms of use.

  5. Aggiungere un'istruzione using per lo spazio dei nomi System.ServiceModel nel file Program.cs.Add a using statement for the System.ServiceModel namespace in the Program.cs file.

    using System.ServiceModel;
    
  6. Aggiungere la definizione del contratto di servizio allo spazio dei nomi, come mostrato nell'esempio seguente.Add the service contract definition to the namespace, as shown in the following example. Si noti che questa definizione è identica alla definizione usata nel progetto Service.Note that this definition is identical to the definition used in the Service project. È necessario aggiungere il codice alla parte iniziale dello spazio dei nomi Microsoft.ServiceBus.Samples.You should add this code at the top of the Microsoft.ServiceBus.Samples namespace.

    [ServiceContract(Name = "IEchoContract", Namespace = "http://samples.microsoft.com/ServiceModel/Relay/")]
    public interface IEchoContract
    {
        [OperationContract]
        string Echo(string text);
    }
    
    public interface IEchoChannel : IEchoContract, IClientChannel { }
    
  7. Premere CTRL+MAIUSC+B per compilare il client.Press Ctrl+Shift+B to build the client.

EsempioExample

Il codice seguente illustra lo stato corrente del file Program.cs nel progetto EchoClient.The following code shows the current status of the Program.cs file in the EchoClient project.

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

namespace Microsoft.ServiceBus.Samples
{

    [ServiceContract(Name = "IEchoContract", Namespace = "http://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)
        {
        }
    }
}

Configurare il client WCFConfigure the WCF client

In questo passaggio si crea un file App.config per un'applicazione client di base che accede al servizio creato in precedenza in questa esercitazione.In this step, you create an App.config file for a basic client application that accesses the service created previously in this tutorial. Il file App.config definisce il contratto, il binding e il nome dell'endpoint.This App.config file defines the contract, binding, and name of the endpoint. Il codice usato per eseguire queste attività viene fornito nell'esempio che segue la procedura.The code used for these tasks is provided in the example following the procedure.

  1. In Esplora soluzioni fare doppio clic su App.config nel progetto EchoClient per aprire il file nell'editor di Visual Studio.In Solution Explorer, in the EchoClient project, double-click App.config to open the file in the Visual Studio editor.
  2. Nell'elemento <appSettings> sostituire i segnaposto con il nome dello spazio dei nomi del servizio e la chiave di firma di accesso condiviso copiata nel passaggio precedente.In the <appSettings> element, replace the placeholders with the name of your service namespace, and the SAS key that you copied in an earlier step.
  3. Nell'elemento system.serviceModel aggiungere un elemento <client>.Within the system.serviceModel element, add a <client> element.

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

    Questo passaggio dichiara che si sta definendo un'applicazione client di tipo WCF.This step declares that you are defining a WCF-style client application.

  4. Nell'elemento client definire il nome, il contratto e il tipo di binding per l'endpoint.Within the client element, define the name, contract, and binding type for the endpoint.

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

    Questo passaggio specifica il nome dell'endpoint, il contratto definito nel servizio e l'uso del protocollo TCP da parte dell'applicazione per comunicare con l'inoltro di Azure.This step defines the name of the endpoint, the contract defined in the service, and the fact that the client application uses TCP to communicate with Azure Relay. Il nome dell'endpoint viene usato nel passaggio successivo per collegare questa configurazione dell'endpoint con l'URI del servizio.The endpoint name is used in the next step to link this endpoint configuration with the service URI.

  5. Fare clic su File quindi su Salva tutto.Click File, then click Save All.

EsempioExample

Il codice seguente mostra il file App.config per il client Echo.The following code shows the App.config file for the Echo client.

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

Implementare il client WCFImplement the WCF client

In questo passaggio si implementa un'applicazione client di base che accede al servizio creato in precedenza in questa esercitazione.In this step, you implement a basic client application that accesses the service you created previously in this tutorial. Analogamente al servizio, il client esegue molte delle stesse operazioni per accedere all'inoltro di Azure:Similar to the service, the client performs many of the same operations to access Azure Relay:

  1. Imposta la modalità di connessione.Sets the connectivity mode.
  2. Crea l'URI che individua il servizio host.Creates the URI that locates the host service.
  3. Definisce le credenziali di sicurezza.Defines the security credentials.
  4. Applica le credenziali alla connessione.Applies the credentials to the connection.
  5. Apre la connessione.Opens the connection.
  6. Esegue attività specifiche dell'applicazione.Performs the application-specific tasks.
  7. Chiude la connessione.Closes the connection.

Una delle differenze principali, tuttavia, consiste nel fatto che l'applicazione client usa un canale per connettersi al servizio di inoltro, mentre il servizio usa una chiamata a ServiceHost.However, one of the main differences is that the client application uses a channel to connect to the relay service, whereas the service uses a call to ServiceHost. Il codice usato per eseguire queste attività viene fornito nell'esempio che segue la procedura.The code used for these tasks is provided in the example following the procedure.

Implementare un'applicazione clientImplement a client application

  1. Impostare la modalità di connessione su AutoDetect.Set the connectivity mode to AutoDetect. Aggiungere il codice seguente nel metodo Main() dell'applicazione EchoClient.Add the following code inside the Main() method of the EchoClient application.

    ServiceBusEnvironment.SystemConnectivity.Mode = ConnectivityMode.AutoDetect;
    
  2. Definire le variabile per includere i valori per lo spazio dei nomi del servizio e la chiave di firma di accesso condiviso letti dalla console.Define variables to hold the values for the service namespace, and SAS key that are read from the console.

    Console.Write("Your Service Namespace: ");
    string serviceNamespace = Console.ReadLine();
    Console.Write("Your SAS Key: ");
    string sasKey = Console.ReadLine();
    
  3. Creare l'URI che definisce il percorso dell'host nel progetto di inoltro.Create the URI that defines the location of the host in your Relay project.

    Uri serviceUri = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, "EchoService");
    
  4. Creare l'oggetto credential per l'endpoint dello spazio dei nomi del servizio.Create the credential object for your service namespace endpoint.

    TransportClientEndpointBehavior sasCredential = new TransportClientEndpointBehavior();
    sasCredential.TokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider("RootManageSharedAccessKey", sasKey);
    
  5. Creare la channel factory che carica la configurazione descritta nel file App.config.Create the channel factory that loads the configuration described in the App.config file.

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

    Una channel factory è un oggetto WCF che crea un canale attraverso il quale comunicano le applicazioni di servizio e client.A channel factory is a WCF object that creates a channel through which the service and client applications communicate.

  6. Applicare le credenziali.Apply the credentials.

    channelFactory.Endpoint.Behaviors.Add(sasCredential);
    
  7. Creare e aprire il canale per il servizio.Create and open the channel to the service.

    IEchoChannel channel = channelFactory.CreateChannel();
    channel.Open();
    
  8. Scrivere l'interfaccia utente di base e la funzionalità per echo.Write the basic user interface and functionality for the echo.

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

    Si noti che il codice usa l'istanza dell'oggetto canale come proxy per il servizio.Note that the code uses the instance of the channel object as a proxy for the service.

  9. Chiudere il canale, quindi chiudere la factory.Close the channel, and close the factory.

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

EsempioExample

Il codice completo dovrebbe apparire come mostrato di seguito e illustra come creare un'applicazione client, come chiamare le operazioni del servizio e come chiudere il client al termine della chiamata dell'operazione.Your completed code should appear as follows, showing how to create a client application, how to call the operations of the service, and how to close the client after the operation call is finished.

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

namespace Microsoft.ServiceBus.Samples
{
    [ServiceContract(Name = "IEchoContract", Namespace = "http://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();

        }
    }
}

Eseguire le applicazioniRun the applications

  1. Premere CTRL+MAIUSC+B per compilare la soluzione.Press Ctrl+Shift+B to build the solution. Verranno compilati sia il progetto client che il progetto di servizio creati nei passaggi precedenti.This builds both the client project and the service project that you created in the previous steps.
  2. Prima di eseguire l'applicazione client, è necessario assicurarsi che l'applicazione di servizio sia in esecuzione.Before running the client application, you must make sure that the service application is running. In Esplora soluzioni in Visual Studio fare clic con il pulsante destro del mouse sulla soluzione EchoService e scegliere Proprietà.In Solution Explorer in Visual Studio, right-click the EchoService solution, then click Properties.
  3. Nella finestra di dialogo delle proprietà della soluzione fare clic su Progetto di avvio e quindi sul pulsante Progetti di avvio multipli.In the solution properties dialog box, click Startup Project, then click the Multiple startup projects button. Verificare che EchoService sia visualizzato per primo nell'elenco.Make sure EchoService appears first in the list.
  4. Impostare su Avvio la casella Azione per entrambi i progetti EchoService ed EchoClient.Set the Action box for both the EchoService and EchoClient projects to Start.

  5. Fare clic su Dipendenze progetto.Click Project Dependencies. Nella casella Progetti selezionare EchoClient.In the Projects box, select EchoClient. Nella casella Dipendente da verificare che sia selezionato EchoService.In the Depends on box, make sure EchoService is checked.

  6. Fare clic su OK per chiudere la finestra di dialogo Proprietà.Click OK to dismiss the Properties dialog.
  7. Premere F5 per eseguire entrambi i progetti.Press F5 to run both projects.
  8. Verranno visualizzate entrambe le finestre della console e verrà richiesto il nome dello spazio dei nomi.Both console windows open and prompt you for the namespace name. Il servizio deve essere eseguito per primo. Nella finestra della console EchoService immettere lo spazio dei nomi e quindi premere INVIO.The service must run first, so in the EchoService console window, enter the namespace and then press Enter.
  9. Verrà quindi chiesto di specificare la chiave di firma di accesso condiviso.Next, you are prompted for your SAS key. Immettere la chiave di firma di accesso condiviso e premere INVIO.Enter the SAS key and press ENTER.

    Ecco un esempio dell'output dalla finestra della console.Here is example output from the console window. Si noti che i valori specificati hanno semplicemente scopo esemplificativo.Note that the values provided here are for example purposes only.

    Your Service Namespace: myNamespace``Your SAS Key: <SAS key value>Your Service Namespace: myNamespace Your SAS Key: <SAS key value>

    L'applicazione di servizio stampa l'indirizzo su cui è in ascolto nella finestra della console, come illustrato nell'esempio seguente.The service application prints to the console window the address on which it's listening, as seen in the following example.

    Service address: sb://mynamespace.servicebus.windows.net/EchoService/``Press [Enter] to exitService address: sb://mynamespace.servicebus.windows.net/EchoService/ Press [Enter] to exit

  10. Nella finestra della console EchoClient immettere le stesse informazioni immesse precedentemente per l'applicazione di servizio.In the EchoClient console window, enter the same information that you entered previously for the service application. Eseguire la procedura precedente per immettere gli stessi valori di spazio dei nomi del servizio e chiave di firma di accesso condiviso per l'applicazione client.Follow the previous steps to enter the same service namespace and SAS key values for the client application.
  11. Dopo l'immissione di questi valori, il client aprirà un canale per il servizio e richiederà l'immissione dello stesso testo, come mostrato nell'esempio di output della console seguente.After entering these values, the client opens a channel to the service and prompts you to enter some text as seen in the following console output example.

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

    Immettere il testo da inviare all'applicazione del servizio, quindi premere INVIO.Enter some text to send to the service application and press Enter. Il testo viene inviato al servizio tramite l'operazione del servizio Echo e viene visualizzato nella finestra della console del servizio, come illustrato nell'output di esempio seguente.This text is sent to the service through the Echo service operation and appears in the service console window as in the following example output.

    Echoing: My sample text

    L'applicazione client riceve il valore restituito dell'operazione Echo, ovvero il testo originale, quindi lo stampa nella finestra della console.The client application receives the return value of the Echo operation, which is the original text, and prints it to its console window. Di seguito è riportato un output di esempio dalla finestra della console client.The following is example output from the client console window.

    Server echoed: My sample text

  12. È possibile continuare a inviare messaggi di testo dal client al servizio in questo modo.You can continue sending text messages from the client to the service in this manner. Al termine, premere INVIO nelle finestre del client e della console per terminare entrambe le applicazioni.When you are finished, press Enter in the client and service console windows to end both applications.

Passaggi successiviNext steps

Questa esercitazione ha illustrato come compilare un'applicazione client e di servizio di inoltro di Azure usando le funzionalità di inoltro WCF del bus di servizio.This tutorial showed how to build an Azure Relay client application and service using the WCF Relay capabilities of Service Bus. Per un'esercitazione simile che usa la messaggistica del bus di servizio, vedere Introduzione alle code del bus di servizio.For a similar tutorial that uses Service Bus Messaging, see Get started with Service Bus queues.

Per altre informazioni sul servizio d'inoltro di Azure, vedere gli argomenti seguenti.To learn more about Azure Relay, see the following topics.