Megosztás a következőn keresztül:

Digitális ikereszközök kezelése

  • Cikk

A környezet entitásait digitális ikerpéldányok képviselik. A digitális ikerpéldányok kezelése magában foglalhatja a létrehozást, a módosítást és az eltávolítást.

Ez a cikk a digitális ikerpéldányok kezelésével foglalkozik; a kapcsolatok és az ikergráf egészének kezeléséhez lásd : Az ikergráf és a kapcsolatok kezelése.

Tipp.

Minden SDK-függvény szinkron és aszinkron verzióban jön létre.

Előfeltételek

Az Azure Digital Twins ebben a cikkben való használatához szüksége lesz egy Azure Digital Twins-példányra és a használatához szükséges engedélyekre. Ha már beállított egy Azure Digital Twins-példányt, használhatja ezt a példányt, és ugorjon a következő szakaszra. Ellenkező esetben kövesse a példány és a hitelesítés beállítása című témakör utasításait. Az utasítások olyan információkat tartalmaznak, amelyek segítenek ellenőrizni, hogy sikeresen végrehajtotta-e az egyes lépéseket.

A példány beállítása után jegyezze fel a példány állomásnevét. A gazdagép nevét az Azure Portalon találja.

Fejlesztői felületek

Ez a cikk bemutatja, hogyan hajthat végre különböző felügyeleti műveleteket a .NET (C#) SDK használatával. Ugyanezeket a felügyeleti hívásokat az Azure Digital Twins API-kban és SDK-kban leírt egyéb nyelvi SDK-k használatával is létrehozhatja.

A műveletek végrehajtásához használható egyéb fejlesztői felületek a következők:

Visualization

Az Azure Digital Twins Explorer egy vizuális eszköz az Azure Digital Twins-gráf adatainak feltárására. Az Explorerrel megtekintheti, lekérdezheti és szerkesztheti modelljeit, ikerpéldányait és kapcsolatait.

Az Azure Digital Twins Explorer eszközről az Azure Digital Twins Explorerben olvashat. A funkciók használatának részletes lépéseit az Azure Digital Twins Explorer használata című témakörben találja.

Így néz ki a vizualizáció:

Screenshot of Azure Digital Twins Explorer showing sample models and twins.

Digitális ikerpéldány létrehozása

Ikerpéldány létrehozásához a következő módon kell használnia a CreateOrReplaceDigitalTwinAsync() szolgáltatásügyfélen a következő módszert:

await client.CreateOrReplaceDigitalTwinAsync<BasicDigitalTwin>(twinId, initData);

Digitális ikerpéldány létrehozásához meg kell adnia a következőket:

  • A digitális ikerpéldányhoz hozzárendelni kívánt azonosítóérték (ezt az azonosítót az ikerpéldány létrehozásakor definiálja)
  • A használni kívánt modell
  • Az ikeradatok kívánt inicializálása, beleértve a...
    • Tulajdonságok (az inicializálás nem kötelező): Igény szerint beállíthatja a digitális ikerpéldány tulajdonságainak kezdeti értékeit. A tulajdonságok nem kötelezőként lesznek kezelve, és később is beállíthatók, de vegye figyelembe, hogy az ikerpéldányok csak akkor jelennek meg, ha be vannak állítva.
    • Összetevők (inicializálás szükséges, ha ikerpéldányon találhatók): Ha az ikerpéldány tartalmaz összetevőket, ezeket inicializálni kell az ikerpéldány létrehozásakor. Lehetnek üres objektumok, de maguknak az összetevőknek is létezniük kell.

A modell és a kezdeti tulajdonságértékek a initData paraméteren keresztül vannak megadva, amely egy JSON-sztring, amely a releváns adatokat tartalmazza. Az objektum strukturálásával kapcsolatos további információkért folytassa a következő szakaszban.

Tipp.

Ikerpéldány létrehozása vagy frissítése után akár 10 másodperces késés is előfordulhat, mielőtt a módosítások megjelennek a lekérdezésekben. Az GetDigitalTwin API (amelyről a cikk későbbi részében olvashat) nem tapasztalja ezt a késést, ezért ha azonnali válaszra van szüksége, a lekérdezés helyett használja az API-hívást az újonnan létrehozott ikerpéldányok megtekintéséhez.

Modell és tulajdonságok inicializálása

Az ikerpéldány tulajdonságai inicializálhatók az ikerpéldány létrehozásakor.

Az ikerlétrehozási API elfogad egy objektumot, amely szerializálva van az ikertulajdonságok érvényes JSON-leírásában. Az ikerpéldány JSON-formátumának leírását a Digital twins és az ikergráf című témakörben talál.

Először létrehozhat egy adatobjektumot, amely az ikerpéldányt és annak tulajdonságadatait jelöli. Paraméterobjektumot manuálisan vagy egy megadott segédosztály használatával hozhat létre. Íme egy példa mindegyikre.

Ikerpéldányok létrehozása manuálisan létrehozott adatokkal

Egyéni segédosztályok használata nélkül egy ikerpéldány tulajdonságait jelölheti a Dictionary<string, object>tulajdonságban, ahol a string tulajdonság neve, az object objektum pedig a tulajdonságot és annak értékét jelképezi.

// Define a custom model type for the twin to be created

internal class CustomDigitalTwin
{
    [JsonPropertyName(DigitalTwinsJsonPropertyNames.DigitalTwinId)]
    public string Id { get; set; }

    [JsonPropertyName(DigitalTwinsJsonPropertyNames.DigitalTwinETag)]
    public string ETag { get; set; }

    [JsonPropertyName("temperature")]
    public double Temperature { get; set; }

    [JsonPropertyName("humidity")]
    public double Humidity{ get; set; }
}

// Initialize properties and create the twin
public class TwinOperationsCreateTwin
{
    public async Task CreateTwinAsync(DigitalTwinsClient client)
    {
        // Initialize the twin properties
        var myTwin = new CustomDigitalTwin
        {
            Temperature = 25.0,
            Humidity = 50.0,
        };

        // Create the twin
        const string twinId = "<twin-ID>";
        Response<CustomDigitalTwin> response = await client.CreateOrReplaceDigitalTwinAsync(twinId, myTwin);
        Console.WriteLine($"Temperature value: {response.Value.Temperature}");
    }
}

Ikerpéldányok létrehozása a segédosztálysal

A segédosztály BasicDigitalTwin lehetővé teszi a tulajdonságmezők közvetlen tárolását egy "iker" objektumban. Előfordulhat, hogy a tulajdonságok listáját továbbra is egy Dictionary<string, object>, az ikerobjektumhoz CustomProperties közvetlenül hozzáfűzhető tulajdonsággal szeretné összeállítani.

string twinId = "myTwinID";
var initData = new BasicDigitalTwin
{
    Id = twinId,
    Metadata = { ModelId = "dtmi:example:Room;1" },
    // Initialize properties
    Contents =
    {
        { "Temperature", 25.0 },
        { "Humidity", 50.0 },
    },
};

await client.CreateOrReplaceDigitalTwinAsync<BasicDigitalTwin>(twinId, initData);

Megjegyzés:

BasicDigitalTwin az objektumok mezővel érkeznek Id . Ezt a mezőt üresen hagyhatja, de ha azonosítóértéket ad hozzá, annak meg kell egyeznie a CreateOrReplaceDigitalTwinAsync() hívásnak átadott azonosító paraméterével. Például:

twin.Id = "myRoomId";

Ikerpéldányok tömeges létrehozása az Import Jobs API-val

Az Import Jobs API használatával egyszerre több ikerpéldányt is létrehozhat egyetlen API-hívásban. Ez a módszer megköveteli az Azure Blob Storage használatát, és írási engedélyeket az Azure Digital Twins-példányban iker- és tömeges feladatokhoz.

Tipp.

Az Importálási feladatok API lehetővé teszi a modellek és kapcsolatok importálását ugyanabban a hívásban, hogy egyszerre hozza létre a gráf összes részét. Erről a folyamatról további információt a Modellek, ikerpéldányok és kapcsolatok tömeges feltöltése az Import Jobs API-val című témakörben talál.

Az ikerpéldányok tömeges importálásához NDJSON-fájlként kell strukturálnia az ikerpéldányokat (és a tömeges importálási feladat egyéb erőforrásait). A Twins szakasz a Models szakasz után (és a Relationships szakasz előtt) következik. A fájlban definiált ikerpéldányok hivatkozhatnak a fájlban definiált vagy a példányban már meglévő modellekre, és opcionálisan magukban foglalhatják az iker tulajdonságainak inicializálását is.

Az Importálási feladatok API bevezetőjében megtekintheti az importálási példafájlt és egy mintaprojektet, amellyel létrehozhatja ezeket a fájlokat.

Ezután a fájlt fel kell tölteni egy hozzáfűző blobba az Azure Blob Storage-ban. Az Azure Storage-tárolók létrehozásával kapcsolatos utasításokért lásd : Tároló létrehozása. Ezután töltse fel a fájlt az előnyben részesített feltöltési módszerrel (néhány lehetőség az AzCopy parancs, az Azure CLI vagy az Azure Portal).

Miután feltöltötte az NDJSON-fájlt a tárolóba, kérje le annak URL-címét a blobtárolóban. Ezt az értéket később fogja használni a tömeges importálási API-hívás törzsében.

Az alábbi képernyőképen egy blobfájl URL-értéke látható az Azure Portalon:

Screenshot of the Azure portal showing the URL of a file in a storage container.

Ezután a fájl használható egy Importálási feladatok API-hívásban . Megadja a bemeneti fájl blobtároló URL-címét, valamint egy új blobtároló URL-címét, amely jelzi, hogy hol szeretné tárolni a kimeneti naplót a szolgáltatás létrehozása után.

Digitális ikerpéldány adatainak lekérése

Bármely digitális ikerpéldány adatait az alábbi módon hívhatja GetDigitalTwin() meg:

Response<BasicDigitalTwin> twinResponse = await client.GetDigitalTwinAsync<BasicDigitalTwin>(twinId);
twin = twinResponse.Value;

Ez a hívás ikeradatokat ad vissza erősen gépelt objektumtípusként, például BasicDigitalTwin. BasicDigitalTwin az SDK-hoz tartozó szerializációs segédosztály, amely az ikerpéldányok alapvető metaadatait és tulajdonságait adja vissza előkészített formában. Az ikeradatokat mindig deszerializálhatja a választott JSON-kódtár használatával, például System.Text.Json vagy Newtonsoft.Json. Az ikerpéldányokhoz való alapszintű hozzáférés érdekében azonban a segítő osztályok ezt kényelmesebbé tehetik.

Megjegyzés:

BasicDigitalTwin attribútumokat használ System.Text.Json . BasicDigitalTwin A DigitalTwinsClient használatához inicializálnia kell az ügyfelet az alapértelmezett konstruktorral, vagy ha testre szeretné szabni a szerializálót, használja a JsonObjectSerializert.

A BasicDigitalTwin segédosztály az ikerpéldányon definiált tulajdonságokhoz is hozzáférést biztosít egy Dictionary<string, object>. Az ikerpéldány tulajdonságainak listázásához a következőket használhatja:

BasicDigitalTwin twin;
Response<BasicDigitalTwin> twinResponse = await client.GetDigitalTwinAsync<BasicDigitalTwin>(twinId);
twin = twinResponse.Value;
Console.WriteLine($"Model id: {twin.Metadata.ModelId}");
foreach (string prop in twin.Contents.Keys)
{
    if (twin.Contents.TryGetValue(prop, out object value))
        Console.WriteLine($"Property '{prop}': {value}");
}

Csak azok a tulajdonságok lesznek visszaadva, amelyek legalább egyszer lettek beállítva, amikor lekér egy ikerpéldányt a GetDigitalTwin() metódussal.

Tipp.

Az displayName ikerpéldány a modell metaadatainak része, ezért nem jelenik meg az ikerpéldány adatainak lekérésekor. Az érték megtekintéséhez lekérheti a modellből.

Ha több ikerpéldányt szeretne lekérni egyetlen API-hívással, tekintse meg az ikergráf lekérdezése api-példáit.

Vegye figyelembe a holdat definiáló következő modellt ( digital twins definition language (DTDL)):

{
    "@id": "dtmi:example:Moon;1",
    "@type": "Interface",
    "@context": "dtmi:dtdl:context;3",
    "contents": [
        {
            "@type": "Property",
            "name": "radius",
            "schema": "double",
            "writable": true
        },
        {
            "@type": "Property",
            "name": "mass",
            "schema": "double",
            "writable": true
        }
    ]
}

A Hold típusú ikerpéldány hívásának object result = await client.GetDigitalTwinAsync("my-moon"); eredménye így nézhet ki:

{
  "$dtId": "myMoon-001",
  "$etag": "W/\"e59ce8f5-03c0-4356-aea9-249ecbdc07f9\"",
  "radius": 1737.1,
  "mass": 0.0734,
  "$metadata": {
    "$model": "dtmi:example:Moon;1",
    "radius": {
      "lastUpdateTime": "2022-12-06T20:00:32.8209188Z"
    },
    "mass": {
      "lastUpdateTime": "2022-12-04T12:04:43.3859361Z"
    }
  }
}

A digitális ikerpéldány definiált tulajdonságai a digitális ikerpéldány legfelső szintű tulajdonságaiként jelennek meg. A DTDL-definíció részét nem képező metaadatok vagy rendszerinformációk egy $ előtaggal lesznek visszaadva. A metaadat-tulajdonságok a következő értékeket tartalmazzák:

  • $dtId: A digitális ikerpéldány azonosítója ebben az Azure Digital Twins-példányban
  • $etag: A webkiszolgáló által hozzárendelt szabványos HTTP-mező. Ez minden alkalommal új értékre frissül, amikor az ikerpéldány frissül, ami hasznos lehet annak megállapításához, hogy az ikerpéldány adatai frissültek-e a kiszolgálón egy korábbi ellenőrzés óta. Olyan frissítéseket és törléseket hajthat If-Match végre, amelyek csak akkor fejeződnek be, ha az entitás etagje megfelel a megadott etagnek. Ezekről a műveletekről további információt a DigitalTwins Update és a DigitalTwins Delete dokumentációjában talál.
  • $metadata: Metaadat-tulajdonságok halmaza, amelyek a következőket tartalmazhatják:
    • $model, a digitális ikerpéldány modelljének DTMI-je.
    • lastUpdateTime ikertulajdonságok esetén. Ez egy időbélyeg, amely azt jelzi, hogy az Azure Digital Twins feldolgozta a tulajdonságfrissítési üzenetet
    • sourceTime ikertulajdonságok esetén. Ez egy nem kötelező írható tulajdonság, amely azt az időbélyeget jelöli, amikor a tulajdonságfrissítést a valós világban figyelték meg.

A Digitális ikerpéldány JSON formátumú digitális ikerpéldányok mezőiről bővebben is olvashat. További információ a szerializálási segédosztályokról, például BasicDigitalTwin az Azure Digital Twins API-kban és az SDK-kban.

Az összes digitális ikerpéldány megtekintése

A példány összes digitális ikerpéldányának megtekintéséhez használjon lekérdezést. Lekérdezést a Lekérdezés API-kkal vagy a parancssori felület parancsaival is futtathat.

Az alapszintű lekérdezés törzse, amely a példányban lévő összes digitális ikerpéldány listáját adja vissza:

SELECT * FROM DIGITALTWINS

Digitális ikerpéldány frissítése

A digitális ikerpéldány tulajdonságainak frissítéséhez írja be a lecserélni kívánt információkat JSON-javítás formátumban. A használható JSON Patch-műveletek teljes listája, beleértve replaceadd a JSON-javítás műveleteit és removeazokat is, tekintse meg a JSON-javítás műveleteit.

A frissítési információkat tartalmazó JSON Patch-dokumentum létrehozása után adja át a dokumentumot a UpdateDigitalTwin() metódusnak:

await client.UpdateDigitalTwinAsync(twinId, updateTwinData);

Egyetlen javításhívás annyi tulajdonságot frissíthet egyetlen ikerpéldányon, amennyit csak szeretne (még az összeset is). Ha több ikerpéldány tulajdonságainak frissítésére van szüksége, minden ikerpéldányhoz külön frissítési hívásra van szükség.

Tipp.

Ikerpéldány létrehozása vagy frissítése után akár 10 másodperces késés is előfordulhat, mielőtt a módosítások megjelennek a lekérdezésekben. Az GetDigitalTwin API (a jelen cikkben korábban ismertetett) nem tapasztalja ezt a késést, ezért lekérdezés helyett használja az API-hívást az újonnan frissített ikerpéldányok megtekintéséhez, ha azonnali válaszra van szüksége.

Íme egy példa a JSON Patch-kódra. Ez a dokumentum lecseréli az alkalmazott digitális ikerpéldány tömeg - és sugártulajdonság-értékeit . Ez a példa a JSON Patch replace műveletet mutatja be, amely egy meglévő tulajdonság értékét váltja fel.

[
    {
      "op": "replace",
      "path": "/mass",
      "value": 0.0799
    },
    {
      "op": "replace",
      "path": "/radius",
      "value": 0.800
    }
  ]

Ha az ikerpéldányt egy kódprojektből frissíti a .NET SDK-val, JSON-javításokat hozhat létre az Azure .NET SDK JsonPatchDocument használatával. Íme egy példa egy JSON Patch-dokumentum létrehozására és a projektkódban való használatára UpdateDigitalTwin() .

var updateTwinData = new JsonPatchDocument();
updateTwinData.AppendAdd("/Temperature", 25.0);
updateTwinData.AppendAdd("/myComponent/Property", "Hello");
// Un-set a property
updateTwinData.AppendRemove("/Humidity");

await client.UpdateDigitalTwinAsync("myTwin", updateTwinData).ConfigureAwait(false);

Tipp.

A digitális ikerpéldányokon a forrásidőbélyegeket úgy tarthatja fenn, hogy frissíti a $metadata.<property-name>.sourceTime mezőt az ebben a szakaszban ismertetett eljárással. Erről a mezőről és a digitális ikerpéldányokon írható egyéb mezőkről további információt a Digital twin JSON formátumában talál.

Altulajdonságok frissítése a digitális ikerösszetevőkben

Ne feledje, hogy egy modell tartalmazhat összetevőket, így más modellekből állhat.

A digitális ikerpéldányok összetevőinek tulajdonságainak javításához használja az elérési út szintaxisát a JSON-javításban:

[
  {
    "op": "replace",
    "path": "/mycomponentname/mass",
    "value": 0.0799
  }
]

Altulajdonságok frissítése objektumtípus-tulajdonságokban

A modellek objektumtípusú tulajdonságokat tartalmazhatnak. Előfordulhat, hogy ezek az objektumok saját tulajdonságokkal rendelkeznek, és érdemes lehet frissíteni az objektum típusú tulajdonsághoz tartozó altulajdonságok egyikét. Ez a folyamat hasonló az összetevők altulajdonságainak frissítéséhez, de szükség lehet néhány további lépésre.

Fontolja meg egy objektum típusú tulajdonsággal rendelkező modellt. ObjectProperty ObjectProperty nevű karakterlánc-tulajdonsága StringSubPropertyvan.

Ha ezzel a modellel hoz létre ikerpéldányt, akkor nem szükséges példányosítani az ObjectProperty adott időpontban. Ha az objektumtulajdonság nem példányosul az ikerpéldány létrehozásakor, nincs alapértelmezett elérési út a hozzáféréshez ObjectProperty és a StringSubProperty javításművelethez. Mielőtt frissítené a tulajdonságait, hozzá kell adnia az elérési utat ObjectProperty saját magához.

Ez egy JSON Patch-művelettel add végezhető el, a következőhöz hasonlóan:

[
  {
    "op": "add", 
    "path": "/ObjectProperty", 
    "value": {"StringSubProperty":"<string-value>"}
  }
]

Megjegyzés:

Ha ObjectProperty egynél több tulajdonsága van, akkor is bele kell foglalnia az összes tulajdonságot a value művelet mezőjébe, még akkor is, ha csak egyet frissít:

... "value": {"StringSubProperty":"<string-value>", "Property2":"<property2-value>", ...}

Miután ezt egyszer elvégezték, létezik egy elérési út StringSubProperty , amely mostantól közvetlenül frissíthető egy tipikus replace művelettel:

[
  {
    "op": "replace",
    "path": "/ObjectProperty/StringSubProperty",
    "value": "<string-value>"
  }
]

Bár az első lépés nem szükséges azokban az esetekben, amikor ObjectProperty az ikerpéldány létrehozásakor példányosították, javasoljuk, hogy minden alkalommal használja, amikor először frissít egy altulajdonságot, mivel lehet, hogy nem mindig tudja biztosan, hogy az objektumtulajdonság kezdetben példányosítva lett-e, vagy sem.

Digitális ikerpéldány modelljének frissítése

A UpdateDigitalTwin() függvény arra is használható, hogy egy digitális ikerpéldányt egy másik modellbe migráljon.

Vegyük például a következő JSON Patch-dokumentumot, amely lecseréli a digitális ikerpéldány metaadatmezőjét $model :

[
  {
    "op": "replace",
    "path": "/$metadata/$model",
    "value": "dtmi:example:foo;1"
  }
]

Ez a művelet csak akkor sikeres, ha a javítás által módosított digitális ikerpéldány megfelel az új modellnek.

Vegyük a következő példát:

  1. Képzeljen el egy digitális ikerpéldányt foo_old modellel. foo_old definiálja a szükséges tulajdonságtömeget.
  2. Az új modell foo_new definiál egy tulajdonságtömeget, és hozzáad egy új, szükséges tulajdonsághőmérsékletet.
  3. A javítás után a digitális ikerpéldánynak tömeg- és hőmérséklettulajdonságokkal kell rendelkeznie.

Ehhez a helyzethez a javításnak frissítenie kell a modellt és az ikerpéldány hőmérsékleti tulajdonságát is, a következőképpen:

[
  {
    "op": "replace",
    "path": "/$metadata/$model",
    "value": "dtmi:example:foo_new;1"
  },
  {
    "op": "add",
    "path": "/temperature",
    "value": 60
  }
]

Tulajdonság sourceTime-jának frissítése

Dönthet úgy is, hogy az sourceTime ikertulajdonságok mezője segítségével rögzíti az időbélyegeket, amikor a tulajdonságfrissítések a valós világban figyelhetők meg. Az Azure Digital Twins natív módon támogatja sourceTime az egyes ikertulajdonságok metaadatait. Az sourceTime értéknek meg kell felelnie az ISO 8601 dátum- és időformátumának. Erről a mezőről és a digitális ikerpéldányok egyéb mezőiről további információt a Digitális ikerpéldány JSON formátumában talál.

A mező támogatásának minimális stabil REST API-verziója a 2022-05-31-es verzió. Ha ezt a mezőt az Azure Digital Twins SDK-kkal szeretné használni, javasoljuk, hogy az SDK legújabb verziójával győződjön meg arról, hogy ez a mező szerepel benne.

Íme egy példa egy JSON Patch-dokumentumra, amely egy tulajdonság értékét és sourceTime mezőjét Temperature is frissíti:

[
  {
    "op": "replace",
    "path": "/Temperature",
    "value": "22.3"
  },
  {
    "op": "replace",
    "path": "/$metadata/Temperature/sourceTime",
    "value": "2021-11-30T18:47:53.7648958Z"
  }
]

Az összetevő részét képező tulajdonság mezőjének frissítéséhez sourceTime az összetevőt az elérési út elején kell megadni. A fenti példában ezt úgy teheti meg, hogy az elérési út értékét a következőre /$metadata/Temperature/sourceTimemyComponent/$metadata/Temperature/sourceTimemódosítja.

Megjegyzés:

Ha egy tulajdonságon frissíti az értéket és az sourceTime értéket is, majd később csak a tulajdonság értékét frissíti, az sourceTime első frissítés időbélyege megmarad.

Ütköző frissítési hívások kezelése

Az Azure Digital Twins biztosítja, hogy az összes bejövő kérés feldolgozása egymás után történik. Ez azt jelenti, hogy még ha több függvény is megpróbálja egyszerre frissíteni ugyanazt a tulajdonságot egy ikerpéldányon, nincs szükség explicit zárolási kód írására az ütközés kezeléséhez.

Ez a viselkedés ikerpéldányonként történik.

Képzeljen el például egy forgatókönyvet, amelyben ez a három hívás egyszerre érkezik:

  • Az A tulajdonság írása twin1-en
  • B tulajdonság írása Twin1-en
  • Az A tulajdonság írása Twin2-n

Az Twin1-et módosító két hívás egymás után lesz végrehajtva, és minden módosításhoz létre lesznek hozva a változásüzenetek. A Twin2 módosítására irányuló hívás egyidejűleg, ütközés nélkül végrehajtható, amint megérkezik.

Digitális ikerpéldány törlése

A módszerrel törölheti az DeleteDigitalTwin() ikerpéldányokat. Az ikerpéldányt azonban csak akkor törölheti, ha nincs több kapcsolata. Ezért először törölje az ikerpéldány bejövő és kimenő kapcsolatait.

Íme egy példa az ikerpéldányok és kapcsolataik törlésére szolgáló kódra. Az DeleteDigitalTwin SDK-hívás ki van emelve, hogy tisztázza, hol esik a tágabb példakörnyezetbe.

private static async Task CustomMethod_DeleteTwinAsync(DigitalTwinsClient client, string twinId)
{
    await CustomMethod_FindAndDeleteOutgoingRelationshipsAsync(client, twinId);
    await CustomMethod_FindAndDeleteIncomingRelationshipsAsync(client, twinId);
    try
    {
        await client.DeleteDigitalTwinAsync(twinId);
        Console.WriteLine("Twin deleted successfully");
    }
    catch (RequestFailedException ex)
    {
        Console.WriteLine($"*** Error:{ex.Message}");
    }
}

private static async Task CustomMethod_FindAndDeleteOutgoingRelationshipsAsync(DigitalTwinsClient client, string dtId)
{
    // Find the relationships for the twin

    try
    {
        // GetRelationshipsAsync will throw an error if a problem occurs
        AsyncPageable<BasicRelationship> rels = client.GetRelationshipsAsync<BasicRelationship>(dtId);

        await foreach (BasicRelationship rel in rels)
        {
            await client.DeleteRelationshipAsync(dtId, rel.Id).ConfigureAwait(false);
            Console.WriteLine($"Deleted relationship {rel.Id} from {dtId}");
        }
    }
    catch (RequestFailedException ex)
    {
        Console.WriteLine($"*** Error {ex.Status}/{ex.ErrorCode} retrieving or deleting relationships for {dtId} due to {ex.Message}");
    }
}

private static async Task CustomMethod_FindAndDeleteIncomingRelationshipsAsync(DigitalTwinsClient client, string dtId)
{
    // Find the relationships for the twin

    try
    {
        // GetRelationshipsAsync will throw an error if a problem occurs
        AsyncPageable<IncomingRelationship> incomingRels = client.GetIncomingRelationshipsAsync(dtId);

        await foreach (IncomingRelationship incomingRel in incomingRels)
        {
            await client.DeleteRelationshipAsync(incomingRel.SourceId, incomingRel.RelationshipId).ConfigureAwait(false);
            Console.WriteLine($"Deleted incoming relationship {incomingRel.RelationshipId} from {dtId}");
        }
    }
    catch (RequestFailedException ex)
    {
        Console.WriteLine($"*** Error {ex.Status}/{ex.ErrorCode} retrieving or deleting incoming relationships for {dtId} due to {ex.Message}");
    }
}

Az összes digitális ikerpéldány törlése

Ha szeretné, hogy az összes ikerpéldány egyszerre törölhető legyen, töltse le az alapismeretek megismeréséhez használt mintaalkalmazást egy mintaügyfél-alkalmazással. A CommandLoop.cs fájl ezt egy CommandDeleteAllTwins() függvényben végzi el.

Megjegyzés:

Ha egyszerre szeretné törölni az összes modellt, ikerpéldányt és kapcsolatot egy példányban, használja a Feladatok törlése API-t.

Futtatható digitális ikerkód minta

Az alábbi futtatható kódmintával létrehozhat egy ikerpéldányt, frissítheti annak részleteit, és törölheti az ikerpéldányt.

Mintaprojektfájlok beállítása

A kódrészlet a Room.json mintamodell-definíciót használja. Ha le szeretné tölteni a modellfájlt , hogy a kódban használhassa, ezen a hivatkozáson keresztül közvetlenül a GitHubon lévő fájlra léphet. Ezután kattintson a jobb gombbal a képernyő tetszőleges pontjára, válassza a Mentés másként lehetőséget a böngésző jobb oldali menüjében, és a Mentés másként ablakban mentse a fájlt Room.json néven.

Ezután hozzon létre egy új konzolalkalmazás-projektet a Visual Studióban vagy a választott szerkesztőben.

Ezután másolja a futtatható minta következő kódját a projektbe:

using System;
using System.Threading.Tasks;
using System.Collections.Generic;
using Azure;
using Azure.DigitalTwins.Core;
using Azure.Identity;
using System.IO;

namespace DigitalTwins_Samples
{
    class TwinOperationsSample
    {
        public static async Task Main(string[] args)
        {
            Console.WriteLine("Hello World!");

            // Create the Azure Digital Twins client for API calls
            string adtInstanceUrl = "https://<your-instance-hostname>";
            var credentials = new DefaultAzureCredential();
            var client = new DigitalTwinsClient(new Uri(adtInstanceUrl), credentials);
            Console.WriteLine($"Service client created – ready to go");

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

            // Create new digital twin
            // <CreateTwin_withHelper>
            string twinId = "myTwinID";
            var initData = new BasicDigitalTwin
            {
                Id = twinId,
                Metadata = { ModelId = "dtmi:example:Room;1" },
                // Initialize properties
                Contents =
                {
                    { "Temperature", 25.0 },
                    { "Humidity", 50.0 },
                },
            };

            // <CreateTwinCall>
            await client.CreateOrReplaceDigitalTwinAsync<BasicDigitalTwin>(twinId, initData);
            // </CreateTwinCall>
            // </CreateTwin_withHelper>
            Console.WriteLine("Twin created successfully");

            //Print twin
            Console.WriteLine("--- Printing twin details:");
            await CustomMethod_FetchAndPrintTwinAsync(twinId, client);
            Console.WriteLine("--------");

            //Update twin data
            var updateTwinData = new JsonPatchDocument();
            updateTwinData.AppendAdd("/Temperature", 30.0);
            // <UpdateTwinCall>
            await client.UpdateDigitalTwinAsync(twinId, updateTwinData);
            // </UpdateTwinCall>
            Console.WriteLine("Twin properties updated");
            Console.WriteLine();

            //Print twin again
            Console.WriteLine("--- Printing twin details (after update):");
            await CustomMethod_FetchAndPrintTwinAsync(twinId, client);
            Console.WriteLine("--------");
            Console.WriteLine();

            //Delete twin
            await CustomMethod_DeleteTwinAsync(client, twinId);
        }

        private static async Task<BasicDigitalTwin> CustomMethod_FetchAndPrintTwinAsync(string twinId, DigitalTwinsClient client)
        {
            // <GetTwin>
            BasicDigitalTwin twin;
            // <GetTwinCall>
            Response<BasicDigitalTwin> twinResponse = await client.GetDigitalTwinAsync<BasicDigitalTwin>(twinId);
            twin = twinResponse.Value;
            // </GetTwinCall>
            Console.WriteLine($"Model id: {twin.Metadata.ModelId}");
            foreach (string prop in twin.Contents.Keys)
            {
                if (twin.Contents.TryGetValue(prop, out object value))
                    Console.WriteLine($"Property '{prop}': {value}");
            }
            // </GetTwin>

            return twin;
        }

        // <DeleteTwin>
        private static async Task CustomMethod_DeleteTwinAsync(DigitalTwinsClient client, string twinId)
        {
            await CustomMethod_FindAndDeleteOutgoingRelationshipsAsync(client, twinId);
            await CustomMethod_FindAndDeleteIncomingRelationshipsAsync(client, twinId);
            try
            {
                await client.DeleteDigitalTwinAsync(twinId);
                Console.WriteLine("Twin deleted successfully");
            }
            catch (RequestFailedException ex)
            {
                Console.WriteLine($"*** Error:{ex.Message}");
            }
        }

        private static async Task CustomMethod_FindAndDeleteOutgoingRelationshipsAsync(DigitalTwinsClient client, string dtId)
        {
            // Find the relationships for the twin

            try
            {
                // GetRelationshipsAsync will throw an error if a problem occurs
                AsyncPageable<BasicRelationship> rels = client.GetRelationshipsAsync<BasicRelationship>(dtId);

                await foreach (BasicRelationship rel in rels)
                {
                    await client.DeleteRelationshipAsync(dtId, rel.Id).ConfigureAwait(false);
                    Console.WriteLine($"Deleted relationship {rel.Id} from {dtId}");
                }
            }
            catch (RequestFailedException ex)
            {
                Console.WriteLine($"*** Error {ex.Status}/{ex.ErrorCode} retrieving or deleting relationships for {dtId} due to {ex.Message}");
            }
        }

        private static async Task CustomMethod_FindAndDeleteIncomingRelationshipsAsync(DigitalTwinsClient client, string dtId)
        {
            // Find the relationships for the twin

            try
            {
                // GetRelationshipsAsync will throw an error if a problem occurs
                AsyncPageable<IncomingRelationship> incomingRels = client.GetIncomingRelationshipsAsync(dtId);

                await foreach (IncomingRelationship incomingRel in incomingRels)
                {
                    await client.DeleteRelationshipAsync(incomingRel.SourceId, incomingRel.RelationshipId).ConfigureAwait(false);
                    Console.WriteLine($"Deleted incoming relationship {incomingRel.RelationshipId} from {dtId}");
                }
            }
            catch (RequestFailedException ex)
            {
                Console.WriteLine($"*** Error {ex.Status}/{ex.ErrorCode} retrieving or deleting incoming relationships for {dtId} due to {ex.Message}");
            }
        }
        // </DeleteTwin>

    }
}

Megjegyzés:

Jelenleg ismert probléma van a DefaultAzureCredential burkolóosztályt érintően, amely a hitelesítés során hibát okozhat. Ha ezt a problémát tapasztalja, a probléma megoldásához próbálja meg példányosítani DefaultAzureCredential a következő opcionális paramétert: new DefaultAzureCredential(new DefaultAzureCredentialOptions { ExcludeSharedTokenCacheCredential = true });

A problémával kapcsolatos további információkért tekintse meg az Azure Digital Twins ismert problémáit.

Projekt konfigurálása

Ezután hajtsa végre a következő lépéseket a projektkód konfigurálásához:

  1. Adja hozzá a korábban letöltött Room.json fájlt a projekthez, és cserélje le a <path-to> kód helyőrzőjére, hogy a program hol találja meg.

  2. Cserélje le a helyőrzőt <your-instance-hostname> az Azure Digital Twins-példány gazdagépnevére.

  3. Adjon hozzá két függőséget a projekthez, amelyek az Azure Digital Twins használatához szükségesek. Az első a .NET-hez készült Azure Digital Twins SDK csomagja, a második pedig az Azure-beli hitelesítést segítő eszközöket biztosít.

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

Ha közvetlenül szeretné futtatni a mintát, helyi hitelesítő adatokat is be kell állítania. A következő szakasz végigvezeti ezt a szakaszon.

Helyi Azure-hitelesítő adatok beállítása

Ez a minta a DefaultAzureCredential (a tár része) használatával hitelesíti a Azure.Identity felhasználókat az Azure Digital Twins-példánysal, amikor a helyi gépen futtatja. Az ügyfélalkalmazások Azure Digital Twins-hitelesítésének különböző módjairól az alkalmazáshitelesítési kód írása című témakörben olvashat bővebben.

Ezzel DefaultAzureCredentiala példával a minta hitelesítő adatokat keres a helyi környezetben, például egy Azure-bejelentkezést egy helyi Azure CLI-ben vagy a Visual Studióban vagy a Visual Studio Code-ban. Ezért helyileg kell bejelentkeznie az Azure-ba ezen mechanizmusok egyikével a minta hitelesítő adatainak beállításához.

Ha a Visual Studio vagy a Visual Studio Code használatával futtat kódmintákat, győződjön meg arról , hogy ugyanazokkal az Azure-hitelesítő adatokkal jelentkezett be a szerkesztőbe , amelyeket az Azure Digital Twins-példány eléréséhez használni szeretne. Ha helyi CLI-ablakot használ, futtassa a parancsot az az login Azure-fiókba való bejelentkezéshez. Ezt követően a kódminta futtatásakor automatikusan hitelesíteni kell.

Minta futtatása

Most, hogy a telepítés befejeződött, futtathatja a mintakódprojektet.

A fenti program konzolkimenete:

Screenshot of the console output showing that the twin is created, updated, and deleted.

További lépések

Megtudhatja, hogyan hozhat létre és kezelhet kapcsolatokat a digitális ikerpéldányok között: