.NET Framework
LINQ

ASP.NET asp.net-mvc C# Language Entity Framework JavaScript Regular Expressions SQL Microsoft SQL Server Visual Basic .NET Language wpf
Ricerca…


introduzione

LINQ (Language Integrated Query) è un'espressione che recupera i dati da un'origine dati. LINQ semplifica questa situazione offrendo un modello coerente per lavorare con i dati attraverso vari tipi di fonti e formati di dati. In una query LINQ, si lavora sempre con gli oggetti. Si utilizzano gli stessi schemi di codifica di base per interrogare e trasformare i dati in documenti XML, database SQL, set di dati ADO.NET, raccolte .NET e qualsiasi altro formato per il quale un provider è disponibile. LINQ può essere utilizzato in C # e VB.

Sintassi

  • public static TSource Aggregate <TSource> (questa sorgente IEnumerable <TSource>, Func <TSource, TSource, TSource> func)
  • TAccumulate Aggregate statico pubblico <TSource, TAccumulate> (questa sorgente IEnumerable <TSource>, seme TAccumulate, Func <TAccumulate, TSource, TAccumulate> func)
  • statico pubblico TResult Aggregate <TSource, TAccumulate, TResult> (questa sorgente IEnumerable <TSource>, TAccumulate seed, Func <TAccumulate, TSource, TAccumulate>, Func <TAccumulate, TResult> resultSelector)
  • public static Booleano Tutti <TSource> (questo predicato IEnumerable <Origine TSource, Func <TSource, Boolean>)
  • public static Boolean Any <TSource> (questa origine IEnumerable <TSource>)
  • public static Booleano Any <TSource> (questo predicato IEnumerable <Origine TS, Fun <TSource, Boolean>)
  • public static IEnumerable <TSource> AsEnumerable <TSource> (questa sorgente IEnumerable <TSource>)
  • Media decimale statica pubblica (questa origine IEnumerable <Decimal>)
  • Double Average statico pubblico (questo IEnumerable <Double> origine)
  • Double Average statico pubblico (questa sorgente IEnumerable <Int32>)
  • Double Average statico pubblico (questa sorgente IEnumerable <Int64>)
  • public static Nullable <Decimal> Average (questa fonte IEnumerable <Nullable <Decimal >>)
  • public static Nullable <Double> Average (this IEnumerable <Nullable <Double >> source)
  • public static Nullable <Double> Average (questa sorgente IEnumerable <Nullable <Int32 >>)
  • public static Nullable <Double> Average (questa fonte IEnumerable <Nullable <Int64 >>)
  • public static Nullable <Single> Average (this IEnumerable <Nullable <Single >> source)
  • Media statica pubblica singola (questa origine IEnumerable <Single>)
  • Media decimale statica media <TSource> (questo selettore IEnumerable <TSource>, Func <TSource, Decimal>)
  • media statica Double Average <TSource> (questo sorgente IEnumerable <TSource>, Func <TSource, Double>)
  • media statica Double Average <TSource> (questo componente IEnumerable <TSource>, Func <TSource, Int32>)
  • media statica Double Average <TSource> (questo selettore IEnumerable <TSource>, Func <TSource, Int64>)
  • public static Nullable <Decimal> Average <TSource> (questo IEnumerable <Origine TSource, Func <TSource, Nullable <Decimale >> Selettore)
  • public static Nullable <Double> Average <TSource> (questa sorgente IEnumerable <TSource>, Func <TSource, Nullable <Double >>)
  • public static Nullable <Double> Average <TSource> (questo IEnumerable <Origine TSource> Func <TSource, Nullable <Int32 >> selector)
  • public static Nullable <Double> Average <TSource> (questo IEnumerable <Origine TSource> Func <TSource, Nullable <Int64 >> selector)
  • public static Nullable <Single> Average <TSource> (questa sorgente IEnumerable <TSource>, Func <TSource, Nullable <Single >>)
  • media singola statica pubblica <TSource> (questo selettore IEnumerable <Origine TSource, Func <TSource, Single>)
  • public static IEnumerable <TResult> Cast <TResult> (questa sorgente IEnumerable)
  • public static IEnumerable <TSource> Concat <TSource> (questo IEnumerable <TSource> first, IEnumerable <TSource> secondo)
  • public static Boolean Contiene <TSource> (questa origine IEnumerable <TSource>, valore TSource)
  • public static Boolean Contiene <TSource> (questa origine IEnumerable <TSource>, valore TSource, Comparatore IEqualityComparer <TSource>)
  • Conteggio Int32 statico pubblico <TSource> (questa origine IEnumerable <TSource>)
  • Conteggio Int32 statico pubblico <TSource> (questo predicato IEnumerable <Origine TSource, Func <TSource, Boolean>)
  • public static IEnumerable <TSource> DefaultIfEmpty <TSource> (questa origine IEnumerable <TSource>)
  • public static IEnumerable <TSource> DefaultIfEmpty <TSource> (questa sorgente IEnumerable <TSource>, TSource defaultValue)
  • public static IEnumerable <TSource> Distinct <TSource> (questa origine IEnumerable <TSource>)
  • public static IEnumerable <TSource> Distinct <TSource> (questa sorgente IEnumerable <TSource>, IEqualityComparer <TSource> comparer)
  • public static TSource ElementAt <TSource> (questa sorgente IEnumerable <TSource>, indice Int32)
  • pubblico statico TSource ElementAtOrDefault <TSource> (questa origine IEnumerable <TSource>, indice Int32)
  • public static IEnumerable <TResult> Empty <TResult> ()
  • public static IEnumerable <TSource> Eccetto <TSource> (questo IEnumerable <TSource> first, IEnumerable <TSource> secondo)
  • public static IEnumerable <TSource> Tranne <TSource> (questo IEnumerable <TSource> first, IEnumerable <TSource> secondo, IEqualityComparer <TSource> comparer)
  • public static TSource First <TSource> (questa origine IEnumerable <TSource>)
  • public static TSource First <TSource> (questo predicato IEnumerable <TSource> source, Func <TSource, Boolean>)
  • public static TSource FirstOrDefault <TSource> (questa origine IEnumerable <TSource>)
  • public static TSource FirstOrDefault <TSource> (questo predicato IEnumerable <TSource> source, Func <TSource, Boolean>)
  • public static IEnumerable <IGrouping <TKey, TSource >> GroupBy <TSource, TKey> (questa sorgente IEnumerable <TSource>, Func <TSource, TKey> keySelector)
  • public static IEnumerable <IGrouping <TKey, TSource >> GroupBy <TSource, TKey> (questa sorgente IEnumerable <TSource>, Func <TSource, TKey> keySelector, IEqualityComparer <TKey> comparer)
  • public static IEnumerable <IGrouping <TKey, TElement >> GroupBy <TSource, TKey, TElement> (questa sorgente IEnumerable <TSource>, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector)
  • public static IEnumerable <IGrouping <TKey, TElement >> GroupBy <TSource, TKey, TElement> (questa sorgente IEnumerable <TSource>, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, IEqualityComparer <TKey> comparer)
  • public static IEnumerable <TResult> GroupBy <TSource, TKey, TResult> (questa sorgente IEnumerable <TSource>, Func <TSource, TKey> keySelector, Func <TKey, IEnumerable <TSource>, TResult> resultSelector)
  • public static IEnumerable <TResult> GroupBy <TSource, TKey, TResult> (questa sorgente IEnumerable <TSource>, Func <TSource, TKey> keySelector, Func <TKey, IEnumerable <TSource>, TResult> resultSelector, IEqualityComparer <TKey> comparer)
  • public static IEnumerable <TResult> GroupBy <TSource, TKey, TElement, TResult> (questa sorgente IEnumerable <TSource>, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, Func <TKey, IEnumerable <TElement>, TResult > resultSelector)
  • public static IEnumerable <TResult> GroupBy <TSource, TKey, TElement, TResult> (questa sorgente IEnumerable <TSource>, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, Func <TKey, IEnumerable <TElement>, TResult > resultSelector, IEqualityComparer <TKey> comparer)
  • public static IEnumerable <TResult> GroupJoin <TOuter, TInner, TKey, TResult> (questo IEnumerable <TOuter> esterno, IEnumerable <TInner> interno, Func <TOuter, TKey> outerKeySelector, Func <TInner, TKey> innerKeySelector, Func <TOuter, IEnumerable <TInner>, TResult> resultSelector)
  • public static IEnumerable <TResult> GroupJoin <TOuter, TInner, TKey, TResult> (questo IEnumerable <TOuter> esterno, IEnumerable <TInner> interno, Func <TOuter, TKey> outerKeySelector, Func <TInner, TKey> innerKeySelector, Func <TOuter, IEnumerable <TInner>, TResult> resultSelector, IEqualityComparer <TKey> comparer)
  • public static IEnumerable <TSource> Intersect <TSource> (questo IEnumerable <TSource> first, IEnumerable <TSource> second)
  • public static IEnumerable <TSource> Intersect <TSource> (questo IEnumerable <TSource> first, IEnumerable <TSource> secondo, IEqualityComparer <TSource> comparer)
  • public static IEnumerable <TResult> Join <TOuter, TInner, TKey, TResult> (questo IEnumerable <TOuter> esterno, IEnumerable <TInner> interno, Func <TOuter, TKey> outerKeySelector, Func <TInner, TKey> innerKeySelector, Func <TOuter, TInner, TResult> resultSelector)
  • public static IEnumerable <TResult> Join <TOuter, TInner, TKey, TResult> (questo IEnumerable <TOuter> esterno, IEnumerable <TInner> interno, Func <TOuter, TKey> outerKeySelector, Func <TInner, TKey> innerKeySelector, Func <TOuter, TInner, TResult> resultSelector, IEqualityComparer <TKey> comparer)
  • public static TSource Last <TSource> (questa fonte IEnumerable <TSource>)
  • public static TSource Last <TSource> (questo predicato IEnumerable <TSource> source, Func <TSource, Boolean>)
  • public static TSource LastOrDefault <TSource> (questa origine IEnumerable <TSource>)
  • public static TSource LastOrDefault <TSource> (questo predicato IEnumerable <TSource>, Func <TSource, Boolean>)
  • public static Int64 LongCount <TSource> (questa origine IEnumerable <TSource>)
  • public static Int64 LongCount <TSource> (questo predicato IEnumerable <TSource> source, Func <TSource, Boolean>)
  • Max decimale statico pubblico (questa origine IEnumerable <Decimal>)
  • Double Max statico pubblico (questa sorgente <Double> di IEnumerable)
  • Int32 Max statico pubblico (questa origine IEnumerable <Int32>)
  • pubblico statico Int64 Max (questa sorgente IEnumerable <Int64>)
  • public static Nullable <Decimal> Max (questa sorgente IEnumerable <Nullable <Decimal >>)
  • public static Nullable <Double> Max (questa sorgente IEnumerable <Nullable <Double >>)
  • statico pubblico Nullable <Int32> Max (questa sorgente IEnumerable <Nullable <Int32 >>)
  • public static Nullable <Int64> Max (questa sorgente IEnumerable <Nullable <Int64 >>)
  • public static Nullable <Single> Max (questa sorgente IEnumerable <Nullable <Single >>)
  • Single Max pubblico statico (questa sorgente IEnumerable <Single>)
  • public static TSource Max <TSource> (questa origine IEnumerable <TSource>)
  • decimale statico pubblico massimo <TSource> (questo selettore IEnumerable <TSource>, Func <TSource, Decimal>)
  • public static Double Max <TSource> (questo sorgente IEnumerable <TSource>, Func <TSource, Double>)
  • public static Int32 Max <TSource> (questo selettore IEnumerable <TSource>, Func <TSource, Int32>)
  • public static Int64 Max <TSource> (questo selettore IEnumerable <TSource>, Func <TSource, Int64>)
  • public static Nullable <Decimal> Max <TSource> (questo sorgente IEnumerable <TSource>, Func <TSource, Nullable <Decimal >>)
  • public static Nullable <Double> Max <TSource> (questa sorgente IEnumerable <TSource>, Func <TSource, Nullable <Double >>)
  • public static Nullable <Int32> Max <TSource> (questo sorgente IEnumerable <TSource>, Func <TSource, Nullable <Int32 >>)
  • public static Nullable <Int64> Max <TSource> (questo IEnumerable <Origine TSource> Func <TSource, Nullable <Int64 >> selector)
  • public static Nullable <Single> Max <TSource> (questo sorgente IEnumerable <TSource>, Func <TSource, Nullable <Single >>)
  • public static Single Max <TSource> (questo sorgente IEnumerable <TSource>, Func <TSource, Single>)
  • pubblico statico TResult Max <TSource, TResult> (questo sorgente IEnumerable <TSource>, Func <TSource, TResult>)
  • Minimo statico pubblico Minimo (questa origine IEnumerable <Decimal>)
  • Double Min statico pubblico (questa origine IEnumerable <Double>)
  • public static Int32 Min (questa sorgente IEnumerable <Int32>)
  • pubblico statico Int64 Min (questa sorgente IEnumerable <Int64>)
  • public static Nullable <Decimal> Min (questa fonte IEnumerable <Nullable <Decimal >>)
  • public static Nullable <Double> Min (questa sorgente IEnumerable <Nullable <Double >>)
  • public static Nullable <Int32> Min (questa sorgente IEnumerable <Nullable <Int32 >>)
  • public static Nullable <Int64> Min (questa sorgente IEnumerable <Nullable <Int64 >>)
  • statico pubblico Nullable <Singolo> Min (questo oggetto IEnumerable <Nullable <Single >>)
  • Single Min statico pubblico (questa origine IEnumerable <Single>)
  • public static TSource Min <TSource> (questa origine IEnumerable <TSource>)
  • public static Decimal Min <TSource> (questo selettore IEnumerable <TSource>, Func <TSource, Decimal>)
  • public static Double Min <TSource> (questo sorgente IEnumerable <TSource>, Func <TSource, Double>)
  • public static Int32 Min <TSource> (questo sorgente IEnumerable <TSource>, Func <TSource, Int32>)
  • public static Int64 Min <TSource> (questo selettore IEnumerable <TSource>, Func <TSource, Int64>)
  • public static Nullable <Decimal> Min <TSource> (questo sorgente IEnumerable <Origine TS, Func <TSource, Nullable <Decimale >>)
  • public static Nullable <Double> Min <TSource> (questa sorgente IEnumerable <TSource>, Func <TSource, Nullable <Double >>)
  • public static Nullable <Int32> Min <TSource> (questo sorgente IEnumerable <Origine TS, Func <TSource, Nullable <Int32 >>)
  • public static Nullable <Int64> Min <TSource> (questo IEnumerable <Origine TSource> Func <TSource, Nullable <Int64 >> selector)
  • public static Nullable <Single> Min <TSource> (questo sorgente IEnumerable <TSource>, Func <TSource, Nullable <Single >>)
  • public static Single Min <TSource> (questo sorgente IEnumerable <TSource>, Func <TSource, Single>)
  • pubblico statico TResult Min <TSource, TResult> (questo sorgente IEnumerable <TSource>, Func <TSource, TResult>)
  • public static IEnumerable <TResult> OfType <TResult> (questa sorgente IEnumerable)
  • public static IOrderedEnumerable <TSource> OrderBy <TSource, TKey> (questa sorgente IEnumerable <TSource>, Func <TSource, TKey> keySelector)
  • public static IOrderedEnumerable <TSource> OrderBy <TSource, TKey> (questa sorgente IEnumerable <TSource>, Func <TSource, TKey> keySelector, IComparer <TKey> comparer)
  • public static IOrderedEnumerable <TSource> OrderByDescending <TSource, TKey> (questa sorgente IEnumerable <TSource>, Func <TSource, TKey> keySelector)
  • public static IOrderedEnumerable <TSource> OrderByDescending <TSource, TKey> (questa sorgente IEnumerable <TSource>, Func <TSource, TKey> keySelector, IComparer <TKey> comparer)
  • Intervallo pubblico IEnumerable <Int32> public (Int32 start, Int32 count)
  • public static IEnumerable <TResult> Repeat <TResult> (elemento TResult, numero Int32)
  • public static IEnumerable <TSource> Reverse <TSource> (questa sorgente IEnumerable <TSource>)
  • public static IEnumerable <TResult> Seleziona <TSource, TResult> (questo sorgente IEnumerable <TSource>, Func <TSource, TResult>)
  • public static IEnumerable <TResult> Seleziona <TSource, TResult> (questo sorgente IEnumerable <TSource>, Func <TSource, Int32, TResult>)
  • public static IEnumerable <TResult> SelectMany <TSource, TResult> (questo sorgente IEnumerable <TSource>, Func <TSource, IEnumerable <TResult >>)
  • public static IEnumerable <TResult> SelectMany <TSource, TResult> (questo sorgente IEnumerable <TSource>, Func <TSource, Int32, IEnumerable <TResult >>)
  • public static IEnumerable <TResult> SelectMany <TSource, TCollection, TResult> (questa sorgente IEnumerable <TSource>, Func <TSource, IEnumerable <TCollection >> collectionSelector, Func <TSource, TCollection, TResult> resultSelector)
  • public static IEnumerable <TResult> SelectMany <TSource, TCollection, TResult> (questa sorgente IEnumerable <TSource>, Func <TSource, Int32, IEnumerable <TCollection >> collectionSelector, Func <TSource, TCollection, TResult> resultSelector)
  • public static Boolean SequenceEqual <TSource> (questo IEnumerable <TSource> first, IEnumerable <TSource> second)
  • public static Boolean SequenceEqual <TSource> (questo IEnumerable <TSource> first, IEnumerable <TSource> secondo, IEqualityComparer <TSource> comparer)
  • public static TSource Single <TSource> (questa sorgente IEnumerable <TSource>)
  • public static TSource Single <TSource> (questo predicato IEnumerable <TSource> source, Func <TSource, Boolean>)
  • public static TSource SingleOrDefault <TSource> (questa origine IEnumerable <TSource>)
  • public static TSource SingleOrDefault <TSource> (questo predicato IEnumerable <TSource> source, Func <TSource, Boolean>)
  • public static IEnumerable <TSource> Salta <TSource> (questa sorgente IEnumerable <TSource>, conteggio Int32)
  • public static IEnumerable <TSource> SkipWhile <TSource> (questo predicato IEnumerable <TSource>, Func <TSource, Boolean>)
  • statico pubblico IEnumerable <TSource> SkipWhile <TSource> (questo predicato IEnumerable <TSource>, Func <TSource, Int32, Boolean>)
  • Somma decimale statica pubblica (questa origine IEnumerable <Decimal>)
  • Double Sum statico pubblico (questa origine <Double> di IEnumerable)
  • Somma Int32 statica pubblica (questa origine IEnumerable <Int32>)
  • Somma Int64 statica pubblica (questa origine IEnumerable <Int64>)
  • Sommario <decimale> Nullable statico pubblico (questa origine IEnumerable <Nullable <Decimal >>)
  • public static Nullable <Double> Sum (this IEnumerable <Nullable <Double >> source)
  • Somma statica pubblica Nullable <Int32> (questa origine IEnumerable <Nullable <Int32 >>)
  • Somma statica pubblica Nullable <Int64> (questa origine IEnumerable <Nullable <Int64 >>)
  • public static Nullable <Single> Sum (this IEnumerable <Nullable <Single >> source)
  • Somma statica pubblica singola (questa origine IEnumerable <Single>)
  • Somma decimale statica pubblica <TSource> (questo selettore IEnumerable <TSource>, Func <TSource, Decimal>)
  • Double Sum statico pubblico <TSource> (questo sorgente IEnumerable <Origine TSource, Func <TSource, Double>)
  • Somma Intica statica pubblica <TSource> (questo sorgente IEnumerable <Origine TSource, Func <TSource, Int32>)
  • Somma Int64 statica pubblica <TSource> (questo selettore IEnumerable <TSource>, Func <TSource, Int64>)
  • public static Nullable <Decimal> Sum <TSource> (questo IEnumerable <Origine TSource, Func <TSource, Nullable <Decimale >> Selettore)
  • public static Nullable <Double> Sum <TSource> (questa sorgente IEnumerable <TSource>, Func <TSource, Nullable <Double >>)
  • public static Nullable <Int32> Sum <TSource> (questo IEnumerable <Origine TSource> Func <TSource, Nullable <Int32 >> selector)
  • public static Nullable <Int64> Sum <TSource> (questo componente IEnumerable <TSource>, Func <TSource, Nullable <Int64 >>)
  • public static Nullable <Single> Sum <TSource> (questo sorgente IEnumerable <TSource>, Func <TSource, Nullable <Single >>)
  • Somma statica pubblica singola <TSource> (questo selettore IEnumerable <TSource>, Func <TSource, Single>)
  • public static IEnumerable <TSource> Take <TSource> (questa sorgente IEnumerable <TSource>, conteggio Int32)
  • public static IEnumerable <TSource> TakeWhile <TSource> (questo predicato IEnumerable <TSource> source, Func <TSource, Boolean>)
  • public static IEnumerable <TSource> TakeWhile <TSource> (questo predicato IEnumerable <TSource>, Func <TSource, Int32, Boolean>)
  • public static IOrderedEnumerable <TSource> ThenBy <TSource, TKey> (questa sorgente IOrderedEnumerable <TSource>, Func <TSource, TKey> keySelector)
  • public static IOrderedEnumerable <TSource> ThenBy <TSource, TKey> (questa sorgente IOrderedEnumerable <TSource>, Func <TSource, TKey> keySelector, IComparer <TKey> comparer)
  • public static IOrderedEnumerable <TSource> ThenByDescending <TSource, TKey> (questa sorgente IOrderedEnumerable <TSource>, Func <TSource, TKey> keySelector)
  • public static IOrderedEnumerable <TSource> ThenByDescending <TSource, TKey> (questa sorgente IOrderedEnumerable <TSource>, Func <TSource, TKey> keySelector, IComparer <TKey> comparer)
  • public static TSource [] ToArray <TSource> (questa sorgente IEnumerable <TSource>)
  • Dizionario statico pubblico <TKey, TSource> ToDictionary <TSource, TKey> (questa sorgente IEnumerable <TSource>, Func <TSource, TKey> keySelector)
  • Dizionario statico pubblico <TKey, TSource> ToDictionary <TSource, TKey> (questa sorgente IEnumerable <TSource>, Func <TSource, TKey> keySelector, IEqualityComparer <TKey> comparer)
  • Dizionario statico pubblico <TKey, TElement> ToDictionary <TSource, TKey, TElement> (questa sorgente IEnumerable <TSource>, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector)
  • Dizionario statico pubblico <TKey, TElement> ToDictionary <TSource, TKey, TElement> (questa sorgente IEnumerable <TSource>, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, IEqualityComparer <TKey> comparer)
  • elenco statico pubblico <TSource> ToList <TSource> (questa origine IEnumerable <TSource>)
  • public static ILookup <TKey, TSource> ToLookup <TSource, TKey> (questa sorgente IEnumerable <TSource>, Func <TSource, TKey> keySelector)
  • public static ILookup <TKey, TSource> ToLookup <TSource, TKey> (questa sorgente IEnumerable <TSource>, Func <TSource, TKey> keySelector, IEqualityComparer <TKey> comparer)
  • public static ILookup <TKey, TElement> ToLookup <TSource, TKey, TElement> (questa sorgente IEnumerable <TSource>, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector)
  • public static ILookup <TKey, TElement> ToLookup <TSource, TKey, TElement> (questa sorgente IEnumerable <TSource>, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, IEqualityComparer <TKey> comparer)
  • public static IEnumerable <TSource> Union <TSource> (questo IEnumerable <TSource> first, IEnumerable <TSource> second)
  • public static IEnumerable <TSource> Union <TSource> (questo IEnumerable <TSource> first, IEnumerable <TSource> secondo, IEqualityComparer <TSource> comparer)
  • public static IEnumerable <TSource> Dove <TSource> (questo sorgente IEnumerable <TSource>, Func <TSource, Boolean>)
  • public static IEnumerable <TSource> Dove <TSource> (questo sorgente IEnumerable <TSource>, Func <TSource, Int32, Boolean>)
  • public static IEnumerable <TResult> Zip <TFirst, TSecond, TResult> (questo IEnumerable <TFirst> primo, IEnumerable <TSecond> secondo, Func <TFirst, TSecond, TResult> resultSelector)

Osservazioni

I metodi integrati LINQ sono metodi di estensione per l'interfaccia IEnumerable<T> che risiedono nella classe System.Linq.Enumerable nell'assembly System.Core . Sono disponibili in .NET Framework 3.5 e versioni successive.

LINQ consente la modifica, la trasformazione e la combinazione di vari IEnumerable usando una sintassi di tipo query o funzionale.

Mentre i metodi LINQ standard possono funzionare su qualsiasi IEnumerable<T> , compresi gli array semplici e List<T> s, possono essere utilizzati anche su oggetti di database, in cui l'insieme di espressioni LINQ può essere trasformato in molti casi in SQL se il l'oggetto dati lo supporta. Vedi LINQ to SQL .

Per i metodi che confrontano gli oggetti (come Contains ed Except ), IEquatable<T>.Equals viene utilizzato se il tipo T della raccolta implementa tale interfaccia. In caso contrario, vengono utilizzati gli standard Equals e GetHashCode del tipo (eventualmente sovrascritti dalle implementazioni Object predefinite). Esistono anche sovraccarichi per questi metodi che consentono di specificare un IEqualityComparer<T> personalizzato IEqualityComparer<T> .

Per i metodi ...OrDefault , il default(T) viene utilizzato per generare valori predefiniti.

