Hinweis
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, sich anzumelden oder das Verzeichnis zu wechseln.
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, das Verzeichnis zu wechseln.
In diesem Artikel wird beschrieben, wie Sie Azure Digital Twins-Modelle mithilfe der .NET-Parserbibliothek analysieren und validieren.
Modelle in Azure Digital Twins werden mithilfe der JSON-LD-basierten Digital Twins Definition Sprache (DTDL) definiert.
Nach dem Erstellen eines Modells wird empfohlen, Ihre Modelle offline zu überprüfen, bevor Sie sie in Ihre Azure Digital Twins-Instanz hochladen.
Um Ihre Modelle zu überprüfen, wird eine clientseitige DTDL-Analysebibliothek für .NET auf NuGet: DTDLParser bereitgestellt. Sie können die Parserbibliothek direkt in Ihrem C#-Code verwenden. Sie können auch die Beispielverwendung des Parsers im DTDLParserResolveSample in GitHub anzeigen.
Informationen zur .NET-Parserbibliothek
Die DTDLParser-Bibliothek bietet Modellzugriff auf die DTDL-Definitionen, die im Wesentlichen als Äquivalent der C#-Spiegelung für DTDL fungieren. Diese Bibliothek kann unabhängig von jedem Azure Digital Twins SDK verwendet werden, insbesondere für die DTDL-Validierung in einem visuellen oder Text-Editor. Es ist nützlich, sicherzustellen, dass Ihre Modelldefinitionsdateien gültig sind, bevor Sie versuchen, sie in den Dienst hochzuladen.
Um die Parserbibliothek zu verwenden, stellen Sie sie mit einer Reihe von DTDL-Dokumenten bereit. In der Regel würden Sie diese Modelldokumente aus dem Dienst abrufen, aber möglicherweise auch lokal verfügbar sein, wenn Ihr Client dafür verantwortlich war, sie zuerst in den Dienst hochzuladen.
Hier ist der allgemeine Workflow für die Verwendung des Parsers:
- Rufen Sie einige oder alle DTDL-Dokumente aus dem Dienst ab.
- Übergeben Sie die zurückgegebenen DTDL-Dokumente im Arbeitsspeicher an den Parser.
- Der Parser überprüft die Gruppe der an ihn übergebenen Dokumente und gibt detaillierte Fehlerinformationen zurück. Diese Fähigkeit ist in Editorszenarien nützlich.
- Verwenden Sie die Parser-APIs, um die in der Dokumentenmappe enthaltenen Modelle weiter zu analysieren.
Zu den Funktionen des Parsers gehören:
- Rufen Sie alle implementierten Modellschnittstellen ab (den Inhalt des Abschnitts
extendsder Schnittstelle). - Rufen Sie alle Eigenschaften, Telemetrie, Befehle, Komponenten und Beziehungen ab, die im Modell deklariert sind. Dieser Befehl ruft auch alle Metadaten ab, die in diesen Definitionen enthalten sind, und berücksichtigt vererbung (
extendsAbschnitte). - Rufen Sie alle komplexen Modelldefinitionen ab.
- Bestimmen Sie, ob ein Modell aus einem anderen Modell zugewiesen werden kann.
Hinweis
IoT Plug and Play-Geräte verwenden eine kleine Syntaxvariante, um ihre Funktionalität zu beschreiben. Diese Syntaxvariante ist eine semantisch kompatible Teilmenge der DTDL, die in Azure Digital Twins verwendet wird. Bei Verwendung der Parserbibliothek müssen Sie nicht wissen, welche Syntaxvariante zum Erstellen der DTDL für Ihren digitalen Zwilling verwendet wurde. Der Parser gibt standardmäßig das gleiche Modell für ioT Plug- und Play- und Azure Digital Twins-Syntax zurück.
Codieren mit der Parserbibliothek
Sie können die Parserbibliothek direkt verwenden, z. B. zum Überprüfen von Modellen in Ihrer eigenen Anwendung oder zum Generieren dynamischer, modellgesteuerter UI, Dashboards und Berichte.
Um das folgende Parsercodebeispiel zu unterstützen, sollten Sie mehrere Modelle in einer Azure Digital Twins-Instanz definieren:
[
{
"@context": "dtmi:dtdl:context;3",
"@id": "dtmi:com:contoso:coffeeMaker;1",
"@type": "Interface",
"contents": [
{
"@type": "Component",
"name": "coffeeMaker",
"schema": "dtmi:com:contoso:coffeeMakerInterface;1"
}
]
},
{
"@context": "dtmi:dtdl:context;3",
"@id": "dtmi:com:contoso:coffeeMakerInterface;1",
"@type": "Interface",
"contents": [
{
"@type": "Property",
"name": "waterTemp",
"schema": "double"
}
]
},
{
"@context": "dtmi:dtdl:context;3",
"@id": "dtmi:com:contoso:coffeeBar;1",
"@type": "Interface",
"contents": [
{
"@type": "Relationship",
"name": "foo",
"target": "dtmi:com:contoso:coffeeMaker;1"
},
{
"@type": "Property",
"name": "capacity",
"schema": "integer"
}
]
}
]
Der folgende Code zeigt ein Beispiel für die Verwendung der Parserbibliothek, um diese Definitionen in C# widerzuspiegeln:
using Azure;
using Azure.DigitalTwins.Core;
using DTDLParser;
using DTDLParser.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DigitalTwins_Samples
{
public static class ListExtensions
{
public static async IAsyncEnumerable<T> AsAsyncEnumerable<T>(this IEnumerable<T> input)
{
foreach (var value in input)
{
yield return value;
}
await Task.Yield();
}
}
public class ParseModelsSample
{
public async Task ParseDemoAsync(DigitalTwinsClient client)
{
try
{
AsyncPageable<DigitalTwinsModelData> mdata = client.GetModelsAsync(new GetModelsOptions { IncludeModelDefinition = true });
var models = new List<string>();
await foreach (DigitalTwinsModelData md in mdata)
models.Add(md.DtdlModel);
var parser = new ModelParser();
IReadOnlyDictionary<Dtmi, DTEntityInfo> dtdlOM = await parser.ParseAsync(models.AsAsyncEnumerable());
var interfaces = new List<DTInterfaceInfo>();
IEnumerable<DTInterfaceInfo> ifenum =
from entity in dtdlOM.Values
where entity.EntityKind == DTEntityKind.Interface
select entity as DTInterfaceInfo;
interfaces.AddRange(ifenum);
foreach (DTInterfaceInfo dtif in interfaces)
{
PrintInterfaceContent(dtif, dtdlOM);
}
}
catch (RequestFailedException ex)
{
Console.WriteLine($"Failed due to {ex}");
throw;
}
}
public void PrintInterfaceContent(DTInterfaceInfo dtif, IReadOnlyDictionary<Dtmi, DTEntityInfo> dtdlOM, int indent = 0)
{
var sb = new StringBuilder();
for (int i = 0; i < indent; i++) sb.Append(" ");
Console.WriteLine($"{sb}Interface: {dtif.Id} | {dtif.DisplayName}");
IReadOnlyDictionary<string, DTContentInfo> contents = dtif.Contents;
foreach (DTContentInfo item in contents.Values)
{
switch (item.EntityKind)
{
case DTEntityKind.Property:
DTPropertyInfo pi = item as DTPropertyInfo;
Console.WriteLine($"{sb}--Property: {pi.Name} with schema {pi.Schema}");
break;
case DTEntityKind.Relationship:
DTRelationshipInfo ri = item as DTRelationshipInfo;
Console.WriteLine($"{sb}--Relationship: {ri.Name} with target {ri.Target}");
break;
case DTEntityKind.Telemetry:
DTTelemetryInfo ti = item as DTTelemetryInfo;
Console.WriteLine($"{sb}--Telemetry: {ti.Name} with schema {ti.Schema}");
break;
case DTEntityKind.Component:
DTComponentInfo ci = item as DTComponentInfo;
Console.WriteLine($"{sb}--Component: {ci.Id} | {ci.Name}");
DTInterfaceInfo component = ci.Schema;
PrintInterfaceContent(component, dtdlOM, indent + 1);
break;
}
}
}
}
}
Nächste Schritte
Nachdem Sie ihre Modelle geschrieben haben, erfahren Sie, wie Sie diese (und andere Verwaltungsvorgänge) mit den Azure Digital Twins Models-APIs hochladen: