Usare le proprietà desiderate per configurare i dispositiviUse desired properties to configure devices

IntroduzioneIntroduction

In Introduzione ai dispositivi gemelli dell'hub IoT è stato illustrato come impostare i metadati dei dispositivi dal back-end della soluzione usando tag, come segnalare le condizioni dei dispositivi da un'app per dispositivo con le proprietà segnalate e come eseguire query su tali informazioni con un linguaggio simile a SQL.In Get started with IoT Hub device twins, you learned how to set device metadata from your solution back end using tags, report device conditions from a device app using reported properties, and query this information using a SQL-like language.

In questa esercitazione verrà illustrato come usare le proprietà desiderate del dispositivo gemello con le proprietà segnalate per configurare in remoto le app per dispositivi.In this tutorial, you learn how to use the device twin's desired properties along with reported properties, to remotely configure device apps. In particolare, questa esercitazione descrive come le proprietà segnalate e desiderate di un dispositivo gemello supportano la configurazione in più passaggi di un'applicazione per dispositivi e come ottenere nel back-end della soluzione la visibilità dello stato di tale operazione in tutti i dispositivi.More specifically, this tutorial shows how a device twin's reported and desired properties enable a multi-step configuration of a device application, and provide the visibility to the solution back end of the status of this operation across all devices. Per altre informazioni sul ruolo delle configurazioni del dispositivo, vedere Panoramica della gestione dei dispositivi con l'hub IoT.You can find more information regarding the role of device configurations in Overview of device management with IoT Hub.

In genere, l'uso di dispositivi gemelli abilita il back-end della soluzione per specificare la configurazione voluta per i dispositivi gestiti, invece di inviare comandi specifici.At a high level, using device twins enables the solution back end to specify the desired configuration for the managed devices, instead of sending specific commands. Il dispositivo ha quindi la responsabilità di configurare il modo migliore per aggiornare la propria configurazione (importante negli scenari IoT in cui le condizioni specifiche del dispositivo influiscono sulla possibilità di eseguire immediatamente determinati comandi) segnalando continuamente al back-end della soluzione lo stato corrente e le potenziali condizioni di errore del processo di aggiornamento.This puts the device in charge of setting up the best way to update its configuration (important in IoT scenarios where specific device conditions affect the ability to immediately carry out specific commands), while continually reporting to the solution back end the current state and potential error conditions of the update process. Questo modello è determinante per gestire grandi set di dispositivi, perché offre al back-end della soluzione la visibilità completa dello stato del processo di configurazione in tutti i dispositivi.This pattern is instrumental to the management of large sets of devices, as it enables the solution back end to have full visibility of the state of the configuration process across all devices.

Nota

Negli scenari in cui i dispositivi sono controllati in modo più interattivo (come nel caso dell'attivazione di una ventola da un'app controllata dall'utente), può essere opportuno usare metodi diretti.In scenarios where devices are controlled in a more interactive fashion (turn on a fan from a user-controlled app), consider using direct methods.

In questa esercitazione, il back-end della soluzione modifica la configurazione della telemetria di un dispositivo di destinazione e di conseguenza l'app per dispositivi segue un processo in più passaggi per applicare un aggiornamento della configurazione (che richiede ad esempio un riavvio del modulo software che nell'esercitazione viene simulato con un semplice ritardo).In this tutorial, the solution back end changes the telemetry configuration of a target device and, as a result of that, the device app follows a multi-step process to apply a configuration update (for example, requiring a software module restart, which this tutorial simulates with a simple delay).

Il back-end della soluzione archivia la configurazione nelle proprietà desiderate del dispositivo gemello nel modo seguente:The solution back end stores the configuration in the device twin's desired properties in the following way:

    {
        ...
        "properties": {
            ...
            "desired": {
                "telemetryConfig": {
                    "configId": "{id of the configuration}",
                    "sendFrequency": "{config}"
                }
            }
            ...
        }
        ...
    }

Nota

Dato che le configurazioni possono essere oggetti complessi, per semplificarne il confronto vengono assegnati ID univoci (hash o GUID).Since configurations can be complex objects, they are assigned unique IDs (hashes or GUIDs) to simplify their comparisons.

L'app per dispositivi segnala la propria configurazione corrente eseguendo il mirroring della proprietà desiderata telemetryConfig nelle proprietà segnalate:The device app reports its current configuration mirroring the desired property telemetryConfig in the reported properties:

    {
        "properties": {
            ...
            "reported": {
                "telemetryConfig": {
                    "changeId": "{id of the current configuration}",
                    "sendFrequency": "{current configuration}",
                    "status": "Success",
                }
            }
            ...
        }
    }

Si noti che la proprietà segnalata telemetryConfig ha una proprietà status aggiuntiva usata per segnalare lo stato del processo di aggiornamento della configurazione.Note how the reported telemetryConfig has an additional property status, used to report the state of the configuration update process.

Quando viene ricevuta una nuova configurazione desiderata, l'app per dispositivi segnala una configurazione in sospeso modificando le informazioni:When a new desired configuration is received, the device app reports a pending configuration by changing the information:

    {
        "properties": {
            ...
            "reported": {
                "telemetryConfig": {
                    "changeId": "{id of the current configuration}",
                    "sendFrequency": "{current configuration}",
                    "status": "Pending",
                    "pendingConfig": {
                        "changeId": "{id of the pending configuration}",
                        "sendFrequency": "{pending configuration}"
                    }
                }
            }
            ...
        }
    }

In un secondo momento l'app per dispositivi segnala l'esito positivo o negativo dell'operazione aggiornando la proprietà sopra indicata.Then, at some later time, the device app reports the success or failure of this operation by updating the above property. Si noti che il back-end della soluzione può eseguire in qualsiasi momento query sullo stato del processo di configurazione in tutti i dispositivi.Note how the solution back end is able, at any time, to query the status of the configuration process across all the devices.

Questa esercitazione illustra come:This tutorial shows you how to:

  • Creare un'app per dispositivo simulato che riceve aggiornamenti di configurazione dal back-end della soluzione e segnala più aggiornamenti come proprietà segnalate nel processo di aggiornamento della configurazione.Create a simulated device app that receives configuration updates from the solution back end, and reports multiple updates as reported properties on the configuration update process.
  • Creare un'app back-end che aggiorna la configurazione desiderata di un dispositivo e quindi esegue query sul processo di aggiornamento della configurazione.Create a back-end app that updates the desired configuration of a device, and then queries the configuration update process.

Al termine di questa esercitazione si avranno due app console:At the end of this tutorial, you will have two console apps:

  • SimulateDeviceConfiguration.js, un'app per dispositivo simulata che attende un aggiornamento della configurazione desiderata e segnala lo stato di un processo di aggiornamento della configurazione simulata.SimulateDeviceConfiguration.js, a simulated device app that waits for a desired configuration update and reports the status of a simulated configuration update process.
  • SetDesiredConfigurationAndQuery.js, un'app back-end di .NET, che imposta la configurazione desiderata in un dispositivo ed esegue query sul processo di aggiornamento della configurazione.SetDesiredConfigurationAndQuery, a .NET back-end app, which sets the desired configuration on a device and queries the configuration update process.

Nota

L'articolo Azure IoT SDK contiene informazioni sui componenti Azure IoT SDK che consentono di compilare le app back-end e per dispositivi.The article Azure IoT SDKs provides information about the Azure IoT SDKs that you can use to build both device and back-end apps.

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

  • Visual Studio 2015 o Visual Studio 2017.Visual Studio 2015 or Visual Studio 2017.
  • Node.js 4.0.x o versione successiva.Node.js version 4.0.x or later.
  • Un account Azure attivo.An active Azure account. Se non si ha un account, è possibile crearne uno gratuito in pochi minuti.If you don't have an account, you can create a free account in just a couple of minutes.

Se è stata seguita l'esercitazione Introduzione ai dispositivi gemelli sono già disponibili un hub IoT e un'identità del dispositivo denominata myDeviceId.If you followed the Get started with device twins tutorial, you already have an IoT hub and a device identity called myDeviceId. È quindi possibile ignorare la sezione Creare l'app per dispositivo simulata.In that case, you can skip to the Create the simulated device app section.

Creare un hub IoTCreate an IoT hub

Creare un hub IoT per connettere l'app per dispositivo simulato.Create an IoT hub for your simulated device app to connect to. La procedura seguente illustra come completare questa attività usando il portale di Azure.The following steps show you how to complete this task by using the Azure portal.

  1. Accedere al portale di Azure.Sign in to the Azure portal.
  2. Selezionare Nuovo > Internet delle cose > Hub IoT.Select New > Internet of Things > IoT Hub.

    Indice del portale di Azure

  3. Nel riquadro Hub IoT immettere le informazioni seguenti per l'hub IoT:In the IoT hub pane, enter the following information for your IoT hub:

    • Nome: creare un nome per l'hub IoT.Name: Create a name for your IoT hub. Se il nome immesso è valido, viene visualizzato un segno di spunta verde.If the name you enter is valid, a green check mark appears.

    Importante

    L'hub IoT sarà individuabile pubblicamente come endpoint DNS, quindi evitare di indicare informazioni riservate nell'assegnazione del nome.The IoT hub will be publicly discoverable as a DNS endpoint, so make sure to avoid any sensitive information while naming it.

    • Piano tariffario e livello di scalabilità: per questa esercitazione selezionare il livello F1 gratuito.Pricing and scale tier: For this tutorial, select the F1 - Free tier. Per altre informazioni, vedere la pagina relativa a piano tariffario e livello di scalabilità.For more information, see the Pricing and scale tier.

    • Gruppo di risorse: creare un gruppo di risorse per ospitare l'hub IoT o usarne uno esistente.Resource group: Create a resource group to host the IoT hub or use an existing one. Per altre informazioni, vedere l'articolo su come usare i gruppi di risorse per gestire le risorse di Azure.For more information, see Use resource groups to manage your Azure resources

    • Località: selezionare la località più vicina.Location: Select the closest location to you.

    • Aggiungi al dashboard: selezionare questa opzione per semplificare l'accesso all'hub IoT dal dashboard.Pin to dashboard: Check this option for easy access to your IoT hub from the dashboard.

      Finestra Hub IoT

  4. Fare clic su Crea.Click Create. La creazione dell'hub IoT può richiedere alcuni minuti.Your IoT hub might take a few minutes to create. È possibile monitorare lo stato di avanzamento nel riquadro Notifiche.You can monitor the progress in the Notifications pane.

Ora che è stato creato un hub IoT, individuare le informazioni importanti che consentono di connettere dispositivi e applicazioni all'hub IoT.Now that you have created an IoT hub, locate the important information that you use to connect devices and applications to your IoT hub.

  1. Dopo avere creato l'hub IoT, fare clic sul nuovo riquadro dell'hub IoT nel portale di Azure per aprire la finestra delle proprietà.When the IoT hub has been created successfully, click the new tile for your IoT hub in the Azure portal to open the properties window for the new IoT hub. Annotare il Nome host, quindi fare clic su Criteri di accesso condiviso.Make a note of the Hostname, and then click Shared access policies.

    Finestra del nuovo hub IoT

  2. In Criteri di accesso condivisi fare clic sul criterio iothubowner, quindi copiare e annotare la stringa di connessione dell'hub IoT nella finestra iothubowner.In Shared access policies, click the iothubowner policy, and then copy and make note of the IoT Hub connection string in the iothubowner window. Per altre informazioni, vedere Controllo di accesso nella "Guida per gli sviluppatori dell'hub IoT".For more information, see Access control in the "IoT Hub developer guide."

    Criteri di accesso condivisi

Creare un'identità del dispositivoCreate a device identity

In questa sezione si usa uno strumento di Node.js denominato iothub-explorer per creare un'identità del dispositivo per questa esercitazione.In this section, you use a Node.js tool called iothub-explorer to create a device identity for this tutorial. Gli ID dispositivo fanno distinzione tra maiuscole e minuscole.Device IDs are case sensitive.

  1. Eseguire il codice seguente nell'ambiente della riga di comando:Run the following in your command-line environment:

    npm install -g iothub-explorer@latest

  2. Eseguire quindi il comando indicato di seguito per accedere all'hub.Then, run the following command to login to your hub. Sostituire {iot hub connection string} con la stringa di connessione all'hub IoT copiata prima:Substitute {iot hub connection string} with the IoT Hub connection string you previously copied:

    iothub-explorer login "{iot hub connection string}"

  3. Creare infine una nuova identità del dispositivo denominata myDeviceId con il comando:Finally, create a new device identity called myDeviceId with the command:

    iothub-explorer create myDeviceId --connection-string

    Importante

    L'ID dispositivo può essere visibile nei log raccolti per il supporto tecnico e la risoluzione dei problemi, quindi evitare di indicare informazioni riservate nell'assegnazione del nome.The device ID may be visible in the logs collected for customer support and troubleshooting, so make sure to avoid any sensitive information while naming it.

Annotare la stringa di connessione del dispositivo visualizzata nei risultati.Make a note of the device connection string from the result. Questa stringa di connessione del dispositivo viene usata dall'app del dispositivo per la connessione all'hub IoT come dispositivo.This device connection string is used by the device app to connect to your IoT Hub as a device.

Per creare identità del dispositivo a livello di codice, vedere Introduzione all'hub IoT.Refer to Getting started with IoT Hub to programmatically create device identities.

Creare l'app per dispositivo simulataCreate the simulated device app

In questa sezione si crea un'app console Node.js che si connette all'hub come myDeviceId, attende un aggiornamento della configurazione desiderata e quindi segnala gli aggiornamenti nel processo di aggiornamento della configurazione simulata.In this section, you create a Node.js console app that connects to your hub as myDeviceId, waits for a desired configuration update and then reports updates on the simulated configuration update process.

  1. Creare una nuova cartella vuota denominata simulatedeviceconfiguration.Create a new empty folder called simulatedeviceconfiguration. Nella cartella simulatedeviceconfiguration creare un nuovo file package.json immettendo il comando seguente al prompt dei comandi.In the simulatedeviceconfiguration folder, create a new package.json file using the following command at your command prompt. Accettare tutte le impostazioni predefinite.Accept all the defaults.

    npm init
    
  2. Al prompt dei comandi nella cartella simulatedeviceconfiguration digitare il comando seguente per installare i pacchetti azure-iot-device e azure-iot-device-mqtt:At your command prompt in the simulatedeviceconfiguration folder, run the following command to install the azure-iot-device and azure-iot-device-mqtt packages:

    npm install azure-iot-device azure-iot-device-mqtt --save
    
  3. Usando un editor di testo, creare un nuovo file SimulateDeviceConfiguration.js nella cartella simulatedeviceconfiguration.Using a text editor, create a new SimulateDeviceConfiguration.js file in the simulatedeviceconfiguration folder.
  4. Aggiungere il codice seguente al file SimulateDeviceConfiguration.js e sostituire il segnaposto {device connection string} con la stringa di connessione copiata quando si è creata l'identità del dispositivo myDeviceId:Add the following code to the SimulateDeviceConfiguration.js file, and substitute the {device connection string} placeholder with the device connection string you copied when you created the myDeviceId device identity:

     'use strict';
     var Client = require('azure-iot-device').Client;
     var Protocol = require('azure-iot-device-mqtt').Mqtt;
    
     var connectionString = '{device connection string}';
     var client = Client.fromConnectionString(connectionString, Protocol);
    
     client.open(function(err) {
         if (err) {
             console.error('could not open IotHub client');
         } else {
             client.getTwin(function(err, twin) {
                 if (err) {
                     console.error('could not get twin');
                 } else {
                     console.log('retrieved device twin');
                     twin.properties.reported.telemetryConfig = {
                         configId: "0",
                         sendFrequency: "24h"
                     }
                     twin.on('properties.desired', function(desiredChange) {
                         console.log("received change: "+JSON.stringify(desiredChange));
                         var currentTelemetryConfig = twin.properties.reported.telemetryConfig;
                         if (desiredChange.telemetryConfig &&desiredChange.telemetryConfig.configId !== currentTelemetryConfig.configId) {
                             initConfigChange(twin);
                         }
                     });
                 }
             });
         }
     });
    

    L'oggetto Client espone tutti i metodi necessari per interagire con i dispositivi gemelli dal dispositivo.The Client object exposes all the methods required to interact with device twins from the device. Questo codice inizializza l'oggetto Client, recupera il dispositivo gemello per myDeviceId e quindi collega un gestore per l'aggiornamento nelle proprietà desiderate.This code initializes the Client object, retrieves the device twin for myDeviceId, and then attaches a handler for the update on desired properties. Il gestore verifica che esista una richiesta di modifica della configurazione effettiva confrontando gli elementi configId, quindi richiama un metodo che avvia la modifica della configurazione.The handler verifies that there is an actual configuration change request by comparing the configIds, then invokes a method that starts the configuration change.

    Per motivi di semplicità, questo codice usa un valore predefinito hardcoded per la configurazione iniziale.Note that for the sake of simplicity, this code uses a hard-coded default for the initial configuration. Una vera app probabilmente caricherebbe tale configurazione da una risorsa di archiviazione locale.A real app would probably load that configuration from a local storage.

    Importante

    Gli eventi di modifica delle proprietà desiderate vengono inviati sempre una volta sola alla connessione al dispositivo.Desired property change events are always emitted once at device connection. Assicurarsi di verificare che vi sia un'effettiva modifica nelle proprietà desiderate prima di eseguire qualsiasi azione.Make sure to check that there is an actual change in the desired properties before performing any action.

  5. Aggiungere i metodi seguenti prima della chiamata a client.open():Add the following methods before the client.open() invocation:

     var initConfigChange = function(twin) {
         var currentTelemetryConfig = twin.properties.reported.telemetryConfig;
         currentTelemetryConfig.pendingConfig = twin.properties.desired.telemetryConfig;
         currentTelemetryConfig.status = "Pending";
    
         var patch = {
         telemetryConfig: currentTelemetryConfig
         };
         twin.properties.reported.update(patch, function(err) {
             if (err) {
                 console.log('Could not report properties');
             } else {
                 console.log('Reported pending config change: ' + JSON.stringify(patch));
                 setTimeout(function() {completeConfigChange(twin);}, 60000);
             }
         });
     }
    
     var completeConfigChange =  function(twin) {
         var currentTelemetryConfig = twin.properties.reported.telemetryConfig;
         currentTelemetryConfig.configId = currentTelemetryConfig.pendingConfig.configId;
         currentTelemetryConfig.sendFrequency = currentTelemetryConfig.pendingConfig.sendFrequency;
         currentTelemetryConfig.status = "Success";
         delete currentTelemetryConfig.pendingConfig;
    
         var patch = {
             telemetryConfig: currentTelemetryConfig
         };
         patch.telemetryConfig.pendingConfig = null;
    
         twin.properties.reported.update(patch, function(err) {
             if (err) {
                 console.error('Error reporting properties: ' + err);
             } else {
                 console.log('Reported completed config change: ' + JSON.stringify(patch));
             }
         });
     };
    

    Il metodo initConfigChange aggiorna le proprietà segnalate nell'oggetto dispositivo gemello locale con la richiesta di aggiornamento della configurazione e imposta lo stato su Pending (Sospeso), quindi aggiorna il dispositivo gemello nel servizio.The initConfigChange method updates the reported properties on the local device twin object with the configuration update request and sets the status to Pending, then updates the device twin on the service. Dopo l'aggiornamento del dispositivo gemello, simula un processo a esecuzione prolungata che termina con l'esecuzione di completeConfigChange.After successfully updating the device twin, it simulates a long running process that terminates in the execution of completeConfigChange. Questo metodo aggiorna le proprietà segnalate locali impostando lo stato su Success e rimuovendo l'oggetto pendingConfig,This method updates the local reported properties setting the status to Success and removing the pendingConfig object. quindi aggiorna il dispositivo gemello nel servizio.It then updates the device twin on the service.

    Si noti che, per risparmiare larghezza di banda, le proprietà segnalate vengono aggiornate specificando solo le proprietà da modificare (denominate patch nel codice precedente), invece di sostituire l'intero documento.Note that, to save bandwidth, reported properties are updated by specifying only the properties to be modified (named patch in the above code), instead of replacing the whole document.

    Nota

    Questa esercitazione non simula alcun comportamento per gli aggiornamenti della configurazione simultanei.This tutorial does not simulate any behavior for concurrent configuration updates. Alcuni processi di aggiornamento della configurazione potrebbero consentire modifiche della configurazione di destinazione mentre l'aggiornamento è in esecuzione, altre potrebbero doverle accodare e altri ancora rifiutarle con una condizione di errore.Some configuration update processes might be able to accommodate changes of target configuration while the update is running, some might have to queue them, and some could reject them with an error condition. È importante tenere in considerazione il comportamento desiderato per il processo di configurazione specifico e aggiungere la logica appropriata prima di iniziare la modifica della configurazione.Make sure to consider the desired behavior for your specific configuration process, and add the appropriate logic before initiating the configuration change.

  6. Eseguire l'app per dispositivo:Run the device app:

     node SimulateDeviceConfiguration.js
    

    Dovrebbe essere visualizzato il messaggio retrieved device twin.You should see the message retrieved device twin. Mantenere l'app in esecuzione.Keep the app running.

Creare l'app di servizioCreate the service app

In questa sezione si creerà un'app console .NET che aggiorna le proprietà desiderate nel dispositivo gemello associato a myDeviceId con un nuovo oggetto di configurazione di telemetria.In this section, you will create a .NET console app that updates the desired properties on the device twin associated with myDeviceId with a new telemetry configuration object. Viene quindi effettuata una query dei dispositivi gemelli archiviati nell'hub IoT e viene visualizzata la differenza tra la configurazione desiderata e quella segnalata del dispositivo.It then queries the device twins stored in the IoT hub and shows the difference between the desired and reported configurations of the device.

  1. In Visual Studio aggiungere un progetto desktop di Windows classico in Visual C# usando il modello di progetto Applicazione console .In Visual Studio, add a Visual C# Windows Classic Desktop project to the current solution by using the Console Application project template. Assegnare al progetto il nome SetDesiredConfigurationAndQuery.Name the project SetDesiredConfigurationAndQuery.

    Nuovo progetto desktop di Windows classico in Visual C#

  2. In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto SetDesiredConfigurationAndQuery e quindi fare clic su Gestisci pacchetti NuGet.In Solution Explorer, right-click the SetDesiredConfigurationAndQuery project, and then click Manage NuGet Packages....
  3. Nella finestra Gestione pacchetti NuGet selezionare Esplora, cercare microsoft.azure.devices, selezionare Installa per installare il pacchetto Microsoft.Azure.Devices e accettare le condizioni per l'uso.In the NuGet Package Manager window, select Browse, search for microsoft.azure.devices, select Install to install the Microsoft.Azure.Devices package, and accept the terms of use. Questa procedura scarica, installa e aggiunge un riferimento al pacchetto NuGet Azure IoT - SDK per dispositivi e alle relative dipendenze.This procedure downloads, installs, and adds a reference to the Azure IoT service SDK NuGet package and its dependencies.

    Finestra Gestione pacchetti NuGet

  4. Aggiungere le istruzione using seguenti all'inizio del file Program.cs :Add the following using statements at the top of the Program.cs file:

     using Microsoft.Azure.Devices;
     using System.Threading;
     using Newtonsoft.Json;
    
  5. Aggiungere i campi seguenti alla classe Program .Add the following fields to the Program class. Sostituire il valore del segnaposto con la stringa di connessione dell'hub IoT creato nella sezione precedente.Replace the placeholder value with the IoT Hub connection string for the hub that you created in the previous section.

     static RegistryManager registryManager;
     static string connectionString = "{iot hub connection string}";
    
  6. Aggiungere il metodo seguente alla classe Program :Add the following method to the Program class:

     static private async Task SetDesiredConfigurationAndQuery()
     {
         var twin = await registryManager.GetTwinAsync("myDeviceId");
         var patch = new {
                 properties = new {
                     desired = new {
                         telemetryConfig = new {
                             configId = Guid.NewGuid().ToString(),
                             sendFrequency = "5m"
                         }
                     }
                 }
             };
    
         await registryManager.UpdateTwinAsync(twin.DeviceId, JsonConvert.SerializeObject(patch), twin.ETag);
         Console.WriteLine("Updated desired configuration");
    
         try
         {
             while (true)
             {
                 var query = registryManager.CreateQuery("SELECT * FROM devices WHERE deviceId = 'myDeviceId'");
                 var results = await query.GetNextAsTwinAsync();
                 foreach (var result in results)
                 {
                     Console.WriteLine("Config report for: {0}", result.DeviceId);
                     Console.WriteLine("Desired telemetryConfig: {0}", JsonConvert.SerializeObject(result.Properties.Desired["telemetryConfig"], Formatting.Indented));
                     Console.WriteLine("Reported telemetryConfig: {0}", JsonConvert.SerializeObject(result.Properties.Reported["telemetryConfig"], Formatting.Indented));
                     Console.WriteLine();
                 }
                 Thread.Sleep(10000);
             }
         }
         catch (Exception ex)
         {
             Console.WriteLine($"Exception: {ex.Message}");
         }
     }
    

    L'oggetto Registry espone tutti i metodi necessari per interagire con i dispositivi gemelli dal servizio.The Registry object exposes all the methods required to interact with device twins from the service. Questo codice inizializza l'oggetto Registry, recupera il dispositivo gemello per myDeviceId e ne aggiorna le proprietà desiderate con un nuovo oggetto di configurazione dei dati di telemetria.This code initializes the Registry object, retrieves the device twin for myDeviceId, and then updates its desired properties with a new telemetry configuration object. Ogni 10 secondi esegue una query dei dispositivi gemelli archiviati nell'hub IoT e stampa le configurazioni dei dati di telemetria desiderate e segnalate.After that, it queries the device twins stored in the IoT hub every 10 seconds, and prints the desired and reported telemetry configurations. Vedere il linguaggio di query dell'hub IoT per informazioni su come generare report avanzati in tutti i dispositivi.Refer to the IoT Hub query language to learn how to generate rich reports across all your devices.

    Importante

    Questa applicazione effettua una query dell'hub IoT ogni 10 secondi a scopo illustrativo.This application queries IoT Hub every 10 seconds for illustrative purposes. Usare le query per generare i report destinati all'utente in più dispositivi e non per rilevare le modifiche.Use queries to generate user-facing reports across many devices, and not to detect changes. Se la soluzione richiede notifiche in tempo reale degli eventi del dispositivo, usare le notifiche relative al dispositivo gemello.If your solution requires real-time notifications of device events, use twin notifications.

  7. Aggiungere infine le righe seguenti al metodo Main :Finally, add the following lines to the Main method:

     registryManager = RegistryManager.CreateFromConnectionString(connectionString);
     SetDesiredConfigurationAndQuery().Wait();
     Console.WriteLine("Press any key to quit.");
     Console.ReadLine();
    
  8. In Esplora soluzioni aprire Imposta progetti di avvio e assicurarsi che Azione per il progetto SetDesiredConfigurationAndQuery sia impostata su Avvio.In the Solution Explorer, open the Set StartUp projects... and make sure the Action for SetDesiredConfigurationAndQuery project is Start. Compilare la soluzione.Build the solution.
  9. Mentre SimulateDeviceConfiguration.js è in esecuzione, eseguire l'applicazione .NET da Visual Studio tramite F5: si potrà notare che la configurazione segnalata passa da Operazione riuscita a In sospeso e di nuovo a Operazione riuscita con la nuova frequenza di invio attiva di cinque minuti e non più di 24 ore.With SimulateDeviceConfiguration.js running, run the .NET application from Visual Studio using F5 and you should see the reported configuration change from Success to Pending to Success again with the new active send frequency of five minutes instead of 24 hours.

    Dispositivo configurato correttamente

    Importante

    Tra l'operazione relativa al report del dispositivo e il risultato della query si verifica un ritardo fino a un minuto,There is a delay of up to a minute between the device report operation and the query result. che consente all'infrastruttura della query di funzionare su una scala molto ampia.This is to enable the query infrastructure to work at very high scale. Per recuperare visualizzazioni coerenti di un solo dispositivo gemello, usare il metodo getDeviceTwin nella classe Registry.To retrieve consistent views of a single device twin use the getDeviceTwin method in the Registry class.

Passaggi successiviNext steps

In questa esercitazione è stata impostata una configurazione desiderata come proprietà desiderate da un back-end della soluzione ed è stata scritta un'app per dispositivo per rilevare tale modifica e simulare un processo di aggiornamento in più fasi che segnala lo stato tramite le proprietà segnalate.In this tutorial, you set a desired configuration as desired properties from the solution back end, and wrote a device app to detect that change and simulate a multi-step update process reporting its status through the reported properties.

Per altre informazioni, vedere le risorse seguenti:Use the following resources to learn how to: