public async Task GetQueuesAsync_Prefix()
{
QueueServiceClient service = GetServiceClient_SharedKey();
var prefix = "aaa";
var queueName = prefix + GetNewQueueName();
QueueClient queue = (await service.CreateQueueAsync(queueName)).Value; // Ensure at least one queue
try
{
AsyncPageable <QueueItem> queues = service.GetQueuesAsync(prefix: prefix);
IList <QueueItem> items = await queues.ToListAsync();
Assert.AreNotEqual(0, items.Count());
Assert.IsTrue(items.All(c => c.Name.StartsWith(prefix)));
Assert.IsNotNull(items.Single(c => c.Name == queueName));
}
finally
{
await service.DeleteQueueAsync(queueName);
}
}
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}");
}
}
public async Task GetDeviceClassInstallableUpdates()
{
var client = CreateClient();
var expected = TestEnvironment;
AsyncPageable <UpdateId> response = client.GetDeviceClassInstallableUpdatesAsync(expected.DeviceClassId);
Assert.IsNotNull(response);
var list = new List <UpdateId>();
await foreach (var item in response)
{
list.Add(item);
}
Assert.IsTrue(list.Count > 0);
Assert.IsTrue(
list.Any(
u => u.Provider == expected.Provider &&
u.Name == expected.Model &&
u.Version == expected.Version));
}
public async Task TestGetReservationOrders()
{
AsyncPageable <ReservationOrderResponseResource> response = Collection.GetAllAsync();
List <ReservationOrderResponseResource> result = await response.ToEnumerableAsync();
Assert.IsNotNull(result);
Assert.IsTrue(result.Count > 0);
Assert.IsNotNull(result[0].Data);
Assert.AreEqual("/providers/microsoft.capacity/reservationOrders/c848cae0-7ade-43c8-a42c-52cc53413a72", result[0].Data.Id.ToString());
Assert.AreEqual("Microsoft.Capacity/reservationOrders", result[0].Data.ResourceType.ToString());
Assert.AreEqual("c848cae0-7ade-43c8-a42c-52cc53413a72", result[0].Data.Name);
Assert.AreEqual(9, result[0].Data.Version);
Assert.AreEqual("testVM", result[0].Data.DisplayName);
Assert.AreEqual(ReservationTerm.P1Y, result[0].Data.Term);
Assert.AreEqual(ProvisioningState.Succeeded, result[0].Data.ProvisioningState);
Assert.IsNotNull(result[0].Data.Reservations);
Assert.AreEqual(1, result[0].Data.Reservations.Count);
Assert.AreEqual("/providers/microsoft.capacity/reservationOrders/c848cae0-7ade-43c8-a42c-52cc53413a72/reservations/34a9427a-0966-4186-86dd-bbcf720913c0", result[0].Data.Reservations[0].Id.ToString());
Assert.AreEqual(1, result[0].Data.OriginalQuantity);
Assert.AreEqual(ReservationBillingPlan.Upfront, result[0].Data.BillingPlan);
}
public async Task TestListConfigurations()
{
ConfigurationFilters configurationFilters = new(GetHierarchyInformation());
configurationFilters.FilterableProperty.Add(new FilterableProperty(SupportedFilterTypes.ShipToCountries,
new List <string>()
{
"US"
}));
ConfigurationsRequest configurationsRequest = new(
new List <ConfigurationFilters>()
{
configurationFilters
});
AsyncPageable <ProductConfiguration> configurations = EdgeOrderExtensions.GetConfigurationsAsync(Subscription,
configurationsRequest);
List <ProductConfiguration> configurationsResult = await configurations.ToEnumerableAsync();
Assert.NotNull(configurationsResult);
Assert.IsTrue(configurationsResult.Count >= 1);
}
public async Task CanGetTags()
{
// Arrange
var client = CreateClient();
// Act
AsyncPageable <TagProperties> tags = client.GetTagsAsync();
bool gotV1Tag = false;
await foreach (TagProperties tag in tags)
{
if (tag.Name.Contains("v1"))
{
gotV1Tag = true;
}
}
// Assert
Assert.IsTrue(gotV1Tag);
}
public async Task TestListProductFamilies()
{
IList <FilterableProperty> filterableProperty = new List <FilterableProperty>()
{
new FilterableProperty(SupportedFilterTypes.ShipToCountries, new List <string>()
{
"US"
})
};
IDictionary <string, IList <FilterableProperty> > filterableProperties =
new Dictionary <string, IList <FilterableProperty> >()
{
{ "azurestackedge", filterableProperty }
};
ProductFamiliesRequest productFamiliesRequest = new(filterableProperties);
AsyncPageable <ProductFamily> productFamilies = EdgeOrderExtensions.GetProductFamiliesAsync(Subscription, productFamiliesRequest);
List <ProductFamily> productFamiliesResult = await productFamilies.ToEnumerableAsync();
Assert.NotNull(productFamiliesResult);
Assert.IsTrue(productFamiliesResult.Count >= 1);
}
public static async Task <string> FindParentAsync(DigitalTwinsClient client, string child, string relname, ILogger log)
{
// Find parent using incoming relationships
try
{
AsyncPageable <IncomingRelationship> rels = client.GetIncomingRelationshipsAsync(child);
await foreach (IncomingRelationship ie in rels)
{
if (ie.RelationshipName == relname)
{
return(ie.SourceId);
}
}
}
catch (RequestFailedException exc)
{
log.LogInformation($"*** Error in retrieving parent:{exc.Status}:{exc.Message}");
}
return(null);
}
/// <summary>
/// ViewMembersInAThread() - view existing members in a chat thread
/// </summary>
/// <returns></returns>
private static async Task ViewMembersInAThread()
{
Console.WriteLine("\n# Viewing members in a thread");
Console.Write("Enter thread id: ");
var threadId = Console.ReadLine();
Uri endpoint = new Uri("https://ACS-INSTANCE.communication.azure.com/");
CommunicationUserCredential communicationUserCredential = new CommunicationUserCredential(token);
ChatClient chatClient = new ChatClient(endpoint, communicationUserCredential);
ChatThreadClient chatThreadClient = chatClient.GetChatThreadClient(threadId);
AsyncPageable <ChatThreadMember> allMembers = chatThreadClient.GetMembersAsync();
await foreach (ChatThreadMember member in allMembers)
{
Console.WriteLine($"{member.DisplayName}");
}
}
public async Task GetAllAvailabilitySets()
{
#region Snippet:Managing_Availability_Set_GetAllAvailabilitySets
// First, initialize the ArmClient and get the default subscription
ArmClient armClient = new ArmClient(new DefaultAzureCredential());
// Now we get a ResourceGroupResource collection for that subscription
SubscriptionResource subscription = await armClient.GetDefaultSubscriptionAsync();
ResourceGroupCollection rgCollection = subscription.GetResourceGroups();
string rgName = "myRgName";
ResourceGroupResource resourceGroup = await rgCollection.GetAsync(rgName);
// First, we get the availability set collection from the resource group
AvailabilitySetCollection availabilitySetCollection = resourceGroup.GetAvailabilitySets();
// With GetAllAsync(), we can get a list of the availability sets in the collection
AsyncPageable<AvailabilitySetResource> response = availabilitySetCollection.GetAllAsync();
await foreach (AvailabilitySetResource availabilitySet in response)
{
Console.WriteLine(availabilitySet.Data.Name);
}
#endregion Snippet:Managing_Availability_Set_GetAllAvailabilitySets
}
public async Task GetRevisionsByKeyAndLabel()
{
// The service keeps revision history even after the key was removed
// Avoid reusing ids
Recording.DisableIdReuse();
ConfigurationClient service = GetClient();
ConfigurationSetting testSetting = CreateSetting();
//Prepare environment
ConfigurationSetting setting = testSetting;
setting.Key = GenerateKeyId("key-");
ConfigurationSetting testSettingUpdate = setting.Clone();
testSettingUpdate.Label = "test_label_update";
try
{
await service.SetConfigurationSettingAsync(setting);
await service.SetConfigurationSettingAsync(testSettingUpdate);
AsyncPageable <ConfigurationSetting> revisions = service.GetRevisionsAsync(testSettingUpdate.Key, testSettingUpdate.Label, CancellationToken.None);
int resultsReturned = 0;
await foreach (ConfigurationSetting value in revisions)
{
Assert.True(ConfigurationSettingEqualityComparer.Instance.Equals(value, testSettingUpdate));
resultsReturned++;
}
Assert.AreEqual(1, resultsReturned);
}
finally
{
AssertStatus200(await service.DeleteConfigurationSettingAsync(setting.Key, setting.Label));
AssertStatus200(await service.DeleteConfigurationSettingAsync(testSettingUpdate.Key, testSettingUpdate.Label));
}
}
public async Task QueryTablesAsync()
{
string storageUri = StorageUri;
string accountName = StorageAccountName;
string storageAccountKey = PrimaryStorageAccountKey;
string tableName = "OfficeSupplies3p2";
char label = 'A';
var serviceClient = new TableServiceClient(
new Uri(storageUri),
new TableSharedKeyCredential(accountName, storageAccountKey));
for (int i = 0; i < 10; i++)
{
await serviceClient.CreateTableAsync(tableName + (char)(label + i));
}
try
{
#region Snippet:TablesSample3QueryTablesAsync
// Use the <see cref="TableServiceClient"> to query the service. Passing in OData filter strings is optional.
AsyncPageable <TableItem> queryTableResults = serviceClient.GetTablesAsync(filter: $"TableName gt '{tableName + (char)(label + 4)}'");
Console.WriteLine("The following are the names of the tables in the query results:");
// Iterate the <see cref="Pageable"> in order to access individual queried tables.
await foreach (TableItem table in queryTableResults)
{
Console.WriteLine(table.TableName);
}
#endregion
}
finally
{
for (int i = 0; i < 10; i++)
{
await serviceClient.DeleteTableAsync(tableName + (char)(label + i));
}
}
}
/// <summary>List files</summary>
/// <param name="directoryName">The directory of interest or null if you want the root directory</param>
/// <param name="returnDirectoriesAndFiles">If true, you will get both directories and file. If false, you will get only files.</param>
/// <param name="cancellationToken"></param>
/// <param name="options"></param>
/// <returns></returns>
public async Task <List <ShareFileItem> > ListFilesAsync(string directoryName,
bool returnDirectoriesAndFiles, CancellationToken cancellationToken = default,
ShareDirectoryGetFilesAndDirectoriesOptions options = null)
{
var result = new List <ShareFileItem>();
ShareDirectoryClient directory = string.IsNullOrWhiteSpace(directoryName) ?
_share.GetRootDirectoryClient() :
_share.GetDirectoryClient(directoryName);
// For >= C# 8.0 use:
//await foreach (ShareFileItem fileItem in directory.GetFilesAndDirectoriesAsync(options, cancellationToken))
//{
// result.Add(fileItem);
//}
// For < C# 8.0 use:
AsyncPageable <ShareFileItem> filePages = directory.GetFilesAndDirectoriesAsync(options, cancellationToken);
IAsyncEnumerator <ShareFileItem> enumerator = filePages.GetAsyncEnumerator();
try
{
while (await enumerator.MoveNextAsync())
{
if (returnDirectoriesAndFiles == false && enumerator.Current.IsDirectory)
{
continue;
}
result.Add(enumerator.Current);
}
}
finally
{
await enumerator.DisposeAsync();
}
return(result);
}
public async Task UsageTest()
{
string resourceGroupName = Recording.GenerateAssetName("csmrg");
string location = await NetworkManagementTestUtilities.GetResourceLocation(ResourceManagementClient, "Microsoft.Network/networkSecurityGroups");
await ResourceGroupsOperations.CreateOrUpdateAsync(resourceGroupName, new ResourceGroup(location));
string networkSecurityGroupName = Recording.GenerateAssetName("azsmnet");
NetworkSecurityGroup networkSecurityGroup = new NetworkSecurityGroup()
{
Location = location,
};
// Put Nsg
NetworkSecurityGroupsCreateOrUpdateOperation putNsgResponseOperation = await NetworkManagementClient.NetworkSecurityGroups.StartCreateOrUpdateAsync(resourceGroupName, networkSecurityGroupName, networkSecurityGroup);
Response <NetworkSecurityGroup> putNsgResponse = await WaitForCompletionAsync(putNsgResponseOperation);
Assert.AreEqual("Succeeded", putNsgResponse.Value.ProvisioningState.ToString());
Response <NetworkSecurityGroup> getNsgResponse = await NetworkManagementClient.NetworkSecurityGroups.GetAsync(resourceGroupName, networkSecurityGroupName);
// Query for usages
AsyncPageable <Usage> usagesResponseAP = NetworkManagementClient.Usages.ListAsync(getNsgResponse.Value.Location.Replace(" ", string.Empty));
List <Usage> usagesResponse = await usagesResponseAP.ToEnumerableAsync();
// Verify that the strings are populated
Assert.NotNull(usagesResponse);
Assert.True(usagesResponse.Any());
foreach (Usage usage in usagesResponse)
{
Assert.True(usage.Limit > 0);
Assert.NotNull(usage.Name);
Assert.True(!string.IsNullOrEmpty(usage.Name.LocalizedValue));
Assert.True(!string.IsNullOrEmpty(usage.Name.Value));
}
}
private async Task <Feature> GetFirst(AsyncPageable <Feature> asyncPageable, bool?isRegistered = null)
{
Feature result = null;
await foreach (var feature in asyncPageable)
{
if (isRegistered.HasValue)
{
if (isRegistered.Value == (feature.Data.Properties.State == "Registered"))
{
result = feature;
break;
}
}
else
{
result = feature;
break;
}
}
return(result);
}
public async Task CanGetRepositories()
{
// Arrange
var client = CreateClient();
// Act
AsyncPageable <string> repositories = client.GetRepositoryNamesAsync();
bool gotHelloWorld = false;
await foreach (string repository in repositories)
{
if (repository.Contains("library/hello-world"))
{
gotHelloWorld = true;
break;
}
}
// Assert
Assert.IsTrue(gotHelloWorld);
}
public async Task CanGetRepositoriesWithCustomPageSize()
{
// Arrange
var client = CreateClient();
int pageSize = 2;
int minExpectedPages = 2;
// Act
AsyncPageable <string> repositories = client.GetRepositoryNamesAsync();
var pages = repositories.AsPages(pageSizeHint: pageSize);
int pageCount = 0;
await foreach (var page in pages)
{
Assert.IsTrue(page.Values.Count <= pageSize);
pageCount++;
}
// Assert
Assert.GreaterOrEqual(pageCount, minExpectedPages);
}
public static async Task AssertPaginationAsync(AsyncPageable <T> enumerableResource, int expectedPageSize, int expectedTotalResources)
{
string?continuationToken = null;
int expectedRoundTrips = (expectedTotalResources / expectedPageSize) + 1;
int actualPageSize, actualTotalResources = 0, actualRoundTrips = 0;
await foreach (Page <T> page in enumerableResource.AsPages(continuationToken, expectedPageSize))
{
actualRoundTrips++;
actualPageSize = 0;
foreach (T resource in page.Values)
{
actualPageSize++;
actualTotalResources++;
}
continuationToken = page.ContinuationToken;
Assert.GreaterOrEqual(expectedPageSize, actualPageSize);
}
Assert.IsNull(continuationToken);
Assert.AreEqual(expectedTotalResources, actualTotalResources);
Assert.AreEqual(expectedRoundTrips, actualRoundTrips);
}
public async Task CachesDifferentResponse(bool isAsync)
{
string getClientRequestId;
if (isAsync)
{
Response <KeyVaultSecret> response = await _fixture.Client.GetSecretAsync(_fixture.SecretName);
getClientRequestId = response.GetRawResponse().ClientRequestId;
}
else
{
Response <KeyVaultSecret> response = _fixture.Client.GetSecret(_fixture.SecretName);
getClientRequestId = response.GetRawResponse().ClientRequestId;
}
string listClientRequestId = null;
if (isAsync)
{
AsyncPageable <SecretProperties> response = _fixture.Client.GetPropertiesOfSecretsAsync();
await foreach (Page <SecretProperties> page in response.AsPages())
{
listClientRequestId = page.GetRawResponse().ClientRequestId;
break;
}
}
else
{
Pageable <SecretProperties> response = _fixture.Client.GetPropertiesOfSecrets();
foreach (Page <SecretProperties> page in response.AsPages())
{
listClientRequestId = page.GetRawResponse().ClientRequestId;
break;
}
}
Assert.NotEqual(getClientRequestId, listClientRequestId);
}
public async Task CanGetArtifactsWithCustomPageSize()
{
// Arrange
var client = CreateClient();
int pageSize = 2;
int minExpectedPages = 2;
// Act
AsyncPageable <RegistryArtifactProperties> artifacts = client.GetRegistryArtifactsAsync();
var pages = artifacts.AsPages(pageSizeHint: pageSize);
int pageCount = 0;
await foreach (var page in pages)
{
Assert.GreaterOrEqual(page.Values.Count, pageSize);
pageCount++;
}
// Assert
Assert.IsTrue(pageCount >= minExpectedPages);
}
public async Task CanGetTagsWithCustomPageSize()
{
// Arrange
var client = CreateClient();
int pageSize = 2;
int minExpectedPages = 2;
// Act
AsyncPageable <TagProperties> tags = client.GetTagsAsync();
var pages = tags.AsPages(pageSizeHint: pageSize);
int pageCount = 0;
await foreach (var page in pages)
{
Assert.IsTrue(page.Values.Count <= pageSize);
pageCount++;
}
// Assert
Assert.IsTrue(pageCount >= minExpectedPages);
}
public async Task OrderInGetReadReceiptsIteratorIsNotAltered()
{
//arrange
var baseSenderId = "8:acs:1b5cc06b-f352-4571-b1e6-d9b259b7c776_00000007-0464-274b-b274-5a3a0d00010";
var baseReadOnDate = DateTimeOffset.Parse("2020-12-15T00:00:00Z");
ChatThreadClient chatThreadClient = CreateMockChatThreadClient(200, AllReadReceiptsApiResponsePayload);
//act
AsyncPageable <ChatMessageReadReceipt> allReadReceipts = chatThreadClient.GetReadReceiptsAsync();
//assert
int idCounter = 0;
await foreach (ChatMessageReadReceipt readReceipt in allReadReceipts)
{
idCounter++;
Assert.AreEqual($"{idCounter}", readReceipt.ChatMessageId);
Assert.AreEqual($"{baseSenderId}{idCounter}", ((UnknownIdentifier)readReceipt.Sender).Id);
Assert.AreEqual(baseReadOnDate.AddSeconds(idCounter), readReceipt.ReadOn);
}
Assert.AreEqual(5, idCounter);
}
/// <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($"Retrieved model with Id {model.Id}, display name {model.DisplayName["en"]}, upload time {model.UploadTime}, and decommissioned: {model.Decommissioned}");
}
#endregion Snippet:DigitalTwinsSampleGetModels
}
catch (RequestFailedException ex)
{
FatalError($"Failed to get all the models due to:\n{ex}");
}
}
public async Task SendingGroupSMSMessageWithOptions()
{
SmsClient smsClient = CreateSmsClient();
#region Snippet:Azure_Communication_SmsClient_Send_GroupSmsWithOptions
AsyncPageable <SmsSendResult> results = smsClient.SendAsync(
//@@ from: "<from-phone-number>", // Your E.164 formatted from phone number used to send SMS
//@@ to: new string[] { "<to-phone-number-1>", "<to-phone-number-2>" }, // E.164 formatted recipient phone numbers
/*@@*/ from: TestEnvironment.FromPhoneNumber,
/*@@*/ to: new string[] { TestEnvironment.ToPhoneNumber, TestEnvironment.ToPhoneNumber },
message: "Weekly Promotion!",
options: new SmsSendOptions(enableDeliveryReport: true) // OPTIONAL
{
Tag = "marketing", // custom tags
});
await foreach (SmsSendResult result in results)
{
Console.WriteLine($"Sms id: {result.MessageId}");
Console.WriteLine($"Send Result Successful: {result.Successful}");
}
#endregion Snippet:Azure_Communication_SmsClient_Send_GroupSmsWithOptions
}
public static async Task ReadProperty(DigitalTwinsClient client)
{
string dtID;
string prop;
Console.Write("Digital twin ID: ");
dtID = Console.ReadLine();
Console.Write("Property name: ");
prop = Console.ReadLine();
string q = string.Format("SELECT v.{0}, v.$metadata.{0}.lastUpdateTime FROM DIGITALTWINS v WHERE v.$dtId = '{1}' AND IS_PRIMITIVE(v.{0}) and IS_PRIMITIVE(v.$metadata.{0}.lastUpdateTime)", prop, dtID);
Console.WriteLine("Query: {0}\n\r", q);
AsyncPageable <string> result = client.QueryAsync(q);
await foreach (string s in result)
{
Console.WriteLine(s);
}
}
public async Task FindAndDeleteOutgoingRelationshipsAsync(string dtId)
{
// Find the relationships for the twin
try
{
// GetRelationshipsAsync will throw if an error occurs
AsyncPageable <string> relsJson = client.GetRelationshipsAsync(dtId);
await foreach (string relJson in relsJson)
{
var rel = System.Text.Json.JsonSerializer.Deserialize <BasicRelationship>(relJson);
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}");
}
}
public async Task CanGetManifestsOrdered()
{
// Arrange
string repositoryName = $"library/node";
string tag = "newest";
var client = CreateClient();
var repository = client.GetRepository(repositoryName);
var artifact = client.GetArtifact(repositoryName, tag);
try
{
if (Mode != RecordedTestMode.Playback)
{
await ImportImage(TestEnvironment.Registry, repositoryName, tag);
}
// Act
AsyncPageable <ArtifactManifestProperties> manifests = repository.GetManifestsAsync(ManifestOrderBy.LastUpdatedOnDescending);
// Assert
string digest = null;
await foreach (ArtifactManifestProperties manifest in manifests)
{
// Make sure we're looking at a manifest list, which has the tag
if (manifest.References != null && manifest.References.Count > 0)
{
digest = manifest.Digest;
Assert.That(manifest.RepositoryName.Contains(repositoryName));
Assert.That(manifest.Tags.Contains(tag));
break;
}
}
}
finally
{
// Clean up
await artifact.DeleteAsync();
}
}
public async Task CanGetArtifactsOrdered()
{
// Arrange
string repository = $"library/node";
string tag = "newest";
var client = CreateClient(repository);
try
{
if (Mode != RecordedTestMode.Playback)
{
await ImportImage(repository, tag);
}
// Act
AsyncPageable <RegistryArtifactProperties> artifacts = client.GetRegistryArtifactsAsync(new GetRegistryArtifactsOptions(RegistryArtifactOrderBy.LastUpdatedOnDescending));
// Assert
string digest = null;
await foreach (RegistryArtifactProperties artifact in artifacts)
{
// Make sure we're looking at a manifest list, which has the tag
if (artifact.References != null && artifact.References.Count > 0)
{
digest = artifact.Digest;
Assert.That(artifact.Repository.Contains(repository));
Assert.That(artifact.Tags.Contains(tag));
break;
}
}
}
finally
{
// Clean up
var properties = await client.GetTagPropertiesAsync(tag).ConfigureAwait(false);
await client.DeleteRegistryArtifactAsync(properties.Value.Digest);
}
}
public async Task GetCursor()
{
// Arrange
string shardPath = "shardPath";
long chunkIndex = 2;
long blockOffset = 100;
long eventIndex = 200;
ShardCursor shardCursor = new ShardCursor(
chunkIndex,
blockOffset,
eventIndex);
Mock <BlobContainerClient> containerClient = new Mock <BlobContainerClient>(MockBehavior.Strict);
Mock <ChunkFactory> chunkFactory = new Mock <ChunkFactory>(MockBehavior.Strict);
Mock <Chunk> chunk = new Mock <Chunk>(MockBehavior.Strict);
if (IsAsync)
{
AsyncPageable <BlobHierarchyItem> asyncPageable = PageResponseEnumerator.CreateAsyncEnumerable(GetChunkPagesFuncAsync);
containerClient.Setup(r => r.GetBlobsByHierarchyAsync(
public async Task AsyncPageableAsPages()
{
// create a client
var client = new SecretClient(new Uri("http://example.com"), new DefaultAzureCredential());
#region Snippet:AsyncPageableAsPages
// call a service method, which returns AsyncPageable<T>
AsyncPageable <SecretProperties> response = client.GetPropertiesOfSecretsAsync();
await foreach (Page <SecretProperties> page in response.AsPages())
{
// enumerate through page items
foreach (SecretProperties secretProperties in page.Values)
{
Console.WriteLine(secretProperties.Name);
}
// get continuation token that can be used in AsPages call to resume enumeration
Console.WriteLine(page.ContinuationToken);
}
#endregion
}
