Operazioni sui set (C#)

Le operazioni sui set in LINQ si riferiscono alle operazioni di query che generano un set di risultati basato sulla presenza o sull'assenza di elementi equivalenti all'interno delle stesse Collection oppure di Collection (o set) distinte.

La sezione seguente elenca i metodi dell'operatore query standard che eseguono operazioni sui set.

Metodi

Nome metodo Descrizione Sintassi di espressione della query C# Altre informazioni
Distinct Rimuove i valori duplicati da una Collection. Non applicabile. Enumerable.Distinct

Queryable.Distinct
Except Restituisce la differenza dei set, ovvero gli elementi di una Collection che non sono presenti in una seconda Collection. Non applicabile. Enumerable.Except

Queryable.Except
Intersect Restituisce l'intersezione di set, ovvero gli elementi presenti in ognuna delle due Collection. Non applicabile. Enumerable.Intersect

Queryable.Intersect
Union Restituisce l'unione di set, ovvero gli elementi univoci presenti in una delle due Collection. Non applicabile. Enumerable.Union

Queryable.Union

Confronto tra le operazioni sui set

Distinct

Nell'esempio seguente viene illustrato il comportamento del Enumerable.Distinct metodo su una sequenza di caratteri. La sequenza restituita contiene gli elementi univoci dalla sequenza di input.

Elemento grafico che illustra il comportamento di Distinct().

string[] planets = { "Mercury", "Venus", "Venus", "Earth", "Mars", "Earth" };

IEnumerable<string> query = from planet in planets.Distinct()
                            select planet;

foreach (var str in query)
{
    Console.WriteLine(str);
}

/* This code produces the following output:
 *
 * Mercury
 * Venus
 * Earth
 * Mars
 */

Except

Nell'esempio seguente viene illustrato il comportamento di Enumerable.Except . La sequenza restituita contiene solo gli elementi dalla prima sequenza di input che non sono presenti nella seconda sequenza di input.

Immagine che mostra l'azione di except().

string[] planets1 = { "Mercury", "Venus", "Earth", "Jupiter" };
string[] planets2 = { "Mercury", "Earth", "Mars", "Jupiter" };

IEnumerable<string> query = from planet in planets1.Except(planets2)
                            select planet;

foreach (var str in query)
{
    Console.WriteLine(str);
}

/* This code produces the following output:
 *
 * Venus
 */

Intersect

Nell'esempio seguente viene illustrato il comportamento di Enumerable.Intersect . La sequenza restituita contiene gli elementi comuni a entrambe le sequenze di input.

Elemento grafico che illustra l'intersezione di due sequenze.

string[] planets1 = { "Mercury", "Venus", "Earth", "Jupiter" };
string[] planets2 = { "Mercury", "Earth", "Mars", "Jupiter" };

IEnumerable<string> query = from planet in planets1.Intersect(planets2)
                            select planet;

foreach (var str in query)
{
    Console.WriteLine(str);
}

/* This code produces the following output:
 *
 * Mercury
 * Earth
 * Jupiter
 */

Union

Nell'esempio seguente viene illustrata un'operazione di Unione su due sequenze di caratteri. La sequenza restituita contiene gli elementi univoci da entrambe le sequenze di input.

Elemento grafico che illustra l'unione di due sequenze.

string[] planets1 = { "Mercury", "Venus", "Earth", "Jupiter" };
string[] planets2 = { "Mercury", "Earth", "Mars", "Jupiter" };

IEnumerable<string> query = from planet in planets1.Union(planets2)
                            select planet;

foreach (var str in query)
{
    Console.WriteLine(str);
}

/* This code produces the following output:
 *
 * Mercury
 * Venus
 * Earth
 * Jupiter
 * Mars
 */

Vedere anche