Riferimento ufficiale: classe enumerabile

Valutazione pigra

Praticamente ogni query che restituisce un IEnumerable<T> non viene valutata immediatamente; invece, la logica viene ritardata fino a quando la query non viene ripetuta. Una implicazione è che ogni volta che qualcuno esegue un'iterazione su un oggetto IEnumerable<T> creato da una di queste query, ad esempio, .Where() , viene ripetuta la logica di query completa. Se il predicato è di lunga durata, ciò può essere causa di problemi di prestazioni.

Una soluzione semplice (quando si conosce o può controllare la dimensione approssimativa della sequenza risultante) consiste nel bufferizzare completamente i risultati utilizzando .ToArray() o .ToList() . .ToDictionary() o .ToLookup() può svolgere lo stesso ruolo. Si può anche, ovviamente, iterare sull'intera sequenza e bufferizzare gli elementi secondo un'altra logica personalizzata.

ToArray() o ToList() ?

Sia .ToArray() che .ToList() ciclo di tutti gli elementi di una sequenza I IEnumerable<T> .ToList() IEnumerable<T> e salvano i risultati in una raccolta archiviata in memoria. Utilizzare le seguenti linee guida per determinare quale scegliere:

  • Alcune API potrebbero richiedere un T[] o un List<T> .
  • .ToList() genere gira più velocemente e genera meno garbage di .ToArray() , perché quest'ultimo deve copiare tutti gli elementi in una nuova raccolta di dimensioni fisse ancora una volta rispetto al primo, in quasi tutti i casi.
  • Gli elementi possono essere aggiunti o rimossi dall'elenco List<T> restituito da .ToList() , mentre il T[] restituito da .ToArray() rimane una dimensione fissa per tutta la sua durata. In altre parole, List<T> è mutabile e T[] è immutabile.
  • Il T[] restituito da .ToArray() utilizza meno memoria rispetto a List<T> restituito da .ToList() , quindi se il risultato verrà memorizzato per un lungo periodo, preferisci .ToArray() . Calling List<T>.TrimExcess() renderebbe la differenza di memoria strettamente accademica, al costo di eliminare il vantaggio relativo della velocità di .ToList() .

Seleziona (mappa)

var persons = new[] 
{
    new {Id = 1, Name = "Foo"},
    new {Id = 2, Name = "Bar"},
    new {Id = 3, Name = "Fizz"},
    new {Id = 4, Name = "Buzz"}
};

var names = persons.Select(p => p.Name);
Console.WriteLine(string.Join(",", names.ToArray()));

//Foo,Bar,Fizz,Buzz

Questo tipo di funzione viene solitamente chiamato map nei linguaggi di programmazione funzionale.

Dove (filtro)

Questo metodo restituisce un oggetto IEnumerable con tutti gli elementi che soddisfano l'espressione lambda

Esempio 

var personNames = new[] 
{
    "Foo", "Bar", "Fizz", "Buzz"
};

var namesStartingWithF = personNames.Where(p => p.StartsWith("F"));
Console.WriteLine(string.Join(",", namesStartingWithF));

Produzione:

Foo, Fizz

Visualizza la demo

Ordinato da

var persons = new[] 
{
    new {Id = 1, Name = "Foo"},
    new {Id = 2, Name = "Bar"},
    new {Id = 3, Name = "Fizz"},
    new {Id = 4, Name = "Buzz"}
};

var personsSortedByName = persons.OrderBy(p => p.Name);

Console.WriteLine(string.Join(",", personsSortedByName.Select(p => p.Id).ToArray()));

//2,4,3,1

OrderByDescending

var persons = new[] 
{
    new {Id = 1, Name = "Foo"},
    new {Id = 2, Name = "Bar"},
    new {Id = 3, Name = "Fizz"},
    new {Id = 4, Name = "Buzz"}
};

var personsSortedByNameDescending = persons.OrderByDescending(p => p.Name);

Console.WriteLine(string.Join(",", personsSortedByNameDescending.Select(p => p.Id).ToArray()));

//1,3,4,2

contiene

var numbers = new[] {1,2,3,4,5};
Console.WriteLine(numbers.Contains(3)); //True
Console.WriteLine(numbers.Contains(34)); //False

tranne

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

var result = numbers.Except(evenNumbersBetweenSixAndFourteen);

Console.WriteLine(string.Join(",", result));

//1, 2, 3, 4, 5, 7, 9

intersecare

var numbers1to10 = new[] {1,2,3,4,5,6,7,8,9,10};
var numbers5to15 = new[] {5,6,7,8,9,10,11,12,13,14,15};

var numbers5to10 = numbers1to10.Intersect(numbers5to15);

Console.WriteLine(string.Join(",", numbers5to10));

//5,6,7,8,9,10

concat

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

var numbers1to8 = numbers1to5.Concat(numbers4to8);

Console.WriteLine(string.Join(",", numbers1to8));

//1,2,3,4,5,4,5,6,7,8

Si noti che i duplicati vengono mantenuti nel risultato. Se questo non è desiderabile, usa invece Union .

Primo (trova)

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

var firstNumber = numbers.First();
Console.WriteLine(firstNumber); //1

var firstEvenNumber = numbers.First(n => (n & 1) == 0);
Console.WriteLine(firstEvenNumber); //2

Il seguente lancio di InvalidOperationException con il messaggio "Sequenza non contiene elementi corrispondenti": 

var firstNegativeNumber = numbers.First(n => n < 0);

singolo

var oneNumber = new[] {5};
var theOnlyNumber = oneNumber.Single();
Console.WriteLine(theOnlyNumber);  //5

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

var theOnlyNumberSmallerThanTwo = numbers.Single(n => n < 2);
Console.WriteLine(theOnlyNumberSmallerThanTwo);  //1

Di seguito viene InvalidOperationException poiché è presente più di un elemento nella sequenza: 

var theOnlyNumberInNumbers = numbers.Single();
var theOnlyNegativeNumber = numbers.Single(n => n < 0);

Scorso

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

var lastNumber = numbers.Last();
Console.WriteLine(lastNumber); //5

var lastEvenNumber = numbers.Last(n => (n & 1) == 0);
Console.WriteLine(lastEvenNumber); //4

Il seguente lancio di InvalidOperationException : 

var lastNegativeNumber = numbers.Last(n => n < 0);

LastOrDefault

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

var lastNumber = numbers.LastOrDefault();
Console.WriteLine(lastNumber); //5

var lastEvenNumber = numbers.LastOrDefault(n => (n & 1) == 0);
Console.WriteLine(lastEvenNumber); //4

var lastNegativeNumber = numbers.LastOrDefault(n => n < 0);
Console.WriteLine(lastNegativeNumber); //0

var words = new[] { "one", "two", "three", "four", "five" };

var lastWord = words.LastOrDefault();
Console.WriteLine(lastWord); // five

var lastLongWord = words.LastOrDefault(w => w.Length > 4);
Console.WriteLine(lastLongWord); // three

var lastMissingWord = words.LastOrDefault(w => w.Length > 5);
Console.WriteLine(lastMissingWord); // null

SingleOrDefault

var oneNumber = new[] {5};
var theOnlyNumber = oneNumber.SingleOrDefault();
Console.WriteLine(theOnlyNumber);  //5

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

var theOnlyNumberSmallerThanTwo = numbers.SingleOrDefault(n => n < 2);
Console.WriteLine(theOnlyNumberSmallerThanTwo);  //1

var theOnlyNegativeNumber = numbers.SingleOrDefault(n => n < 0);
Console.WriteLine(theOnlyNegativeNumber);  //0

Il seguente lancio di InvalidOperationException : 

var theOnlyNumberInNumbers = numbers.SingleOrDefault();

FirstOrDefault

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

var firstNumber = numbers.FirstOrDefault();
Console.WriteLine(firstNumber); //1

var firstEvenNumber = numbers.FirstOrDefault(n => (n & 1) == 0);
Console.WriteLine(firstEvenNumber); //2

var firstNegativeNumber = numbers.FirstOrDefault(n => n < 0);
Console.WriteLine(firstNegativeNumber); //0

var words = new[] { "one", "two", "three", "four", "five" };

var firstWord = words.FirstOrDefault();
Console.WriteLine(firstWord); // one

var firstLongWord = words.FirstOrDefault(w => w.Length > 3);
Console.WriteLine(firstLongWord); // three

var firstMissingWord = words.FirstOrDefault(w => w.Length > 5);
Console.WriteLine(firstMissingWord); // null

Qualunque

Restituisce true se la raccolta ha elementi che soddisfano la condizione nell'espressione lambda: 

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

var isNotEmpty = numbers.Any();
Console.WriteLine(isNotEmpty); //True

var anyNumberIsOne = numbers.Any(n => n == 1);
Console.WriteLine(anyNumberIsOne); //True

var anyNumberIsSix = numbers.Any(n => n == 6);
Console.WriteLine(anyNumberIsSix); //False    

var anyNumberIsOdd = numbers.Any(n => (n & 1) == 1);
Console.WriteLine(anyNumberIsOdd); //True

var anyNumberIsNegative = numbers.Any(n => n < 0);
Console.WriteLine(anyNumberIsNegative); //False

Tutti

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

var allNumbersAreOdd = numbers.All(n => (n & 1) == 1);
Console.WriteLine(allNumbersAreOdd); //False

var allNumbersArePositive = numbers.All(n => n > 0);
Console.WriteLine(allNumbersArePositive); //True

Si noti che All funzioni del metodo controllano che il primo elemento venga valutato come false base al predicato. Pertanto, il metodo restituirà true per qualsiasi predicato nel caso in cui il set sia vuoto: 

var numbers = new int[0];
var allNumbersArePositive = numbers.All(n => n > 0);
Console.WriteLine(allNumbersArePositive); //True

SelectMany (mappa piana)

Enumerable.Select restituisce un elemento di output per ogni elemento di input. Mentre Enumerable.SelectMany produce un numero variabile di elementi di output per ciascun elemento di input. Ciò significa che la sequenza di output può contenere più o meno elementi rispetto alla sequenza di input.

Lambda expressions passate a Enumerable.Select devono restituire un singolo elemento. Le espressioni lambda passate a Enumerable.SelectMany devono produrre una sequenza figlio. Questa sequenza figlio può contenere un numero variabile di elementi per ciascun elemento nella sequenza di input.

Esempio 

class Invoice
{
    public int Id { get; set; }
}

class Customer
{
    public Invoice[] Invoices {get;set;}
}

var customers = new[] {
    new Customer {
        Invoices = new[] {
            new Invoice {Id=1},
            new Invoice {Id=2},
        }
    },
    new Customer {
        Invoices = new[] {
            new Invoice {Id=3},
            new Invoice {Id=4},
        }
    },
    new Customer {
        Invoices = new[] {
            new Invoice {Id=5},
            new Invoice {Id=6},
        }
    }
};

var allInvoicesFromAllCustomers = customers.SelectMany(c => c.Invoices);

Console.WriteLine(
    string.Join(",", allInvoicesFromAllCustomers.Select(i => i.Id).ToArray()));

Produzione:

1,2,3,4,5,6

Visualizza la demo

Enumerable.SelectMany può essere ottenuta anche con una query sintassi basata utilizzando due consecutivi from clausole: 

var allInvoicesFromAllCustomers
    = from customer in customers
      from invoice in customer.Invoices
      select invoice;

Somma

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

var sumOfAllNumbers = numbers.Sum();
Console.WriteLine(sumOfAllNumbers); //10

var cities = new[] {
    new {Population = 1000},
    new {Population = 2500},
    new {Population = 4000}
};

var totalPopulation = cities.Sum(c => c.Population);
Console.WriteLine(totalPopulation); //7500

Salta

Salta enumera i primi N elementi senza restituirli. Una volta raggiunto il numero di articolo N + 1, Skip inizia a restituire ogni elemento elencato: 

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

var allNumbersExceptFirstTwo = numbers.Skip(2);
Console.WriteLine(string.Join(",", allNumbersExceptFirstTwo.ToArray()));

//3,4,5

Prendere

Questo metodo prende i primi n elementi da una enumerabile. 

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

var threeFirstNumbers = numbers.Take(3);
Console.WriteLine(string.Join(",", threeFirstNumbers.ToArray()));

//1,2,3

SequenceEqual

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

var equalIfSameOrder = numbers.SequenceEqual(sameNumbers);
Console.WriteLine(equalIfSameOrder); //True

var equalIfDifferentOrder = numbers.SequenceEqual(sameNumbersInDifferentOrder);
Console.WriteLine(equalIfDifferentOrder); //False

Inverso

var numbers = new[] {1,2,3,4,5};
var reversed = numbers.Reverse();

Console.WriteLine(string.Join(",", reversed.ToArray()));

//5,4,3,2,1

OfType

var mixed = new object[] {1,"Foo",2,"Bar",3,"Fizz",4,"Buzz"};
var numbers = mixed.OfType<int>();

Console.WriteLine(string.Join(",", numbers.ToArray()));

//1,2,3,4

Max

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

var maxNumber = numbers.Max();
Console.WriteLine(maxNumber); //4

var cities = new[] {
    new {Population = 1000},
    new {Population = 2500},
    new {Population = 4000}
};

var maxPopulation = cities.Max(c => c.Population);
Console.WriteLine(maxPopulation); //4000

min

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

var minNumber = numbers.Min();
Console.WriteLine(minNumber); //1

var cities = new[] {
    new {Population = 1000},
    new {Population = 2500},
    new {Population = 4000}
};

var minPopulation = cities.Min(c => c.Population);
Console.WriteLine(minPopulation); //1000

Media

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

var averageNumber = numbers.Average();
Console.WriteLine(averageNumber); 
// 2,5

Questo metodo calcola la media di enumerable di numeri. 

var cities = new[] {
    new {Population = 1000},
    new {Population = 2000},
    new {Population = 4000}
};

var averagePopulation = cities.Average(c => c.Population);
Console.WriteLine(averagePopulation);
// 2333,33

Questo metodo calcola la media di enumerable utilizzando la funzione delegata.

Cerniera lampo

.NET 4.0 
var tens = new[] {10,20,30,40,50};
var units = new[] {1,2,3,4,5};

var sums = tens.Zip(units, (first, second) => first + second);

Console.WriteLine(string.Join(",", sums));

//11,22,33,44,55

distinto

var numbers = new[] {1, 1, 2, 2, 3, 3, 4, 4, 5, 5};
var distinctNumbers = numbers.Distinct();

Console.WriteLine(string.Join(",", distinctNumbers));

//1,2,3,4,5

Raggruppa per

var persons = new[] {
    new { Name="Fizz", Job="Developer"},
    new { Name="Buzz", Job="Developer"},
    new { Name="Foo", Job="Astronaut"},
    new { Name="Bar", Job="Astronaut"},
};

var groupedByJob = persons.GroupBy(p => p.Job);

foreach(var theGroup in groupedByJob)
{
    Console.WriteLine(
        "{0} are {1}s", 
        string.Join(",", theGroup.Select(g => g.Name).ToArray()),
        theGroup.Key);
}

//Fizz,Buzz are Developers
//Foo,Bar are Astronauts

Raggruppa le fatture per paese, generando un nuovo oggetto con il numero di record, totale pagato e retribuzione media 

var a = db.Invoices.GroupBy(i => i.Country)
          .Select(g => new { Country = g.Key,
                             Count = g.Count(),
                             Total = g.Sum(i => i.Paid),
                             Average = g.Average(i => i.Paid) });

Se vogliamo solo i totali, nessun gruppo 

var a = db.Invoices.GroupBy(i => 1)
          .Select(g => new { Count = g.Count(),
                             Total = g.Sum(i => i.Paid),
                             Average = g.Average(i => i.Paid) });

Se abbiamo bisogno di più conteggi 

var a = db.Invoices.GroupBy(g => 1)
          .Select(g => new { High = g.Count(i => i.Paid >= 1000),
                             Low = g.Count(i => i.Paid < 1000),
                             Sum = g.Sum(i => i.Paid) });

ToDictionary

Restituisce un nuovo dizionario dalla sorgente IEnumerable utilizzando la funzione keySelector fornita per determinare le chiavi. Lancia una ArgumentException se keySelector non è iniettivo (restituisce un valore univoco per ogni membro della collezione di origine.) Esistono sovraccarichi che consentono di specificare il valore da memorizzare e la chiave. 

var persons = new[] {
    new { Name="Fizz", Id=1},
    new { Name="Buzz", Id=2},
    new { Name="Foo", Id=3},
    new { Name="Bar", Id=4},
};

Specificando solo una funzione selettore di chiave creerai un Dictionary<TKey,TVal> con TKey il tipo di ritorno del selettore di chiave, TVal il tipo di oggetto originale e l'oggetto originale come valore memorizzato. 

var personsById = persons.ToDictionary(p => p.Id);
// personsById is a Dictionary<int,object>

Console.WriteLine(personsById[1].Name); //Fizz
Console.WriteLine(personsById[2].Name); //Buzz

Specificando anche una funzione selettore valore creerai un Dictionary<TKey,TVal> con TKey ancora il tipo di ritorno del selettore di chiave, ma TVal ora il tipo restituito della funzione selettore valore e il valore restituito come valore memorizzato. 

var namesById = persons.ToDictionary(p => p.Id, p => p.Name);
//namesById is a Dictionary<int,string>

Console.WriteLine(namesById[3]); //Foo
Console.WriteLine(namesById[4]); //Bar

Come detto sopra, le chiavi restituite dal selettore di chiave devono essere uniche. Quanto segue genererà un'eccezione. 

var persons = new[] {
    new { Name="Fizz", Id=1},
    new { Name="Buzz", Id=2},
    new { Name="Foo", Id=3},
    new { Name="Bar", Id=4},
    new { Name="Oops", Id=4}
};

var willThrowException = persons.ToDictionary(p => p.Id)

Se non è possibile fornire una chiave univoca per la raccolta di origine, prendere in considerazione l'utilizzo di ToLookup. In superficie, ToLookup si comporta in modo simile a ToDictionary, tuttavia, nella ricerca risultante ogni chiave è abbinata a un insieme di valori con chiavi corrispondenti.

Unione

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

var numbers1to8 = numbers1to5.Union(numbers4to8);

Console.WriteLine(string.Join(",", numbers1to8));

//1,2,3,4,5,6,7,8

Si noti che i duplicati vengono rimossi dal risultato. Se questo non è auspicabile, utilizzare invece Concat .

ToArray

var numbers = new[] {1,2,3,4,5,6,7,8,9,10};
var someNumbers = numbers.Where(n => n < 6);

Console.WriteLine(someNumbers.GetType().Name);
//WhereArrayIterator`1

var someNumbersArray = someNumbers.ToArray();

Console.WriteLine(someNumbersArray.GetType().Name);
//Int32[]

Elencare

var numbers = new[] {1,2,3,4,5,6,7,8,9,10};
var someNumbers = numbers.Where(n => n < 6);

Console.WriteLine(someNumbers.GetType().Name);
//WhereArrayIterator`1

var someNumbersList = someNumbers.ToList();

Console.WriteLine(
    someNumbersList.GetType().Name + " - " +
    someNumbersList.GetType().GetGenericArguments()[0].Name);
//List`1 - Int32

Contare

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

var numbersCount = numbers.Count();
Console.WriteLine(numbersCount); //10

var evenNumbersCount = numbers.Count(n => (n & 1) == 0);
Console.WriteLine(evenNumbersCount); //5

ElementAt

var names = new[] {"Foo","Bar","Fizz","Buzz"};

var thirdName = names.ElementAt(2);
Console.WriteLine(thirdName); //Fizz

//The following throws ArgumentOutOfRangeException

var minusOnethName = names.ElementAt(-1);
var fifthName = names.ElementAt(4);

ElementAtOrDefault

var names = new[] {"Foo","Bar","Fizz","Buzz"};

var thirdName = names.ElementAtOrDefault(2);
Console.WriteLine(thirdName); //Fizz

var minusOnethName = names.ElementAtOrDefault(-1);
Console.WriteLine(minusOnethName); //null

var fifthName = names.ElementAtOrDefault(4);
Console.WriteLine(fifthName); //null

SkipWhile

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

var oddNumbers = numbers.SkipWhile(n => (n & 1) == 0);

Console.WriteLine(string.Join(",", oddNumbers.ToArray()));

//1,3,5,7

TakeWhile

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

var evenNumbers = numbers.TakeWhile(n => (n & 1) == 0);

Console.WriteLine(string.Join(",", evenNumbers.ToArray()));

//2,4,6

DefaultIfEmpty

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

var numbersOrDefault = numbers.DefaultIfEmpty();
Console.WriteLine(numbers.SequenceEqual(numbersOrDefault)); //True

var noNumbers = new int[0];

var noNumbersOrDefault = noNumbers.DefaultIfEmpty();
Console.WriteLine(noNumbersOrDefault.Count()); //1
Console.WriteLine(noNumbersOrDefault.Single()); //0

var noNumbersOrExplicitDefault = noNumbers.DefaultIfEmpty(34);
Console.WriteLine(noNumbersOrExplicitDefault.Count()); //1
Console.WriteLine(noNumbersOrExplicitDefault.Single()); //34

Aggregato (piega)

Generazione di un nuovo oggetto in ogni fase: 

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

var commaSeparatedElements = elements.Aggregate(
    seed: "",
    func: (aggregate, element) => $"{aggregate}{element},");
    
Console.WriteLine(commaSeparatedElements);  //1,2,3,4,5,

Utilizzando lo stesso oggetto in tutti i passaggi: 

var commaSeparatedElements2 = elements.Aggregate(
    seed: new StringBuilder(),
    func: (seed, element) => seed.Append($"{element},"));
    
Console.WriteLine(commaSeparatedElements2.ToString());  //1,2,3,4,5,

Utilizzando un selettore di risultati: 

var commaSeparatedElements3 = elements.Aggregate(
    seed: new StringBuilder(),
    func: (seed, element) => seed.Append($"{element},"),
    resultSelector: (seed) => seed.ToString());
Console.WriteLine(commaSeparatedElements3);  //1,2,3,4,5,

Se un seme viene omesso, il primo elemento diventa il seme: 

var seedAndElements = elements.Select(n=>n.ToString());
var commaSeparatedElements4 = seedAndElements.Aggregate(
    func: (aggregate, element) => $"{aggregate}{element},");

Console.WriteLine(commaSeparatedElements4);  //12,3,4,5,

ToLookup

var persons = new[] {
    new { Name="Fizz", Job="Developer"},
    new { Name="Buzz", Job="Developer"},
    new { Name="Foo", Job="Astronaut"},
    new { Name="Bar", Job="Astronaut"},
};

var groupedByJob = persons.ToLookup(p => p.Job);

foreach(var theGroup in groupedByJob)
{
    Console.WriteLine(
        "{0} are {1}s", 
        string.Join(",", theGroup.Select(g => g.Name).ToArray()),
        theGroup.Key);
}

//Fizz,Buzz are Developers
//Foo,Bar are Astronauts

Aderire

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

class Project
{
    public int DeveloperId { get; set; }
    public string Name { get; set; }
}

var developers = new[] {
    new Developer {
        Id = 1,
        Name = "Foobuzz"
    },
    new Developer {
        Id = 2,
        Name = "Barfizz"
    }
};

var projects = new[] {
    new Project {
        DeveloperId = 1,
        Name = "Hello World 3D"
    },
    new Project {
        DeveloperId = 1,
        Name = "Super Fizzbuzz Maker"
    },
    new Project {
        DeveloperId = 2,
        Name = "Citizen Kane - The action game"
    },
    new Project {
        DeveloperId = 2,
        Name = "Pro Pong 2016"
    }
};

var denormalized = developers.Join(
    inner: projects,
    outerKeySelector: dev => dev.Id,
    innerKeySelector: proj => proj.DeveloperId,
    resultSelector: 
        (dev, proj) => new {
            ProjectName = proj.Name,
            DeveloperName = dev.Name});
    
foreach(var item in denormalized)
{
    Console.WriteLine("{0} by {1}", item.ProjectName, item.DeveloperName);
}

//Hello World 3D by Foobuzz
//Super Fizzbuzz Maker by Foobuzz
//Citizen Kane - The action game by Barfizz
//Pro Pong 2016 by Barfizz

GroupJoin

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

class Project
{
    public int DeveloperId { get; set; }
    public string Name { get; set; }
}

var developers = new[] {
    new Developer {
        Id = 1,
        Name = "Foobuzz"
    },
    new Developer {
        Id = 2,
        Name = "Barfizz"
    }
};

var projects = new[] {
    new Project {
        DeveloperId = 1,
        Name = "Hello World 3D"
    },
    new Project {
        DeveloperId = 1,
        Name = "Super Fizzbuzz Maker"
    },
    new Project {
        DeveloperId = 2,
        Name = "Citizen Kane - The action game"
    },
    new Project {
        DeveloperId = 2,
        Name = "Pro Pong 2016"
    }
};

var grouped = developers.GroupJoin(
    inner: projects,
    outerKeySelector: dev => dev.Id,
    innerKeySelector: proj => proj.DeveloperId,
    resultSelector: 
        (dev, projs) => new {
            DeveloperName = dev.Name, 
            ProjectNames = projs.Select(p => p.Name).ToArray()});
    
foreach(var item in grouped)
{
    Console.WriteLine(
        "{0}'s projects: {1}", 
        item.DeveloperName,
        string.Join(", ", item.ProjectNames));
}

//Foobuzz's projects: Hello World 3D, Super Fizzbuzz Maker
//Barfizz's projects: Citizen Kane - The action game, Pro Pong 2016

lanciare

Cast è diverso dagli altri metodi di Enumerable in quanto è un metodo di estensione per IEnumerable , non per IEnumerable<T> . Quindi può essere usato per convertire istanze del precedente in istanze del successivo.

Questo non viene compilato poiché ArrayList non implementa IEnumerable<T> : 

var numbers = new ArrayList() {1,2,3,4,5};
Console.WriteLine(numbers.First());

Funziona come previsto: 

var numbers = new ArrayList() {1,2,3,4,5};
Console.WriteLine(numbers.Cast<int>().First()); //1

Cast non esegue cast di conversione. Il seguente compila, ma lancia InvalidCastException in fase di runtime: 

var numbers = new int[] {1,2,3,4,5};
decimal[] numbersAsDecimal = numbers.Cast<decimal>().ToArray();

Il modo corretto per eseguire un cast di conversione in una raccolta è il seguente: 

var numbers= new int[] {1,2,3,4,5};
decimal[] numbersAsDecimal = numbers.Select(n => (decimal)n).ToArray();

Vuoto

Per creare un IEnumerable vuoto di int: 

IEnumerable<int> emptyList = Enumerable.Empty<int>();

Questo IEnumerable vuoto viene memorizzato nella cache per ogni tipo T, in modo che: 

Enumerable.Empty<decimal>() == Enumerable.Empty<decimal>(); // This is True
Enumerable.Empty<int>() == Enumerable.Empty<decimal>();     // This is False

ThenBy

ThenBy può essere utilizzato solo dopo una clausola OrderBy che consente di ordinare utilizzando più criteri 

var persons = new[] 
{
    new {Id = 1, Name = "Foo", Order = 1},
    new {Id = 1, Name = "FooTwo", Order = 2},
    new {Id = 2, Name = "Bar", Order = 2},
    new {Id = 2, Name = "BarTwo", Order = 1},
    new {Id = 3, Name = "Fizz", Order = 2},
    new {Id = 3, Name = "FizzTwo", Order = 1},  
};

var personsSortedByName = persons.OrderBy(p => p.Id).ThenBy(p => p.Order);

Console.WriteLine(string.Join(",", personsSortedByName.Select(p => p.Name)));
//This will display : 
//Foo,FooTwo,BarTwo,Bar,FizzTwo,Fizz

Gamma

I due parametri di Range sono il primo numero e il numero di elementi da produrre (non l'ultimo numero). 

// prints 1,2,3,4,5,6,7,8,9,10
Console.WriteLine(string.Join(",", Enumerable.Range(1, 10)));

// prints 10,11,12,13,14
Console.WriteLine(string.Join(",", Enumerable.Range(10, 5)));

Left Outer Join

class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

class Pet
{
    public string Name { get; set; }
    public Person Owner { get; set; }
}

public static void Main(string[] args)
{
    var magnus = new Person { FirstName = "Magnus", LastName = "Hedlund" };
    var terry = new Person { FirstName = "Terry", LastName = "Adams" };

    var barley = new Pet { Name = "Barley", Owner = terry };

    var people = new[] { magnus, terry };
    var pets = new[] { barley };

    var query =
        from person in people
        join pet in pets on person equals pet.Owner into gj
        from subpet in gj.DefaultIfEmpty()
        select new
        {
            person.FirstName,
            PetName = subpet?.Name ?? "-" // Use - if he has no pet
        };

    foreach (var p in query)
        Console.WriteLine($"{p.FirstName}: {p.PetName}");
}

Ripetere

Enumerable.Repeat genera una sequenza di un valore ripetuto. In questo esempio genera "Ciao" 4 volte. 

var repeats = Enumerable.Repeat("Hello", 4);
   
foreach (var item in repeats)
{
    Console.WriteLine(item);
}

/* output:
    Hello
    Hello
    Hello
    Hello
*/


Modified text is an extract of the original Stack Overflow Documentation
Autorizzato sotto CC BY-SA 3.0
Non affiliato con Stack Overflow