Introduzione alle code del bus di servizioGet started with Service Bus queues

Questa esercitazione illustra i passaggi seguenti:This tutorial covers the following steps:

  1. Creare uno spazio dei nomi del bus di servizio usando il portale di Azure.Create a Service Bus namespace, using the Azure portal.
  2. Creare una coda del bus di servizio usando il portale di Azure.Create a Service Bus queue, using the Azure portal.
  3. Scrivere un'applicazione console .NET Core per inviare un set di messaggi alla coda.Write a .NET Core console application to send a set of messages to the queue.
  4. Scrivere un'applicazione console .NET Core per ricevere tali messaggi dalla coda.Write a .NET Core console application to receive those messages from the queue.

PrerequisitiPrerequisites

  1. Visual Studio 2017 Update 3 (versione 15.3, 26730.01) o versioni successive.Visual Studio 2017 Update 3 (version 15.3, 26730.01) or later.
  2. NET Core SDK versione 2.0 o successiva.NET Core SDK, version 2.0 or later.
  3. Una sottoscrizione di Azure.An Azure subscription.

Nota

Per completare l'esercitazione, è necessario un account Azure.To complete this tutorial, you need an Azure account. È possibile attivare i benefici della sottoscrizione MSDN o iscriversi per un account gratuito.You can activate your MSDN subscriber benefits or sign up for a free account.

1. Creare uno spazio dei nomi tramite il portale di Azure1. Create a namespace using the Azure portal

Nota

È possibile creare entità di messaggistica e uno spazio dei nomi del bus di servizio anche usando PowerShell.You can also create a Service Bus namespace and messaging entities using PowerShell. Per altre informazioni, vedere Gestire le risorse del bus di servizio di Azure con PowerShell.For more information, see Use PowerShell to manage Service Bus resources.

Se è già stato creato uno spazio dei nomi di messaggistica del bus di servizio, passare alla sezione Creare una coda usando il portale di Azure.If you have already created a Service Bus Messaging namespace, jump to the Create a queue using the Azure portal section.

Per iniziare a usare le entità di messaggistica del bus di servizio in Azure, prima di tutto è necessario creare uno spazio dei nomi con un nome univoco in Azure.To begin using Service Bus messaging entities in Azure, you must first create a namespace with a name that is unique across Azure. Uno spazio dei nomi fornisce un contenitore di ambito per fare riferimento alle risorse del bus di servizio all'interno dell'applicazione.A namespace provides a scoping container for addressing Service Bus resources within your application.

Per creare uno spazio dei nomi:To create a namespace:

  1. Accedere al portale di Azure.Log on to the Azure portal.
  2. Nel riquadro di spostamento sinistro del portale fare clic su + Crea una risorsa, quindi su Enterprise Integration e infine su Bus di servizio.In the left navigation pane of the portal, click + Create a resource, then click Enterprise Integration, and then click Service Bus.
  3. Nella finestra di dialogo Crea spazio dei nomi immettere un nome per lo spazio dei nomi.In the Create namespace dialog, enter a namespace name. Verrà effettuato immediatamente un controllo sulla disponibilità del nome.The system immediately checks to see if the name is available.
  4. Dopo aver verificato che il nome dello spazio dei nomi sia disponibile, scegliere il piano tariffario, ovvero Basic, Standard o Premium.After making sure the namespace name is available, choose the pricing tier (Basic, Standard, or Premium).
  5. Nel campo Sottoscrizione scegliere una sottoscrizione di Azure in cui creare lo spazio dei nomi.In the Subscription field, choose an Azure subscription in which to create the namespace.
  6. Nel campo Gruppo di risorse scegliere un gruppo di risorse esistente nel quale risiederà lo spazio dei nomi oppure crearne uno nuovo.In the Resource group field, choose an existing resource group in which the namespace will live, or create a new one.
  7. In Localitàscegliere il paese o l'area in cui deve essere ospitato lo spazio dei nomi.In Location, choose the country or region in which your namespace should be hosted.

    Crea spazio dei nomi

  8. Fare clic su Crea.Click Create. A questo punto, lo spazio dei nomi verrà creato e abilitato nel sistema.The system now creates your namespace and enables it. Potrebbero essere necessari alcuni minuti per consentire al sistema di effettuare il provisioning delle risorse per lo spazio dei nomi creato.You might have to wait several minutes as the system provisions resources for your account.

Ottenere le credenziali di gestioneObtain the management credentials

Con la creazione di un nuovo spazio dei nomi viene generata automaticamente una regola di firma di accesso condiviso iniziale con una coppia associata di chiavi primaria e secondaria, ognuna delle quali concede il controllo completo su tutti gli aspetti dello spazio dei nomi.Creating a new namespace automatically generates an initial Shared Access Signature (SAS) rule with an associated pair of primary and secondary keys that each grant full control over all aspects of the namespace. Per informazioni su come creare altre regole con diritti più limitati per mittenti e ricevitori normali, vedere Autenticazione e autorizzazione del bus di servizio.See Service Bus authentication and authorization for information about how to create further rules with more constrained rights for regular senders and receivers. Per copiare la regola iniziale seguire questa procedura:To copy the initial rule, follow these steps:

  1. Nell'elenco degli spazi dei nomi fare clic sul nome dello spazio dei nomi appena creato.In the list of namespaces, click the newly created namespace name.
  2. Nella finestra dello spazio dei nomi fare clic su Criteri di accesso condiviso.In the namespace window, click Shared access policies.
  3. Nella schermata Criteri di accesso condiviso fare clic su RootManageSharedAccessKey.In the Shared access policies screen, click RootManageSharedAccessKey.

    connection-info

  4. Nella finestra Criteri: RootManageSharedAccessKey fare clic sul pulsante Copia accanto a Stringa di connessione - chiave primaria per copiare la stringa di connessione negli Appunti e usarla in un secondo momento.In the Policy: RootManageSharedAccessKey window, click the copy button next to Connection string–primary key, to copy the connection string to your clipboard for later use. Incollare questo valore nel Blocco note o in un'altra posizione temporanea.Paste this value into Notepad or some other temporary location.

    connection-string

  5. Ripetere il passaggio precedente e copiare e incollare il valore della chiave primaria in un percorso temporaneo per usarlo in seguito.Repeat the previous step, copying and pasting the value of Primary key to a temporary location for later use.

2. Creare una coda usando il portale di Azure2. Create a queue using the Azure portal

Se è già stata creata una coda del bus di servizio, passare alla sezione Inviare messaggi alla coda.If you have already created a Service Bus queue, jump to the Send messages to the queue section.

Verificare che sia già stato creato uno spazio dei nomi del bus di servizio, come illustrato qui.Please ensure that you have already created a Service Bus namespace, as shown here.

  1. Accedere al portale di Azure.Log on to the Azure portal.
  2. Nel riquadro di spostamento a sinistra del portale, fare clic su Bus di servizio (se non viene visualizzato Bus di servizio, fare clic su Altri servizi).In the left navigation pane of the portal, click Service Bus (if you don't see Service Bus, click More services).
  3. Fare clic sullo spazio dei nomi in cui si vuole creare la coda.Click the namespace in which you would like to create the queue. In questo caso è sbnstest1.In this case, it is sbnstest1.

    Creare una coda

  4. Nella finestra dello spazio dei nomi fare clic su Code e quindi nella finestra Code fare clic su + Coda.In the namespace window, click Queues, then in the Queues window, click + Queue.

    Selezionare Code

  5. Immettere il nome della coda in Nome e lasciare le impostazioni predefinite per gli altri valori.Enter the queue Name and leave the other values with their defaults.

    Selezionare Nuovo

  6. Nella parte inferiore della finestra fare clic su Crea.At the bottom of the window, click Create.

3. Inviare messaggi alla coda3. Send messages to the queue

Per inviare messaggi alla coda, scrivere un'applicazione console C# in Visual Studio.To send messages to the queue, write a C# console application using Visual Studio.

Creare un'applicazione consoleCreate a console application

Avviare Visual Studio e creare un nuovo progetto Console App (.NET Core) (App console - .NET Core).Launch Visual Studio and create a new Console App (.NET Core) project.

Aggiungere il pacchetto NuGet del bus di servizioAdd the Service Bus NuGet package

  1. Fare clic con il pulsante destro del mouse sul progetto appena creato e scegliere Gestisci pacchetti NuGet.Right-click the newly created project and select Manage NuGet Packages.
  2. Fare clic sulla scheda Sfoglia, cercare Microsoft.Azure.ServiceBus e quindi selezionare l'elemento Microsoft.Azure.ServiceBus.Click the Browse tab, search for Microsoft.Azure.ServiceBus, and then select the Microsoft.Azure.ServiceBus item. Fare clic su Installa per completare l'installazione, quindi chiudere questa finestra di dialogo.Click Install to complete the installation, then close this dialog box.

    Selezionare un pacchetto NuGet

Scrivere il codice per inviare messaggi alla codaWrite code to send messages to the queue

  1. In Program.cs aggiungere le istruzioni using seguenti all'inizio della definizione dello spazio dei nomi, prima della dichiarazione della classe:In Program.cs, add the following using statements at the top of the namespace definition, before the class declaration:

    using System.Text;
    using System.Threading;
    using System.Threading.Tasks;
    using Microsoft.Azure.ServiceBus;
    
  2. Nella classe Program dichiarare le variabili seguenti.Within the Program class, declare the following variables. Impostare la variabile ServiceBusConnectionString sulla stessa stringa di connessione ottenuta al momento della creazione dello spazio dei nomi e impostare QueueName sul nome usato durante la creazione della coda:Set the ServiceBusConnectionString variable to the connection string that you obtained when creating the namespace, and set QueueName to the name that you used when creating the queue:

    const string ServiceBusConnectionString = "<your_connection_string>";
    const string QueueName = "<your_queue_name>";
    static IQueueClient queueClient;
    
  3. Sostituire il contenuto predefinito di Main() con la riga di codice seguente:Replace the default contents of Main() with the following line of code:

    MainAsync().GetAwaiter().GetResult();
    
  4. Subito dopo Main() aggiungere il metodo asincrono MainAsync() seguente, che chiama il metodo per l'invio dei messaggi:Directly after Main(), add the following asynchronous MainAsync() method that calls the send messages method:

    static async Task MainAsync()
    {
        const int numberOfMessages = 10;
        queueClient = new QueueClient(ServiceBusConnectionString, QueueName);
    
        Console.WriteLine("======================================================");
        Console.WriteLine("Press ENTER key to exit after sending all the messages.");
        Console.WriteLine("======================================================");
    
        // Send messages.
        await SendMessagesAsync(numberOfMessages);
    
        Console.ReadKey();
    
        await queueClient.CloseAsync();
    }
    
  5. Subito dopo il metodo MainAsync() aggiungere il metodo SendMessagesAsync() seguente, che esegue l'operazione di invio del numero di messaggi specificato da numberOfMessagesToSend (attualmente impostato su 10):Directly after the MainAsync() method, add the following SendMessagesAsync() method that performs the work of sending the number of messages specified by numberOfMessagesToSend (currently set to 10):

    static async Task SendMessagesAsync(int numberOfMessagesToSend)
    {
        try
        {
            for (var i = 0; i < numberOfMessagesToSend; i++)
            {
                // Create a new message to send to the queue.
                string messageBody = $"Message {i}";
                var message = new Message(Encoding.UTF8.GetBytes(messageBody));
    
                // Write the body of the message to the console.
                Console.WriteLine($"Sending message: {messageBody}");
    
                // Send the message to the queue.
                await queueClient.SendAsync(message);
            }
        }
        catch (Exception exception)
        {
            Console.WriteLine($"{DateTime.Now} :: Exception: {exception.Message}");
        }
    }
    
  6. Ecco l'aspetto che avrà il file Program.cs.Here is what your Program.cs file should look like.

    namespace CoreSenderApp
    {
        using System;
        using System.Text;
        using System.Threading;
        using System.Threading.Tasks;
        using Microsoft.Azure.ServiceBus;
    
        class Program
        {
            // Connection String for the namespace can be obtained from the Azure portal under the 
            // 'Shared Access policies' section.
            const string ServiceBusConnectionString = "<your_connection_string>";
            const string QueueName = "<your_queue_name>";
            static IQueueClient queueClient;
    
            static void Main(string[] args)
            {
                MainAsync().GetAwaiter().GetResult();
            }
    
            static async Task MainAsync()
            {
                const int numberOfMessages = 10;
                queueClient = new QueueClient(ServiceBusConnectionString, QueueName);
    
                Console.WriteLine("======================================================");
                Console.WriteLine("Press ENTER key to exit after receiving all the messages.");
                Console.WriteLine("======================================================");
    
                // Send Messages
                await SendMessagesAsync(numberOfMessages);
    
                Console.ReadKey();
    
                await queueClient.CloseAsync();
            }
    
            static async Task SendMessagesAsync(int numberOfMessagesToSend)
            {
                try
                {
                    for (var i = 0; i < numberOfMessagesToSend; i++)
                    {
                        // Create a new message to send to the queue
                        string messageBody = $"Message {i}";
                        var message = new Message(Encoding.UTF8.GetBytes(messageBody));
    
                        // Write the body of the message to the console
                        Console.WriteLine($"Sending message: {messageBody}");
    
                        // Send the message to the queue
                        await queueClient.SendAsync(message);
                    }
                }
                catch (Exception exception)
                {
                    Console.WriteLine($"{DateTime.Now} :: Exception: {exception.Message}");
                }
            }
        }
    }
    
  7. Eseguire il programma e nel portale di Azure fare clic sul nome della coda nella finestra Panoramica dello spazio dei nomi.Run the program, and check the Azure portal: click the name of your queue in the namespace Overview window. Verrà visualizzata la schermata Informazioni di base della coda.The queue Essentials screen is displayed. Si noti che ora il valore Numero di messaggi attivi per la coda è 10.Notice that the Active Message Count value for the queue is now 10. Ogni volta che si esegue l'applicazione mittente senza recuperare i messaggi (come descritto nella sezione successiva), questo valore aumenta di 10.Each time you run the sender application without retrieving the messages (as described in the next section), this value increases by 10. Si noti anche che la dimensione corrente della coda aumenta il valore di Corrente nella finestra Informazioni di base ogni volta che l'app aggiunge messaggi alla coda.Also note that the current size of the queue increments the Current value in the Essentials window each time the app adds messages to the queue.

    Dimensioni dei messaggi

4. Ricezione di messaggi dalla coda4. Receive messages from the queue

Per ricevere i messaggi inviati, creare un'altra applicazione console .NET Core e installare il pacchetto NuGet Microsoft.Azure.ServiceBus, come per l'applicazione mittente precedente.To receive the messages you just sent, create another .NET Core console application and install the Microsoft.Azure.ServiceBus NuGet package, similar to the previous sender application.

Scrivere il codice per ricevere messaggi dalla codaWrite code to receive messages from the queue

  1. In Program.cs aggiungere le istruzioni using seguenti all'inizio della definizione dello spazio dei nomi, prima della dichiarazione della classe:In Program.cs, add the following using statements at the top of the namespace definition, before the class declaration:

    using System.Text;
    using System.Threading;
    using System.Threading.Tasks;
    using Microsoft.Azure.ServiceBus;
    
  2. Nella classe Program dichiarare le variabili seguenti.Within the Program class, declare the following variables. Impostare la variabile ServiceBusConnectionString sulla stessa stringa di connessione ottenuta al momento della creazione dello spazio dei nomi e impostare QueueName sul nome usato durante la creazione della coda:Set the ServiceBusConnectionString variable to the connection string that you obtained when creating the namespace, and set QueueName to the name that you used when creating the queue:

    const string ServiceBusConnectionString = "<your_connection_string>";
    const string QueueName = "<your_queue_name>";
    static IQueueClient queueClient;
    
  3. Sostituire il contenuto predefinito di Main() con la riga di codice seguente:Replace the default contents of Main() with the following line of code:

    MainAsync().GetAwaiter().GetResult();
    
  4. Subito dopo Main() aggiungere il metodo asincrono MainAsync() seguente, che chiama il metodo RegisterOnMessageHandlerAndReceiveMessages():Directly after Main(), add the following asynchronous MainAsync() method that calls the RegisterOnMessageHandlerAndReceiveMessages() method:

    static async Task MainAsync()
    {
        queueClient = new QueueClient(ServiceBusConnectionString, QueueName);
    
        Console.WriteLine("======================================================");
        Console.WriteLine("Press ENTER key to exit after receiving all the messages.");
        Console.WriteLine("======================================================");
    
        // Register the queue message handler and receive messages in a loop
        RegisterOnMessageHandlerAndReceiveMessages();
    
        Console.ReadKey();
    
        await queueClient.CloseAsync();
    }
    
  5. Subito dopo il metodo MainAsync() aggiungere il metodo seguente, che registra il gestore di messaggi e riceve i messaggi inviati dall'applicazione mittente:Directly after the MainAsync() method, add the following method that registers the message handler and receives the messages sent by the sender application:

    static void RegisterOnMessageHandlerAndReceiveMessages()
    {
        // Configure the message handler options in terms of exception handling, number of concurrent messages to deliver, etc.
        var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
        {
            // Maximum number of concurrent calls to the callback ProcessMessagesAsync(), set to 1 for simplicity.
            // Set it according to how many messages the application wants to process in parallel.
            MaxConcurrentCalls = 1,
    
            // Indicates whether the message pump should automatically complete the messages after returning from user callback.
            // False below indicates the complete operation is handled by the user callback as in ProcessMessagesAsync().
            AutoComplete = false
        };
    
        // Register the function that processes messages.
        queueClient.RegisterMessageHandler(ProcessMessagesAsync, messageHandlerOptions);
    }
    
  6. Subito dopo il metodo precedente aggiungere il metodo ProcessMessagesAsync() seguente per elaborare i messaggi ricevuti:Directly after the previous method, add the following ProcessMessagesAsync() method to process the received messages:

    static async Task ProcessMessagesAsync(Message message, CancellationToken token)
    {
        // Process the message.
        Console.WriteLine($"Received message: SequenceNumber:{message.SystemProperties.SequenceNumber} Body:{Encoding.UTF8.GetString(message.Body)}");
    
        // Complete the message so that it is not received again.
        // This can be done only if the queue Client is created in ReceiveMode.PeekLock mode (which is the default).
        await queueClient.CompleteAsync(message.SystemProperties.LockToken);
    
        // Note: Use the cancellationToken passed as necessary to determine if the queueClient has already been closed.
        // If queueClient has already been closed, you can choose to not call CompleteAsync() or AbandonAsync() etc.
        // to avoid unnecessary exceptions.
    }
    
  7. Aggiungere infine il metodo seguente per gestire le eccezioni che potrebbero verificarsi:Finally, add the following method to handle any exceptions that might occur:

    // Use this handler to examine the exceptions received on the message pump.
    static Task ExceptionReceivedHandler(ExceptionReceivedEventArgs exceptionReceivedEventArgs)
    {
        Console.WriteLine($"Message handler encountered an exception {exceptionReceivedEventArgs.Exception}.");
        var context = exceptionReceivedEventArgs.ExceptionReceivedContext;
        Console.WriteLine("Exception context for troubleshooting:");
        Console.WriteLine($"- Endpoint: {context.Endpoint}");
        Console.WriteLine($"- Entity Path: {context.EntityPath}");
        Console.WriteLine($"- Executing Action: {context.Action}");
        return Task.CompletedTask;
    }    
    
  8. Ecco l'aspetto che avrà il file Program.cs:Here is what your Program.cs file should look like:

    namespace CoreReceiverApp
    {
        using System;
        using System.Text;
        using System.Threading;
        using System.Threading.Tasks;
        using Microsoft.Azure.ServiceBus;
    
        class Program
        {
            // Connection String for the namespace can be obtained from the Azure portal under the 
            // 'Shared Access policies' section.
            const string ServiceBusConnectionString = "<your_connection_string>";
            const string QueueName = "<your_queue_name>";
            static IQueueClient queueClient;
    
            static void Main(string[] args)
            {
                MainAsync().GetAwaiter().GetResult();
            }
    
            static async Task MainAsync()
            {
                queueClient = new QueueClient(ServiceBusConnectionString, QueueName);
    
                Console.WriteLine("======================================================");
                Console.WriteLine("Press ENTER key to exit after receiving all the messages.");
                Console.WriteLine("======================================================");
    
                // Register QueueClient's MessageHandler and receive messages in a loop
                RegisterOnMessageHandlerAndReceiveMessages();
    
                Console.ReadKey();
    
                await queueClient.CloseAsync();
            }
    
            static void RegisterOnMessageHandlerAndReceiveMessages()
            {
                // Configure the MessageHandler Options in terms of exception handling, number of concurrent messages to deliver etc.
                var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
                {
                    // Maximum number of Concurrent calls to the callback `ProcessMessagesAsync`, set to 1 for simplicity.
                    // Set it according to how many messages the application wants to process in parallel.
                    MaxConcurrentCalls = 1,
    
                    // Indicates whether MessagePump should automatically complete the messages after returning from User Callback.
                    // False below indicates the Complete will be handled by the User Callback as in `ProcessMessagesAsync` below.
                    AutoComplete = false
                };
    
                // Register the function that will process messages
                queueClient.RegisterMessageHandler(ProcessMessagesAsync, messageHandlerOptions);
            }
    
            static async Task ProcessMessagesAsync(Message message, CancellationToken token)
            {
                // Process the message
                Console.WriteLine($"Received message: SequenceNumber:{message.SystemProperties.SequenceNumber} Body:{Encoding.UTF8.GetString(message.Body)}");
    
                // Complete the message so that it is not received again.
                // This can be done only if the queueClient is created in ReceiveMode.PeekLock mode (which is default).
                await queueClient.CompleteAsync(message.SystemProperties.LockToken);
    
                // Note: Use the cancellationToken passed as necessary to determine if the queueClient has already been closed.
                // If queueClient has already been Closed, you may chose to not call CompleteAsync() or AbandonAsync() etc. calls 
               // to avoid unnecessary exceptions.
            }
    
            static Task ExceptionReceivedHandler(ExceptionReceivedEventArgs exceptionReceivedEventArgs)
            {
                Console.WriteLine($"Message handler encountered an exception {exceptionReceivedEventArgs.Exception}.");
                var context = exceptionReceivedEventArgs.ExceptionReceivedContext;
                Console.WriteLine("Exception context for troubleshooting:");
                Console.WriteLine($"- Endpoint: {context.Endpoint}");
                Console.WriteLine($"- Entity Path: {context.EntityPath}");
                Console.WriteLine($"- Executing Action: {context.Action}");
                return Task.CompletedTask;
            }
        }
    }
    
  9. Eseguire il programma e verificare di nuovo il portale.Run the program, and check the portal again. Si noti che ora i valori di Numero di messaggi attivi e di Corrente sono pari a 0.Notice that the Active Message Count and Current values are now 0.

    Lunghezza coda

Congratulazioni.Congratulations! È stata creata una coda, è stato inviato un set di messaggi alla coda e sono stati ricevuti tali messaggi dalla stessa coda.You have now created a queue, sent a set of messages to that queue, and received those messages from the same queue.

Passaggi successiviNext steps

Vedere il repository GitHub con esempi che illustrano alcune delle funzionalità più avanzate della messaggistica del bus di servizio.Check out our GitHub repository with samples that demonstrate some of the more advanced features of Service Bus messaging.