Zelfstudie: Coderen met de Azure Digital Twins SDK
Ontwikkelaars die met Azure Digital Twins werken, schrijven vaak clienttoepassingen voor interactie met hun exemplaar van de Azure Digital Twins-service. Deze zelfstudie voor ontwikkelaars biedt een inleiding op het programmeren van de Azure Digital Twins-service, met behulp van de Azure Digital Twins-SDK voor .NET (C#). U wordt stap voor stap begeleid bij het schrijven van een C# console-client-app, vanaf het begin.
- Project instellen
- Aan de slag met projectcode
- Codevoorbeeld voltooien
- Resources opschonen
- Volgende stappen
Vereisten
In deze zelfstudie over Azure Digital Twins wordt de opdrachtregel gebruikt voor het instellen en projectwerk. Als zodanig kunt u elke code-editor gebruiken om de oefeningen te doorlopen.
U gaat als volgt aan de slag:
- Elk soort code-editor
- .NET Core 3.1 op uw ontwikkelcomputer. U kunt deze versie van .NET Core SDK voor meerdere platforms downloaden van .NET Core 3.1. downloaden.
Een Azure Digital Twins-exemplaar voorbereiden
Als u met Azure Digital Twins in dit artikel wilt werken, hebt u een Azure Digital Twins-exemplaar en de vereiste machtigingen nodig om deze te gebruiken. Als u al een Azure Digital Twins-exemplaar hebt ingesteld, kunt u dat exemplaar gebruiken en doorgaan naar de volgende sectie. Volg anders de instructies in Een instantie en verificatie instellen. De instructies bevatten informatie om te controleren of u elke stap hebt voltooid.
Nadat u uw exemplaar hebt ingesteld, noteert u de hostnaam van het exemplaar. U vindt de hostnaam in Azure Portal.
Lokale Azure-referenties instellen
In dit voorbeeld wordt gebruikgemaakt van DefaultAzureCredential (onderdeel van de Azure.Identity-bibliotheek) om gebruikers te verifiëren bij de Azure Digital Twins-instantie wanneer u deze uitvoert op uw lokale machine. Voor meer informatie over verschillende manieren waarop een client-app kan verifiëren met Azure Digital Twins, raadpleegt u Verificatiecode voor app schrijven.
Met DefaultAzureCredential zoekt het voorbeeld naar referenties in uw lokale omgeving, zoals een Azure-aanmelding in een lokale Azure-CLI of in Visual Studio of Visual Studio Code. Daarom moet u zich lokaal aanmelden bij Azure via een van deze mechanismen om referenties in te stellen voor het voorbeeld.
Als u Visual Studio of Visual Studio Code gebruikt om codevoorbeelden uit te voeren, moet u ervoor zorgen dat u bent aangemeld bij die editor met dezelfde Azure-referenties die u wilt gebruiken voor toegang tot uw Azure Digital Twins-exemplaar. Als u een lokaal CLI-venster gebruikt, voert u de az login opdracht uit om u aan te melden bij uw Azure-account. Daarna moet u, wanneer u het codevoorbeeld uitvoert, automatisch worden geverifieerd.
Project instellen
Zodra u klaar bent om met uw Azure Digital Twins-exemplaar te gaan, begint u met het instellen van het client-app-project.
Open een consolevenster op uw computer en maak een lege projectmap waarin u uw werk wilt opslaan tijdens deze zelfstudie. Geef de map een naam op wat u wilt (bijvoorbeeld DigitalTwinsCodeTutorial).
Navigeer naar de nieuwe map.
Maak een leeg .NET-console-app-project in de projectmap. In het opdrachtvenster kunt u de volgende opdracht uitvoeren om een minimaal C#-project voor de console te maken:
dotnet new console
Met deze opdracht maakt u verschillende bestanden in uw map, waaronder een met de naam Program.cs , waar u de meeste code schrijft.
Houd het opdrachtvenster geopend, omdat u het in de zelfstudie blijft gebruiken.
Vervolgens voegt u twee afhankelijkheden toe aan uw project die nodig zijn om te werken met Azure Digital Twins. De eerste bestaat uit het pakket voor Azure Digital Twins SDK voor .NET, de tweede biedt hulpmiddelen voor de verificatie met Azure.
dotnet add package Azure.DigitalTwins.Core
dotnet add package Azure.Identity
Aan de slag met projectcode
In deze sectie begint u met het schrijven van de code voor uw nieuwe app-project voor gebruik met Azure Digital Twins. De behandelde acties zijn onder meer:
- Verificatie op basis van de service
- Een model uploaden
- Fouten waarnemen
- Digitale tweelingen maken
- Relaties maken
- Query uitvoeren voor digitale tweeling
Er is ook een sectie met de volledige code aan het einde van de zelfstudie. U kunt deze sectie gebruiken als verwijzing om uw programma te controleren terwijl u aan de slag gaat.
Open het bestand Program.cs in een code-editor om te beginnen. U ziet een minimale codesjabloon die er ongeveer als volgt uitziet:
Voeg eerst enkele using regels toe boven aan de code om de benodigde afhankelijkheden op te halen.
using Azure.DigitalTwins.Core;
using Azure.Identity;
Vervolgens voegt u code toe aan dit bestand om een deel van de functionaliteit in te vullen.
Verificatie op basis van de service
Het eerste wat uw app moet doen, is verifiëren op basis van de Azure Digital Twins-service. Vervolgens kunt u een service-clientklasse maken voor toegang tot de SDK-functies.
Voor verificatie hebt u de hostnaam van uw Azure Digital Twins-exemplaar nodig.
Plak in Program.cs de volgende code onder de afdrukregel Hello, World! in de Main methode.
Stel de waarde in van de hostnaam van adtInstanceUrl uw Azure Digital Twins-exemplaar.
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");
Sla het bestand op.
Voer in het opdrachtvenster de code uit met de volgende opdracht:
dotnet run
Met deze opdracht worden de afhankelijkheden voor de eerste uitvoering hersteld en vervolgens het programma uitgevoerd.
- Als er geen fout optreedt, wordt het programma afgedrukt: 'Serviceclient created - ready to go'.
- Omdat er nog geen foutafhandeling in dit project is, ziet u, als er problemen zijn, een uitzondering die door de code wordt gegenereerd.
Notitie
Er is momenteel een bekend probleem dat van invloed is op de DefaultAzureCredential wrapper-klasse die kan leiden tot een fout tijdens het verifiëren. Als u dit probleem ondervindt, kunt u proberen te instantiëren DefaultAzureCredential met de volgende optionele parameter om dit op te lossen: new DefaultAzureCredential(new DefaultAzureCredentialOptions { ExcludeSharedTokenCacheCredential = true });
Zie bekende problemen met Azure Digital Twins voor meer informatie over dit probleem.
Een model uploaden
Azure Digital Twins heeft geen intrinsieke domeinwoordenlijst. De typen elementen in uw omgeving die u kunt vertegenwoordigen in Azure Digital Twins, worden door u gedefinieerd met behulp van Modellen. Modellen lijken op klassen in objectgeoriënteerde programmeertalen. Ze bieden door de gebruiker gedefinieerde sjablonen die digitale tweelingen later kunnen volgen en instantiëren. Ze worden geschreven in een JSON-achtige taal met de naam Digital Twins Definition Language (DTDL).
De eerste stap bij het maken van een Azure Digital Twins-oplossing is het definiëren van ten minste een model in een DTDL-bestand.
Maak in de map waarin u het project hebt gemaakt een nieuw .json-bestand met de naam SampleModel.json. Plak in de volgende hoofdtekst van het bestand:
{
"@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"
}
Tip
Als u Visual Studio voor deze zelfstudie gebruikt, wilt u mogelijk het zojuist gemaakte JSON-bestand selecteren en de eigenschap Kopiëren naar uitvoermap instellen in de Eigenschappencontrole naar te Kopiëren als nieuwer of Altijd kopiëren. Hierdoor kan Visual Studio het JSON-bestand met het standaardpad vinden wanneer u het programma uitvoert met F5 tijdens de rest van de zelfstudie.
Tip
U kunt modeldocumenten controleren om te controleren of de DTDL geldig is met behulp van de DTDLParser-bibliotheek. Zie Modellen parseren en valideren voor meer informatie over het gebruik van deze bibliotheek.
Voeg vervolgens nog wat code toe aan Program.cs om het model dat u hebt gemaakt, te uploaden naar uw Azure Digital Twins-exemplaar.
Voer eerst boven aan het bestand de volgende using-instructies toe:
using System.Threading.Tasks;
using System.IO;
using System.Collections.Generic;
using Azure;
Vervolgens bereidt u het gebruik van de asynchrone methoden in de C# service-SDK voor door de handtekening van de Main methode te wijzigen zodat asynchrone uitvoering kan worden uitgevoerd.
static async Task Main(string[] args)
{
Notitie
Het gebruik van async is niet strikt vereist, omdat de SDK ook synchrone versies van alle aanroepen biedt. In deze zelfstudie gebruikt async.
Vervolgens wordt de eerste bit van code geleverd die samenwerkt met de Azure Digital Twins-service. Met deze code wordt het DTDL-bestand dat u hebt gemaakt op basis van de schijf, geladen en vervolgens geüpload naar uw Azure Digital Twins-service-exemplaar.
Plak de volgende code onder de autorisatiecode die u eerder hebt toegevoegd.
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);
Voer in het opdrachtvenster de programma uit met de volgende opdracht:
dotnet run
'Een model uploaden' wordt afgedrukt in de uitvoer, waarmee wordt aangegeven dat deze code is bereikt, maar er nog geen uitvoer is om aan te geven of het uploaden is geslaagd.
Als u een afdrukinstructie wilt toevoegen waarmee alle modellen worden weergegeven die zijn geüpload, voegt u de volgende code toe, direct na de vorige sectie:
// 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}");
}
Voordat u het programma opnieuw uitvoert om deze nieuwe code te testen, moet u even terug denken aan de laatste keer dat u het programma hebt uitgevoerd. U hebt uw model toen al geüpload. Met Azure Digital Twins kunt u hetzelfde model niet tweemaal uploaden, dus als u hetzelfde model opnieuw probeert te uploaden, moet het programma een uitzondering genereren.
Voer met deze informatie het programma opnieuw uit met deze opdracht in het opdrachtvenster:
dotnet run
Het programma moet een uitzondering genereren. Wanneer u probeert een model te uploaden dat al is geüpload, retourneert de service de fout "ongeldige aanvraag" via de REST API. Als gevolg hiervan zal de Azure Digital Twins-client SDK een uitzondering genereren voor elke serviceretourcode die niet geslaagd is.
In de volgende sectie vindt u informatie over uitzonderingen zoals deze en hoe u deze in uw code kunt verwerken.
Fouten detecteren
Als u wilt voorkomen dat het programma vastloopt, kunt u uitzonderingscode toevoegen rond de code voor het uploaden van het model. Verpak de bestaande clientaanroep await client.CreateModelsAsync(typeList) in een try/catch-handler, zoals:
try
{
await client.CreateModelsAsync(models);
Console.WriteLine("Models uploaded to the instance:");
}
catch (RequestFailedException e)
{
Console.WriteLine($"Upload model error: {e.Status}: {e.Message}");
}
Voer het programma opnieuw uit met dotnet run het opdrachtvenster. U ziet dat u meer informatie krijgt over het probleem met het uploaden van het model, inclusief een foutcode die aangeeft dat ModelIdAlreadyExists.
Vanaf dit punt verstuurt de zelfstudie alle aanroepen naar servicemethoden in try/catch-handlers.
Digitale tweelingen maken
Nu u een model hebt geüpload naar Azure Digital Twins, kunt u deze modeldefinitie gebruiken om digitale dubbels te maken. Digitale tweelingen zijn exemplaren van een model en vertegenwoordigen de entiteiten in uw bedrijfsomgeving: dingen als sensoren op een boerderij, ruimten in een gebouw, of lichten in een auto. In deze sectie wordt een aantal digitale tweelingen gemaakt op basis van het model dat u eerder hebt geüpload.
Voeg de volgende code toe aan het einde van de methode Main om drie digitale tweelingen te maken en initialiseren op basis van dit model.
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}");
}
}
Voer in het opdrachtvenster de programma uit met dotnet run. Zoek in de uitvoer naar de weergaveberichten die melden dat sampleTwin-0, sampleTwin-1 en sampleTwin-2 zijn gemaakt.
Voer vervolgens het programma opnieuw uit.
U ziet dat er geen fout wordt gegenereerd wanneer de tweelingen de tweede keer worden gemaakt, zelfs als tweeling al bestaan na de eerste uitvoering. In tegenstelling tot het maken van een model, is het maken van tweelingen op het REST-niveau een PUT-aanroep met upsert-semantiek. Als u dit type REST-aanroep gebruikt, betekent dit dat als er al een tweeling bestaat, een poging om dezelfde dubbel opnieuw te maken, alleen de oorspronkelijke dubbel vervangt. Er wordt geen fout gegenereerd.
Relaties maken
Vervolgens kunt u relaties maken tussen deze gemaakte tweelingen, om ze te verbinden in een tweelinggrafiek. Tweelinggrafieken worden gebruikt om uw gehele omgeving voor te stellen.
Voeg een nieuwe statische methode toe aan de Program klasse, onder de Main methode (de code heeft nu twee 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}");
}
}
Voeg vervolgens de volgende code toe aan het einde van de Main-methode om de CreateRelationship-methode aan te roepen en gebruik de code die u zojuist hebt geschreven:
// Connect the twins with relationships
await CreateRelationshipAsync(client, "sampleTwin-0", "sampleTwin-1");
await CreateRelationshipAsync(client, "sampleTwin-0", "sampleTwin-2");
Voer in het opdrachtvenster de programma uit met dotnet run. Zoek in de uitvoer naar afdrukinstructies, waarin wordt gemeld dat de twee relaties zijn gemaakt.
Met Azure Digital Twins kunt u geen relatie maken als er al een andere relatie met dezelfde id bestaat. Als u het programma dus meerdere keren uitvoert, ziet u uitzonderingen bij het maken van relaties. Met deze code worden de uitzonderingen onderschept en genegeerd.
Lijst met relaties
Met de volgende code die u toevoegt, kunt u de lijst met relaties zien die u hebt gemaakt.
Voeg de volgende nieuwe methode toe aan de klasse Program:
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}");
}
}
Voeg vervolgens de volgende code toe aan het einde van de Main-methode om de ListRelationships-code aan te roepen:
//List the relationships
await ListRelationshipsAsync(client, "sampleTwin-0");
Voer in het opdrachtvenster de programma uit met dotnet run. U ziet nu een lijst met alle relaties die u hebt gemaakt in een uitvoerinstructie die er als volgt uitziet:
Query's uitvoeren op digitale tweelingen
Een hoofdfunctie van Azure Digital Twins is de mogelijkheid om gemakkelijk en efficiënt query's uit te voeren op uw tweelinggrafiek om vragen over uw omgeving te beantwoorden.
In de laatste sectie van de code die in deze zelfstudie moet worden toegevoegd, wordt een query uitgevoerd op het Azure Digital Twins-exemplaar. Met de query die in dit voorbeeld wordt gebruikt, worden alle digitale tweelingen in het exemplaar geretourneerd.
Voeg deze using-instructie toe om het gebruik van de JsonSerializer-klasse in te schakelen om de informatie over de digitale tweeling te presenteren:
using System.Text.Json;
Voeg vervolgens de volgende code aan het einde van de Main-methode toe:
// 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("---------------");
}
Voer in het opdrachtvenster de programma uit met dotnet run. In de uitvoer ziet u alle digitale tweelingen in dit exemplaar.
Notitie
Nadat u een wijziging hebt aangebracht in de gegevens in uw grafiek, kan er een latentie van maximaal 10 seconden zijn voordat de wijzigingen worden doorgevoerd in query's.
De DigitalTwins-API weerspiegelt wijzigingen onmiddellijk, dus als u een direct antwoord nodig hebt, gebruikt u een API-aanvraag (DigitalTwins GetById) of een SDK-aanroep (GetDigitalTwin) om dubbelgegevens op te halen in plaats van een query.
Volledig voorbeeld van de code
Op dit moment in de zelfstudie hebt u een volledige client-app die basisacties voor Azure Digital Twins kan uitvoeren. Ter referentie wordt de volledige code van het programma in Program.cs hieronder weergegeven:
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>
}
}
Resources opschonen
Nadat u deze zelfstudie hebt voltooid, kunt u kiezen welke resources u wilt verwijderen, afhankelijk van wat u hierna wilt doen.
- Als u van plan bent door te gaan naar de volgende zelfstudie, kan het exemplaar dat in deze zelfstudie wordt gebruikt, opnieuw worden gebruikt in de volgende zelfstudie. U kunt de Azure Digital Twins-resources die u hier hebt ingesteld, behouden en de rest van deze sectie overslaan.
Als u het Azure Digital Twins-exemplaar uit dit artikel wilt blijven gebruiken, maar alle bijbehorende modellen, tweelingen en relaties wilt wissen, voert u de volgende CLI-opdracht az dt job deletion CLI uit:
az dt job deletion create -n <name-of-Azure-Digital-Twins-instance> -yAls u slechts enkele van deze elementen wilt verwijderen, kunt u de opdrachten az dt twin relationship delete, az dt twin delete en az dt model delete gebruiken om alleen de elementen die u wilt verwijderen selectief te verwijderen.
Als u geen van de resources nodig hebt die u in deze zelfstudie hebt gemaakt, kunt u het Azure Digital Twins-exemplaar en alle andere resources uit dit artikel verwijderen met de opdracht az group delete CLI. Hiermee verwijdert u alle Azure-resources in een resourcegroep, evenals de resourcegroep zelf.
Belangrijk
Het verwijderen van een resourcegroep kan niet ongedaan worden gemaakt. De resourcegroep en alle resources daarin worden permanent verwijderd. Zorg ervoor dat u niet per ongeluk de verkeerde resourcegroep of resources verwijdert.
Open Azure Cloud Shell of een lokaal CLI-venster en voer de volgende opdracht uit om de resourcegroep en alles wat deze bevat te verwijderen.
az group delete --name <your-resource-group>
U kunt ook de projectmap van uw lokale computer verwijderen.
Volgende stappen
In deze zelfstudie hebt u een volledig nieuwe .NET-console-clienttoepassing gemaakt. U hebt code voor deze client-app geschreven om de basisacties uit te voeren op een Azure Digital Twins-exemplaar.
Ga verder met de volgende zelfstudie om de dingen te bekijken die u kunt doen met een dergelijke voorbeeld-client-app: