/// <summary>
/// Using Iothub owner?
///
/// Also add tags to device and query back
/// </summary>
/// <returns></returns>
public static async Task AddTagsAndQuery()
{
var twin = await registryManager.GetTwinAsync("bszuwp");
var patch =
@"{
tags: {
location: {
region: 'US',
plant: 'Redmond43'
}
}
}";
await registryManager.UpdateTwinAsync(twin.DeviceId, patch, twin.ETag);
var query = registryManager.CreateQuery(
"SELECT * FROM devices WHERE tags.location.plant = 'Redmond43'", 100);
var twinsInRedmond43 = await query.GetNextAsTwinAsync();
Console.WriteLine("Devices in Redmond43: {0}",
string.Join(", ", twinsInRedmond43.Select(t => t.DeviceId)));
query = registryManager.CreateQuery("SELECT * FROM devices WHERE tags.location.plant = 'Redmond43' AND properties.reported.connectivity.type = 'cellular'", 100);
var twinsInRedmond43UsingCellular = await query.GetNextAsTwinAsync();
Console.WriteLine("Devices in Redmond43 using cellular network: {0}",
string.Join(", ", twinsInRedmond43UsingCellular.Select(t => t.DeviceId)));
}
public static async Task AddTagsAndQuery()
{
var patch =
@"{
tags: {
location: {
region: 'US',
plant: 'Madison43'
},
settings: {
RollerFreq: 44,
PresserFreq: 22,
},
}
}";
var twin = await registryManager.GetTwinAsync(deviceId);
await registryManager.UpdateTwinAsync(twin.DeviceId, patch, twin.ETag);
var query = registryManager.CreateQuery("SELECT * FROM devices WHERE tags.location.plant = 'Madison43'", 100);
var twinsInRedmond43 = await query.GetNextAsTwinAsync();
System.Diagnostics.Debug.WriteLine("Devices in Madison43: {0}", string.Join(", ", twinsInRedmond43.Select(t => t.DeviceId)));
query = registryManager.CreateQuery("SELECT * FROM devices WHERE tags.location.plant = 'Madison43' AND properties.reported.connectivity.type = 'cellular'", 100);
var twinsInRedmond43UsingCellular = await query.GetNextAsTwinAsync();
System.Diagnostics.Debug.WriteLine("Devices in Madison43 using cellular network: {0}", string.Join(", ", twinsInRedmond43UsingCellular.Select(t => t.DeviceId)));
}
public static async Task AddTagsAndQuery()
{
var twin = await registryManager.GetTwinAsync(deviceId);
var patch =
@"{
tags: {
location: {
region: 'EU',
lon: '52.3054724',
lat: '4.7533562'
},
allocation:{fleet: 'AgriAutomotive_F12',
fleetId: 'F12C345'}
}
}";
await registryManager.UpdateTwinAsync(twin.DeviceId, patch, twin.ETag);
var query = registryManager.CreateQuery("SELECT * FROM devices WHERE tags.allocation.fleetId = 'F12C345q'", 100);
var twinsInFleet = await query.GetNextAsTwinAsync();
Console.WriteLine("Devices in F12C345: {0}", string.Join(", ", twinsInFleet.Select(t => t.DeviceId)));
query = registryManager.CreateQuery("SELECT * FROM devices WHERE tags.allocation.fleetId = 'F12C345q' AND properties.reported.connectivity.type = 'cellular'", 100);
var twinsInFleetUsingCellular = await query.GetNextAsTwinAsync();
Console.WriteLine("Vehicles in EU using cellular network: {0}", string.Join(", ", twinsInFleetUsingCellular.Select(t => t.DeviceId)));
query = registryManager.CreateQuery("SELECT * FROM devices WHERE tags.location.lon < 53 AND tags.location.lat < 5", 100);
var twinsInNearFogZone = await query.GetNextAsTwinAsync();
Console.WriteLine("Vehicles in fog zone: {0}", string.Join(", ", twinsInFleetUsingCellular.Select(t => t.DeviceId)));
}
public static async Task AddTagsAndQuery()
{
var twin = await registryManager.GetTwinAsync("AndroidThingsDevice1");
var patch =
@"{
tags: {
location: {
region: 'Jakarta',
position: 'Kalibata'
}
}
}";
await registryManager.UpdateTwinAsync(twin.DeviceId, patch, twin.ETag);
var query = registryManager.CreateQuery("SELECT * FROM devices WHERE tags.location.position = 'Kalibata'", 100);
var twinsInJakarta = await query.GetNextAsTwinAsync();
Console.WriteLine("Devices in Jakarta: {0}", string.Join(", ", twinsInJakarta.Select(t => t.DeviceId)));
query = registryManager.CreateQuery("SELECT * FROM devices WHERE tags.location.position = 'Kalibata' AND properties.reported.connectivity.type = 'wifi'", 100);
var twinsUsingWifi = await query.GetNextAsTwinAsync();
Console.WriteLine("Devices in Jakarta using wifi network: {0}", string.Join(", ", twinsUsingWifi.Select(t => t.DeviceId)));
}
/*Query Devices upto QueryPageSize*/
public async Task <IDictionary <string, Twin> > GetDevicesByTagFilter(string tagFilter)
{
IDictionary <string, Twin> devices = new Dictionary <string, Twin>();
try {
tagFilter = tagFilter ?? throw new ArgumentNullException(nameof(tagFilter));
//Query for the given devices
string query = $"select * From devices where {tagFilter}";
var queryResults = _registryManager.CreateQuery(query, QueryPageSize);
while (queryResults.HasMoreResults)
{
IEnumerable <Twin> twins = await queryResults.GetNextAsTwinAsync().ConfigureAwait(false);
foreach (Twin twin in twins)
{
devices.Add(twin.DeviceId, twin);
}
}
}
catch (Exception e)
{
Console.WriteLine($"{e}");
}
return(devices);
}
public static async Task AddTagsAndQuery()
{
var twin = await registryManager.GetTwinAsync(deviceId);
var patch =
@"{
tags: {
conference: {
name: 'DDDEastAnglia',
location: 'Cambridge'
}
}
}";
await registryManager.UpdateTwinAsync(twin.DeviceId, patch, twin.ETag);
var query = registryManager.CreateQuery(
"SELECT * FROM devices WHERE tags.conference.name = 'DDDEastAnglia'", 100);
var twinsInRedmond43 = await query.GetNextAsTwinAsync();
Console.WriteLine("Devices on DDDEastAnglia: {0}",
string.Join(", ", twinsInRedmond43.Select(t => t.DeviceId)));
query = registryManager.CreateQuery("SELECT * FROM devices WHERE tags.conference.name = 'DDDEastAnglia'" +
" AND properties.reported.personalInfo.mood = 'happy'", 100);
var twinsInRedmond43UsingCellular = await query.GetNextAsTwinAsync();
Console.WriteLine("Happy devices on DDDEastAnglia: {0}",
string.Join(", ", twinsInRedmond43UsingCellular.Select(t => t.DeviceId)));
}
private async Task <int> PrintDeviceCountAsync()
{
//{
// "numberOfDevices": 10456
//}
string queryResultText = null;
int deviceCount = 0;
try
{
string countSqlQuery = "select count() AS numberOfDevices from devices";
IQuery countQuery = _registryManager.CreateQuery(countSqlQuery);
IEnumerable <string> queryResult = await countQuery.GetNextAsJsonAsync();
queryResultText = queryResult.First();
var resultObject = JObject.Parse(queryResultText);
deviceCount = resultObject.Value <int>("numberOfDevices");
Console.WriteLine($"Total # of devices in the hub: \n{deviceCount}");
}
catch (Exception ex)
{
Console.WriteLine($"Failed to parse device count of {queryResultText} due to {ex}");
}
return(deviceCount);
}
private async void buttonConnect_Click(object sender, RoutedEventArgs e)
{
try
{
registryManager = RegistryManager.CreateFromConnectionString(tbCS.Text);
await registryManager.OpenAsync();
serviceClient = ServiceClient.CreateFromConnectionString(tbCS.Text);
await serviceClient.OpenAsync();
WriteLog("Connected.");
buttonConnect.IsEnabled = false;
buttonDisconnect.IsEnabled = true;
buttonDeviceSelect.IsEnabled = true;
registedDeviceNames.Clear();
//var devices = await registryManager.GetDevicesAsync(10);
var dq = registryManager.CreateQuery("SELECT * FROM devices");
while (dq.HasMoreResults)
{
var twins = await dq.GetNextAsTwinAsync();
foreach (var twin in twins)
{
registedDeviceNames.Add(twin.DeviceId);
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
public List <DeviceRegistry> ToList()
{
deviceRegistries.Clear();
int index = 0;
var deviceQuery = registryManager.CreateQuery("SELECT * FROM devices");
while (deviceQuery.HasMoreResults)
{
var twinsTask = deviceQuery.GetNextAsTwinAsync();
twinsTask.Wait();
foreach (var twin in twinsTask.Result)
{
var dr = new DeviceRegistry()
{
Id = index++,
DeviceId = twin.DeviceId,
ETags = twin.ETag,
DesiredProperties = twin.Properties.Desired.ToJson(),
ReportedProperties = twin.Properties.Reported.ToJson()
};
deviceRegistries.Add(dr);
}
}
return(deviceRegistries);
}
private static async Task SetTwinProperties()
{
var twin = await registryManager.GetTwinAsync("CheeseCaveID");
var patch =
@"{
tags: {
customerID: 'Customer1',
cellar: 'Cellar1'
},
properties: {
desired: {
patchId: 'set values',
temperature: '50',
humidity: '85'
}
}
}";
await registryManager.UpdateTwinAsync(twin.DeviceId, patch, twin.ETag);
var query = registryManager.CreateQuery(
"SELECT * FROM devices WHERE tags.cellar = 'Cellar1'", 100);
var twinsInCellar1 = await query.GetNextAsTwinAsync();
Console.WriteLine("Devices in Cellar1: {0}",
string.Join(", ", twinsInCellar1.Select(t => t.DeviceId)));
}
private async Task <IEnumerable <JToken> > GetDevicesAsJson(string query, int maxCount = 100)
{
if (string.IsNullOrEmpty(query))
{
throw new ArgumentNullException(nameof(query));
}
var iotQuery = _registryManager.CreateQuery(query, maxCount);
List <JToken> data = new List <JToken>();
IEnumerable <string> itemsToAdd = null;
while (iotQuery.HasMoreResults)
{
itemsToAdd = await iotQuery.GetNextAsJsonAsync();
if (itemsToAdd != null && itemsToAdd.Any())
{
data.AddRange(itemsToAdd.Select(i => JToken.Parse(i)));
itemsToAdd = null;
}
}
return(data);
}
private async Task <LoraKeys> GetKeysRegistryMode(string DevAddr)
{
//need to fix sql injection attack
var query = registryManager.CreateQuery($"SELECT * FROM devices WHERE tags.DevAddr = '{DevAddr}'", 1);
LoraKeys loraKeys = new LoraKeys();
loraKeys.DevAddr = DevAddr;
while (query.HasMoreResults)
{
var page = await query.GetNextAsTwinAsync();
foreach (var twin in page)
{
loraKeys.DeviceEUI = twin.DeviceId;
loraKeys.AppSKey = twin.Tags["AppSKey"].Value;
loraKeys.NwkSKey = twin.Tags["NwkSKey"].Value;
loraKeys.Accept = true;
}
}
return(loraKeys);
}
public static async Task <Object> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
ILogger log)
{
log.LogInformation("C# HTTP trigger function processed a request.");
try
{
var iotHubServiceConnectionString = Environment.GetEnvironmentVariable("iotHubServiceConnectionString");
registryManager = RegistryManager.CreateFromConnectionString(iotHubServiceConnectionString);
string devices = "";
var query = registryManager.CreateQuery("SELECT * FROM devices");
while (query.HasMoreResults)
{
var result = await query.GetNextAsTwinAsync();
List <DeviceInfo> deviceList = new List <DeviceInfo>();
foreach (var twin in result)
{
DeviceInfo deviceInfo = new DeviceInfo();
deviceInfo.DeviceId = twin.DeviceId;
deviceInfo.thresholdProps = twin.Properties.Desired;
deviceList.Add(deviceInfo);
}
devices = JsonConvert.SerializeObject(deviceList);
}
return((object)new OkObjectResult(devices));
}
catch (System.Exception e)
{
return((object)new ExceptionResult(e, true));
}
}
static public async Task QueryDevicesByCondition(RegistryManager client, string condition)
{
bool twinResult = new Regex(@"^SELECT\s+\*").Match(condition).Success;
var result = client.CreateQuery(condition);
while (result.HasMoreResults)
{
if (twinResult)
{
var twins = await result.GetNextAsTwinAsync();
foreach (var twin in twins)
{
var device = await client.GetDeviceAsync(twin.DeviceId);
OutputDevice(twin, device);
}
}
else
{
var rawStrings = await result.GetNextAsJsonAsync();
foreach (var json in rawStrings)
{
Console.WriteLine(json);
}
}
}
}
public async Task <IEnumerable <Vehicle> > getVehiclesAsync()
{
registryManager = RegistryManager.CreateFromConnectionString(connectionString);
var twin = await registryManager.GetTwinAsync("simulator_bus_4");
var list = new List <Vehicle>();
var patch =
@"{
tags: {
location: {
region: 'US',
plant: 'Redmond43'
}
}
}";
await registryManager.UpdateTwinAsync(twin.DeviceId, patch, twin.ETag);
var query = registryManager.CreateQuery(
"SELECT * FROM devices", 100);
var vehicles = await query.GetNextAsTwinAsync();
foreach (var vehical in vehicles)
{
Vehicle user = JsonConvert.DeserializeObject <Vehicle>(vehical.Properties.Reported.ToString());
list.Add(user);
}
return(list);
}
public async Task <IEnumerable <Twin> > GetDevices()
{
var queryDevices = _registryManager.CreateQuery("select * from devices", 100);
var twins = await queryDevices.GetNextAsTwinAsync();
return(twins);
}
/// <summary>
/// Updating Twins of all devices that selected by input query
/// </summary>
/// <param name="IotHubQuery">Iot Hub devices query</param>
/// <returns></returns>
public static async Task UpdateTwins(string blobUrl)
{
var query = registryManager.CreateQuery(iotHubQuery, 100);
List <Microsoft.Azure.Devices.Shared.Twin> twins = new List <Microsoft.Azure.Devices.Shared.Twin>();
List <Microsoft.Azure.Devices.Shared.Twin> batchtwins = new List <Microsoft.Azure.Devices.Shared.Twin>();
string changeDateTime = System.DateTime.UtcNow.ToString("o");
string patch = String.Format(@"{{'configurationBlob': {{
'uri': '{0}',
'ts': '{1}',
'contentType': 'json'
}}}}", blobUrl, changeDateTime);
TwinCollection collection = new TwinCollection();
while (query.HasMoreResults)
{
batchtwins = (await query.GetNextAsTwinAsync()).ToList();
foreach (var twin in batchtwins)
{
twin.Properties.Desired = new TwinCollection(patch);
twins.Add(twin);
}
}
await registryManager.UpdateTwins2Async(twins);
}
private static async Task QueryDevices(RegistryManager registryManager, string sqlQueryString)
{
try
{
ConsoleWriteLine();
ConsoleWriteLine($"Will execute query {sqlQueryString}...", ConsoleColor.Yellow);
var query = registryManager.CreateQuery(
sqlQueryString: sqlQueryString,
pageSize: 3);
var pageIndex = -1;
while (query.HasMoreResults && ++pageIndex < maximumQueryPageCount)
{
var deviceJsons = (await query.GetNextAsJsonAsync()).ToList();
ConsoleWriteLine();
ConsoleWriteLine($"Found {deviceJsons.Count} device(s) in page {pageIndex + 1}", ConsoleColor.Yellow);
for (var deviceIndex = 0; deviceIndex < deviceJsons.Count; deviceIndex++)
{
var deviceJson = deviceJsons[deviceIndex];
ConsoleWriteLine();
ConsoleWriteLine($"Device {deviceIndex + 1}/{deviceJsons.Count} of page {pageIndex + 1}:", ConsoleColor.Yellow);
ConsoleWriteLine(deviceJson, ConsoleColor.Yellow);
}
}
}
catch (Exception ex)
{
ConsoleWriteLine($"* ERROR * {ex.Message}", ConsoleColor.Red);
}
}
private static async System.Threading.Tasks.Task <List <Twin> > CheckDisconnection(List <Twin> disconnectedDevicesPrev)
{
registryManager = RegistryManager.CreateFromConnectionString(connectionString);
List <Twin> disconnectedDevices = new List <Twin> {
};
List <Twin> disconnectedDevicesOver15min = new List <Twin> {
};
var query = registryManager.CreateQuery("SELECT * FROM devices WHERE connectionState = 'Disconnected'");
while (query.HasMoreResults)
{
var page = await query.GetNextAsTwinAsync();
foreach (var twin in page)
{
disconnectedDevices.Add(twin);
if (disconnectedDevicesPrev.Exists((Twin obj) => obj.DeviceId == twin.DeviceId))
{
disconnectedDevicesOver15min.Add(twin);
}
}
}
Console.WriteLine("start printing devices disconnected over 15min");
foreach (Twin device in disconnectedDevicesOver15min)
{
Console.WriteLine(device.DeviceId);
}
return(disconnectedDevices);
}
private async Task EnumerateTwinsAsync(RegistryManager registryManager)
{
Console.WriteLine("\n=== Querying twins ===\n");
await Task.Delay(5000); // give a little time for the twin store to reflect all our recent additions
string queryText = $"SELECT * FROM devices WHERE STARTSWITH(id, '{_parameters.DevicePrefix}')";
Console.WriteLine($"Using query text of: {queryText}");
var query = registryManager.CreateQuery(queryText);
while (query.HasMoreResults)
{
IEnumerable <Twin> twins = await query.GetNextAsTwinAsync();
foreach (Twin twin in twins)
{
Console.WriteLine($"{twin.DeviceId}");
Console.WriteLine($"\tIs edge: {twin.Capabilities.IotEdge}");
if (!string.IsNullOrWhiteSpace(twin.DeviceScope))
{
Console.WriteLine($"\tDevice scope: {twin.DeviceScope}");
}
if (twin.ParentScopes?.Any() ?? false)
{
Console.WriteLine($"\tParent scope: {twin.ParentScopes?.FirstOrDefault()}");
}
}
}
}
private static async Task RemoveAllDevices(RegistryManager registryManager)
{
int count = 0;
var totalDevicesQuery = registryManager.CreateQuery("SELECT count() AS TotalDevices FROM devices");
var content = await totalDevicesQuery.GetNextAsJsonAsync();
if (!content.Any())
{
Console.WriteLine("No devices to remove");
return;
}
var totalDevices = Convert.ToInt32(JsonConvert.DeserializeObject <dynamic>(content.Single()).TotalDevices);
Console.WriteLine($"Found {totalDevices} devices to be removed");
while (true)
{
var devices = await registryManager.GetDevicesAsync(1000);
if (!devices.Any())
{
break;
}
await RemoveDevices(registryManager, devices);
count += devices.Count();
Console.WriteLine($"{count} devices removed, {totalDevices - count} device left");
}
}
// INSERT Device twins section below here
// Device twins section.
private static async Task SetTwinProperties()
{
var twin = await registryManager.GetTwinAsync(deviceId);
Console.WriteLine("Enter temperature:");
int temp = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("Enter humidity");
int hum = Convert.ToInt32(Console.ReadLine());
var patch =
@"{
tags: {
customerID: 'Customer1',
cheeseCave: 'CheeseCave1'
},
properties: {
desired: {
patchId: 'set values',
temperature: '" + temp + @"',
humidity: '" + hum + @"'
}
}
}";
await registryManager.UpdateTwinAsync(twin.DeviceId, patch, twin.ETag);
var query = registryManager.CreateQuery(
"SELECT * FROM devices WHERE tags.cheeseCave = 'CheeseCave1'", 100);
var twinsInCheeseCave1 = await query.GetNextAsTwinAsync();
Console.WriteLine("Devices in CheeseCave1: {0}",
string.Join(", ", twinsInCheeseCave1.Select(t => t.DeviceId)));
}
/**********************************************************************************
* Get list of devices from IoT Hub
*********************************************************************************/
public async Task <IEnumerable <SelectListItem> > GetIoTHubDevices()
{
List <SelectListItem> deviceList = new List <SelectListItem>();
// add empty one
deviceList.Add(new SelectListItem {
Value = "", Text = ""
});
try
{
IQuery query = _registryManager.CreateQuery("select * from devices");
while (query.HasMoreResults)
{
var twins = await query.GetNextAsTwinAsync().ConfigureAwait(false);
foreach (var twin in twins)
{
_logger.LogInformation($"Found a device : {twin.DeviceId}");
deviceList.Add(new SelectListItem {
Value = twin.DeviceId, Text = twin.DeviceId
});
}
}
}
catch (Exception e)
{
_logger.LogError($"Exception in GetIoTHubDevices() : {e.Message}");
}
return(deviceList);
}
public async Task <IEnumerable <AirCon> > GetAirCons()
{
RegistryManager registryManager = RegistryManager.CreateFromConnectionString(_azureConfiguration.IoTHubConnectionString);
var query = registryManager.CreateQuery("SELECT * FROM DEVICES");
var results = await query.GetNextAsTwinAsync();
return(results.Select(x => _airConMapper.GetAirConFromTwin(x)));
}
private static async Task QueryDevices(string iotHubName, int pageSize)
{
RegistryManager registryManager = RegistryManager.CreateFromConnectionString(Settings.IotHubNameToConnectionStringDictionary[iotHubName]);
Console.WriteLine($"{iotHubName,-25}, {DateTime.UtcNow:T} before query for number of devices");
//this piece of code is to hit for the first time the iothub with a query
string queryString = "SELECT COUNT() AS numberOfDevices FROM devices";
await registryManager.CreateQuery(queryString, 1).GetNextAsJsonAsync();
Console.WriteLine($"{iotHubName,-25}, {DateTime.UtcNow:T} after query for number of devices");
//starting the actual measurement...
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
Console.WriteLine($"{iotHubName,-25}, {DateTime.UtcNow:T} elapsed (before query)... total seconds: {stopwatch.Elapsed.TotalSeconds,7:N0}");
var query = registryManager.CreateQuery("SELECT deviceId FROM devices", pageSize);
Console.WriteLine($"{iotHubName,-25}, {DateTime.UtcNow:T} elapsed (after query )... total seconds: {stopwatch.Elapsed.TotalSeconds,7:N0}");
int currentCount = 0;
while (query.HasMoreResults)
{
Console.WriteLine($"{iotHubName,-25}, {DateTime.UtcNow:T} elapsed (start)... total seconds: {stopwatch.Elapsed.TotalSeconds,7:N0}");
IEnumerable <string> jsons = await query.GetNextAsJsonAsync().ConfigureAwait(false);
foreach (string json in jsons)
{
var deviceId = JObject.Parse(json).SelectToken("deviceId")?.Value <string>();
currentCount++;
}
Console.WriteLine($"{iotHubName,-25}, {DateTime.UtcNow:T}, currentCount {currentCount,7}, elapsed (end ) ... total seconds: {stopwatch.Elapsed.TotalSeconds,7:N0}");
}
stopwatch.Stop();
Console.WriteLine($"{iotHubName,-25}, paging {pageSize,7}, total seconds: {stopwatch.Elapsed.TotalSeconds,7:N0}");
}
public async Task <IEnumerable <Twin> > SetDesiredConfigurationAndQuery(Twin deviceTwin)
{
var patch = new
{
properties = new
{
desired = new
{
deviceConfig = new
{
configId = Guid.NewGuid().ToString(),
DeviceOwner = "yatish",
latitude = "17.5122560",
longitude = "70.7760470"
}
},
reported = new
{
deviceConfig = new
{
configId = Guid.NewGuid().ToString(),
DeviceOwner = "Rudra",
latitude = "17.5122560",
longitude = "70.7760470"
}
}
},
tags = new
{
location = new
{
region = "US",
plant = "Redmond43"
}
}
};
await _registryManager.UpdateTwinAsync(deviceTwin.DeviceId, JsonConvert.SerializeObject(patch), deviceTwin.ETag);
var query = _registryManager.CreateQuery("SELECT * FROM devices WHERE deviceId = '" + deviceTwin.DeviceId + "'");
var results = await query.GetNextAsTwinAsync();
return(results);
}
public async Task <Twin> GetDeviceFromAzureAsync(string id)
{
RegistryManager registryManager = RegistryManager.CreateFromConnectionString(_azureConfiguration.IoTHubConnectionString);
var query = registryManager.CreateQuery($"SELECT * FROM DEVICES WHERE deviceId = '{id}'");
var results = await query.GetNextAsTwinAsync();
return(results.FirstOrDefault());
}
static void Main(string[] args)
{
RegistryManager registryManager = RegistryManager.CreateFromConnectionString("<connection string>");
var query = registryManager.CreateQuery("SELECT * FROM devices");
var result = query.GetNextAsTwinAsync().Result;
Console.WriteLine(JsonConvert.SerializeObject(result));
}
public async Task<IEnumerable<JsonDocument>> GetDevicesAsync(string query, int maxCount = 100)
{
var iotQuery = _registryManager.CreateQuery(query, maxCount);
var data = new List<string>();
while (iotQuery.HasMoreResults) data.AddRange(await iotQuery.GetNextAsJsonAsync().ConfigureAwait(false));
return data.Select(i => JsonDocument.Parse(i));
}
public async Task <IEnumerable <DeviceDto> > GetDevicesFromAzureAsync()
{
RegistryManager registryManager = RegistryManager.CreateFromConnectionString(_azureConfiguration.IoTHubConnectionString);
var query = registryManager.CreateQuery("SELECT * FROM DEVICES");
var results = await query.GetNextAsTwinAsync();
return(results.Select(Map));
}
