Introduzione agli argomenti e alle sottoscrizioni del bus di servizio di Azure (.NET)

Questa guida introduttiva illustra come inviare messaggi a un argomento del bus di servizio e ricevere messaggi da una sottoscrizione a tale argomento usando la libreria .NET Azure.Messaging.ServiceBus .

In questa guida introduttiva si eseguiranno i passaggi seguenti:

  1. Creare uno spazio dei nomi del bus di servizio usando il portale di Azure.
  2. Creare un argomento del bus di servizio usando il portale di Azure.
  3. Creare una sottoscrizione a tale argomento del bus di servizio usando il portale di Azure.
  4. Scrivere un'applicazione console .NET Core per inviare un set di messaggi all'argomento.
  5. Scrivere un'applicazione console .NET Core per ricevere tali messaggi dalla sottoscrizione.

Nota

Questa guida introduttiva fornisce istruzioni dettagliate per implementare uno scenario semplice di invio di un batch di messaggi a un argomento del bus di servizio e la ricezione di tali messaggi da una sottoscrizione dell'argomento. Per altri esempi su altri scenari e avanzati, vedere Esempi .NET del bus di servizio in GitHub.

Prerequisiti

Se non si ha familiarità con il servizio, vedere Panoramica del bus di servizio prima di eseguire questa guida introduttiva.

  • Sottoscrizione di Azure. Per usare i servizi di Azure, incluso il bus di servizio di Azure, è necessaria una sottoscrizione. Se non si ha un account Azure, è possibile iscriversi per ottenere una versione di valutazione gratuita oppure usare i vantaggi della sottoscrizione di MSDN per la creazione di un account.
  • Microsoft Visual Studio 2019. La libreria client del bus di servizio di Azure usa nuove funzionalità introdotte in C# 8.0. È comunque possibile usare la libreria con le versioni precedenti del linguaggio C#, ma la nuova sintassi non sarà disponibile. Per usare la sintassi completa, è consigliabile compilare con .NET Core SDK 3.0 o versione successiva e la versione del linguaggio impostata su latest. Se si usa Visual Studio, le versioni precedenti a Visual Studio 2019 non sono compatibili con gli strumenti necessari per la compilazione di progetti in C# 8.0. Visual Studio 2019, inclusa l'edizione Community gratuita, può essere scaricato qui.

Creare uno spazio dei nomi nel portale di Azure

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. Uno spazio dei nomi fornisce un contenitore di ambito per le risorse del bus di servizio all'interno dell'applicazione.

Per creare uno spazio dei nomi:

  1. Accedere al portale di Azure

  2. Nel riquadro di spostamento sinistro del portale fare clic su + Crea una risorsa, selezionare Integrazione e quindi Bus di servizio.

    Image showing selection of Create a resource, Integration, and then Service Bus in the menu.

  3. Nel tag Informazioni di base della pagina Crea spazio dei nomi seguire questa procedura:

    1. Per Sottoscrizione scegliere una sottoscrizione di Azure in cui creare lo spazio dei nomi.

    2. Per Gruppo di risorse scegliere un gruppo di risorse esistente in cui risiederà lo spazio dei nomi oppure crearne uno nuovo.

    3. Immettere un nome per lo spazio dei nomi. Il nome dello spazio dei nomi deve rispettare le convenzioni di denominazione seguenti:

      • Il nome deve essere univoco in Azure. Verrà effettuato immediatamente un controllo sulla disponibilità del nome.
      • La lunghezza del nome deve essere compresa tra 6 e 50 caratteri.
      • Il nome può contenere solo lettere, numeri, trattini "-".
      • Il nome deve iniziare con una lettera e terminare con una lettera o un numero.
      • Il nome non termina con "-sb" o "-mgmt".
    4. Per Localitàscegliere l'area in cui deve essere ospitato lo spazio dei nomi.

    5. Per Piano tariffario selezionare il piano tariffario (Basic, Standard o Premium) per lo spazio dei nomi . Per questa guida introduttiva selezionare Standard.

      Importante

      Se si vogliono usare argomenti e sottoscrizioni, scegliere Standard o Premium. Gli argomenti o le sottoscrizioni non sono supportati nel piano tariffario Basic.

      Se è stato selezionato il piano tariffario Premium , specificare il numero di unità di messaggistica. Il piano Premium fornisce l'isolamento delle risorse a livello di CPU e memoria in modo che ogni carico di lavoro venga eseguito in isolamento. Questo contenitore di risorse viene chiamato unità di messaggistica. Uno spazio dei nomi Premium ha almeno un'unità di messaggistica. È possibile selezionare 1, 2, 4, 8 o 16 unità di messaggistica per ogni spazio dei nomi Premium del bus di servizio. Per altre informazioni, vedere Messaggistica Premium del bus di servizio.

    6. Selezionare Rivedi e crea. A questo punto, lo spazio dei nomi verrà creato e abilitato nel sistema. Potrebbero essere necessari alcuni minuti per consentire al sistema di effettuare il provisioning delle risorse per lo spazio dei nomi creato.

      Image showing the Create a namespace page

    7. Nella pagina Crea rivedere le impostazioni e selezionare Crea.

  4. Selezionare Vai alla risorsa nella pagina di distribuzione.

    Image showing the deployment succeeded page with the Go to resource link.

  5. Viene visualizzata la home page dello spazio dei nomi del bus di servizio.

    Image showing the home page of the Service Bus namespace created.

