linq
Operatori di query standard

Osservazioni

Operazioni di concatenazione

La concatenazione si riferisce all'operazione di accodare una sequenza a un'altra.

concat

Concatena due sequenze per formare una sequenza.

Sintassi del metodo

// Concat

var numbers1 = new int[] { 1, 2, 3 };
var numbers2 = new int[] { 4, 5, 6 };

var numbers = numbers1.Concat(numbers2);

// numbers = { 1, 2, 3, 4, 5, 6 }

Sintassi delle query

// Not applicable.

Operazioni di filtraggio

Il filtraggio si riferisce alle operazioni di restrizione del set di risultati per contenere solo quegli elementi che soddisfano una condizione specificata.

Dove

Seleziona i valori che sono basati su una funzione di predicato.

Sintassi del metodo

// Where

var numbers = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 };

var evens = numbers.Where(n => n % 2 == 0);

// evens = { 2, 4, 6, 8 }

Sintassi delle query

// where

var numbers = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 };

var odds = from n in numbers
           where n % 2 != 0
           select n;

// odds = { 1, 3, 5, 7 }

OfType

Seleziona i valori, a seconda della loro capacità di essere espressi su un tipo specificato.

Sintassi del metodo

// OfType

var numbers = new object[] { 1, "one", 2, "two", 3, "three" };

var strings = numbers.OfType<string>();

// strings = { "one", "two", "three" }

Sintassi delle query

// Not applicable.

Partecipa alle operazioni

Un join di due origini dati è l'associazione di oggetti in un'origine dati con oggetti che condividono un attributo comune in un'altra origine dati.

Aderire

Unisce due sequenze basate sulle funzioni di selezione chiave ed estrae coppie di valori.

Sintassi del metodo

// Join

class Customer
{
    public int Id { get; set; }
    public string Name { get; set; }
}

class Order
{
    public string Description { get; set; }
    public int CustomerId { get; set; }
}
...

var customers = new Customer[] 
{
    new Customer { Id = 1, Name = "C1" },
    new Customer { Id = 2, Name = "C2" },
    new Customer { Id = 3, Name = "C3" }
};

var orders = new Order[]
{
    new Order { Description = "O1", CustomerId = 1 },
    new Order { Description = "O2", CustomerId = 1 },
    new Order { Description = "O3", CustomerId = 2 },
    new Order { Description = "O4", CustomerId = 3 },
};

var join = customers.Join(orders, c => c.Id, o => o.CustomerId, (c, o) => c.Name + "-" + o.Description);

// join = { "C1-O1", "C1-O2", "C2-O3", "C3-O4" }

Sintassi delle query

// join … in … on … equals …

var join = from c in customers
           join o in orders
           on c.Id equals o.CustomerId
           select o.Description + "-" + c.Name;

// join = { "O1-C1", "O2-C1", "O3-C2", "O4-C3" }

GroupJoin

Unisce due sequenze basate sulle funzioni di selezione chiave e raggruppa le corrispondenze risultanti per ciascun elemento.

Sintassi del metodo

// GroupJoin

var groupJoin = customers.GroupJoin(orders,
                                    c => c.Id, 
                                    o => o.CustomerId, 
                                    (c, ors) => c.Name + "-" + string.Join(",", ors.Select(o => o.Description)));

// groupJoin = { "C1-O1,O2", "C2-O3", "C3-O4" }

Sintassi delle query

// join … in … on … equals … into …

var groupJoin = from c in customers
                join o in orders               
                on c.Id equals o.CustomerId
                into customerOrders
                select string.Join(",", customerOrders.Select(o => o.Description)) + "-" + c.Name;

// groupJoin = { "O1,O2-C1", "O3-C2", "O4-C3" }

Cerniera lampo

Applica una funzione specificata agli elementi corrispondenti di due sequenze, producendo una sequenza dei risultati.

var numbers = new [] { 1, 2, 3, 4, 5, 6 };
var words = new [] { "one", "two", "three" };

var numbersWithWords =
    numbers
    .Zip(
        words,
        (number, word) => new { number, word });

// Results

//| number | word   |
//| ------ | ------ |
//| 1      |  one   |
//| 2      |  two   |
//| 3      |  three |

Operazioni di proiezione

La proiezione si riferisce alle operazioni di trasformazione di un oggetto in una nuova forma.

Selezionare

Valori dei progetti basati su una funzione di trasformazione.

Sintassi del metodo

// Select

var numbers = new int[] { 1, 2, 3, 4, 5 };

var strings = numbers.Select(n => n.ToString());

// strings = { "1", "2", "3", "4", "5" }

Sintassi delle query

// select

var numbers = new int[] { 1, 2, 3, 4, 5 };

var strings = from n in numbers
              select n.ToString();

// strings = { "1", "2", "3", "4", "5" }

SelectMany

Progetta sequenze di valori basati su una funzione di trasformazione e quindi li appiattisce in un'unica sequenza.

Sintassi del metodo

// SelectMany

class Customer
{
    public Order[] Orders { get; set; }
}

class Order
{
    public Order(string desc) { Description = desc; }
    public string Description { get; set; }
}
...

var customers = new Customer[] 
{
    new Customer { Orders = new Order[] { new Order("O1"), new Order("O2") } },
    new Customer { Orders = new Order[] { new Order("O3") } },
    new Customer { Orders = new Order[] { new Order("O4") } },
};

var orders = customers.SelectMany(c => c.Orders);

// orders = { Order("O1"), Order("O3"), Order("O3"), Order("O4") }

Sintassi delle query

// multiples from

var orders = from c in customers
             from o in c.Orders
             select o;

// orders = { Order("O1"), Order("O3"), Order("O3"), Order("O4") }

Operazioni di ordinamento

Un'operazione di ordinamento ordina gli elementi di una sequenza in base a uno o più attributi.

Ordinato da

Ordina i valori in ordine crescente.

Sintassi del metodo

// OrderBy

var numbers = new int[] { 5, 4, 8, 2, 7, 1, 9, 3, 6 };

var ordered = numbers.OrderBy(n => n);

// ordered = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }

Sintassi delle query

// orderby

var numbers = new int[] { 5, 4, 8, 2, 7, 1, 9, 3, 6 };

var ordered = from n in numbers
              orderby n
              select n;

// ordered = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }

OrderByDescending

Ordina i valori in ordine decrescente.

Sintassi del metodo

// OrderByDescending

var numbers = new int[] { 5, 4, 8, 2, 7, 1, 9, 3, 6 };

var ordered = numbers.OrderByDescending(n => n);

// ordered = { 9, 8, 7, 6, 5, 4, 3, 2, 1 }

Sintassi delle query

// orderby

var numbers = new int[] { 5, 4, 8, 2, 7, 1, 9, 3, 6 };

var ordered = from n in numbers
              orderby n descending
              select n;

// ordered = { 9, 8, 7, 6, 5, 4, 3, 2, 1 }

ThenBy

Esegue un ordinamento secondario in ordine crescente.

Sintassi del metodo

// ThenBy

string[] words = { "the", "quick", "brown", "fox", "jumps" };

var ordered = words.OrderBy(w => w.Length).ThenBy(w => w[0]);

// ordered = { "fox", "the", "brown", "jumps", "quick" }

Sintassi delle query

// orderby …, …

string[] words = { "the", "quick", "brown", "fox", "jumps" };

var ordered = from w in words
              orderby w.Length, w[0]
              select w;

// ordered = { "fox", "the", "brown", "jumps", "quick" }

ThenByDescending

Esegue un ordinamento secondario in ordine decrescente.

Sintassi del metodo

// ThenByDescending

string[] words = { "the", "quick", "brown", "fox", "jumps" };

var ordered = words.OrderBy(w => w[0]).ThenByDescending(w => w.Length);

// ordered = { "brown", "fox", "jumps", "quick", "the" }

Sintassi delle query

// orderby …, … descending

string[] words = { "the", "quick", "brown", "fox", "jumps" };

var ordered = from w in words
              orderby w.Length, w[0] descending
              select w;

// ordered = { "the", "fox", "quick", "jumps", "brown" }

Inverso

Inverte l'ordine degli elementi in una raccolta.

Sintassi del metodo

// Reverse

var numbers = new int[] { 1, 2, 3, 4, 5 };

var reversed = numbers.Reverse();

// reversed = { 5, 4, 3, 2, 1 }

Sintassi delle query

// Not applicable.

Operazioni di conversione

Le operazioni di conversione cambiano il tipo di oggetti di input.

AsEnumerable

Restituisce l'input digitato come IEnumerable.

Sintassi del metodo

// AsEnumerable

int[] numbers = { 1, 2, 3, 4, 5 };

var nums = numbers.AsEnumerable();

// nums: static type is IEnumerable<int>

Sintassi delle query

// Not applicable.

AsQueryable

Converte un oggetto IEnumerable in IQueryable.

Sintassi del metodo

// AsQueryable

int[] numbers = { 1, 2, 3, 4, 5 };

var nums = numbers.AsQueryable();

// nums: static type is IQueryable<int>

Sintassi delle query

// Not applicable.

lanciare

Casta gli elementi di una raccolta in un tipo specificato.

Sintassi del metodo

// Cast

var numbers = new object[] { 1, 2, 3, 4, 5 };

var nums = numbers.Cast<int>();

// nums: static type is IEnumerable<int>

Sintassi delle query

// Use an explicitly typed range variable.

var numbers = new object[] { 1, 2, 3, 4, 5 };

var nums = from int n in numbers select n;

// nums: static type is IEnumerable<int>

OfType

Valori dei filtri, in base alla loro capacità di essere espressi su un tipo specificato.

Sintassi del metodo

// OfType

var objects = new object[] { 1, "one", 2, "two", 3, "three" };

var numbers = objects.OfType<int>();

// nums = { 1, 2, 3 }

Sintassi delle query

// Not applicable.

ToArray

Converte una raccolta in una matrice.

Sintassi del metodo

// ToArray

var numbers = Enumerable.Range(1, 5);

int[] array = numbers.ToArray();

// array = { 1, 2, 3, 4, 5 }

Sintassi delle query

// Not applicable.

Elencare

Converte una collezione in una lista.

Sintassi del metodo

// ToList

var numbers = Enumerable.Range(1, 5);

List<int> list = numbers.ToList();

// list = { 1, 2, 3, 4, 5 }

Sintassi delle query

// Not applicable.

ToDictionary

Inserisce elementi in un dizionario basato su una funzione di selezione chiave.

Sintassi del metodo

// ToDictionary

var numbers = new int[] { 1, 2, 3 };

var dict = numbers.ToDictionary(n => n.ToString());

// dict = { "1" => 1, "2" => 2, "3" => 3 }

Sintassi delle query

// Not applicable.

Operazioni di aggregazione

Le operazioni di aggregazione calcolano un singolo valore da un insieme di valori.

Aggregato

Esegue un'operazione di aggregazione personalizzata sui valori di una raccolta.

Sintassi del metodo

// Aggregate

var numbers = new int[] { 1, 2, 3, 4, 5 };

var product = numbers.Aggregate(1, (acc, n) => acc * n);

// product = 120

Sintassi delle query

// Not applicable.

Media

Calcola il valore medio di un insieme di valori.

Sintassi del metodo

// Average

var numbers = new int[] { 1, 2, 3, 4, 5 };

var average = numbers.Average();

// average = 3

Sintassi delle query

// Not applicable.

Contare

Conta gli elementi in una raccolta, opzionalmente solo quegli elementi che soddisfano una funzione di predicato.

Sintassi del metodo

// Count

var numbers = new int[] { 1, 2, 3, 4, 5 };

int count = numbers.Count(n => n % 2 == 0);

// count = 2

Sintassi delle query

// Not applicable.

LongCount

Conta gli elementi in una grande raccolta, opzionalmente solo quegli elementi che soddisfano una funzione di predicato.

Sintassi del metodo

// LongCount

var numbers = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

long count = numbers.LongCount();

// count = 10

Sintassi delle query

// Not applicable.

Max

Determina il valore massimo in una raccolta. Genera un'eccezione se la raccolta è vuota.

Sintassi del metodo

// Max

var numbers = new int[] { 1, 2, 3, 4, 5 };

var max = numbers.Max();

// max = 5

Sintassi delle query

// Not applicable.

min

Determina il valore minimo in una raccolta. Genera un'eccezione se la raccolta è vuota.

Sintassi del metodo

// Min

var numbers = new int[] { 1, 2, 3, 4, 5 };

var min = numbers.Min();

// min = 1

Sintassi delle query

// Not applicable.

Min- / MaxOrDefault

A differenza di altre estensioni LinQ Min() e Max() non hanno un sovraccarico senza eccezioni. Pertanto, è necessario selezionare IEnumerable Any() prima di chiamare Min() o Max()

// Max

var numbers = new int[] { };

var max = numbers.Any() ? numbers.Max() : 0;

// max = 0

Somma

Calcola la somma dei valori in una raccolta.

Sintassi del metodo

// Sum

var numbers = new int[] { 1, 2, 3, 4, 5 };

var sum = numbers.Sum();

// sum = 15

Sintassi delle query

// Not applicable.

Operazioni di Quantificatore

Le operazioni Quantifier restituiscono un valore booleano che indica se alcuni o tutti gli elementi di una sequenza soddisfano una condizione.

Tutti

Determina se tutti gli elementi di una sequenza soddisfano una condizione.

Sintassi del metodo

// All

var numbers = new int[] { 1, 2, 3, 4, 5 };

bool areLessThan10 = numbers.All(n => n < 10);

// areLessThan10 = true

Sintassi delle query

// Not applicable.

Qualunque

Determina se alcuni elementi in una sequenza soddisfano una condizione.

Sintassi del metodo

// Any

var numbers = new int[] { 1, 2, 3, 4, 5 };

bool anyOneIsEven = numbers.Any(n => n % 2 == 0);

// anyOneIsEven = true

Sintassi delle query

// Not applicable.

contiene

Determina se una sequenza contiene un elemento specificato.

Sintassi del metodo

// Contains

var numbers = new int[] { 1, 2, 3, 4, 5 };

bool appears = numbers.Contains(10);

// appears = false

Sintassi delle query

// Not applicable.

Operazioni di raggruppamento

Raggruppamento si riferisce alle operazioni di inserimento dei dati in gruppi in modo che gli elementi di ciascun gruppo condividano un attributo comune.

Raggruppa per

Gruppi di elementi che condividono un attributo comune.

Sintassi del metodo

// GroupBy

class Order
{
    public string Customer { get; set; }
    public string Description { get; set; }
}
...

var orders = new Order[] 
{
    new Order { Customer = "C1", Description = "O1" },
    new Order { Customer = "C2", Description = "O2" },
    new Order { Customer = "C3", Description = "O3" },
    new Order { Customer = "C1", Description = "O4" },
    new Order { Customer = "C1", Description = "O5" },
    new Order { Customer = "C3", Description = "O6" },
};

var groups = orders.GroupBy(o => o.Customer);

// groups: { (Key="C1", Values="O1","O4","O5"), (Key="C2", Values="O2"), (Key="C3", Values="O3","O6") }

Sintassi delle query

// group … by

var groups = from o in orders
             group o by o.Customer;

// groups: { (Key="C1", Values="O1","O4","O5"), (Key="C2", Values="O2"), (Key="C3", Values="O3","O6") }

ToLookup

Inserisce elementi in un dizionario uno-a-molti basato su una funzione di selezione chiave.

Sintassi del metodo

// ToLookUp

var ordersByCustomer = orders.ToLookup(o => o.Customer);

// ordersByCustomer = ILookUp<string, Order>
// {
//     "C1" => { Order("01"), Order("04"), Order("05") },
//     "C2" => { Order("02") },
//     "C3" => { Order("03"), Order("06") }
// }

Sintassi delle query

// Not applicable.

Operazioni di partizione

Il partizionamento si riferisce alle operazioni di divisione di una sequenza di input in due sezioni, senza riorganizzare gli elementi e quindi restituire una delle sezioni.

Salta

Salta gli elementi fino a una posizione specificata in una sequenza.

Sintassi del metodo

// Skip

var numbers = new int[] { 1, 2, 3, 4, 5 };

var skipped = numbers.Skip(3);

// skipped = { 4, 5 }

Sintassi delle query

// Not applicable.

SkipWhile

Salta gli elementi in base a una funzione predicato fino a quando un elemento non soddisfa la condizione.

Sintassi del metodo

// Skip

var numbers = new int[] { 1, 3, 5, 2, 1, 3, 5 };

var skipLeadingOdds = numbers.SkipWhile(n => n % 2 != 0);

// skipLeadingOdds = { 2, 1, 3, 5 }

Sintassi delle query

// Not applicable.

Prendere

Porta gli elementi fino a una posizione specificata in una sequenza.

Sintassi del metodo

// Take

var numbers = new int[] { 1, 2, 3, 4, 5 };

var taken = numbers.Take(3);

// taken = { 1, 2, 3 }

Sintassi delle query

// Not applicable.

TakeWhile

Accetta elementi in base a una funzione di predicato fino a quando un elemento non soddisfa la condizione.

Sintassi del metodo

// TakeWhile

var numbers = new int[] { 1, 3, 5, 2, 1, 3, 5 };

var takeLeadingOdds = numbers.TakeWhile(n => n % 2 != 0);

// takeLeadingOdds = { 1, 3, 5 }

Sintassi delle query

// Not applicable.

Operazioni generazionali

La generazione si riferisce alla creazione di una nuova sequenza di valori.

DefaultIfEmpty

Sostituisce una raccolta vuota con una raccolta singleton con valore predefinito.

Sintassi del metodo

// DefaultIfEmpty

var nums = new int[0];

var numbers = nums.DefaultIfEmpty();

// numbers = { 0 }

Sintassi delle query

// Not applicable.

Vuoto

Restituisce una collezione vuota.

Sintassi del metodo

// Empty

var empty = Enumerable.Empty<string>();

// empty = IEnumerable<string> { }

Sintassi delle query

// Not applicable.

Gamma

Genera una collezione che contiene una sequenza di numeri.

Sintassi del metodo

// Range

var range = Enumerable.Range(1, 5);

// range = { 1, 2, 3, 4, 5 }

Sintassi delle query

// Not applicable.

Ripetere

Genera una collezione che contiene un valore ripetuto.

Sintassi del metodo

// Repeat

var repeats = Enumerable.Repeat("s", 3);

// repeats = { "s", "s", "s" }

Sintassi delle query

// Not applicable.

Imposta le operazioni

Le operazioni di set si riferiscono a operazioni di query che producono un set di risultati basato sulla presenza o l'assenza di elementi equivalenti all'interno delle raccolte o insiemi uguali o separati.

distinto

Rimuove i valori duplicati da una raccolta.

Sintassi del metodo

// Distinct

var numbers = new int[] { 1, 2, 3, 1, 2, 3 };

var distinct = numbers.Distinct();

// distinct = { 1, 2, 3 }

Sintassi delle query

// Not applicable.

tranne

Restituisce la differenza impostata, ovvero gli elementi di una raccolta che non appaiono in una seconda raccolta.

Sintassi del metodo

// Except

var numbers1 = new int[] { 1, 2, 3, 4, 5 };
var numbers2 = new int[] { 4, 5, 6, 7, 8 };

var except = numbers1.Except(numbers2);

// except = { 1, 2, 3 }

Sintassi delle query

// Not applicable.

intersecare

Restituisce l'intersezione impostata, ovvero gli elementi che appaiono in ciascuna delle due raccolte.

Sintassi del metodo

// Intersect

var numbers1 = new int[] { 1, 2, 3, 4, 5 };
var numbers2 = new int[] { 4, 5, 6, 7, 8 };

var intersect = numbers1.Intersect(numbers2);

// intersect = { 4, 5 }

Sintassi delle query

// Not applicable.

Unione

Restituisce l'unione dell'insieme, che significa elementi unici che appaiono in una delle due raccolte.

Sintassi del metodo

// Union

var numbers1 = new int[] { 1, 2, 3, 4, 5 };
var numbers2 = new int[] { 4, 5, 6, 7, 8 };

var union = numbers1.Union(numbers2);

// union = { 1, 2, 3, 4, 5, 6, 7, 8 }

Sintassi delle query

// Not applicable.

Operazioni di uguaglianza

Due sequenze i cui elementi corrispondenti sono uguali e che hanno lo stesso numero di elementi sono considerate uguali.

SequenceEqual

Determina se due sequenze sono uguali confrontando gli elementi in un modo saggio coppia.

Sintassi del metodo

// SequenceEqual

var numbers1 = new int[] { 1, 2, 3, 4, 5 };
var numbers2 = new int[] { 1, 2, 3, 4, 5 };

var equals = numbers1.SequenceEqual(numbers2);

// equals = true

Sintassi delle query

// Not Applicable.

Operazioni sugli elementi

Le operazioni sugli elementi restituiscono un singolo elemento specifico da una sequenza.

ElementAt

Restituisce l'elemento in un indice specificato in una raccolta.

Sintassi del metodo

// ElementAt

var strings = new string[] { "zero", "one", "two", "three" };

var str = strings.ElementAt(2);

// str = "two"

Sintassi delle query

// Not Applicable.

ElementAtOrDefault

Restituisce l'elemento in un indice specificato in una raccolta o un valore predefinito se l'indice non è compreso nell'intervallo.

Sintassi del metodo

// ElementAtOrDefault

var strings = new string[] { "zero", "one", "two", "three" };

var str = strings.ElementAtOrDefault(10);

// str = null

Sintassi delle query

// Not Applicable.

Primo

Restituisce il primo elemento di una raccolta o il primo elemento che soddisfa una condizione.

Sintassi del metodo

// First

var numbers = new int[] { 1, 2, 3, 4, 5 };

var first = strings.First();

// first = 1

Sintassi delle query

// Not Applicable.

FirstOrDefault

Restituisce il primo elemento di una raccolta o il primo elemento che soddisfa una condizione. Restituisce un valore predefinito se non esiste alcun elemento di questo tipo.

Sintassi del metodo

// FirstOrDefault

var numbers = new int[] { 1, 2, 3, 4, 5 };

var firstGreaterThanTen = strings.FirstOrDefault(n => n > 10);

// firstGreaterThanTen = 0

Sintassi delle query

// Not Applicable.

Scorso

Restituisce l'ultimo elemento di una raccolta o l'ultimo elemento che soddisfa una condizione.

Sintassi del metodo

// Last

var numbers = new int[] { 1, 2, 3, 4, 5 };

var last = strings.Last();

// last = 5

Sintassi delle query

// Not Applicable.

LastOrDefault

Restituisce l'ultimo elemento di una raccolta o l'ultimo elemento che soddisfa una condizione. Restituisce un valore predefinito se non esiste alcun elemento di questo tipo.

Sintassi del metodo

// LastOrDefault

var numbers = new int[] { 1, 2, 3, 4, 5 };

var lastGreaterThanTen = strings.LastOrDefault(n => n > 10);

// lastGreaterThanTen = 0

Sintassi delle query

// Not Applicable.

singolo

Restituisce l'unico elemento di una raccolta o l'unico elemento che soddisfa una condizione.

Sintassi del metodo

// Single

var numbers = new int[] { 1 };

var single = strings.Single();

// single = 1

Sintassi delle query

// Not Applicable.

SingleOrDefault

Restituisce l'unico elemento di una raccolta o l'unico elemento che soddisfa una condizione. Restituisce un valore predefinito se non esiste alcun elemento di questo tipo o la raccolta non contiene esattamente un elemento.

Sintassi del metodo

// SingleOrDefault

var numbers = new int[] { 1, 2, 3, 4, 5 };

var singleGreaterThanFour = strings.SingleOrDefault(n => n > 4);

// singleGreaterThanFour = 5

Sintassi delle query

// Not Applicable.