Udostępnij za pomocą

Samouczek: kodowanie przy użyciu zestawu SDK usługi Azure Digital Twins

Deweloperzy pracujący z usługą Azure Digital Twins często piszą aplikacje klienckie do interakcji ze swoją instancją usługi Azure Digital Twins. Ten samouczek skoncentrowany na deweloperach zawiera wprowadzenie do programowania w usłudze Azure Digital Twins przy użyciu zestawu SDK usługi Azure Digital Twins dla platformy .NET (C#). Przeprowadzi Cię przez pisanie aplikacji klienckiej konsoli języka C# krok po kroku, począwszy od podstaw.

  • Konfigurowanie projektu
  • Wprowadzenie do kodu projektu
  • Kompletny przykład kodu
  • Czyszczenie zasobów
  • Następne kroki

Wymagania wstępne

Ten samouczek usługi Azure Digital Twins używa wiersza polecenia do konfigurowania i pracy nad projektem. W związku z tym możesz użyć dowolnego edytora kodu, aby przejść przez ćwiczenia.

Co należy rozpocząć:

  • Dowolny edytor kodu
  • Platforma .NET Core 3.1 na komputerze deweloperskim. Tę wersję zestawu .NET Core SDK dla wielu platform można pobrać z witryny Pobierz platformę .NET Core 3.1.

Przygotowywanie wystąpienia usługi Azure Digital Twins

Aby pracować z usługą Azure Digital Twins w tym artykule, potrzebujesz wystąpienia usługi Azure Digital Twins i wymaganych uprawnień do korzystania z niego. Jeśli masz już skonfigurowane wystąpienie usługi Azure Digital Twins, możesz użyć tego wystąpienia i przejść do następnej sekcji. W przeciwnym razie postępuj zgodnie z instrukcjami zawartymi w Konfigurowanie instancji i uwierzytelnianie. Instrukcje zawierają informacje ułatwiające sprawdzenie, czy każdy krok został ukończony pomyślnie.

Po skonfigurowaniu wystąpienia zanotuj nazwę hosta wystąpienia. Nazwę hosta można znaleźć w witrynie Azure Portal.

Konfigurowanie lokalnych poświadczeń platformy Azure

W tym przykładzie użyto elementu DefaultAzureCredential (część Azure.Identity biblioteki) do uwierzytelniania w wystąpieniu usługi Azure Digital Twins podczas uruchamiania przykładu na komputerze lokalnym. DefaultAzureCredential jest jedną z wielu opcji uwierzytelniania. Aby uzyskać więcej informacji na temat różnych sposobów uwierzytelniania aplikacji klienckiej za pomocą usługi Azure Digital Twins, zobacz Pisanie kodu uwierzytelniania aplikacji.

W DefaultAzureCredentialpróbka wyszukuje poświadczenia w środowisku lokalnym, na przykład logowanie do platformy Azure w lokalnym interfejsie wiersza polecenia platformy Azure lub w programie Visual Studio czy Visual Studio Code. Powinno się zalogować się do platformy Azure lokalnie za pomocą jednego z tych mechanizmów, aby skonfigurować poświadczenia dla przykładowego projektu.

Jeśli używasz programu Visual Studio lub Visual Studio Code do uruchamiania przykładów kodu, upewnij się, że jesteś zalogowany/a do tego edytora przy użyciu tych samych poświadczeń Azure, których chcesz użyć do uzyskania dostępu do wystąpienia usługi Azure Digital Twins. Jeśli używasz lokalnego okna interfejsu wiersza polecenia, uruchom polecenie az login, aby zalogować się do konta Azure. Po zalogowaniu przykładowy kod uwierzytelnia Cię automatycznie po uruchomieniu.

Konfigurowanie projektu

Kiedy jesteś gotowy do rozpoczęcia pracy z instancją Azure Digital Twins, zacznij konfigurowanie projektu aplikacji klienckiej.

Otwórz okno konsoli na komputerze i utwórz pusty katalog projektu, w którym chcesz przechowywać swoją pracę podczas tego samouczka. Nadaj katalogowi dowolną nazwę (na przykład DigitalTwinsCodeTutorial).

Przejdź do nowego katalogu.

Po przejściu do katalogu projektu utwórz pusty projekt aplikacji konsolowej platformy .NET. W oknie polecenia możesz uruchomić następujące polecenie, aby utworzyć minimalny projekt języka C# dla konsoli:

dotnet new console

To polecenie tworzy kilka plików wewnątrz katalogu, w tym jeden o nazwie Program.cs , w którym piszesz większość kodu.

Pozostaw otwarte okno polecenia, kontynuując jego używanie w całym samouczku.

Następnie dodaj dwie zależności do projektu, które są potrzebne do pracy z usługą Azure Digital Twins. Pierwsza zależność to pakiet zestawu SDK usługi Azure Digital Twins dla platformy .NET. Druga zależność udostępnia narzędzia ułatwiające uwierzytelnianie na platformie Azure.

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

Wprowadzenie do kodu projektu

W tej sekcji zaczniesz pisać kod dla nowego projektu aplikacji do pracy z usługą Azure Digital Twins. Omówione akcje obejmują:

  • Uwierzytelnianie w stosunku do usługi
  • Przekazywanie modelu
  • Przechwytywanie błędów
  • Tworzenie cyfrowych bliźniaków
  • Tworzenie relacji
  • Zapytania dotyczące cyfrowych bliźniaków

Na końcu samouczka znajduje się również sekcja przedstawiająca pełny kod. Możesz użyć tej sekcji jako punktu odniesienia, aby sprawdzić swój program w trakcie pracy.

Aby rozpocząć, otwórz plik Program.cs w dowolnym edytorze kodu. Zostanie wyświetlony minimalny szablon kodu, który wygląda mniej więcej tak:

Zrzut ekranu przedstawiający fragment przykładowego kodu w edytorze kodu.

Najpierw dodaj kilka using wierszy na początku kodu, aby zaimportować niezbędne zależności.

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

Następnie dodasz kod do tego pliku, aby wypełnić niektóre funkcje.

Uwierzytelnij się w usłudze

Pierwszą rzeczą, którą aplikacja musi wykonać, jest uwierzytelnianie w usłudze Azure Digital Twins. Następnie możesz utworzyć klasę klienta usługi w celu uzyskania dostępu do funkcji zestawu SDK.

Do uwierzytelnienia potrzebna jest nazwa hosta instancji Azure Digital Twins.

W Program.cs wklej następujący kod poniżej wiersza wydruku "Hello, World!" w metodzie Main . Ustaw nazwę hosta wystąpienia usługi Azure Digital Twins jako wartość adtInstanceUrl.

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");

Zapisz plik.

W oknie polecenia uruchom kod za pomocą następującego polecenia:

dotnet run

To polecenie przywraca zależności po pierwszym uruchomieniu, a następnie wykonuje program.

  • Jeśli wystąpi żaden błąd, program wyświetli komunikat" "Klient usługi utworzony — gotowy do użycia".
  • Ponieważ w tym projekcie nie ma jeszcze żadnej obsługi błędów, jeśli wystąpią jakiekolwiek problemy, zostanie wyświetlony wyjątek zgłoszony przez kod.

Uwaga

Obecnie znany problem wpływa na klasę wrapper DefaultAzureCredential, co może spowodować błąd podczas uwierzytelniania. Jeśli wystąpi ten problem, możesz spróbować utworzyć wystąpienie DefaultAzureCredential za pomocą następującego opcjonalnego parametru, aby rozwiązać ten problem: new DefaultAzureCredential(new DefaultAzureCredentialOptions { ExcludeSharedTokenCacheCredential = true });

Aby uzyskać więcej informacji na temat tego problemu, zobacz Znane problemy usługi Azure Digital Twins.

Prześlij model

Usługa Azure Digital Twins nie ma wewnętrznego słownictwa domeny. Modele służą do definiowania typów elementów w środowisku, które można reprezentować w usłudze Azure Digital Twins. Modele są podobne do klas w językach programowania zorientowanych na obiekty; udostępniają szablony zdefiniowane przez użytkownika dla cyfrowych bliźniaków do późniejszego tworzenia wystąpień. Są one napisane w języku przypominającym kod JSON o nazwie Digital Twins Definition Language (DTDL).

Pierwszym krokiem tworzenia rozwiązania usługi Azure Digital Twins jest zdefiniowanie co najmniej jednego modelu w pliku DTDL.

W katalogu, w którym utworzono projekt, utwórz nowy plik .json o nazwie SampleModel.json. Wklej następującą treść pliku:

{
  "@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"
}

Napiwek

Jeśli używasz programu Visual Studio na potrzeby tego samouczka, możesz wybrać nowo utworzony plik JSON i ustawić właściwość Kopiuj do katalogu wyjściowego w inspektorze właściwości na Kopiuj, jeśli nowsze lub Kopiuj zawsze. Ta wartość właściwości umożliwia programowi Visual Studio znalezienie pliku JSON ze ścieżką domyślną podczas uruchamiania programu za pomocą F5 w pozostałej części samouczka.

Napiwek

Możesz sprawdzić dokumenty modelu, aby upewnić się, że kod DTDL jest prawidłowy przy użyciu biblioteki DTDLParser. Aby uzyskać więcej informacji na temat korzystania z tej biblioteki, zobacz Analizowanie i weryfikowanie modeli.

Następnie dodaj więcej kodu do Program.cs, aby załadować stworzony model do wystąpienia usługi Azure Digital Twins.

Najpierw dodaj kilka using instrukcji na początku pliku:

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

Następnie przygotuj się do użycia metod asynchronicznych w zestawie SDK usługi języka C#, zmieniając sygnaturę Main metody, aby umożliwić wykonywanie asynchroniczne.

static async Task Main(string[] args)
{

Uwaga

Użycie async nie jest ściśle wymagane, ponieważ zestaw SDK udostępnia również synchroniczne wersje wszystkich wywołań. Ten samouczek ćwiczy używanie async.

Następnym krokiem jest pierwszy fragment kodu, który wchodzi w interakcję z usługą Azure Digital Twins. Ten kod ładuje plik DTDL utworzony z twojego dysku, a następnie przesyła go do wystąpienia usługi Azure Digital Twins.

Wklej następujący kod w obszarze dodanego wcześniej kodu autoryzacji.

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);

W oknie polecenia uruchom program za pomocą następującego polecenia:

dotnet run

Komunikat "Przekaż model" jest wyświetlany w danych wyjściowych, aby wskazać, że ten kod został osiągnięty. Jednak nie ma jeszcze żadnych danych wyjściowych, aby wskazać, czy przekazywanie zakończyło się pomyślnie.

Aby dodać instrukcję wyświetlania przedstawiającą wszystkie modele, które zostały pomyślnie przesłane do instancji, dodaj następujący kod bezpośrednio po tej sekcji.

// 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}");
}

Zanim ponownie uruchomisz program, aby przetestować ten nowy kod, pamiętaj, że ostatnim razem, gdy uruchomiłeś program, już wgrałeś swój model. Usługa Azure Digital Twins nie zezwala na dwukrotne przekazanie tego samego modelu, więc jeśli spróbujesz ponownie przekazać ten sam model, program powinien zgłosić wyjątek.

Mając na uwadze te informacje, uruchom program ponownie za pomocą tego polecenia w oknie polecenia:

dotnet run

Program powinien zgłosić wyjątek. Podczas próby przekazania modelu, który został już przekazany, usługa zwraca błąd "nieprawidłowe żądanie" za pośrednictwem interfejsu API REST. W związku z tym zestaw SDK klienta usługi Azure Digital Twins zgłasza wyjątek dla każdego kodu zwracanego przez usługę inną niż powodzenie.

W następnej sekcji omówiono takie wyjątki i sposób ich obsługi w kodzie.

Wykryj błędy

Aby program nie ulegał awarii, można dodać kod wyjątku wokół kodu przekazywania modelu. Zawijaj istniejące wywołanie await client.CreateModelsAsync(typeList) klienta w procedurze obsługi try/catch, w następujący sposób:

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

Uruchom program ponownie za pomocą dotnet run polecenia w oknie polecenia. Widzisz, że otrzymujesz więcej szczegółów dotyczących problemu z przekazywaniem modelu, w tym kod błędu, który wskazuje, że ModelIdAlreadyExists.

Od tego momentu samouczek opakowuje wszystkie wywołania metod usługi w blokach try/catch.

Tworzenie cyfrowych bliźniaków

Po przekazaniu modelu do usługi Azure Digital Twins możesz użyć tej definicji modelu do utworzenia cyfrowych reprezentacji bliźniaczych. Cyfrowe bliźniaki są instancjami modelu i reprezentują byty w środowisku biznesowym, takie jak czujniki na farmie, pokoje w budynku czy światła w samochodzie. Ta sekcja tworzy kilka cyfrowych bliźniaków na podstawie przekazanego wcześniej modelu.

Aby utworzyć i zainicjować trzy cyfrowe bliźniaki na podstawie tego modelu, dodaj następujący kod na końcu metody Main.

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}");
    }
}

W oknie poleceń uruchom program dotnet run. W danych wyjściowych poszukaj komunikatów drukowania utworzonych przez sampleTwin-0, sampleTwin-1 i sampleTwin-2.

Następnie ponownie uruchom program.

Zwróć uwagę, że gdy bliźniaki są tworzone po raz drugi, nie występuje żaden błąd, mimo że bliźniaki już istnieją po pierwszym razie. W przeciwieństwie do tworzenia modelu, tworzenie bliźniaków cyfrowych to wywołanie PUT z semantyką upsert na poziomie REST. Użycie tego rodzaju wywołania REST oznacza, że jeśli bliźniak już istnieje, próba utworzenia tego samego bliźniaka ponownie zastąpi oryginalnego bliźniaka. Nie jest zgłaszany żaden błąd.

Utwórz relacje

Następnie możesz utworzyć relacje między utworzonymi bliźniakami, aby połączyć je w graf bliźniaków. Wykresy bliźniacze są używane do reprezentowania całego środowiska.

Dodaj nową metodę statyczną do Program klasy poniżej Main metody (kod ma teraz dwie metody):

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}");
    }
}

Następnie dodaj następujący kod na końcu Main metody, aby wywołać metodę CreateRelationship i użyć właśnie napisanego kodu:

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

W oknie poleceń uruchom program dotnet run. W wynikach poszukaj komunikatów wyjściowych z informacją, że obie relacje zostały utworzone pomyślnie.

Usługa Azure Digital Twins nie umożliwia utworzenia relacji, jeśli istnieje już inna relacja z tym samym identyfikatorem. W związku z tym w przypadku wielokrotnego uruchamiania programu są widoczne wyjątki dotyczące tworzenia relacji. Ten kod przechwytuje wyjątki i ignoruje je.

Lista relacji

Następny kod, który dodasz, umożliwia wyświetlenie listy utworzonych relacji.

Dodaj następującą nową metodę do klasy 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}");
    }
}

Następnie dodaj następujący kod na końcu Main metody , aby wywołać ListRelationships kod:

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

W oknie poleceń uruchom program dotnet run. Powinna zostać wyświetlona lista wszystkich relacji utworzonych w instrukcji wyjściowej, która wygląda następująco:

Zrzut ekranu przedstawiający konsolę przedstawiającą dane wyjściowe programu, co powoduje wyświetlenie komunikatu z listą relacji bliźniaczych reprezentacji.

Wykonywanie zapytań dotyczących cyfrowych reprezentacji bliźniaczych

Główną funkcją usługi Azure Digital Twins jest możliwość łatwego i wydajnego wykonywania zapytań względem grafu bliźniaków w celu odpowiadania na pytania dotyczące środowiska.

Ostatnia sekcja kodu do dodania w tym samouczku wykonuje zapytanie względem wystąpienia usługi Azure Digital Twins. Zapytanie użyte w tym przykładzie zwraca wszystkie cyfrowe bliźniaki w instancji.

Dodaj tę using instrukcję, aby umożliwić korzystanie z JsonSerializer klasy, aby ułatwić prezentację informacji o cyfrowym bliźniaku.

using System.Text.Json;

Następnie dodaj następujący kod na końcu Main metody:

// 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("---------------");
}

W oknie poleceń uruchom program dotnet run. Wszystkie cyfrowe reprezentacje bliźniacze powinny być widoczne w tym wystąpieniu w danych wyjściowych.

Uwaga

Po wprowadzeniu zmiany danych na grafie może wystąpić opóźnienie do 10 sekund, zanim zmiany zostaną odzwierciedlone w zapytaniach.

Interfejs DigitalTwins API odzwierciedla zmiany natychmiast, więc jeśli potrzebujesz natychmiastowej odpowiedzi, użyj żądania API (DigitalTwins GetById) lub wywołania metody SDK (GetDigitalTwin), aby pobrać dane bliźniaka, zamiast wykonywać zapytanie.

Kompletny przykład kodu

Na tym etapie samouczka masz kompletną aplikację kliencką, która może wykonywać podstawowe akcje względem usługi Azure Digital Twins. W poniższym przykładzie przedstawiono pełny kod programu w Program.cs:

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>
    }
}

Czyszczenie zasobów

Po ukończeniu tego samouczka możesz wybrać zasoby, które chcesz usunąć, w zależności od tego, co chcesz zrobić dalej.

  • Jeśli planujesz przejść do następnego samouczka, wystąpienie używane w tym samouczku można użyć ponownie w następnym samouczku. Możesz zachować zasoby usługi Azure Digital Twins skonfigurowane tutaj i pominąć pozostałą część tej sekcji.

  • Jeśli chcesz kontynuować korzystanie z wystąpienia Azure Digital Twins opisanego w tym artykule, ale chcesz wyczyścić wszystkie jego modele, bliźniaki i relacje, uruchom następujące polecenie CLI: az dt job deletion.

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

    Jeśli chcesz usunąć tylko niektóre z tych elementów, możesz użyć polecenia az dt twin relationship delete, az dt twin delete i az dt model delete, aby selektywnie usunąć elementy, które chcesz usunąć.

  • Jeśli nie potrzebujesz żadnych zasobów utworzonych w tym samouczku, możesz usunąć wystąpienie usługi Azure Digital Twins i wszystkie inne zasoby z tego samouczka za pomocą polecenia az group delete w interfejsie wiersza polecenia. Spowoduje to usunięcie wszystkich zasobów platformy Azure w grupie zasobów, a także samej grupy zasobów.

    Ważne

    Usunięcie grupy zasobów jest nieodwracalne. Grupa zasobów oraz wszystkie zawarte w niej zasoby zostaną trwale usunięte. Uważaj, aby nie usunąć przypadkowo niewłaściwych zasobów lub niewłaściwej grupy zasobów.

    Otwórz usługę Azure Cloud Shell lub lokalne okno interfejsu wiersza polecenia, a następnie uruchom następujące polecenie, aby usunąć grupę zasobów i wszystko, co zawiera.

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

Możesz również usunąć folder projektu z komputera lokalnego.

Następne kroki

W tym samouczku utworzono aplikację kliencką konsolową platformy .NET od podstaw. Napisałeś kod dla tej aplikacji klienckiej w celu wykonania podstawowych akcji w wystąpieniu usługi Azure Digital Twins.

Przejdź do następnego samouczka, aby zapoznać się z zadaniami, które można wykonać za pomocą takiej przykładowej aplikacji klienckiej:

Zapoznaj się z podstawami za pomocą przykładowej aplikacji klienckiej

  • Last updated on