evento
Participe do Desafio Microsoft Learn
19/11, 23 - 10/01, 23
Ignite Edition - Desenvolva habilidades no Microsoft Azure e ganhe um selo digital até 10 de janeiro!
Registe-se agoraEste browser já não é suportado.
Atualize para o Microsoft Edge para tirar partido das mais recentes funcionalidades, atualizações de segurança e de suporte técnico.
Neste artigo, você aprenderá a usar a funcionalidade de paginação do SDK do Azure para .NET para trabalhar de forma eficiente e produtiva com grandes conjuntos de dados. A paginação é o ato de dividir grandes conjuntos de dados em páginas, tornando mais fácil para o consumidor iterar através de quantidades menores de dados. A partir do C# 8, você pode criar e consumir fluxos de forma assíncrona usando fluxos assíncronos (assíncronos). Os fluxos assíncronos IAsyncEnumerable<T> são baseados na interface. O SDK do Azure para .NET expõe uma implementação de IAsyncEnumerable<T>
com sua AsyncPageable<T>
classe.
Todos os exemplos neste artigo dependem dos seguintes pacotes NuGet:
Para obter o diretório mais recente dos pacotes do SDK do Azure para .NET, consulte Versões mais recentes do SDK do Azure.
Os clientes instanciados a partir do SDK do Azure para .NET podem retornar os seguintes tipos pagináveis.
Tipo | Description |
---|---|
Pageable<T> |
Uma coleção de valores recuperados em páginas |
AsyncPageable<T> |
Uma coleção de valores recuperados de forma assíncrona em páginas |
A maioria dos exemplos neste artigo são assíncronos, usando variações do AsyncPageable<T>
tipo. O uso de programação assíncrona para operações vinculadas a E/S é o ideal. Um caso de uso perfeito é usar as APIs assíncronas do SDK do Azure para .NET, pois essas operações representam chamadas de rede HTTP/S.
Para iterar sobre um AsyncPageable<T>
usando a await foreach
sintaxe, considere o seguinte exemplo:
async Task IterateSecretsWithAwaitForeachAsync()
{
AsyncPageable<SecretProperties> allSecrets = client.GetPropertiesOfSecretsAsync();
await foreach (SecretProperties secret in allSecrets)
{
Console.WriteLine($"IterateSecretsWithAwaitForeachAsync: {secret.Name}");
}
}
No código C# anterior:
AsyncPageable<SecretProperties>
objeto.SecretProperties
um await foreach
é produzido de forma assíncrona.secret
se materializa, o seu Name
é gravado na consola.Para iterar sobre um AsyncPageable<T>
quando a await foreach
sintaxe não estiver disponível, use um while
loop.
async Task IterateSecretsWithWhileLoopAsync()
{
AsyncPageable<SecretProperties> allSecrets = client.GetPropertiesOfSecretsAsync();
IAsyncEnumerator<SecretProperties> enumerator = allSecrets.GetAsyncEnumerator();
try
{
while (await enumerator.MoveNextAsync())
{
SecretProperties secret = enumerator.Current;
Console.WriteLine($"IterateSecretsWithWhileLoopAsync: {secret.Name}");
}
}
finally
{
await enumerator.DisposeAsync();
}
}
No código C# anterior:
AsyncPageable<SecretProperties>
objeto.IAsyncEnumerator<SecretProperties>
arquivo .Se você quiser ter controle sobre o recebimento de páginas de valores do serviço, use o AsyncPageable<T>.AsPages
método:
async Task IterateSecretsAsPagesAsync()
{
AsyncPageable<SecretProperties> allSecrets = client.GetPropertiesOfSecretsAsync();
await foreach (Page<SecretProperties> page in allSecrets.AsPages())
{
foreach (SecretProperties secret in page.Values)
{
Console.WriteLine($"IterateSecretsAsPagesAsync: {secret.Name}");
}
// The continuation token that can be used in AsPages call to resume enumeration
Console.WriteLine(page.ContinuationToken);
}
}
No código C# anterior:
AsyncPageable<SecretProperties>
objeto.IAsyncEnumerable<Page<SecretProperties>>
arquivo .await foreach
o .IReadOnlyList<T>
que é iterado com um .foreach
O System.Linq.Async
pacote fornece um conjunto de métodos LINQ que operam no IAsyncEnumerable<T> tipo. Como AsyncPageable<T>
implementa IAsyncEnumerable<T>
o , você pode usar System.Linq.Async
para consultar e transformar os dados.
Use ToListAsync
para converter um AsyncPageable<T>
em um List<T>
arquivo . Esse método pode fazer várias chamadas de serviço se os dados não forem retornados em uma única página.
async Task ToListAsync()
{
AsyncPageable<SecretProperties> allSecrets =
client.GetPropertiesOfSecretsAsync();
List<SecretProperties> secretList = await allSecrets.ToListAsync();
secretList.ForEach(secret =>
Console.WriteLine($"ToListAsync: {secret.Name}"));
}
No código C# anterior:
AsyncPageable<SecretProperties>
objeto.ToListAsync
método, que materializa uma nova List<SecretProperties>
instância.Take
pode ser usado para obter apenas os primeiros N
elementos do AsyncPageable
. Usar Take
fará o menor número de chamadas de serviço necessárias para obter N
itens.
async Task TakeAsync(int count = 30)
{
AsyncPageable<SecretProperties> allSecrets =
client.GetPropertiesOfSecretsAsync();
await foreach (SecretProperties secret in allSecrets.Take(count))
{
Console.WriteLine($"TakeAsync: {secret.Name}");
}
}
System.Linq.Async
fornece outros métodos que fornecem funcionalidade equivalente às suas contrapartes síncronasEnumerable
. Exemplos de tais métodos incluem Select
, Where
, OrderBy
, e GroupBy
.
Ao usar o System.Linq.Async
pacote, cuidado para que as operações LINQ sejam executadas no cliente. A consulta a seguir buscaria todos os itens apenas para contá-los:
// ⚠️ DON'T DO THIS! 😲
int expensiveSecretCount =
await client.GetPropertiesOfSecretsAsync()
.CountAsync();
Aviso
O mesmo aviso se aplica a operadores como Where
. Prefira sempre filtragem, agregação ou projeções de dados do lado do servidor, se disponíveis.
O System.Linq.Async
pacote é usado principalmente para fornecer recursos de padrão de observador em IAsyncEnumerable<T>
sequências. Os fluxos assíncronos são baseados em pull. À medida que seus itens são iterados, o próximo item disponível é puxado. Esta abordagem está em justaposição com o padrão do observador, que é baseado em push. À medida que os itens ficam disponíveis, eles são enviados para assinantes que atuam como observadores. O System.Linq.Async
pacote fornece o ToObservable
método de extensão que permite converter um IAsyncEnumerable<T>
em um IObservable<T>
arquivo .
Imagine uma IObserver<SecretProperties>
implementação:
sealed file class SecretPropertyObserver : IObserver<SecretProperties>
{
public void OnCompleted() =>
Console.WriteLine("Done observing secrets");
public void OnError(Exception error) =>
Console.WriteLine($"Error observing secrets: {error}");
public void OnNext(SecretProperties secret) =>
Console.WriteLine($"Observable: {secret.Name}");
}
Você pode consumir o método de ToObservable
extensão da seguinte maneira:
IDisposable UseTheToObservableMethod()
{
AsyncPageable<SecretProperties> allSecrets =
client.GetPropertiesOfSecretsAsync();
IObservable<SecretProperties> observable = allSecrets.ToObservable();
return observable.Subscribe(
new SecretPropertyObserver());
}
No código C# anterior:
AsyncPageable<SecretProperties>
objeto.ToObservable()
método é chamado na AsyncPageable<SecretProperties>
instância, retornando um IObservable<SecretProperties>
arquivo .observable
é subscrito, passando na implementação do observador, devolvendo a subscrição ao chamador.IDisposable
ficheiro . Quando é descartado, a assinatura termina.Pageable<T>
é uma versão síncrona que AsyncPageable<T>
pode ser usada com um loop normal foreach
.
void IterateWithPageable()
{
Pageable<SecretProperties> allSecrets = client.GetPropertiesOfSecrets();
foreach (SecretProperties secret in allSecrets)
{
Console.WriteLine($"IterateWithPageable: {secret.Name}");
}
}
Importante
Enquanto essa API síncrona estiver disponível, use as alternativas de API assíncrona para uma melhor experiência.
Comentários do .NET
O .NET é um projeto código aberto. Selecione um link para fornecer comentários:
evento
Participe do Desafio Microsoft Learn
19/11, 23 - 10/01, 23
Ignite Edition - Desenvolva habilidades no Microsoft Azure e ganhe um selo digital até 10 de janeiro!
Registe-se agoraFormação
Módulo
Armazenar e iterar sequências de dados ao utilizar Matrizes e a instrução foreach em C# - Training
Aprenda a criar variáveis de matriz e iterar através de elementos da matriz.