linq
Opérateurs de requêtes standard

Remarques

Opérations de concaténation

La concaténation fait référence à l'opération consistant à ajouter une séquence à une autre.

Concat

Concatène deux séquences pour former une séquence.

Syntaxe de la méthode

// 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 }

Syntaxe de requête

// Not applicable.

Opérations de filtrage

Le filtrage fait référence aux opérations de restriction du jeu de résultats pour ne contenir que les éléments satisfaisant à une condition spécifiée.

Où

Sélectionne les valeurs basées sur une fonction de prédicat.

Syntaxe de la méthode

// 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 }

Syntaxe de requête

// 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 }

De type

Sélectionne des valeurs en fonction de leur capacité à être converties en un type spécifié.

Syntaxe de la méthode

// OfType

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

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

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

Syntaxe de requête

// Not applicable.

Rejoindre les opérations

Une jointure de deux sources de données est l'association d'objets dans une source de données avec des objets partageant un attribut commun dans une autre source de données.

Joindre

Joint deux séquences basées sur des fonctions de sélection de clé et extrait des paires de valeurs.

Syntaxe de la méthode

// 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" }

Syntaxe de requête

// 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

Joint deux séquences en fonction des fonctions du sélecteur de touches et regroupe les correspondances résultantes pour chaque élément.

Syntaxe de la méthode

// 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" }

Syntaxe de requête

// 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" }

Zip *: français

Applique une fonction spécifiée aux éléments correspondants de deux séquences, produisant une séquence des résultats.

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 |

Opérations de projection

La projection fait référence aux opérations de transformation d'un objet en une nouvelle forme.

Sélectionner

Projets de valeurs basées sur une fonction de transformation.

Syntaxe de la méthode

// Select

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

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

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

Syntaxe de requête

// 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

Projette des séquences de valeurs basées sur une fonction de transformation, puis les aplatit en une séquence.

Syntaxe de la méthode

// 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") }

Syntaxe de requête

// multiples from

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

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

Opérations de tri

Une opération de tri commande les éléments d'une séquence en fonction d'un ou de plusieurs attributs.

Commandé par

Trie les valeurs en ordre croissant.

Syntaxe de la méthode

// 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 }

Syntaxe de requête

// 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

Trie les valeurs par ordre décroissant.

Syntaxe de la méthode

// 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 }

Syntaxe de requête

// 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 }

Puis par

Effectue un tri secondaire dans l'ordre croissant.

Syntaxe de la méthode

// 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" }

Syntaxe de requête

// 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

Effectue un tri secondaire par ordre décroissant.

Syntaxe de la méthode

// 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" }

Syntaxe de requête

// 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" }

Sens inverse

Inverse l'ordre des éléments dans une collection.

Syntaxe de la méthode

// Reverse

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

var reversed = numbers.Reverse();

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

Syntaxe de requête

// Not applicable.

Opérations de conversion

Les opérations de conversion modifient le type des objets en entrée.

AsEnumerable

Renvoie l'entrée typée IEnumerable.

Syntaxe de la méthode

// AsEnumerable

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

var nums = numbers.AsEnumerable();

// nums: static type is IEnumerable<int>

Syntaxe de requête

// Not applicable.

AsQueryable

Convertit un IEnumerable en un IQueryable.

Syntaxe de la méthode

// AsQueryable

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

var nums = numbers.AsQueryable();

// nums: static type is IQueryable<int>

Syntaxe de requête

// Not applicable.

Jeter

Convertit les éléments d'une collection en un type spécifié.

Syntaxe de la méthode

// Cast

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

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

// nums: static type is IEnumerable<int>

Syntaxe de requête

// 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>

De type

Filtre les valeurs en fonction de leur capacité à être converties en un type spécifié.

Syntaxe de la méthode

// OfType

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

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

// nums = { 1, 2, 3 }

Syntaxe de requête

// Not applicable.

ToArray

Convertit une collection en un tableau.

Syntaxe de la méthode

// ToArray

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

int[] array = numbers.ToArray();

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

Syntaxe de requête

// Not applicable.

Lister

Convertit une collection en une liste.

Syntaxe de la méthode

// ToList

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

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

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

Syntaxe de requête

// Not applicable.

ToDictionary

Met des éléments dans un dictionnaire en fonction d'une fonction de sélection de clé.

Syntaxe de la méthode

// ToDictionary

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

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

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

Syntaxe de requête

// Not applicable.

Opérations d'agrégation

Les opérations d’agrégation calculent une valeur unique à partir d’une collection de valeurs.

Agrégat

Effectue une opération d'agrégation personnalisée sur les valeurs d'une collection.

Syntaxe de la méthode

// Aggregate

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

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

// product = 120

Syntaxe de requête

// Not applicable.

Moyenne

Calcule la valeur moyenne d'une collection de valeurs.

Syntaxe de la méthode

// Average

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

var average = numbers.Average();

// average = 3

Syntaxe de requête

// Not applicable.

Compter

Compte les éléments d'une collection, éventuellement uniquement les éléments satisfaisant une fonction de prédicat.

Syntaxe de la méthode

// Count

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

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

// count = 2

Syntaxe de requête

// Not applicable.

LongCount

Compte les éléments d'une grande collection, éventuellement uniquement les éléments satisfaisant une fonction de prédicat.

Syntaxe de la méthode

// LongCount

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

long count = numbers.LongCount();

// count = 10

Syntaxe de requête

// Not applicable.

Max

Détermine la valeur maximale dans une collection. Lève une exception si la collecte est vide.

Syntaxe de la méthode

// Max

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

var max = numbers.Max();

// max = 5

Syntaxe de requête

// Not applicable.

Min

Détermine la valeur minimale dans une collection. Lève une exception si la collecte est vide.

Syntaxe de la méthode

// Min

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

var min = numbers.Min();

// min = 1

Syntaxe de requête

// Not applicable.

Min- / MaxOrDefault

Contrairement à d'autres extensions LinQ, Min() et Max() n'ont pas de surcharge sans exceptions. Pour cela, IEnumerable doit être vérifié pour Any() avant d’appeler Min() ou Max()

// Max

var numbers = new int[] { };

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

// max = 0

Somme

Calcule la somme des valeurs dans une collection.

Syntaxe de la méthode

// Sum

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

var sum = numbers.Sum();

// sum = 15

Syntaxe de requête

// Not applicable.

Opérations de quantification

Les opérations du quantificateur renvoient une valeur booléenne qui indique si certains ou tous les éléments d'une séquence satisfont à une condition.

Tout

Détermine si tous les éléments d'une séquence satisfont à une condition.

Syntaxe de la méthode

// All

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

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

// areLessThan10 = true

Syntaxe de requête

// Not applicable.

Tout

Détermine si des éléments d'une séquence satisfont à une condition.

Syntaxe de la méthode

// Any

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

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

// anyOneIsEven = true

Syntaxe de requête

// Not applicable.

Contient

Détermine si une séquence contient un élément spécifié.

Syntaxe de la méthode

// Contains

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

bool appears = numbers.Contains(10);

// appears = false

Syntaxe de requête

// Not applicable.

Opérations de regroupement

Le regroupement fait référence aux opérations consistant à mettre des données en groupes afin que les éléments de chaque groupe partagent un attribut commun.

Par groupe

Groupes d'éléments qui partagent un attribut commun.

Syntaxe de la méthode

// 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") }

Syntaxe de requête

// 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") }

Pour rechercher

Insère des éléments dans un dictionnaire un à plusieurs basé sur une fonction de sélection de clé.

Syntaxe de la méthode

// 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") }
// }

Syntaxe de requête

// Not applicable.

Opérations de partition

Le partitionnement fait référence aux opérations consistant à diviser une séquence d'entrée en deux sections, sans réorganiser les éléments, puis à renvoyer l'une des sections.

Sauter

Saut des éléments à une position spécifiée dans une séquence.

Syntaxe de la méthode

// Skip

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

var skipped = numbers.Skip(3);

// skipped = { 4, 5 }

Syntaxe de requête

// Not applicable.

SkipWhile

Ignore les éléments en fonction d'une fonction de prédicat jusqu'à ce qu'un élément ne satisfasse pas la condition.

Syntaxe de la méthode

// 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 }

Syntaxe de requête

// Not applicable.

Prendre

Prend des éléments à une position spécifiée dans une séquence.

Syntaxe de la méthode

// Take

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

var taken = numbers.Take(3);

// taken = { 1, 2, 3 }

Syntaxe de requête

// Not applicable.

TakeWhile

Prend des éléments basés sur une fonction de prédicat jusqu'à ce qu'un élément ne satisfasse pas la condition.

Syntaxe de la méthode

// TakeWhile

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

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

// takeLeadingOdds = { 1, 3, 5 }

Syntaxe de requête

// Not applicable.

Opérations de génération

Generation désigne la création d'une nouvelle séquence de valeurs.

DefaultIfEmpty

Remplace une collection vide par une collection singleton évaluée par défaut.

Syntaxe de la méthode

// DefaultIfEmpty

var nums = new int[0];

var numbers = nums.DefaultIfEmpty();

// numbers = { 0 }

Syntaxe de requête

// Not applicable.

Vide

Retourne une collection vide.

Syntaxe de la méthode

// Empty

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

// empty = IEnumerable<string> { }

Syntaxe de requête

// Not applicable.

Gamme

Génère une collection qui contient une séquence de nombres.

Syntaxe de la méthode

// Range

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

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

Syntaxe de requête

// Not applicable.

Répéter

Génère une collection qui contient une valeur répétée.

Syntaxe de la méthode

// Repeat

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

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

Syntaxe de requête

// Not applicable.

Définir les opérations

Les opérations d'ensemble font référence aux opérations de requête qui produisent un jeu de résultats basé sur la présence ou l'absence d'éléments équivalents au sein de collections (ou d'ensembles) identiques ou distinctes.

Distinct

Supprime les valeurs en double d'une collection.

Syntaxe de la méthode

// Distinct

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

var distinct = numbers.Distinct();

// distinct = { 1, 2, 3 }

Syntaxe de requête

// Not applicable.

Sauf

Renvoie la différence de set, ce qui signifie les éléments d'une collection qui n'apparaissent pas dans une deuxième collection.

Syntaxe de la méthode

// 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 }

Syntaxe de requête

// Not applicable.

Couper

Renvoie l'intersection définie, c'est-à-dire les éléments qui apparaissent dans chacune des deux collections.

Syntaxe de la méthode

// 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 }

Syntaxe de requête

// Not applicable.

syndicat

Renvoie l'union définie, ce qui signifie des éléments uniques qui apparaissent dans l'une des deux collections.

Syntaxe de la méthode

// 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 }

Syntaxe de requête

// Not applicable.

Opérations d'égalité

Deux séquences dont les éléments correspondants sont égaux et qui ont le même nombre d'éléments sont considérées égales.

SéquenceEqual

Détermine si deux séquences sont égales en comparant les éléments par paires.

Syntaxe de la méthode

// 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

Syntaxe de requête

// Not Applicable.

Opérations d'élément

Les opérations d'élément renvoient un seul élément spécifique d'une séquence.

ElementAt

Renvoie l'élément à un index spécifié dans une collection.

Syntaxe de la méthode

// ElementAt

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

var str = strings.ElementAt(2);

// str = "two"

Syntaxe de requête

// Not Applicable.

ElementAtOrDefault

Retourne l'élément à un index spécifié dans une collection ou une valeur par défaut si l'index est hors limites.

Syntaxe de la méthode

// ElementAtOrDefault

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

var str = strings.ElementAtOrDefault(10);

// str = null

Syntaxe de requête

// Not Applicable.

Premier

Renvoie le premier élément d'une collection ou le premier élément qui satisfait à une condition.

Syntaxe de la méthode

// First

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

var first = strings.First();

// first = 1

Syntaxe de requête

// Not Applicable.

FirstOrDefault

Renvoie le premier élément d'une collection ou le premier élément qui satisfait à une condition. Renvoie une valeur par défaut si aucun élément de ce type n'existe.

Syntaxe de la méthode

// FirstOrDefault

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

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

// firstGreaterThanTen = 0

Syntaxe de requête

// Not Applicable.

Dernier

Renvoie le dernier élément d'une collection ou le dernier élément qui satisfait à une condition.

Syntaxe de la méthode

// Last

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

var last = strings.Last();

// last = 5

Syntaxe de requête

// Not Applicable.

LastOrDefault

Renvoie le dernier élément d'une collection ou le dernier élément qui satisfait à une condition. Renvoie une valeur par défaut si aucun élément de ce type n'existe.

Syntaxe de la méthode

// LastOrDefault

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

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

// lastGreaterThanTen = 0

Syntaxe de requête

// Not Applicable.

Unique

Retourne le seul élément d'une collection ou le seul élément qui satisfait à une condition.

Syntaxe de la méthode

// Single

var numbers = new int[] { 1 };

var single = strings.Single();

// single = 1

Syntaxe de requête

// Not Applicable.

SingleOrDefault

Retourne le seul élément d'une collection ou le seul élément qui satisfait à une condition. Renvoie une valeur par défaut si aucun élément n'existe ou si la collection ne contient pas exactement un élément.

Syntaxe de la méthode

// SingleOrDefault

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

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

// singleGreaterThanFour = 5

Syntaxe de requête

// Not Applicable.