Partizionamento dei dati (C#)

Il partizionamento in LINQ è l'operazione di divisione di una sequenza di input in due sezioni senza ridisposizione degli elementi e la successiva restituzione di una delle sezioni.

Importante

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

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

Nella sezione seguente sono elencati i metodi degli operatori di query standard che eseguono la partizione delle sequenze.

Operatori

Nomi dei metodi	Descrizione	Sintassi dell'espressione di query C#	Ulteriori informazioni
Ignora	Ignora gli elementi fino a una posizione specificata in una sequenza.	Non applicabile.	Enumerable.Skip Queryable.Skip
SkipWhile	Ignora gli elementi in base a una funzione di predicato fino a quando un elemento non soddisfa la condizione.	Non applicabile.	Enumerable.SkipWhile Queryable.SkipWhile
Take	Accetta gli elementi fino a una posizione specificata in una sequenza.	Non applicabile.	Enumerable.Take Queryable.Take
TakeWhile	Accetta gli elementi in base a una funzione di 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.

Usare il metodo Take per accettare 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 metodo Skip 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 finché 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 size.

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.

Vedi anche

• System.Linq