Ottenere la stringa di connessione

La creazione di un nuovo spazio dei nomi genera automaticamente un criterio di firma di accesso condiviso iniziale con chiavi primarie e secondarie e stringhe di connessione primaria e secondaria che ogni concede il controllo completo su tutti gli aspetti dello spazio dei nomi. Per informazioni su come creare regole con diritti più limitati per mittenti e ricevitori, vedere Autenticazione e autorizzazione del bus di servizio.

Per copiare la stringa di connessione primaria per lo spazio dei nomi, seguire questa procedura:

  1. Nella pagina Spazio dei nomi del bus di servizio selezionare Criteri di accesso condiviso nel menu a sinistra.

  2. Nella pagina Criteri di accesso condiviso selezionare RootManageSharedAccessKey.

  3. Nella finestra Criteri: RootManageSharedAccessKey selezionare il pulsante copia accanto a Stringa di connessione primaria per copiare la stringa di connessione negli Appunti per usarla in un secondo momento. Incollare questo valore nel Blocco note o in un'altra posizione temporanea.

    Screenshot shows an S A S policy called RootManageSharedAccessKey, which includes keys and connection strings.

    È possibile usare questa pagina per copiare la chiave primaria, la chiave secondaria, la stringa di connessione primaria e la stringa di connessione secondaria.

Creare un argomento usando il portale di Azure

  1. Nella pagina Spazio dei nomi del bus di servizio scegliere Argomenti dal menu a sinistra.

  2. Selezionare + Argomento sulla barra degli strumenti.

  3. Immettere un nome per l'argomento. Lasciare invariati i valori predefiniti delle altre opzioni.

  4. Selezionare Crea.

    Image showing the Create topic page.

Creare una sottoscrizione all'argomento

  1. Selezionare l'argomento creato nella sezione precedente.

    Image showing the selection of topic from the list of topics.

  2. Nella pagina Argomento del bus di servizio selezionare + Sottoscrizione sulla barra degli strumenti.

    Image showing the Add subscription button.

  3. Nella pagina Crea sottoscrizione seguire questa procedura:

    1. Immettere S1 come nome della sottoscrizione.

    2. Immettere 3 per Numero massimo di recapito.

    3. Selezionare quindi Crea per creare la sottoscrizione.

      Image showing the Create subscription page.

Importante

Prendere nota della stringa di connessione allo spazio dei nomi, al nome dell'argomento e al nome della sottoscrizione. Verranno usati più avanti in questa esercitazione.

Inviare messaggi all'argomento

Questa sezione illustra come creare un'applicazione console .NET Core per inviare messaggi a un argomento del bus di servizio.

Nota

Questa guida introduttiva fornisce istruzioni dettagliate per implementare uno scenario semplice di invio di un batch di messaggi a un argomento del bus di servizio e la ricezione di tali messaggi da una sottoscrizione dell'argomento. Per altri esempi su altri scenari e avanzati, vedere Esempi .NET del bus di servizio in GitHub.

Creare un'applicazione console

  1. Avviare Visual Studio 2019.
  2. Selezionare Crea un nuovo progetto.
  3. Nella finestra di dialogo Crea un nuovo progetto seguire questa procedura: Se questa finestra di dialogo non viene visualizzata, scegliere File dal menu, selezionare Nuovo e quindi Progetto.
    1. Selezionare C# come linguaggio di programmazione.

    2. Selezionare Console come tipo di applicazione.

    3. Selezionare Applicazione console nell'elenco dei risultati.

    4. Quindi selezionare Avanti.

      Image showing the Create a new project dialog box with C# and Console selected

  4. Immettere TopicSender per il nome del progetto, ServiceBusTopicQuickStart per il nome della soluzione e quindi selezionare Avanti.
  5. Nella pagina Informazioni aggiuntive selezionare Crea per creare la soluzione e il progetto.

Aggiungere il pacchetto NuGet del bus di servizio

  1. Scegliere Strumenti>Gestione pacchetti NuGet>Console di Gestione pacchetti dal menu.

  2. Eseguire il comando seguente per installare il pacchetto NuGet Azure.Messaging.ServiceBus :

    Install-Package Azure.Messaging.ServiceBus
    

Aggiungere il codice per inviare messaggi all'argomento

  1. In Program.cs aggiungere le istruzioni seguenti using nella parte superiore della definizione dello spazio dei nomi prima della dichiarazione di classe.

    using System.Threading.Tasks;
    using Azure.Messaging.ServiceBus;
    
  2. All'interno della Program classe dichiarare le proprietà seguenti, appena prima del Main metodo. Sostituire <NAMESPACE CONNECTION STRING> con la stringa di connessione allo spazio dei nomi del bus di servizio. Sostituire con <TOPIC NAME> il nome dell'argomento del bus di servizio.

    // connection string to your Service Bus namespace
    static string connectionString = "<NAMESPACE CONNECTION STRING>";
    
    // name of your Service Bus topic
    static string topicName = "<TOPIC NAME>";
    
    // the client that owns the connection and can be used to create senders and receivers
    static ServiceBusClient client;
    
    // the sender used to publish messages to the topic
    static ServiceBusSender sender;
    
    // number of messages to be sent to the topic
    private const int numOfMessages = 3;
    
  3. Sostituire il codice in Program.cs con il codice seguente. Ecco i passaggi importanti del codice.

    1. Crea un oggetto ServiceBusClient usando la stringa di connessione allo spazio dei nomi.
    2. Richiama il metodo CreateSender nell'oggetto per creare un oggetto ServiceBusSender per l'argomento ServiceBusClient del bus di servizio specifico.
    3. Crea un oggetto ServiceBusMessageBatch usando ServiceBusSender.CreateMessageBatchAsync.
    4. Aggiungere messaggi al batch usando ServiceBusMessageBatch.TryAddMessage.
    5. Invia il batch di messaggi all'argomento del bus di servizio usando il metodo ServiceBusSender.SendMessagesAsync .
    static async Task Main()
    {
        // The Service Bus client types are safe to cache and use as a singleton for the lifetime
        // of the application, which is best practice when messages are being published or read
        // regularly.
        //
        // Create the clients that we'll use for sending and processing messages.
        client = new ServiceBusClient(connectionString);
        sender = client.CreateSender(topicName);
    
        // create a batch 
        using ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync();
    
        for (int i = 1; i <= numOfMessages; i++)
        {
            // try adding a message to the batch
            if (!messageBatch.TryAddMessage(new ServiceBusMessage($"Message {i}")))
            {
                // if it is too large for the batch
                throw new Exception($"The message {i} is too large to fit in the batch.");
            }
        }
    
        try
        {
            // Use the producer client to send the batch of messages to the Service Bus topic
            await sender.SendMessagesAsync(messageBatch);
            Console.WriteLine($"A batch of {numOfMessages} messages has been published to the topic.");
        }
        finally
        {
            // Calling DisposeAsync on client types is required to ensure that network
            // resources and other unmanaged objects are properly cleaned up.
            await sender.DisposeAsync();
            await client.DisposeAsync();
        }
    
        Console.WriteLine("Press any key to end the application");
        Console.ReadKey();
    }
    
  4. Ecco l'aspetto del file Program.cs:

    Per altre informazioni, vedere Commenti di codice.

    using System;
    using System.Threading.Tasks;
    using Azure.Messaging.ServiceBus;
    
    namespace TopicSender
    {
        class Program
        {
            // connection string to your Service Bus namespace
            static string connectionString = "<NAMESPACE CONNECTION STRING>";
    
            // name of your Service Bus topic
            static string topicName = "<TOPIC NAME>";
    
            // the client that owns the connection and can be used to create senders and receivers
            static ServiceBusClient client;
    
            // the sender used to publish messages to the topic
            static ServiceBusSender sender;
    
            // number of messages to be sent to the topic
            private const int numOfMessages = 3;
    
            static async Task Main()
            {
                // The Service Bus client types are safe to cache and use as a singleton for the lifetime
                // of the application, which is best practice when messages are being published or read
                // regularly.
                //
                // Create the clients that we'll use for sending and processing messages.
                client = new ServiceBusClient(connectionString);
                sender = client.CreateSender(topicName);
    
                // create a batch 
                using ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync();
    
                for (int i = 1; i <= numOfMessages; i++)
                {
                    // try adding a message to the batch
                    if (!messageBatch.TryAddMessage(new ServiceBusMessage($"Message {i}")))
                    {
                        // if it is too large for the batch
                        throw new Exception($"The message {i} is too large to fit in the batch.");
                    }
                }
    
                try
                {
                    // Use the producer client to send the batch of messages to the Service Bus topic
                    await sender.SendMessagesAsync(messageBatch);
                    Console.WriteLine($"A batch of {numOfMessages} messages has been published to the topic.");
                }
                finally
                {
                    // Calling DisposeAsync on client types is required to ensure that network
                    // resources and other unmanaged objects are properly cleaned up.
                    await sender.DisposeAsync();
                    await client.DisposeAsync();
                }
    
                Console.WriteLine("Press any key to end the application");
                Console.ReadKey();
            }
        }
    }    
    
  5. Sostituire <NAMESPACE CONNECTION STRING> con la stringa di connessione allo spazio dei nomi del bus di servizio. Sostituire con <TOPIC NAME> il nome dell'argomento del bus di servizio.

  6. Compilare il progetto e assicurarsi che non siano presenti errori.

  7. Eseguire il programma e attendere il messaggio di conferma.

    A batch of 3 messages has been published to the topic
    
  8. Nel portale di Azure seguire questa procedura:

    1. Passare allo spazio dei nomi del bus di servizio.

    2. Nella pagina Panoramica passare alla scheda Argomenti nel riquadro centrale inferiore e selezionare l'argomento del bus di servizio. Nell'esempio seguente è mytopic.

      Select topic

    3. Nella pagina Argomento del bus di servizio , nel grafico Messaggi nella sezione Metriche inferiore è possibile notare che sono presenti tre messaggi in ingresso per l'argomento. Se il valore non viene visualizzato, attendere alcuni minuti e aggiornare la pagina per vedere il grafico aggiornato.

      Messages sent to the topic

    4. Selezionare la sottoscrizione nel riquadro in basso. Nell'esempio seguente è S1. Nella pagina Sottoscrizione del bus di servizio viene visualizzato il conteggio dei messaggi attivi come 3. La sottoscrizione ha ricevuto i tre messaggi inviati all'argomento, ma non è ancora stato selezionato alcun ricevitore.

      Messages received at the subscription

