async public void GetModels(DigitalTwinsClient client) { // ------------------ GET MODELS --------------------- // <GetModels> // 'client' is a valid DigitalTwinsClient object // Get a single model, metadata and data Response <DigitalTwinsModelData> md1 = await client.GetModelAsync("<model-Id>"); DigitalTwinsModelData model1 = md1.Value; // Get a list of the metadata of all available models; print their IDs AsyncPageable <DigitalTwinsModelData> md2 = client.GetModelsAsync(); await foreach (DigitalTwinsModelData md in md2) { Console.WriteLine($"Type ID: {md.Id}"); } // Get models and metadata for a model ID, including all dependencies (models that it inherits from, components it references) AsyncPageable <DigitalTwinsModelData> md3 = client.GetModelsAsync(new GetModelsOptions { IncludeModelDefinition = true }); // </GetModels> }
/// <summary> /// Gets all the models within the ADT service instance. /// </summary> public async Task GetAllModelsAsync() { PrintHeader("LISTING MODELS"); try { // Get all the twin types #region Snippet:DigitalTwinsSampleGetModels AsyncPageable <DigitalTwinsModelData> allModels = client.GetModelsAsync(); await foreach (DigitalTwinsModelData model in allModels) { Console.WriteLine($"Retrieved model '{model.Id}', " + $"display name '{model.DisplayName["en"]}', " + $"uploaded on '{model.UploadedOn}', " + $"and decommissioned '{model.Decommissioned}'"); } #endregion Snippet:DigitalTwinsSampleGetModels } catch (RequestFailedException ex) { FatalError($"Failed to get all the models due to:\n{ex}"); } }
static async Task Main(string[] args) { DigitalTwinsClient client; try { var credential = new InteractiveBrowserCredential(tenantId, clientId); // Open a browser window and allow user to select which account to authenticate with // If you omit this, the browser will only be launched to authenticate the user once, // then will silently acquire access tokens through the users refresh token as long as it's valid. // So if you are switching between AAD accounts, keep this uncommented. var auth_result = credential.Authenticate(); Console.WriteLine($"Sucessfully authenticated as: {auth_result.Username}"); client = new DigitalTwinsClient(new Uri(adtInstanceUrl), credential); AsyncPageable <ModelData> modelList = client.GetModelsAsync(null, true); await foreach (ModelData md in modelList) { Console.WriteLine($"Id: {md.Id}"); } Console.WriteLine("Done"); } catch (Exception e) { Console.WriteLine($"Authentication or client creation error: {e.Message}"); Environment.Exit(0); } }
static async Task Main(string[] args) { DigitalTwinsClient client; try { var credential = new ClientSecretCredential(tenantId, clientId, secret); client = new DigitalTwinsClient(new Uri(adtInstanceUrl), credential); AsyncPageable <ModelData> modelList = client.GetModelsAsync(null, true); await foreach (ModelData md in modelList) { Console.WriteLine($"Id: {md.Id}"); } Console.WriteLine("Done"); } catch (Exception e) { Console.WriteLine($"Authentication or client creation error: {e.Message}"); Environment.Exit(0); } }
static async Task Main(string[] args) { Console.WriteLine("Hello World!"); //string clientId = "5c694aad-e4ed-43a3-95cc-3d45af6685e5"; //string tenantId = "72f988bf-86f1-41af-91ab-2d7cd011db47"; string adtInstanceUrl = "https://digital-twin-demo-jc.api.wcus.digitaltwins.azure.net"; var credOpts = new DefaultAzureCredentialOptions() { ExcludeSharedTokenCacheCredential = true, ExcludeVisualStudioCodeCredential = true }; var cred = new DefaultAzureCredential(credOpts); DigitalTwinsClient client = new DigitalTwinsClient(new Uri(adtInstanceUrl), cred); //var credentials = new InteractiveBrowserCredential(tenantId, clientId); // DigitalTwinsClient client = new DigitalTwinsClient(new Uri(adtInstanceUrl), credentials); Console.WriteLine($"Service client created – ready to go"); Console.WriteLine(); Console.WriteLine($"Upload a model"); var typeList = new List <string>(); string dtdl = File.ReadAllText("SampleModel.json"); typeList.Add(dtdl); // Upload the model to the service await client.CreateModelsAsync(typeList); // Read a list of models back from the service AsyncPageable <ModelData> modelDataList = client.GetModelsAsync(); await foreach (ModelData md in modelDataList) { Console.WriteLine($"Type name: {md.DisplayName}: {md.Id}"); } }
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); 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 async Task Models_Lifecycle() { DigitalTwinsClient client = GetClient(); string buildingModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.BuildingModelId).ConfigureAwait(false); string floorModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.FloorModelId).ConfigureAwait(false); string hvacModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.HvacModelId).ConfigureAwait(false); string wardModelId = await GetUniqueModelIdAsync(client, TestAssetDefaults.WardModelId).ConfigureAwait(false); try { string modelBuilding = TestAssetsHelper.GetBuildingModelPayload(buildingModelId, hvacModelId, floorModelId); string modelHvac = TestAssetsHelper.GetHvacModelPayload(hvacModelId, floorModelId); string modelWard = TestAssetsHelper.GetWardModelPayload(wardModelId); // CREATE models var modelsList = new List <string> { modelBuilding, modelHvac, modelWard }; await CreateAndListModelsAsync(client, modelsList).ConfigureAwait(false); // GET one created model Response <DigitalTwinsModelData> buildingModel = await client.GetModelAsync(buildingModelId).ConfigureAwait(false); Console.WriteLine($"Got {buildingModelId} as {buildingModel.Value.DtdlModel}"); // LIST all models AsyncPageable <DigitalTwinsModelData> models = client.GetModelsAsync(); await foreach (DigitalTwinsModelData model in models) { Console.WriteLine($"{model.Id}"); } // DECOMMISSION a model await client.DecommissionModelAsync(buildingModelId).ConfigureAwait(false); } catch (Exception ex) { Assert.Fail($"Failure in executing a step in the test case: {ex.Message}."); } finally { // Test DELETE all models. try { await client.DeleteModelAsync(buildingModelId).ConfigureAwait(false); await client.DeleteModelAsync(hvacModelId).ConfigureAwait(false); await client.DeleteModelAsync(wardModelId).ConfigureAwait(false); } catch (Exception ex) { Assert.Fail($"Test clean up failed: {ex.Message}"); } } }
// This method is used as a helper method to accommodate for the lag on the service side between creating a new // model and creating a digital twin that implements this model. The work around is to list the model(s) after // creating them in order to accommodate for that lag. Once service side investigates and comes up with a solution, // there is no need to list the models after creating them. protected async Task CreateAndListModelsAsync(DigitalTwinsClient client, List <string> lists) { await client.CreateModelsAsync(lists).ConfigureAwait(false); // list the models AsyncPageable <DigitalTwinsModelData> models = client.GetModelsAsync(); await foreach (DigitalTwinsModelData model in models) { Console.WriteLine($"{model.Id}"); } }
public override async Task GlobalCleanupAsync() { // Global cleanup code that runs once at the end of test execution. await base.GlobalCleanupAsync(); // List all the models and delete all of them. AsyncPageable <DigitalTwinsModelData> allModels = _digitalTwinsClient.GetModelsAsync(); await foreach (DigitalTwinsModelData model in allModels) { await _digitalTwinsClient.DeleteModelAsync(model.Id).ConfigureAwait(false); } }
public static async Task ListModels(DigitalTwinsClient client) { string[] dependenciesFor = null; try { AsyncPageable <ModelData> results = client.GetModelsAsync(dependenciesFor, false); await foreach (ModelData md in results) { Console.WriteLine(md.Id); } } catch (RequestFailedException e) { Console.WriteLine($"Response {e.Status}: {e.Message}"); } catch (Exception ex) { Console.WriteLine($"Error: {ex.Message}"); } }
/// <summary> /// Gets all the models within the ADT service instance. /// </summary> public async Task GetAllModelsAsync() { PrintHeader("LISTING MODELS"); try { // Get all the twin types #region Snippet:DigitalTwinsSampleGetModels AsyncPageable <ModelData> allModels = client.GetModelsAsync(); await foreach (ModelData model in allModels) { Console.WriteLine($"Model Id: {model.Id}, display name: {model.DisplayName["en"]}, upload time: {model.UploadTime}, is decommissioned: {model.Decommissioned}"); } #endregion Snippet:DigitalTwinsSampleGetModels } catch (RequestFailedException ex) { FatalError($"Failed to get all the models due to:\n{ex}"); } }
public static async Task <IActionResult> Run( [HttpTrigger(AuthorizationLevel.Function, "get", Route = null)] HttpRequest req, ILogger log) { log.LogInformation("C# HTTP trigger function processed a request."); DigitalTwinsClient client; AsyncPageable <ModelData> modelList; try { ManagedIdentityCredential cred = new ManagedIdentityCredential(adtAppId); DigitalTwinsClientOptions opts = new DigitalTwinsClientOptions { Transport = new HttpClientTransport(httpClient) }; client = new DigitalTwinsClient(new Uri(adtInstanceUrl), cred, opts); modelList = client.GetModelsAsync(null, true); await foreach (ModelData md in modelList) { log.LogInformation($"Id: {md.Id}"); } log.LogInformation("Done"); } catch (Exception e) { log.LogCritical($"Authentication or client creation error: {e.Message}"); return(new BadRequestObjectResult(e.Message)); } return(new OkObjectResult(modelList)); }
/// <summary> /// Create a temporary component model, twin model and digital twin instance. /// Publish a telemetry message and a component telemetry message to the digital twin instance. /// </summary> public async Task RunSamplesAsync(DigitalTwinsClient client) { PrintHeader("PUBLISH TELEMETRY MESSAGE SAMPLE"); // For the purpose of this example we will create temporary models using a random model Ids. // We will also create temporary twin instances to publish the telemetry to. string componentModelId = await GetUniqueModelIdAsync(SamplesConstants.TemporaryComponentModelPrefix, client); string modelId = await GetUniqueModelIdAsync(SamplesConstants.TemporaryModelPrefix, client); string twinId = await GetUniqueTwinIdAsync(SamplesConstants.TemporaryTwinPrefix, client); string newComponentModelPayload = SamplesConstants.TemporaryComponentModelPayload .Replace(SamplesConstants.ComponentId, componentModelId); string newModelPayload = SamplesConstants.TemporaryModelWithComponentPayload .Replace(SamplesConstants.ModelId, modelId) .Replace(SamplesConstants.ComponentId, componentModelId); // Then we create the models. await client .CreateModelsAsync(new[] { newComponentModelPayload, newModelPayload }); // Get the models we just created AsyncPageable <DigitalTwinsModelData> models = client.GetModelsAsync(); await foreach (DigitalTwinsModelData model in models) { Console.WriteLine($"Successfully created model '{model.Id}'"); } // Create digital twin with Component payload. string twinPayload = SamplesConstants.TemporaryTwinPayload .Replace(SamplesConstants.ModelId, modelId); BasicDigitalTwin basicDigitalTwin = JsonSerializer.Deserialize <BasicDigitalTwin>(twinPayload); Response <BasicDigitalTwin> createDigitalTwinResponse = await client.CreateOrReplaceDigitalTwinAsync <BasicDigitalTwin>(twinId, basicDigitalTwin); Console.WriteLine($"Created digital twin '{createDigitalTwinResponse.Value.Id}'."); try { #region Snippet:DigitalTwinsSamplePublishTelemetry // construct your json telemetry payload by hand. await client.PublishTelemetryAsync(twinId, Guid.NewGuid().ToString(), "{\"Telemetry1\": 5}"); Console.WriteLine($"Published telemetry message to twin '{twinId}'."); #endregion Snippet:DigitalTwinsSamplePublishTelemetry #region Snippet:DigitalTwinsSamplePublishComponentTelemetry // construct your json telemetry payload by serializing a dictionary. var telemetryPayload = new Dictionary <string, int> { { "ComponentTelemetry1", 9 } }; await client.PublishComponentTelemetryAsync( twinId, "Component1", Guid.NewGuid().ToString(), JsonSerializer.Serialize(telemetryPayload)); Console.WriteLine($"Published component telemetry message to twin '{twinId}'."); #endregion Snippet:DigitalTwinsSamplePublishComponentTelemetry } catch (Exception ex) { FatalError($"Failed to publish a telemetry message due to: {ex.Message}"); } try { // Delete the twin. await client.DeleteDigitalTwinAsync(twinId); // Delete the models. await client.DeleteModelAsync(modelId); await client.DeleteModelAsync(componentModelId); } catch (RequestFailedException ex) when(ex.Status == (int)HttpStatusCode.NotFound) { // Digital twin or models do not exist. } catch (RequestFailedException ex) { FatalError($"Failed to delete due to: {ex.Message}"); } }
/// <summary> /// Creates a digital twin with Component and upates Component /// </summary> public async Task RunSamplesAsync(DigitalTwinsClient client) { PrintHeader("COMPONENT SAMPLE"); // For the purpose of this example we will create temporary models using a random model Ids. // We have to make sure these model Ids are unique within the DT instance. string componentModelId = await GetUniqueModelIdAsync(SamplesConstants.TemporaryComponentModelPrefix, client); string modelId = await GetUniqueModelIdAsync(SamplesConstants.TemporaryModelPrefix, client); string basicDtId = await GetUniqueTwinIdAsync(SamplesConstants.TemporaryTwinPrefix, client); string newComponentModelPayload = SamplesConstants.TemporaryComponentModelPayload .Replace(SamplesConstants.ComponentId, componentModelId); string newModelPayload = SamplesConstants.TemporaryModelWithComponentPayload .Replace(SamplesConstants.ModelId, modelId) .Replace(SamplesConstants.ComponentId, componentModelId); // Then we create models await client.CreateModelsAsync( new[] { newComponentModelPayload, newModelPayload }); // Get the models we just created AsyncPageable <DigitalTwinsModelData> models = client.GetModelsAsync(); await foreach (DigitalTwinsModelData model in models) { Console.WriteLine($"Created model {model.Id}."); } #region Snippet:DigitalTwinsSampleCreateBasicTwin // Create digital twin with component payload using the BasicDigitalTwin serialization helper var basicTwin = new BasicDigitalTwin { Id = basicDtId, // model Id of digital twin Metadata = { ModelId = modelId }, Contents = { // digital twin properties { "Prop1", "Value1" }, { "Prop2", 987 }, // component { "Component1", new BasicDigitalTwinComponent { // component properties Contents = { { "ComponentProp1", "Component value 1" }, { "ComponentProp2", 123 }, }, } }, }, }; Response <BasicDigitalTwin> createDigitalTwinResponse = await client.CreateOrReplaceDigitalTwinAsync(basicDtId, basicTwin); Console.WriteLine($"Created digital twin '{createDigitalTwinResponse.Value.Id}'."); #endregion Snippet:DigitalTwinsSampleCreateBasicTwin // You can also get a digital twin as a BasicDigitalTwin type. // It works well for basic stuff, but as you can see it gets more difficult when delving into // more complex properties, like components. #region Snippet:DigitalTwinsSampleGetBasicDigitalTwin Response <BasicDigitalTwin> getBasicDtResponse = await client.GetDigitalTwinAsync <BasicDigitalTwin>(basicDtId); BasicDigitalTwin basicDt = getBasicDtResponse.Value; // Must cast Component1 as a JsonElement and get its raw text in order to deserialize it as a dictionary string component1RawText = ((JsonElement)basicDt.Contents["Component1"]).GetRawText(); var component1 = JsonSerializer.Deserialize <BasicDigitalTwinComponent>(component1RawText); Console.WriteLine($"Retrieved and deserialized digital twin {basicDt.Id}:\n\t" + $"ETag: {basicDt.ETag}\n\t" + $"ModelId: {basicDt.Metadata.ModelId}\n\t" + $"Prop1: {basicDt.Contents["Prop1"]} and last updated on {basicDt.Metadata.PropertyMetadata["Prop1"].LastUpdatedOn}\n\t" + $"Prop2: {basicDt.Contents["Prop2"]} and last updated on {basicDt.Metadata.PropertyMetadata["Prop2"].LastUpdatedOn}\n\t" + $"Component1.Prop1: {component1.Contents["ComponentProp1"]} and last updated on: {component1.Metadata["ComponentProp1"].LastUpdatedOn}\n\t" + $"Component1.Prop2: {component1.Contents["ComponentProp2"]} and last updated on: {component1.Metadata["ComponentProp2"].LastUpdatedOn}"); #endregion Snippet:DigitalTwinsSampleGetBasicDigitalTwin string customDtId = await GetUniqueTwinIdAsync(SamplesConstants.TemporaryTwinPrefix, client); // Alternatively, you can create your own custom data types to serialize and deserialize your digital twins. // By specifying your properties and types directly, it requires less code or knowledge of the type for // interaction. #region Snippet:DigitalTwinsSampleCreateCustomTwin var customTwin = new CustomDigitalTwin { Id = customDtId, Metadata = { ModelId = modelId }, Prop1 = "Prop1 val", Prop2 = 987, Component1 = new MyCustomComponent { ComponentProp1 = "Component prop1 val", ComponentProp2 = 123, }, }; Response <CustomDigitalTwin> createCustomDigitalTwinResponse = await client.CreateOrReplaceDigitalTwinAsync(customDtId, customTwin); Console.WriteLine($"Created digital twin '{createCustomDigitalTwinResponse.Value.Id}'."); #endregion Snippet:DigitalTwinsSampleCreateCustomTwin // Getting a digital twin as a custom data type is extremely easy. // Custom types provide the best possible experience. #region Snippet:DigitalTwinsSampleGetCustomDigitalTwin Response <CustomDigitalTwin> getCustomDtResponse = await client.GetDigitalTwinAsync <CustomDigitalTwin>(customDtId); CustomDigitalTwin customDt = getCustomDtResponse.Value; Console.WriteLine($"Retrieved and deserialized digital twin {customDt.Id}:\n\t" + $"ETag: {customDt.ETag}\n\t" + $"ModelId: {customDt.Metadata.ModelId}\n\t" + $"Prop1: [{customDt.Prop1}] last updated on {customDt.Metadata.Prop1.LastUpdatedOn}\n\t" + $"Prop2: [{customDt.Prop2}] last updated on {customDt.Metadata.Prop2.LastUpdatedOn}\n\t" + $"ComponentProp1: [{customDt.Component1.ComponentProp1}] last updated {customDt.Component1.Metadata.ComponentProp1.LastUpdatedOn}\n\t" + $"ComponentProp2: [{customDt.Component1.ComponentProp2}] last updated {customDt.Component1.Metadata.ComponentProp2.LastUpdatedOn}"); #endregion Snippet:DigitalTwinsSampleGetCustomDigitalTwin #region Snippet:DigitalTwinsSampleUpdateComponent // Update Component1 by replacing the property ComponentProp1 value, // using an optional utility to build the payload. var componentJsonPatchDocument = new JsonPatchDocument(); componentJsonPatchDocument.AppendReplace("/ComponentProp1", "Some new value"); await client.UpdateComponentAsync(basicDtId, "Component1", componentJsonPatchDocument); Console.WriteLine($"Updated component for digital twin '{basicDtId}'."); #endregion Snippet:DigitalTwinsSampleUpdateComponent // Get Component #region Snippet:DigitalTwinsSampleGetComponent await client.GetComponentAsync <MyCustomComponent>(basicDtId, SamplesConstants.ComponentName); Console.WriteLine($"Retrieved component for digital twin '{basicDtId}'."); #endregion Snippet:DigitalTwinsSampleGetComponent // Clean up try { await client.DeleteDigitalTwinAsync(basicDtId); await client.DeleteDigitalTwinAsync(customDtId); } catch (RequestFailedException ex) { Console.WriteLine($"Failed to delete digital twin due to {ex}"); } try { await client.DeleteModelAsync(modelId); await client.DeleteModelAsync(componentModelId); } catch (RequestFailedException ex) { Console.WriteLine($"Failed to delete models due to {ex}"); } }
// <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> }
static async Task Main(string[] args) { Console.WriteLine("Hello World!"); string clientId = "<clientId>"; string tenantId = "<tenatId>"; string adtInstanceUrl = "https://yourinstance"; var credentials = new InteractiveBrowserCredential(tenantId, clientId); DigitalTwinsClient client = new DigitalTwinsClient(new Uri(adtInstanceUrl), credentials); Console.WriteLine($"Service client created – ready to go"); Console.WriteLine(); Console.WriteLine($"Upload a model"); var typeList = new List <string>(); string dtdl = File.ReadAllText("Models/SampleModel.json"); typeList.Add(dtdl); // Upload the model to the service try { await client.CreateModelsAsync(typeList); } catch (RequestFailedException rex) { Console.WriteLine($"Load model: {rex.Status}:{rex.Message}"); } // Read a list of models back from the service AsyncPageable <ModelData> modelDataList = client.GetModelsAsync(); await foreach (ModelData md in modelDataList) { Console.WriteLine($"Type name: {md.DisplayName}: {md.Id}"); } // Initialize twin data BasicDigitalTwin twinData = new BasicDigitalTwin(); twinData.Metadata.ModelId = "dtmi:com:contoso:SampleModel;1"; twinData.CustomProperties.Add("data", $"Hello World!"); string prefix = "sampleTwin-"; for (int i = 0; i < 3; i++) { try { twinData.Id = $"{prefix}{i}"; await client.CreateDigitalTwinAsync($"{prefix}{i}", JsonSerializer.Serialize(twinData)); Console.WriteLine($"Created twin: {prefix}{i}"); } catch (RequestFailedException rex) { Console.WriteLine($"Create twin error: {rex.Status}:{rex.Message}"); } } // Connect the twins with relationships await CreateRelationship(client, "sampleTwin-0", "sampleTwin-1"); await CreateRelationship(client, "sampleTwin-0", "sampleTwin-2"); //List the relationships await ListRelationships(client, "sampleTwin-0"); // Run a query AsyncPageable <string> result = client.QueryAsync("Select * From DigitalTwins"); await foreach (string twin in result) { object jsonObj = JsonSerializer.Deserialize <object>(twin); string prettyTwin = JsonSerializer.Serialize(jsonObj, new JsonSerializerOptions { WriteIndented = true }); Console.WriteLine(prettyTwin); Console.WriteLine("---------------"); } }