Esercitazione: Aggiornare l'inventario usando il portale di Azure e argomenti/sottoscrizioni

2025-06-24

Questa esercitazione illustra come usare gli argomenti e le sottoscrizioni del bus di servizio in uno scenario di inventario delle vendite al dettaglio. Include canali di pubblicazione/sottoscrizione tramite il portale di Azure e .NET. Un esempio di questo scenario è un aggiornamento dell'assortimento di magazzino per più punti vendita al dettaglio. In questo scenario ogni negozio o set di negozi ottiene i messaggi a essi destinati per aggiornare gli assortimenti.

Il bus di servizio di Azure è un servizio di messaggistica cloud multi-tenant che invia informazioni tra applicazioni e servizi. Le operazioni asincrone offrono messaggistica negoziata flessibile, insieme a funzionalità di messaggistica e pubblicazione/sottoscrizione FIFO (First-In-First-Out) strutturate. Per una panoramica, vedere Che cos'è il bus di servizio?

Questa esercitazione illustra come implementare lo scenario usando filtri e sottoscrizioni. Si crea prima di tutto un argomento con tre sottoscrizioni, si aggiungono alcune regole e filtri quindi si inviano e ricevono messaggi dall'argomento e dalle sottoscrizioni.

Diagramma che mostra un mittente, un argomento con tre sottoscrizioni e tre ricevitori.

In questa esercitazione verranno illustrate le procedure per:

Creare un argomento del Bus di servizio e tre sottoscrizioni a tale argomento usando il portale di Azure
Aggiungere filtri per le sottoscrizioni usando il codice .NET
Creare messaggi con contenuto differente
Inviare i messaggi e verificare che siano arrivati nelle sottoscrizioni previste
Ricevere messaggi dalle sottoscrizioni

Prerequisiti

Per completare questa esercitazione, accertarsi di avere:

Una sottoscrizione di Azure. Per usare i servizi di Azure, tra cui Bus di servizio di Azure, è necessaria una sottoscrizione. È possibile creare un account gratuito prima di iniziare.
Visual Studio 2019 o versione successiva.

Argomenti e sottoscrizioni del bus di servizio

Ogni sottoscrizione a un argomento può ricevere una copia di ogni messaggio. Gli argomenti sono completamente compatibili a livello di protocollo e di semantica con le code del bus di servizio. Gli argomenti del bus di servizio supportano un'ampia gamma di regole di selezione con condizioni di filtro, con azioni facoltative per impostare o modificare le proprietà dei messaggi. Ogni volta che una regola corrisponde, genera un messaggio. Per altre informazioni su regole, filtri e azioni, vedere Filtri e azioni degli argomenti.

Creare uno spazio dei nomi nel portale di Azure

Per iniziare a usare le entità di messaggistica del bus di servizio in Azure, 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, ad esempio code e argomenti, nell'applicazione.

Per creare uno spazio dei nomi:

Accedere al portale di Azure.
Selezionare il menu a comparsa in alto a sinistra e passare alla pagina Tutti i servizi.
Sulla barra di spostamento a sinistra selezionare Integrazione.
Scorrere verso il basso fino a dei servizi di messaggistica>Service Bus e selezionare Crea.
Nella scheda 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 o crearne uno nuovo.
3. Immettere un nome del namespace che soddisfi 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 e 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 Posizione, scegliere l'area in cui ospitare lo spazio dei nomi.
5. Per Piano tariffario, selezionare il piano tariffario (Basic, Standard o Premium) per lo spazio dei nomi. Per questo avvio rapido selezionare Standard.
  
  Se si seleziona il livello Premium , è possibile abilitare la replica geografica per lo spazio dei nomi. La funzionalità di replica geografica garantisce che i metadati e i dati di uno spazio dei nomi vengano replicati continuamente da un'area primaria a una o più aree secondarie.
  
  Importante
  
  Se si vogliono usare argomenti e sottoscrizioni, scegliere Standard o Premium. Gli argomenti e 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 acquistare 1, 2, 4, 8 o 16 unità di messaggistica per ogni spazio dei nomi Premium del Bus di servizio. Per altre informazioni, vedere Livello di messaggistica Premium del bus di servizio.
6. Selezionare Rivedi e crea nella parte inferiore della pagina.
7. Nella pagina Rivedi + crea controllare le impostazioni e selezionare Crea.
Al termine della distribuzione della risorsa, selezionare Vai alla risorsa nella pagina di distribuzione.
Viene visualizzata la home page dello spazio dei nomi del bus di servizio.

Ottenere la stringa di connessione allo spazio dei nomi (portale di Azure)

La creazione di un nuovo spazio dei nomi genera automaticamente un criterio di firma di accesso condiviso iniziale. La politica include chiavi primarie e secondarie e stringhe di connessione principali e secondarie, ciascuna concede il controllo completo su tutti gli aspetti del namespace. Per altre informazioni su come creare regole con diritti più vincolati per mittenti e ricevitori regolari, vedere Autenticazione e autorizzazione del bus di servizio.

Un client può usare la stringa di connessione per connettersi allo spazio dei nomi di Bus di servizio. Per copiare la stringa di connessione primaria per lo spazio dei nomi, procedere come segue:

Nella pagina Spazio dei nomi del bus di servizio espandere Impostazioni, quindi selezionare Criteri di accesso condiviso.
Nella pagina Criteri di accesso condiviso selezionare RootManageSharedAccessKey.
Nella finestra Criteri SAS: RootManageSharedAccessKey, selezionare il pulsante di copia accanto a Stringa di connessione primaria. La stringa di connessione viene copiata negli Appunti per un uso successivo. Incollare questo valore nel Blocco note o in un'altra posizione temporanea.

È 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

Nella pagina Spazio dei nomi del bus di servizio espandere Entità nel menu di spostamento a sinistra e selezionare Argomenti.
Selezionare + Argomento.
Immettere un nome per l'argomento. Lasciare invariati i valori predefiniti delle altre opzioni.
Selezionare Crea.

Creare le sottoscrizioni dell'argomento

Selezionare l'argomento creato nella sezione precedente.
Nella pagina Argomento del bus di servizio selezionare + Sottoscrizione.
Nella pagina Crea sottoscrizione procedere come segue:
1. Immettere S1 come nome della sottoscrizione.
2. Successivamente, selezionare Crea per creare la sottoscrizione.
Ripetere due volte il passaggio precedente per creare le sottoscrizioni denominate S2 ed S3.

Creare regole di filtro nelle sottoscrizioni

Dopo aver effettuato il provisioning dello spazio dei nomi, degli argomenti e delle sottoscrizioni e aver creato la stringa di connessione nello spazio dei nomi, è possibile creare regole di filtro per le sottoscrizioni. Successivamente, inviare e ricevere messaggi. È possibile esaminare il codice in questa cartella dell'esempio di GitHub.

Inviare e ricevere messaggi

Per eseguire il codice, seguire questa procedura:

In una finestra del prompt dei comandi o in un prompt di PowerShell, clona il Service Bus GitHub repository:
```
git clone https://github.com/Azure/azure-service-bus.git
```
Passare alla cartella dell'esempio azure-service-bus\samples\DotNet\Azure.Messaging.ServiceBus\BasicSendReceiveTutorialWithFilters.
Recupera la stringa di connessione che hai copiato in Blocco note in precedenza in questa esercitazione. È necessario anche il nome dell'argomento creato.
Al prompt dei comandi digitare il comando seguente:
```
dotnet build
```
Passare alla cartella BasicSendReceiveTutorialWithFilters\bin\Debug\netcoreapp3.1.
Per eseguire il programma, immettere il comando seguente. Assicurarsi di sostituire myConnectionString con il valore e myTopicName con il nome dell'argomento creato:
```
dotnet --roll-forward Major BasicSendReceiveTutorialWithFilters.dll -ConnectionString "myConnectionString" -TopicName "myTopicName"
```
Seguire le istruzioni nella console per selezionare prima la creazione dei filtri. Parte della creazione di filtri consiste nel rimuovere i filtri predefiniti. Quando si usa PowerShell o l'interfaccia della riga di comando, non è necessario rimuovere il filtro predefinito. Se si usa il codice per creare filtri, rimuovere prima di tutto il filtro predefinito. I comandi della console 1 e 3 consentono di gestire i filtri nelle sottoscrizioni create in precedenza:
- Esecuzione 1: per rimuovere i filtri predefiniti.
- Esecuzione 2: per aggiungere filtri personalizzati.
- Eseguire 3: Ignorare questo passaggio per l'esercitazione. Questa opzione rimuove facoltativamente i propri filtri. Non ricrea i filtri predefiniti.
Dopo la creazione del filtro, è possibile inviare messaggi. Premere 4 e osservare l'invio di 10 messaggi all'argomento:
Premere 5 e osservare la ricezione dei messaggi. Se non si ottengono nuovamente 10 messaggi, premere "m" per visualizzare il menu, quindi premere ancora 5.

Pulire le risorse

Seguire questa procedura per pulire le risorse non più necessarie.

Passare allo spazio dei nomi nel portale di Azure.
Nella pagina Spazio dei nomi del Bus di servizio selezionare Elimina dalla barra dei comandi per eliminare lo spazio dei nomi e le risorse (code, argomenti e sottoscrizioni).

Informazioni sul codice di esempio

Questa sezione contiene altri dettagli sulle operazioni eseguite dal codice di esempio.

Ottenere la stringa di connessione e l'argomento

Il codice dichiara prima di tutto un set di variabili, che determinano l'esecuzione rimanente del programma.

string ServiceBusConnectionString;
string TopicName;

static string[] Subscriptions = { "S1", "S2", "S3" };
static IDictionary<string, string[]> SubscriptionFilters = new Dictionary<string, string[]> {
    { "S1", new[] { "StoreId IN('Store1', 'Store2', 'Store3')", "StoreId = 'Store4'"} },
    { "S2", new[] { "sys.To IN ('Store5','Store6','Store7') OR StoreId = 'Store8'" } },
    { "S3", new[] { "sys.To NOT IN ('Store1','Store2','Store3','Store4','Store5','Store6','Store7','Store8') OR StoreId NOT IN ('Store1','Store2','Store3','Store4','Store5','Store6','Store7','Store8')" } }
};
// You can have only have one action per rule and this sample code supports only one action for the first filter, which is used to create the first rule. 
static IDictionary<string, string> SubscriptionAction = new Dictionary<string, string> {
    { "S1", "" },
    { "S2", "" },
    { "S3", "SET sys.Label = 'SalesEvent'"  }
};
static string[] Store = { "Store1", "Store2", "Store3", "Store4", "Store5", "Store6", "Store7", "Store8", "Store9", "Store10" };
static string SysField = "sys.To";
static string CustomField = "StoreId";
static int NrOfMessagesPerStore = 1; // Send at least 1.

La stringa di connessione e il nome dell'argomento vengono passati usando i parametri della riga di comando, come illustrato. Vengono lette nel metodo Main():

static void Main(string[] args)
{
    string ServiceBusConnectionString = "";
    string TopicName = "";

    for (int i = 0; i < args.Length; i++)
    {
        if (args[i] == "-ConnectionString")
        {
            Console.WriteLine($"ConnectionString: {args[i + 1]}");
            ServiceBusConnectionString = args[i + 1]; // Alternatively enter your connection string here.
        }
        else if (args[i] == "-TopicName")
        {
            Console.WriteLine($"TopicName: {args[i + 1]}");
            TopicName = args[i + 1]; // Alternatively enter your queue name here.
        }
    }

    if (ServiceBusConnectionString != "" && TopicName != "")
    {
        Program P = StartProgram(ServiceBusConnectionString, TopicName);
        P.PresentMenu().GetAwaiter().GetResult();
    }
    else
    {
        Console.WriteLine("Specify -Connectionstring and -TopicName to execute the example.");
        Console.ReadKey();
    }
}

Rimuovere i filtri predefiniti

Quando si crea una sottoscrizione, il bus di servizio crea un filtro predefinito per ogni sottoscrizione. Questo filtro consente di ricevere ogni messaggio inviato all'argomento. Per usare i filtri personalizzati, è possibile rimuovere il filtro predefinito, come illustrato nel codice seguente:

private async Task RemoveDefaultFilters()
{
    Console.WriteLine($"Starting to remove default filters.");

    try
    {
        var client = new ServiceBusAdministrationClient(ServiceBusConnectionString);
        foreach (var subscription in Subscriptions)
        {
            await client.DeleteRuleAsync(TopicName, subscription, CreateRuleOptions.DefaultRuleName);
            Console.WriteLine($"Default filter for {subscription} has been removed.");
        }

        Console.WriteLine("All default Rules have been removed.\n");
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.ToString());
    }

    await PresentMenu();
}

Creare filtri

Il codice seguente aggiunge i filtri personalizzati definiti in questa esercitazione:

private async Task CreateCustomFilters()
{
    try
    {
        for (int i = 0; i < Subscriptions.Length; i++)
        {
            var client = new ServiceBusAdministrationClient(ServiceBusConnectionString);
            string[] filters = SubscriptionFilters[Subscriptions[i]];
            if (filters[0] != "")
            {
                int count = 0;
                foreach (var myFilter in filters)
                {
                    count++;

                    string action = SubscriptionAction[Subscriptions[i]];
                    if (action != "")
                    {
                        await client.CreateRuleAsync(TopicName, Subscriptions[i], new CreateRuleOptions
                        {
                            Filter = new SqlRuleFilter(myFilter),
                            Action = new SqlRuleAction(action),
                            Name = $"MyRule{count}"
                        });
                    }
                    else
                    {
                        await client.CreateRuleAsync(TopicName, Subscriptions[i], new CreateRuleOptions
                        {
                            Filter = new SqlRuleFilter(myFilter),
                            Name = $"MyRule{count}"
                        });
                    }
                }
            }

            Console.WriteLine($"Filters and actions for {Subscriptions[i]} have been created.");
        }

        Console.WriteLine("All filters and actions have been created.\n");
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.ToString());
    }

    await PresentMenu();
}

Rimuovere i filtri personalizzati creati

Se si vogliono rimuovere tutti i filtri nella sottoscrizione, il codice seguente illustra come eseguire questa operazione:

private async Task CleanUpCustomFilters()
{
    foreach (var subscription in Subscriptions)
    {
        try
        {
            var client = new ServiceBusAdministrationClient(ServiceBusConnectionString);
            IAsyncEnumerator<RuleProperties> rules = client.GetRulesAsync(TopicName, subscription).GetAsyncEnumerator();
            while (await rules.MoveNextAsync())
            {
                await client.DeleteRuleAsync(TopicName, subscription, rules.Current.Name);
                Console.WriteLine($"Rule {rules.Current.Name} has been removed.");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.ToString());
        }
    }
    Console.WriteLine("All default filters have been removed.\n");

    await PresentMenu();
}

Inviare messaggi

L'invio di messaggi a un argomento è simile all'invio di messaggi a una coda. Questo esempio mostra come inviare messaggi, usando un elenco di attività e l'elaborazione asincrona:

public async Task SendMessages()
{
    try
    {
        await using var client = new ServiceBusClient(ServiceBusConnectionString);
        var taskList = new List<Task>();
        for (int i = 0; i < Store.Length; i++)
        {
            taskList.Add(SendItems(client, Store[i]));
        }

        await Task.WhenAll(taskList);
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.ToString());
    }
    Console.WriteLine("\nAll messages sent.\n");
}

private async Task SendItems(ServiceBusClient client, string store)
{
    // create the sender
    ServiceBusSender tc = client.CreateSender(TopicName);

    for (int i = 0; i < NrOfMessagesPerStore; i++)
    {
        Random r = new Random();
        Item item = new Item(r.Next(5), r.Next(5), r.Next(5));

        // Note the extension class which is serializing an deserializing messages
        ServiceBusMessage message = item.AsMessage();
        message.To = store;
        message.ApplicationProperties.Add("StoreId", store);
        message.ApplicationProperties.Add("Price", item.GetPrice().ToString());
        message.ApplicationProperties.Add("Color", item.GetColor());
        message.ApplicationProperties.Add("Category", item.GetItemCategory());

        await tc.SendMessageAsync(message);
        Console.WriteLine($"Sent item to Store {store}. Price={item.GetPrice()}, Color={item.GetColor()}, Category={item.GetItemCategory()}"); ;
    }
}

Ricevere messaggi

I messaggi vengono ricevuti di nuovo usando un elenco di attività e il codice usa l'invio in batch. È possibile inviare e ricevere messaggi usando l'invio in batch, ma questo esempio mostra solo la ricezione in batch. Anche se di fatto il ciclo non verrà interrotto, continuare a eseguirlo e impostare un intervallo di tempo superiore, ad esempio un minuto. La chiamata di ricezione al broker viene mantenuta aperta per questo periodo di tempo. Se arrivano i messaggi, vengono restituiti immediatamente. Viene eseguita una nuova chiamata di ricezione.

Questo concetto è denominato polling di lunga durata. L'uso della pompa di ricezione, che è possibile vedere in diversi esempi nel repository, è un'opzione più tipica. Per altre informazioni, vedere Usare il portale di Azure per creare uno spazio dei nomi del bus di servizio e una coda.

public async Task Receive()
{
    var taskList = new List<Task>();
    for (var i = 0; i < Subscriptions.Length; i++)
    {
        taskList.Add(this.ReceiveMessages(Subscriptions[i]));
    }

    await Task.WhenAll(taskList);
}

private async Task ReceiveMessages(string subscription)
{
    await using var client = new ServiceBusClient(ServiceBusConnectionString);
    ServiceBusReceiver receiver = client.CreateReceiver(TopicName, subscription);

    // In reality you would not break out of the loop like in this example but would keep looping. The receiver keeps the connection open
    // to the broker for the specified amount of seconds and the broker returns messages as soon as they arrive. The client then initiates
    // a new connection. So in reality you would not want to break out of the loop. 
    // Also note that the code shows how to batch receive, which you would do for performance reasons. For convenience you can also always
    // use the regular receive pump which we show in our Quick Start and in other GitHub samples.
    while (true)
    {
        try
        {
            //IList<Message> messages = await receiver.ReceiveAsync(10, TimeSpan.FromSeconds(2));
            // Note the extension class which is serializing an deserializing messages and testing messages is null or 0.
            // If you think you did not receive all messages, just press M and receive again via the menu.
            IReadOnlyList<ServiceBusReceivedMessage> messages = await receiver.ReceiveMessagesAsync(maxMessages: 100);

            if (messages.Any())
            {
                foreach (ServiceBusReceivedMessage message in messages)
                {
                    lock (Console.Out)
                    {
                        Item item = message.As<Item>();
                        IReadOnlyDictionary<string, object> myApplicationProperties = message.ApplicationProperties;
                        Console.WriteLine($"StoreId={myApplicationProperties["StoreId"]}");
                        if (message.Subject != null)
                        {
                            Console.WriteLine($"Subject={message.Subject}");
                        }
                        Console.WriteLine(
                            $"Item data: Price={item.GetPrice()}, Color={item.GetColor()}, Category={item.GetItemCategory()}");
                    }

                    await receiver.CompleteMessageAsync(message);
                }
            }
            else
            {
                break;
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.ToString());
        }
    }
}

Note

È possibile gestire le risorse del bus di servizio con Service Bus Explorer. Service Bus Explorer consente agli utenti di connettersi a uno spazio dei nomi del bus di servizio e di amministrare le entità di messaggistica in modo semplice. Lo strumento offre funzionalità avanzate, ad esempio funzionalità di importazione/esportazione o la possibilità di testare argomenti, code, sottoscrizioni, servizi di inoltro, hub di notifica e hub eventi.

In questa esercitazione è stato effettuato il provisioning delle risorse usando il portale di Azure, quindi sono stati inviati e ricevuti messaggi da un argomento del bus di servizio e dalle relative sottoscrizioni. Si è appreso come:

Creare un argomento del bus di servizio e una o più sottoscrizioni a tale argomento usando il portale di Azure
Aggiungere filtri di argomento usando il codice .NET
Creare due messaggi con contenuto differente
Inviare i messaggi e verificare che siano arrivati nelle sottoscrizioni previste
Ricevere messaggi dalle sottoscrizioni

Per altri esempi di invio e ricezione di messaggi, vedere Esempi del bus di servizio in GitHub.

Passare alla prossima esercitazione per altre informazioni su come usare le funzionalità di pubblicazione/sottoscrizione del bus di servizio.

Rispondere ad eventi tramite Griglia di eventi