Ricevere messaggi da una sottoscrizione

In questa sezione verrà creata un'applicazione console .NET Core che riceve messaggi dalla sottoscrizione all'argomento del bus di servizio.

Nota

Questa guida introduttiva fornisce istruzioni dettagliate per implementare uno scenario semplice di invio di un batch di messaggi a un argomento del bus di servizio e ricezione di tali messaggi da una sottoscrizione dell'argomento. Per altri esempi in altri scenari avanzati, vedere Esempi di bus di servizio .NET in GitHub.

Creare un progetto per l'app ricevente

  1. Nella finestra Esplora soluzioni fare clic con il pulsante destro del mouse sulla soluzione ServiceBusTopicQuickStart , scegliere Aggiungi e selezionare Nuovo progetto.
  2. Selezionare Applicazione console e selezionare Avanti.
  3. Immettere SubscriptionReceiver per il nome del progetto e selezionare Avanti.
  4. Nella pagina Informazioni aggiuntive selezionare Crea.
  5. Nella finestra Esplora soluzioni fare clic con il pulsante destro del mouse su SubscriptionReceiver e scegliere Imposta come progetto di avvio.

Aggiungere il pacchetto NuGet del bus di servizio

  1. Scegliere Strumenti>Gestione pacchetti NuGet>Console di Gestione pacchetti dal menu.

  2. Nella finestra Console di Gestione pacchetti verificare che SubscriptionReceiver sia selezionato per il progetto predefinito. In caso contrario, usare l'elenco a discesa per selezionare SubscriptionReceiver.

    Image showing the selection of SubscriptionReceiver project in the Package Manager Console window.

  3. Eseguire il comando seguente per installare il pacchetto NuGet Azure.Messaging.ServiceBus :

    Install-Package Azure.Messaging.ServiceBus
    

Aggiungere codice per ricevere messaggi dalla sottoscrizione

  1. In Program.cs aggiungere le istruzioni seguenti using nella parte superiore della definizione dello spazio dei nomi prima della dichiarazione di classe.

    using System.Threading.Tasks;
    using Azure.Messaging.ServiceBus;
    
  2. All'interno della Program classe dichiarare le proprietà seguenti, appena prima del Main metodo. Sostituire i segnaposto con valori corretti:

    • <NAMESPACE CONNECTION STRING> con la stringa di connessione allo spazio dei nomi del bus di servizio
    • <TOPIC NAME> con il nome dell'argomento del bus di servizio
    • <SERVICE BUS - TOPIC SUBSCRIPTION NAME> con il nome della sottoscrizione all'argomento.
    // connection string to your Service Bus namespace
    static string connectionString = "<NAMESPACE CONNECTION STRING>";
    
    // name of the Service Bus topic
    static string topicName = "<SERVICE BUS TOPIC NAME>";
    
    // name of the subscription to the topic
    static string subscriptionName = "<SERVICE BUS - TOPIC SUBSCRIPTION NAME>";
    
    // the client that owns the connection and can be used to create senders and receivers
    static ServiceBusClient client;
    
    // the processor that reads and processes messages from the subscription
    static ServiceBusProcessor processor;    
    
  3. Aggiungere i metodi seguenti alla Program classe per gestire i messaggi ricevuti e eventuali errori.

    // handle received messages
    static async Task MessageHandler(ProcessMessageEventArgs args)
    {
        string body = args.Message.Body.ToString();
        Console.WriteLine($"Received: {body} from subscription: {subscriptionName}");
    
        // complete the message. messages is deleted from the subscription. 
        await args.CompleteMessageAsync(args.Message);
    }
    
    // handle any errors when receiving messages
    static Task ErrorHandler(ProcessErrorEventArgs args)
    {
        Console.WriteLine(args.Exception.ToString());
        return Task.CompletedTask;
    }
    
  4. Sostituire il codice in Program.cs con il codice seguente. Ecco i passaggi importanti del codice:

    1. Crea un oggetto ServiceBusClient usando la stringa di connessione allo spazio dei nomi.
    2. Richiama il metodo CreateProcessor nell'oggetto ServiceBusClient per creare un oggetto ServiceBusProcessor per la coda del bus di servizio specificata.
    3. Specifica i gestori per gli eventi ProcessMessageAsync e ProcessErrorAsync dell'oggetto ServiceBusProcessor .
    4. Avvia l'elaborazione dei messaggi richiamando StartProcessingAsync nell'oggetto ServiceBusProcessor .
    5. Quando l'utente preme un tasto per terminare l'elaborazione, richiama StopProcessingAsync nell'oggetto ServiceBusProcessor .

    Per altre informazioni, vedere Commenti di codice.

    static async Task Main()
    {
        // The Service Bus client types are safe to cache and use as a singleton for the lifetime
        // of the application, which is best practice when messages are being published or read
        // regularly.
        //
        // Create the clients that we'll use for sending and processing messages.
        client = new ServiceBusClient(connectionString);
    
        // create a processor that we can use to process the messages
        processor = client.CreateProcessor(topicName, subscriptionName, new ServiceBusProcessorOptions());
    
        try
        {
            // add handler to process messages
            processor.ProcessMessageAsync += MessageHandler;
    
            // add handler to process any errors
            processor.ProcessErrorAsync += ErrorHandler;
    
            // start processing 
            await processor.StartProcessingAsync();
    
            Console.WriteLine("Wait for a minute and then press any key to end the processing");
            Console.ReadKey();
    
            // stop processing 
            Console.WriteLine("\nStopping the receiver...");
            await processor.StopProcessingAsync();
            Console.WriteLine("Stopped receiving messages");
        }
        finally
        {
            // Calling DisposeAsync on client types is required to ensure that network
            // resources and other unmanaged objects are properly cleaned up.
            await processor.DisposeAsync();
            await client.DisposeAsync();
        }
    }    
    
  5. Ecco cosa Program.cs dovrebbe essere simile al seguente:

    using System;
    using System.Threading.Tasks;
    using Azure.Messaging.ServiceBus;
    
    namespace SubscriptionReceiver
    {
        class Program
        {
            // connection string to your Service Bus namespace
            static string connectionString = "<NAMESPACE CONNECTION STRING>";
    
            // name of the Service Bus topic
            static string topicName = "<SERVICE BUS TOPIC NAME>";
    
            // name of the subscription to the topic
            static string subscriptionName = "<SERVICE BUS - TOPIC SUBSCRIPTION NAME>";
    
            // the client that owns the connection and can be used to create senders and receivers
            static ServiceBusClient client;
    
            // the processor that reads and processes messages from the subscription
            static ServiceBusProcessor processor;
    
            // handle received messages
            static async Task MessageHandler(ProcessMessageEventArgs args)
            {
                string body = args.Message.Body.ToString();
                Console.WriteLine($"Received: {body} from subscription: {subscriptionName}");
    
                // complete the message. messages is deleted from the subscription. 
                await args.CompleteMessageAsync(args.Message);
            }
    
            // handle any errors when receiving messages
            static Task ErrorHandler(ProcessErrorEventArgs args)
            {
                Console.WriteLine(args.Exception.ToString());
                return Task.CompletedTask;
            }
    
            static async Task Main()
            {
                // The Service Bus client types are safe to cache and use as a singleton for the lifetime
                // of the application, which is best practice when messages are being published or read
                // regularly.
                //
                // Create the clients that we'll use for sending and processing messages.
                client = new ServiceBusClient(connectionString);
    
                // create a processor that we can use to process the messages
                processor = client.CreateProcessor(topicName, subscriptionName, new ServiceBusProcessorOptions());
    
                try
                {
                    // add handler to process messages
                    processor.ProcessMessageAsync += MessageHandler;
    
                    // add handler to process any errors
                    processor.ProcessErrorAsync += ErrorHandler;
    
                    // start processing 
                    await processor.StartProcessingAsync();
    
                    Console.WriteLine("Wait for a minute and then press any key to end the processing");
                    Console.ReadKey();
    
                    // stop processing 
                    Console.WriteLine("\nStopping the receiver...");
                    await processor.StopProcessingAsync();
                    Console.WriteLine("Stopped receiving messages");
                }
                finally
                {
                    // Calling DisposeAsync on client types is required to ensure that network
                    // resources and other unmanaged objects are properly cleaned up.
                    await processor.DisposeAsync();
                    await client.DisposeAsync();
                }
            }
        }
    }
    
  6. Sostituire i segnaposto con valori corretti:

    • <NAMESPACE CONNECTION STRING> con la stringa di connessione allo spazio dei nomi del bus di servizio
    • <TOPIC NAME> con il nome dell'argomento del bus di servizio
    • <SERVICE BUS - TOPIC SUBSCRIPTION NAME> con il nome della sottoscrizione all'argomento.
  7. Compilare il progetto e assicurarsi che non siano presenti errori.

  8. Eseguire l'applicazione ricevente. Verranno visualizzati i messaggi ricevuti. Premere un tasto qualsiasi per arrestare il destinatario e l'applicazione.

    Wait for a minute and then press any key to end the processing
    Received: Message 1 from subscription: S1
    Received: Message 2 from subscription: S1
    Received: Message 3 from subscription: S1
    
    Stopping the receiver...
    Stopped receiving messages
    
  9. Controllare di nuovo il portale.

    • Nella pagina Argomento del bus di servizio , nel grafico Messaggi vengono visualizzati tre messaggi in ingresso e tre messaggi in uscita. Se questi valori non vengono visualizzati, attendere alcuni minuti e aggiornare la pagina per vedere il grafico aggiornato.

      Messages sent and received

    • Nella pagina Sottoscrizione del bus di servizio il valore visualizzato per Numero di messaggi attivi è zero. Il motivo è che il destinatario ha ricevuto i messaggi inviati da questa sottoscrizione e li ha completati.

      Active message count at the subscription at the end

Passaggi successivi

Vedere la documentazione e gli esempi seguenti: