Tutorial: Codieren mit dem Azure Digital Twins SDK

  • Artikel

Entwickler, die mit Azure Digital Twins arbeiten, schreiben in der Regel Clientanwendungen, um mit ihrer Azure Digital Twins-Dienstinstanz zu interagieren. Dieses Tutorial für Entwickler bietet eine Einführung in die Programmierung für den Azure Digital Twins-Dienst unter Verwendung der Azure Digital Twins-SDK für .NET (C#). Sie werden Schritt für Schritt und von Grund auf durch die Entwicklung einer Client-App für die C#-Konsole geleitet.

  • Einrichten des Projekts
  • Erste Schritte mit dem Projektcode
  • Vollständiges Codebeispiel
  • Bereinigen von Ressourcen
  • Nächste Schritte

Voraussetzungen

Dieses Tutorial zur Azure Digital Twins verwendet die Befehlszeile für Setup und Projektarbeit. Sie können also jeden beliebigen Code-Editor verwenden, um die Übungen zu durchlaufen.

Zum Einstieg benötigen Sie Folgendes:

  • Einen beliebigen Code-Editor
  • .NET Core 3.1 auf Ihrem Entwicklungscomputer. Sie können diese Version des .NET Core SDK für verschiedene Plattformen unter Download .NET Core 3.1 herunterladen.

Vorbereiten einer Azure Digital Twins-Instanz

Damit Sie in diesem Artikel mit Azure Digital Twins arbeiten können, benötigen Sie eine Azure Digital Twins-Instanz und die erforderlichen Berechtigungen, um sie zu verwenden. Wenn Sie über eine bereits eingerichtete Azure Digital Twins-Instanz verfügen, können Sie diese nutzen und zum nächsten Abschnitt springen. Befolgen Sie andernfalls die Anleitung unter Einrichten einer Instanz und der Authentifizierung. Die Anweisungen enthalten Informationen, mit denen Sie überprüfen können, ob jeder Schritt erfolgreich abgeschlossen wurde.

Notieren Sie sich nach dem Einrichten Ihrer Instanz den Hostnamen der Instanz. Sie finden den Hostnamen im Azure-Portal.

Einrichten lokaler Azure-Anmeldeinformationen

Dieses Beispiel verwendet DefaultAzureCredential (Teil der Azure.Identity-Bibliothek) zur Authentifizierung von Benutzern mit der Azure Digital Twins-Instanz, wenn Sie diese auf Ihrem lokalen Computer ausführen. Weitere Informationen zu den verschiedenen Möglichkeiten, wie sich eine Client-App bei Azure Digital Twins authentifizieren kann, finden Sie unter Schreiben von App-Authentifizierungscode.

Mit DefaultAzureCredential sucht das Beispiel nach Anmeldeinformationen in Ihrer lokalen Umgebung, wie eine Azure-Anmeldung in einer lokalen DefaultAzureCredential oder in Visual Studio oder Visual Studio Code. Aus diesem Grund sollten Sie sich lokal über einen dieser Mechanismen bei Azure anmelden, um Anmeldeinformationen für das Beispiel einzurichten.

Wenn Sie Visual Studio oder Visual Studio Code zum Ausführen von Codebeispielen verwenden, stellen Sie sicher, dass Sie bei diesem Editor mit denselben Anmeldeinformationen für Azure angemeldet sind, die Sie für den Zugriff auf Ihre Instanz von Azure Digital Twins verwenden möchten. Wenn Sie ein lokales CLI-Fenster verwenden, führen Sie den Befehl az login aus, um sich bei Ihrem Azure-Konto anzumelden. Wenn Sie danach Ihr Codebeispiel ausführen, sollten Sie automatisch authentifiziert werden.

Einrichten des Projekts

Sobald Sie mit Ihrer Azure Digital Twins-Instanz startklar sind, beginnen Sie mit dem Einrichten des Client-App-Projekts.

Öffnen Sie ein Konsolenfenster auf Ihrem Computer, und erstellen Sie ein leeres Projektverzeichnis, in dem Sie Ihre Arbeit während dieses Tutorials speichern möchten. Geben Sie dem Verzeichnis einen beliebigen Namen (z. B. DigitalTwinsCodeTutorial).

Navigieren Sie zum neuen Verzeichnis.

Öffnen Sie das Projektverzeichnis, und erstellen Sie ein leeres .NET-Konsolen-App-Projekt. Im Befehlsfenster können Sie den folgenden Befehl ausführen, um ein C#-Minimalprojekt für die Konsole zu erstellen:

dotnet new console

Dieser Befehl erstellt mehrere Dateien in Ihrem Verzeichnis, darunter eine Datei mit dem Namen Program.cs, in der Sie den Großteil Ihres Codes schreiben werden.

Lassen Sie das Befehlsfenster geöffnet, da Sie es während des gesamten Tutorials weiter verwenden werden.

Als nächstes fügen Sie Ihrem Projekt zwei Abhängigkeiten hinzu, die für die Arbeit mit Azure Digital Twins erforderlich sind. Bei der ersten handelt es sich um das Paket für das Azure Digital Twins-SDK für .NET, die zweite stellt Tools bereit, die die Authentifizierung bei Azure unterstützen.

dotnet add package Azure.DigitalTwins.Core
dotnet add package Azure.Identity

Erste Schritte mit dem Projektcode

In diesem Abschnitt beginnen Sie damit, den Code für Ihr neues App-Projekt für die Arbeit mit Azure Digital Twins zu schreiben. Folgende Aufgaben werden behandelt:

  • Authentifizierung beim Dienst
  • Hochladen eines Modells
  • Abfangen von Fehlern
  • Erstellen von digitalen Zwillingen
  • Erstellen von Beziehungen
  • Abfragen von digitalen Zwillingen

Es ist auch ein Abschnitt vorhanden, der den vollständigen Code am Ende des Tutorials zeigt. Sie können diesen Abschnitt als eine Referenz zur Überprüfung Ihres Programms während der Bearbeitung verwenden.

Öffnen Sie zunächst die Datei Program.cs in einem beliebigen Code-Editor. Es wird Ihnen eine Minimalcodevorlage angezeigt, die in etwa so aussieht:

Screenshot of a snippet of sample code in a code editor.

Fügen Sie zunächst oberhalb des Codes einige using-Zeilen ein, um erforderliche Abhängigkeiten hineinzuziehen.

using Azure.DigitalTwins.Core;
using Azure.Identity;

Anschließend fügen Sie Code in diese Datei ein, um etwas Funktionalität hinzuzufügen.

Authentifizierung beim Dienst

Als Erstes muss sich Ihre App beim Azure Digital Twins-Dienst authentifizieren. Anschließend können Sie eine Dienstclientklasse für den Zugriff auf die SDK-Funktionen erstellen.

Zur Authentifizierung benötigen Sie den Hostnamen Ihrer Azure Digital Twins-Instanz.

Fügen Sie in Program.cs den folgenden Code unterhalb der Ausgabezeile „Hello, World!“ in der Main-Methode ein. Legen Sie den Wert von adtInstanceUrl auf den Hostnamen Ihrer Azure Digital Twins-Instanz fest.

string adtInstanceUrl = "https://<your-Azure-Digital-Twins-instance-hostName>"; 

var credential = new DefaultAzureCredential();
var client = new DigitalTwinsClient(new Uri(adtInstanceUrl), credential);
Console.WriteLine($"Service client created – ready to go");

Speichern Sie die Datei.

Führen Sie in Ihrem Befehlsfenster den Code mit diesem Befehl aus:

dotnet run

Dieser Befehl stellt die Abhängigkeiten beim ersten Start wieder her und führt dann das Programm aus.

  • Falls keine Fehler auftreten, gibt das Programm die folgende Meldung aus: „Service client created - ready to go“ (Dienstclient erstellt: Fertig).
  • Weil in diesem Projekt noch keine Fehlerbehandlung stattfindet, löst der Code bei Problemen eine Ausnahme aus.

Hinweis

Es gibt derzeit ein bekanntes Problem, das die DefaultAzureCredential-Wrapperklasse betrifft und zu einem Fehler bei der Authentifizierung führen kann. Wenn dieses Problem auftritt, können Sie zum Beheben des Problems versuchen, DefaultAzureCredential mit dem folgenden optionalen Parameter zu instanziieren: new DefaultAzureCredential(new DefaultAzureCredentialOptions { ExcludeSharedTokenCacheCredential = true });

Weitere Informationen zu diesem Problem finden Sie unter Bekannte Probleme von Azure Digital Twins.

Hochladen eines Modells

Azure Digital Twins umfasst kein intrinsisches Domänenvokabular. Die Elementtypen in Ihrer Umgebung, die Sie in Azure Digital Twins darstellen können, werden von Ihnen mithilfe von Modellen definiert. Modelle ähneln Klassen in objektorientierten Programmiersprachen. Sie stellen benutzerdefinierte Vorlagen für digitale Zwillinge bereit, die später eingesetzt und instanziiert werden. Sie werden in einer JSON-ähnlichen Sprache namens Digital Twins Definition Language (DTDL) geschrieben.

Beim Erstellen einer Azure Digital Twins-Lösung wird im ersten Schritt mindestens ein Modell in einer DTDL-Datei definiert.

Erstellen Sie in dem Verzeichnis, in dem Sie Ihr Projekt erstellt haben, eine neue JSON-Datei mit dem Namen SampleModel.json. Fügen Sie den folgenden Dateitext ein:

{
  "@id": "dtmi:example:SampleModel;1",
  "@type": "Interface",
  "displayName": "SampleModel",
  "contents": [
    {
      "@type": "Relationship",
      "name": "contains"
    },
    {
      "@type": "Property",
      "name": "data",
      "schema": "string"
    }
  ],
  "@context": "dtmi:dtdl:context;3"
}

Tipp

Wenn Sie für dieses Tutorial Visual Studio verwenden, können Sie die neu erstellte JSON-Datei auswählen und im Eigenschaften-Inspektor die Eigenschaft In Ausgabeverzeichnis kopieren auf Kopieren, falls aktueller oder Immer kopieren festlegen. So kann Visual Studio die JSON-Datei mit dem Standardpfad finden, wenn Sie das Programm im weiteren Verlauf des Tutorials mit F5 ausführen.

Tipp

Sie können Modelldokumente überprüfen, um die Gültigkeit der DTDL sicherzustellen. Verwenden Sie dazu die DTDLParser-Bibliothek. Weitere Informationen zur Verwendung dieser Bibliothek finden Sie unter Analysieren und Validieren von Modellen.

Als Nächstes fügen Sie Program.cs weiteren Code hinzu, um das erstellte Modell in Ihre Azure Digital Twins-Instanz hochzuladen.

Im ersten Schritt fügen Sie am Dateianfang die folgenden using-Anweisungen hinzu:

using System.Threading.Tasks;
using System.IO;
using System.Collections.Generic;
using Azure;

Als Nächstes bereiten Sie die Verwendung der asynchronen Methoden im Dienst-SDK für C# vor, indem Sie die Main-Methodensignatur so ändern, dass eine asynchrone Ausführung zulässig ist.

static async Task Main(string[] args)
{

Hinweis

Die Verwendung von async ist nicht unbedingt erforderlich, weil das SDK auch synchrone Versionen aller Aufrufe bereitstellt. In diesem Tutorial wird die Verwendung von async geübt.

Als Nächstes folgt ein Codeabschnitt, der mit dem Azure Digital Twins-Dienst interagiert. Dieser Code lädt die erstellte DTDL-Datei von Ihrem Datenträger in Ihre Azure Digital Twins-Dienstinstanz hoch.

Fügen Sie den folgenden Code unterhalb des Autorisierungscodes ein, den Sie zuvor erstellt haben.

Console.WriteLine();
Console.WriteLine($"Upload a model");
string dtdl = File.ReadAllText("SampleModel.json");
var models = new List<string> { dtdl };
// Upload the model to the service
await client.CreateModelsAsync(models);

Führen Sie in Ihrem Befehlsfenster das Programm mit diesem Befehl aus:

dotnet run

Die Ausgabe enthält den Hinweis „Upload a model“. Dies bedeutet, dass dieser Code erreicht wurde, aber noch keine Ausgabe mit einem Hinweis dazu vorhanden ist, ob der Upload erfolgreich war.

Fügen Sie den folgenden Code direkt nach dem vorherigen Abschnitt ein, um eine Ausgabeanweisung zum Anzeigen aller Modelle hinzuzufügen, die erfolgreich in die Instanz hochgeladen wurden:

// Read a list of models back from the service
AsyncPageable<DigitalTwinsModelData> modelDataList = client.GetModelsAsync();
await foreach (DigitalTwinsModelData md in modelDataList)
{
    Console.WriteLine($"Model: {md.Id}");
}

Bedenken Sie vor Ausführung des Programms zum Testen dieses neuen Codes, dass Sie Ihr Modell bei der letzten Programmausführung bereits hochgeladen haben. Mit Azure Digital Twins ist es nicht möglich, das gleiche Modell zweimal hochzuladen. Wenn Sie also versuchen, das gleiche Modell erneut hochzuladen, wird voraussichtlich eine Ausnahme von dem Programm ausgelöst.

Führen Sie das Programm mit diesem Wissen in Ihrem Befehlsfenster jetzt mit diesem Befehl erneut aus:

dotnet run

Das Programm sollte eine Ausnahme ausgeben. Wenn Sie versuchen, ein Modell hochzuladen, das bereits hochgeladen wurde, gibt der Dienst über die REST-API einen Fehler vom Typ „Ungültige Anforderung“ aus. Als Ergebnis löst das Azure Digital Twins-Client SDK für jeden Rückgabecode des Diensts, der nicht „Erfolgreich“ lautet, eine Ausnahme aus.

Im nächsten Abschnitt wenden wir uns Ausnahmen wie diesen zu, und es wird erläutert, wie Sie sie in Ihrem Code behandeln.

Abfangen von Fehlern

Um zu verhindern, dass das Programm abstürzt, können Sie Ausnahmecode um den Code zum Hochladen eines Modells einfügen. Umschließen Sie den vorhandenen Clientaufruf await client.CreateModelsAsync(typeList) wie folgt mit einem try/catch-Handler:

try
{
    await client.CreateModelsAsync(models);
    Console.WriteLine("Models uploaded to the instance:");
}
catch (RequestFailedException e)
{
    Console.WriteLine($"Upload model error: {e.Status}: {e.Message}");
}

Führen Sie in Ihrem Befehlsfenster das Programm mit dotnet run erneut aus. Sie sehen, dass Sie weitere Details zum Modelluploadproblem erhalten, einschließlich eines Fehlercodes, der Folgendes besagt: ModelIdAlreadyExists.

Von diesem Punkt an werden in diesem Tutorial alle Aufrufe von Dienstmethoden in try/catch-Handler eingeschlossen.

Erstellen digitaler Zwillinge

Nun, da Sie ein Modell in Azure Digital Twins hochgeladen haben, können Sie diese Modelldefinition zum Erstellen digitaler Zwillinge verwenden. Digitale Zwillinge sind Instanzen eines Modells und repräsentieren die Entitäten in Ihrer Geschäftsumgebung – beispielsweise Sensoren in einer Farm, Räume in einem Gebäude oder die Beleuchtung in einem Fahrzeug. Im vorliegenden Abschnitt werden basierend auf dem zuvor hochgeladenen Modell einige digitale Zwillinge erstellt.

Fügen Sie am Ende der Main-Methode den folgenden Code hinzu, um basierend auf diesem Modell drei digitale Zwillinge zu erstellen und zu initialisieren.

var twinData = new BasicDigitalTwin();
twinData.Metadata.ModelId = "dtmi:example:SampleModel;1";
twinData.Contents.Add("data", $"Hello World!");

string prefix = "sampleTwin-";
for (int i = 0; i < 3; i++)
{
    try
    {
        twinData.Id = $"{prefix}{i}";
        await client.CreateOrReplaceDigitalTwinAsync<BasicDigitalTwin>(twinData.Id, twinData);
        Console.WriteLine($"Created twin: {twinData.Id}");
    }
    catch(RequestFailedException e)
    {
        Console.WriteLine($"Create twin error: {e.Status}: {e.Message}");
    }
}

Führen Sie in Ihrem Befehlsfenster das Programm mit dotnet run aus. Suchen Sie in der Ausgabe nach den Ausgabemeldungen zur Erstellung von sampleTwin-0, sampleTwin-1 und sampleTwin-2.

Führen Sie das Programm anschließend erneut aus.

Beachten Sie, dass beim zweiten Erstellen der digitalen Zwillinge kein Fehler ausgegeben wird, obwohl die Zwillinge bereits nach der ersten Ausführung vorhanden sind. Im Gegensatz zur Modellerstellung erfolgt die Erstellung der Zwillinge auf REST-Ebene über einen PUT-Aufruf mit upsert-Semantik. Die Verwendung dieser Art von REST-Aufruf bedeutet Folgendes: Wenn bereits ein Zwilling vorhanden ist, wird beim Versuch, den gleichen Zwilling erneut zu erstellen, lediglich der ursprüngliche Zwilling ersetzt. Es wird kein Fehler ausgelöst.

Erstellen von Beziehungen

Im nächsten Schritt können Sie Beziehungen zwischen den erstellten Zwillingen erstellen, um sie in einem Zwillingsgraphen zu verbinden. Zwillingsgraphen werden verwendet, um Ihre gesamte Umgebung darzustellen.

Fügen Sie der Program-Klasse unterhalb der Main-Methode eine neue statische Methode hinzu (der Code verfügt jetzt über zwei Methoden):

public async static Task CreateRelationshipAsync(DigitalTwinsClient client, string srcId, string targetId)
{
    var relationship = new BasicRelationship
    {
        TargetId = targetId,
        Name = "contains"
    };

    try
    {
        string relId = $"{srcId}-contains->{targetId}";
        await client.CreateOrReplaceRelationshipAsync(srcId, relId, relationship);
        Console.WriteLine("Created relationship successfully");
    }
    catch (RequestFailedException e)
    {
        Console.WriteLine($"Create relationship error: {e.Status}: {e.Message}");
    }
}

Fügen Sie als Nächstes den folgenden Code am Ende der Methode Main hinzu, um die Methode CreateRelationship aufzurufen und den soeben geschriebenen Code zu verwenden:

// Connect the twins with relationships
await CreateRelationshipAsync(client, "sampleTwin-0", "sampleTwin-1");
await CreateRelationshipAsync(client, "sampleTwin-0", "sampleTwin-2");

Führen Sie in Ihrem Befehlsfenster das Programm mit dotnet run aus. Suchen Sie in der Ausgabe nach Ausgabeanweisungen mit der Meldung, dass die Erstellung der beiden Beziehungen erfolgreich war.

Azure Digital Twins wird das Erstellen einer Beziehung nicht zulassen, falls bereits eine andere Beziehung mit der gleichen ID vorhanden ist. Wenn Sie das Programm mehrfach ausführen, werden beim Erstellen von Beziehungen Ausnahmen angezeigt. Mit diesem Code werden die Ausnahmen abgefangen und ignoriert.

Auflisten von Beziehungen

Der nächste Codeabschnitt, den Sie hinzufügen, ermöglicht die Anzeige einer Liste der Beziehungen, die Sie erstellt haben.

Fügen Sie der Program-Klasse die folgende neue Methode hinzu:

public async static Task ListRelationshipsAsync(DigitalTwinsClient client, string srcId)
{
    try
    {
        AsyncPageable<BasicRelationship> results = client.GetRelationshipsAsync<BasicRelationship>(srcId);
        Console.WriteLine($"Twin {srcId} is connected to:");
        await foreach (BasicRelationship rel in results)
        {
            Console.WriteLine($" -{rel.Name}->{rel.TargetId}");
        }
    }
    catch (RequestFailedException e)
    {
        Console.WriteLine($"Relationship retrieval error: {e.Status}: {e.Message}");
    }
}

Anschließend fügen Sie den folgenden Code am Ende der Main-Methode zum Aufrufen des ListRelationships-Codes hinzu:

//List the relationships
await ListRelationshipsAsync(client, "sampleTwin-0");

Führen Sie in Ihrem Befehlsfenster das Programm mit dotnet run aus. Daraufhin sollte eine Liste mit allen von Ihnen erstellten Beziehungen in einer Ausgabeanweisung angezeigt werden, die wie folgt aussieht:

Screenshot of a console showing the program output, which results in a message that lists the twin relationships.

Abfragen von digitalen Zwillingen

Eine Hauptfunktion von Azure Digital Twins ist das einfache Abfragen des Zwillingsgraphen und das effiziente Beantworten von Fragen zur Umgebung.

Mit dem letzten Codeabschnitt, den wir im Rahmen dieses Tutorials hinzufügen, wird eine Abfrage der Azure Digital Twins-Instanz ausgeführt. Die in diesem Beispiel verwendete Abfrage gibt alle digitalen Zwillinge in der Instanz zurück.

Fügen Sie diese using-Anweisung hinzu, um die Verwendung der JsonSerializer-Klasse zum Darstellen der Informationen zu digitalen Zwillingen zu ermöglichen:

using System.Text.Json;

Fügen Sie anschließend am Ende der Main-Methode den folgenden Code hinzu:

// Run a query for all twins
string query = "SELECT * FROM digitaltwins";
AsyncPageable<BasicDigitalTwin> queryResult = client.QueryAsync<BasicDigitalTwin>(query);

await foreach (BasicDigitalTwin twin in queryResult)
{
    Console.WriteLine(JsonSerializer.Serialize(twin));
    Console.WriteLine("---------------");
}

Führen Sie in Ihrem Befehlsfenster das Programm mit dotnet run aus. In der Ausgabe sollten alle digitalen Zwillinge in dieser Instanz angezeigt werden.

Hinweis

Nachdem Sie eine Änderung an den Daten in Ihrem Graphen vorgenommen haben, kann eine Latenz von bis zu 10 Sekunden auftreten, bevor die Änderungen in Abfragen berücksichtigt werden.

Die DigitalTwins-API spiegelt Änderungen sofort wider. Wenn Sie also eine sofortige Antwort benötigen, verwenden Sie eine API-Anforderung (DigitalTwins GetById) oder einen SDK-Aufruf (GetDigitalTwin), um Zwillingsdaten zu erhalten, anstatt eine Abfrage durchzuführen.

Vollständiges Codebeispiel

An dieser Stelle des Tutorials verfügen Sie über eine vollständige Client-App, die in der Lage ist, die grundlegenden Aktionen in Azure Digital Twins auszuführen. Zu Ihrer Referenz wird nachfolgend der vollständige Code des Programms in Program.cs aufgeführt:

using System;
// <Azure_Digital_Twins_dependencies>
using Azure.DigitalTwins.Core;
using Azure.Identity;
// </Azure_Digital_Twins_dependencies>
// <Model_dependencies>
using System.Threading.Tasks;
using System.IO;
using System.Collections.Generic;
using Azure;
// </Model_dependencies>
// <Query_dependencies>
using System.Text.Json;
// </Query_dependencies>

namespace DigitalTwins_Samples
{
    class DigitalTwinsClientAppSample
    {
        // <Async_signature>
        static async Task Main(string[] args)
        {
        // </Async_signature>
            Console.WriteLine("Hello World!");
            // <Authentication_code>
            string adtInstanceUrl = "https://<your-Azure-Digital-Twins-instance-hostName>"; 
            
            var credential = new DefaultAzureCredential();
            var client = new DigitalTwinsClient(new Uri(adtInstanceUrl), credential);
            Console.WriteLine($"Service client created – ready to go");
            // </Authentication_code>

            // <Model_code>
            Console.WriteLine();
            Console.WriteLine("Upload a model");
            string dtdl = File.ReadAllText("SampleModel.json");
            var models = new List<string> { dtdl };

            // Upload the model to the service
            // <Model_try_catch>
            try
            {
                await client.CreateModelsAsync(models);
                Console.WriteLine("Models uploaded to the instance:");
            }
            catch (RequestFailedException e)
            {
                Console.WriteLine($"Upload model error: {e.Status}: {e.Message}");
            }
            // </Model_try_catch>

            // <Print_model>
            // Read a list of models back from the service
            AsyncPageable<DigitalTwinsModelData> modelDataList = client.GetModelsAsync();
            await foreach (DigitalTwinsModelData md in modelDataList)
            {
                Console.WriteLine($"Model: {md.Id}");
            }
            // </Print_model>
            // </Model_code>

            // <Initialize_twins>
            var twinData = new BasicDigitalTwin();
            twinData.Metadata.ModelId = "dtmi:example:SampleModel;1";
            twinData.Contents.Add("data", $"Hello World!");
            
            string prefix = "sampleTwin-";
            for (int i = 0; i < 3; i++)
            {
                try
                {
                    twinData.Id = $"{prefix}{i}";
                    await client.CreateOrReplaceDigitalTwinAsync<BasicDigitalTwin>(twinData.Id, twinData);
                    Console.WriteLine($"Created twin: {twinData.Id}");
                }
                catch(RequestFailedException e)
                {
                    Console.WriteLine($"Create twin error: {e.Status}: {e.Message}");
                }
            }
            // </Initialize_twins>

            // <Use_create_relationship>
            // Connect the twins with relationships
            await CreateRelationshipAsync(client, "sampleTwin-0", "sampleTwin-1");
            await CreateRelationshipAsync(client, "sampleTwin-0", "sampleTwin-2");
            // </Use_create_relationship>

            // <Use_list_relationships>
            //List the relationships
            await ListRelationshipsAsync(client, "sampleTwin-0");
            // </Use_list_relationships>

            // <Query_twins>
            // Run a query for all twins
            string query = "SELECT * FROM digitaltwins";
            AsyncPageable<BasicDigitalTwin> queryResult = client.QueryAsync<BasicDigitalTwin>(query);
            
            await foreach (BasicDigitalTwin twin in queryResult)
            {
                Console.WriteLine(JsonSerializer.Serialize(twin));
                Console.WriteLine("---------------");
            }
            // </Query_twins>
        }

        // <Create_relationship>
        public async static Task CreateRelationshipAsync(DigitalTwinsClient client, string srcId, string targetId)
        {
            var relationship = new BasicRelationship
            {
                TargetId = targetId,
                Name = "contains"
            };
        
            try
            {
                string relId = $"{srcId}-contains->{targetId}";
                await client.CreateOrReplaceRelationshipAsync(srcId, relId, relationship);
                Console.WriteLine("Created relationship successfully");
            }
            catch (RequestFailedException e)
            {
                Console.WriteLine($"Create relationship error: {e.Status}: {e.Message}");
            }
        }
        // </Create_relationship>
        
        // <List_relationships>
        public async static Task ListRelationshipsAsync(DigitalTwinsClient client, string srcId)
        {
            try
            {
                AsyncPageable<BasicRelationship> results = client.GetRelationshipsAsync<BasicRelationship>(srcId);
                Console.WriteLine($"Twin {srcId} is connected to:");
                await foreach (BasicRelationship rel in results)
                {
                    Console.WriteLine($" -{rel.Name}->{rel.TargetId}");
                }
            }
            catch (RequestFailedException e)
            {
                Console.WriteLine($"Relationship retrieval error: {e.Status}: {e.Message}");
            }
        }
        // </List_relationships>
    }
}

Bereinigen von Ressourcen

Nach Abschluss dieses Tutorials können Sie die zu entfernenden Ressourcen auswählen, abhängig davon, wie Sie weiter vorgehen möchten.

  • Wenn Sie mit dem nächsten Tutorial fortfahren möchten, kann die in diesem Tutorial verwendete Instanz im nächsten Tutorial wiederverwendet werden. Sie können die hier eingerichteten Azure Digital Twins-Ressourcen behalten und den restlichen Teil dieses Abschnitts überspringen.

  • Wenn Sie die Azure Digital Twins-Instanz aus diesem Artikel weiterhin verwenden möchten, aber alle Modelle, Zwillinge und Beziehungen von ihr löschen möchten, führen Sie den folgenden az dt job deletion-CLI-Befehl aus:

    az dt job deletion create -n <name-of-Azure-Digital-Twins-instance> -y

    Wenn Sie nur einige dieser Elemente löschen möchten, können Sie die Befehle az dt twin relationship delete, az dt twin delete und az dt model delete verwenden, um nur die Elemente, die Sie entfernen möchten, selektiv zu löschen.

  • Wenn Sie die in diesem Tutorial erstellten Ressourcen nicht benötigen, können Sie die Azure Digital Twins-Instanz und alle anderen Ressourcen in diesem Artikel mit dem CLI-Befehl az group delete löschen. Dadurch werden alle Azure-Ressourcen in einer Ressourcengruppe sowie die Ressourcengruppe selbst gelöscht.

    Wichtig

    Das Löschen einer Ressourcengruppe kann nicht rückgängig gemacht werden. Die Ressourcengruppe und alle darin enthaltenen Ressourcen werden unwiderruflich gelöscht. Achten Sie daher darauf, dass Sie nicht versehentlich die falsche Ressourcengruppe oder die falschen Ressourcen löschen.

    Öffnen Sie Azure Cloud Shell oder ein lokales CLI-Fenster, und führen Sie den folgenden Befehl aus, um die Ressourcengruppe und alle darin enthaltenen Elemente zu löschen.

    az group delete --name <your-resource-group>

Löschen Sie ggf. auch den Projektordner von Ihrem lokalen Computer.

Nächste Schritte

In diesem Tutorial haben Sie eine Clientanwendung für die .NET-Konsole von Grund auf neu erstellt. Sie haben Code für die Client-App erstellt, um grundlegende Aufgaben für eine Azure Digital Twins-Instanz auszuführen.

Fahren Sie mit dem nächsten Tutorial fort, um zu untersuchen, welche Möglichkeiten eine solche Beispiel-Client-App bietet:

Untersuchen der Grundlagen mit einer Beispielclient-App