Partizionamento dei dati (C#)

Il partizionamento in LINQ fa riferimento all'operazione di divisione di una sequenza di input in due sezioni, senza ridisporre gli elementi e quindi restituire una delle sezioni.

Importante

In questi esempi viene usata un'origine dati System.Collections.Generic.IEnumerable<T>. Le sorgenti di dati basate su System.Linq.IQueryProvider utilizzano sorgenti di dati System.Linq.IQueryable<T> e alberi di espressioni. La sintassi consentita in C# per gli alberi delle espressioni ha limitazioni. Inoltre, ogni origine dati IQueryProvider, ad esempio EF Core può imporre altre restrizioni. Consultare la documentazione relativa all'origine dati.

La figura seguente mostra i risultati di tre diverse operazioni di partizionamento su una sequenza di caratteri. La prima operazione restituisce i primi tre elementi della sequenza. La seconda operazione ignora i primi tre elementi e restituisce gli elementi rimanenti. La terza operazione ignora i primi due elementi della sequenza e restituisce i tre elementi successivi.

I metodi dell'operatore di query standard che partizionano le sequenze sono elencati nella sezione seguente.

Operatori

Nomi dei metodi	Descrizione	Sintassi delle espressioni di query C#	Maggiori informazioni
Salta	Ignora gli elementi fino a una posizione specificata in una sequenza.	Non applicabile.	Enumerable.Skip Queryable.Skip
SkipWhile	Ignora gli elementi basati su una funzione predicato fino a quando un elemento non soddisfa la condizione.	Non applicabile.	Enumerable.SkipWhile Queryable.SkipWhile
Prendere	Accetta elementi fino a una posizione specificata in una sequenza.	Non applicabile.	Enumerable.Take Queryable.Take
TakeWhile	Accetta elementi basati su una funzione predicato fino a quando un elemento non soddisfa la condizione.	Non applicabile.	Enumerable.TakeWhile Queryable.TakeWhile
Blocco	Suddivide gli elementi di una sequenza in blocchi di una dimensione massima specificata.	Non applicabile.	Enumerable.Chunk Queryable.Chunk

Tutti gli esempi seguenti usano Enumerable.Range(Int32, Int32) per generare una sequenza di numeri da 0 a 7.

Annotazioni

È possibile fare riferimento alle origini dati comuni per questa area nell'articolo Panoramica degli operatori di query standard .

Usi il metodo Take per prendere solo i primi elementi in una sequenza.

foreach (int number in Enumerable.Range(0, 8).Take(3))
{
    Console.WriteLine(number);
}
// This code produces the following output:
// 0
// 1
// 2

Usare il Skip metodo per ignorare i primi elementi di una sequenza e usare gli elementi rimanenti:

foreach (int number in Enumerable.Range(0, 8).Skip(3))
{
    Console.WriteLine(number);
}
// This code produces the following output:
// 3
// 4
// 5
// 6
// 7

I metodi TakeWhile e SkipWhile accettano e ignorano anche gli elementi in una sequenza. Tuttavia, anziché un numero impostato di elementi, questi metodi ignorano o accettano elementi in base a una condizione. TakeWhile accetta gli elementi di una sequenza fino a quando un elemento non corrisponde alla condizione.

foreach (int number in Enumerable.Range(0, 8).TakeWhile(n => n < 5))
{
    Console.WriteLine(number);
}
// This code produces the following output:
// 0
// 1
// 2
// 3
// 4

SkipWhile ignora i primi elementi, purché la condizione sia true. Viene restituito il primo elemento che non corrisponde alla condizione e tutti gli elementi successivi.

foreach (int number in Enumerable.Range(0, 8).SkipWhile(n => n < 5))
{
    Console.WriteLine(number);
}
// This code produces the following output:
// 5
// 6
// 7

L'operatore Chunk viene usato per suddividere gli elementi di una sequenza in base a un determinato sizeoggetto .

int chunkNumber = 1;
foreach (int[] chunk in Enumerable.Range(0, 8).Chunk(3))
{
    Console.WriteLine($"Chunk {chunkNumber++}:");
    foreach (int item in chunk)
    {
        Console.WriteLine($"    {item}");
    }

    Console.WriteLine();
}
// This code produces the following output:
// Chunk 1:
//    0
//    1
//    2
//
//Chunk 2:
//    3
//    4
//    5
//
//Chunk 3:
//    6
//    7

Il codice C# precedente:

• Si basa su Enumerable.Range(Int32, Int32) per generare una sequenza di numeri.
• Applica l'operatore Chunk , suddividendo la sequenza in blocchi con una dimensione massima di tre.

Vedere anche

• System.Linq