ObjectQuery<T> Classe

Définition

Représente une requête typée par rapport à un modèle conceptuel dans un contexte d’objet donné.Represents a typed query against a conceptual model in a given object context.

generic <typename T>
public ref class ObjectQuery : System::Data::Objects::ObjectQuery, System::Collections::Generic::IEnumerable<T>, System::ComponentModel::IListSource, System::Linq::IOrderedQueryable<T>, System::Linq::IQueryable<T>
public class ObjectQuery<T> : System.Data.Objects.ObjectQuery, System.Collections.Generic.IEnumerable<T>, System.ComponentModel.IListSource, System.Linq.IOrderedQueryable<T>, System.Linq.IQueryable<T>
type ObjectQuery<'T> = class
    inherit ObjectQuery
    interface IOrderedQueryable<'T>
    interface IQueryable<'T>
    interface seq<'T>
    interface IOrderedQueryable
    interface IQueryable
    interface IEnumerable
    interface IListSource
type ObjectQuery<'T> = class
    inherit ObjectQuery
    interface seq<'T>
    interface IEnumerable
    interface IQueryable<'T>
    interface IQueryable
    interface IOrderedQueryable<'T>
    interface IOrderedQueryable
    interface IListSource
Public Class ObjectQuery(Of T)
Inherits ObjectQuery
Implements IEnumerable(Of T), IListSource, IOrderedQueryable(Of T), IQueryable(Of T)

Paramètres de type

T

Type d'entité de la requête.The entity type of the query.

Héritage
ObjectQuery<T>
Dérivé
Implémente

Exemples

L’exemple de cette rubrique est basé sur le Microsoft SQL Server exemples de produits : base de données.The example in this topic is based on the Microsoft SQL Server Product Samples: Database.

L'exemple montre comment construire une instance de la classe ObjectQuery<T>.The example shows how to construct an instance of the ObjectQuery<T> class.

using (AdventureWorksEntities context =
    new AdventureWorksEntities())
{
    // Call the constructor with a query for products and the ObjectContext.
    ObjectQuery<Product> productQuery1 =
        new ObjectQuery<Product>("Products", context);

    foreach (Product result in productQuery1)
        Console.WriteLine("Product Name: {0}", result.Name);

    string queryString =
        @"SELECT VALUE product FROM AdventureWorksEntities.Products AS product";

    // Call the constructor with the specified query and the ObjectContext.
    ObjectQuery<Product> productQuery2 =
        new ObjectQuery<Product>(queryString, context);

    foreach (Product result in productQuery2)
        Console.WriteLine("Product Name: {0}", result.Name);

    // Call the constructor with the specified query, the ObjectContext,
    // and the NoTracking merge option.
    ObjectQuery<Product> productQuery3 =
        new ObjectQuery<Product>(queryString,
            context, MergeOption.NoTracking);

    foreach (Product result in productQuery3)
        Console.WriteLine("Product Name: {0}", result.Name);
}
Using context As New AdventureWorksEntities()
    ' Call the constructor with a query for products and the ObjectContext. 
    Dim productQuery1 As New ObjectQuery(Of Product)("Products", context)

    For Each result As Product In productQuery1
        Console.WriteLine("Product Name: {0}", result.Name)
    Next

    Dim queryString As String = "SELECT VALUE product FROM AdventureWorksEntities.Products AS product"

    ' Call the constructor with the specified query and the ObjectContext. 
    Dim productQuery2 As New ObjectQuery(Of Product)(queryString, context)

    For Each result As Product In productQuery2
        Console.WriteLine("Product Name: {0}", result.Name)
    Next

    ' Call the constructor with the specified query, the ObjectContext, 
    ' and the NoTracking merge option. 
    Dim productQuery3 As New ObjectQuery(Of Product)(queryString, context, MergeOption.NoTracking)

    For Each result As Product In productQuery3
        Console.WriteLine("Product Name: {0}", result.Name)
    Next
End Using

Remarques

La classe générique ObjectQuery<T> représente une requête qui retourne une collection de zéro ou plusieurs objets d’un type spécifique.The ObjectQuery<T> generic class represents a query that returns a collection of zero or more objects of a specific type. L'objet ObjectContext doit être défini avant qu'une requête d'objet puisse être exécutée.The ObjectContext must be defined before an object query can be executed. Ce contexte fournit les informations relatives à la connexion et aux métadonnées qui sont requises pour composer et exécuter la requête.This context provides the connection and metadata information that is required to compose and execute the query. Une requête d'objet est exécutée dans les scénarios suivants :An object query is executed in the following scenarios:

  • Lorsqu'une action est réalisée sur celle-ci, comme au cours d'une énumération foreach (en C#) ou For Each (en Visual Basic).When it is acted upon, such as during a foreach (C#) or For Each (Visual Basic) enumeration.

  • Lorsqu'elle est assignée pour remplir une collection List<T>.When it is assigned to fill a List<T> collection.

  • Lorsque la méthode Execute est explicitement appelée.When the Execute method is explicitly called.

La requête elle-même peut être créée à l’aide d’une instruction Entity SQL ou d’une requête LINQ, ou elle peut être générée de façon incrémentielle à l’aide des méthodes du générateur de requêtes incluses dans la classe.The query itself can be created by using an Entity SQL statement or a LINQ query, or it can be incrementally built by using the query builder methods included in the class. Dans tous les cas, le résultat est une nouvelle instance ObjectQuery<T> qui, en cas d'énumération ou d'exécution explicite, envoie la requête vers la source de données pour exécution et retourne les résultats.In every case, the result is a new ObjectQuery<T> instance that, when explicitly executed or enumerated over, will send the query to the data source for execution and return the results.

Un objet ObjectQuery<T> est fréquemment d'un type d'entité, mais il peut également être de type DbDataRecord, pour les projections vers un type anonyme, ou d'un type primitif, tel qu'un entier ou une chaîne.An ObjectQuery<T> is frequently of an entity type, but it can also be of DbDataRecord type, for projections to an anonymous type, or of a primitive type, such as an integer or string. Pour plus d’informations, consultez requêtes d’objet.For more information, see Object Queries.

Constructeurs

ObjectQuery<T>(String, ObjectContext)

Crée une ObjectQuery<T> instance de à l’aide de la commande Entity SQL spécifiée comme requête initiale.Creates a new ObjectQuery<T> instance using the specified Entity SQL command as the initial query.

ObjectQuery<T>(String, ObjectContext, MergeOption)

Crée une ObjectQuery<T> instance de à l’aide de la commande de Entity SQL spécifiée comme requête initiale et l’option de fusion spécifiée.Creates a new ObjectQuery<T> instance using the specified Entity SQL command as the initial query and the specified merge option.

Propriétés

CommandText

Retourne le texte de commande de la requête.Returns the command text for the query.

(Hérité de ObjectQuery)
Context

Obtient l'objet de contexte associé à cette requête d'objet.Gets the object context associated with this object query.

(Hérité de ObjectQuery)
EnablePlanCaching

Obtient ou définit une valeur qui indique si le plan de requête doit être mis en cache.Gets or sets a value that indicates whether the query plan should be cached.

(Hérité de ObjectQuery)
MergeOption

Obtient ou définit la manière dont les objets retournés par une requête sont ajoutés au contexte de l'objet.Gets or sets how objects returned from a query are added to the object context.

(Hérité de ObjectQuery)
Name

Obtient ou définit le nom de la requête d'objet.Gets or sets the name of this object query.

Parameters

Obtient la collection de paramètres pour cette requête d'objet.Gets the parameter collection for this object query.

(Hérité de ObjectQuery)

Méthodes

Distinct()

Limite la requête aux résultats uniques.Limits the query to unique results.

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
Except(ObjectQuery<T>)

Limite les résultats de la requête en excluant les résultats basés sur les résultats d'une autre requête d'objet.Limits the query results by excluding results based on the results of another object query.

Execute(MergeOption)

Exécute la requête d’objet avec l’option de fusion spécifiée.Executes the object query with the specified merge option.

GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetResultType()

Retourne des informations sur le type de résultat de la requête.Returns information about the result type of the query.

(Hérité de ObjectQuery)
GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
GroupBy(String, String, ObjectParameter[])

Groupe les résultats de la requête en fonction des critères spécifiés.Groups the query results by the specified criteria.

Include(String)

Spécifie les objets connexes à inclure dans les résultats de la requête.Specifies the related objects to include in the query results.

Intersect(ObjectQuery<T>)

Limite les résultats de la requête en incluant uniquement les résultats qui existent dans une autre requête d'objet.Limits the query results by including only the results that exist in another object query.

MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
OfType<TResultType>()

Limite la requête uniquement aux résultats d'un type spécifique.Limits the query to only results of a specific type.

OrderBy(String, ObjectParameter[])

Ordonne les résultats de la requête en fonction des critères spécifiés.Orders the query results by the specified criteria.

Select(String, ObjectParameter[])

Limite les résultats de la requête uniquement aux propriétés définies dans la projection spécifiée.Limits the query results to only the properties that are defined in the specified projection.

SelectValue<TResultType>(String, ObjectParameter[])

Limite les résultats de la requête uniquement à la propriété spécifiée dans la projection.Limits the query results to only the property specified in the projection.

Skip(String, String, ObjectParameter[])

Classe les résultats de la requête selon les critères spécifiés et ignore un nombre spécifié de résultats.Orders the query results by the specified criteria and skips a specified number of results.

Top(String, ObjectParameter[])

Limite les résultats de la requête à un nombre d'éléments spécifié.Limits the query results to a specified number of items.

ToString()

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(Hérité de Object)
ToTraceString()

Retourne les commandes à exécuter sur la source de données.Returns the commands to execute against the data source.

(Hérité de ObjectQuery)
Union(ObjectQuery<T>)

Combine les résultats de la requête avec les résultats d'une autre requête d'objet, sans doublon.Combines the results of the query with the results of another object query, without any duplicates.

UnionAll(ObjectQuery<T>)

Combine les résultats de la requête avec les résultats d'une autre requête d'objet, y compris tous les doublons.Combines the results of the query with the results of another object query, including all duplicates.

Where(String, ObjectParameter[])

Limite la requête aux résultats qui correspondent aux critères de filtrage spécifiés.Limits the query to results that match specified filtering criteria.

Implémentations d’interfaces explicites

IEnumerable.GetEnumerator()

Retourne un énumérateur qui itère au sein d’une collection.Returns an enumerator that iterates through a collection.

(Hérité de ObjectQuery)
IEnumerable<T>.GetEnumerator()

Retourne un énumérateur qui itère au sein des résultats de la requête.Returns an enumerator that iterates through the results of the query.

IListSource.ContainsListCollection

Obtient une valeur qui indique si la collection retournée par la requête contient des objets de collection.Gets a value that indicates whether the collection returned by the query contains collection objects.

(Hérité de ObjectQuery)
IListSource.GetList()

Retourne la collection sous la forme d’un objet IList utilisé pour la liaison de données.Returns the collection as an IList used for data binding.

(Hérité de ObjectQuery)
IQueryable.ElementType

Obtient le type d'élément de résultat pour cette instance de requête.Gets the result element type for this query instance.

(Hérité de ObjectQuery)
IQueryable.Expression

Obtient l'expression décrivant cette requête.Gets the expression describing this query.

(Hérité de ObjectQuery)
IQueryable.Provider

Obtient l'objet IQueryProvider LINQ associé à cette instance de requête.Gets the LINQ IQueryProvider associated with this query instance.

(Hérité de ObjectQuery)

Méthodes d’extension

CopyToDataTable<T>(IEnumerable<T>)

Retourne un DataTable qui contient des copies des objets DataRow, à partir d'un objet d'entrée IEnumerable<T> où le paramètre générique T est DataRow.Returns a DataTable that contains copies of the DataRow objects, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)

Copie les objets DataRow vers le DataTable spécifié, à partir d'un objet d'entrée IEnumerable<T> où le paramètre générique T est DataRow.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)

Copie les objets DataRow vers le DataTable spécifié, à partir d'un objet d'entrée IEnumerable<T> où le paramètre générique T est DataRow.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>)

Applique une fonction d'accumulation sur une séquence.Applies an accumulator function over a sequence.

Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>)

Applique une fonction d'accumulation sur une séquence.Applies an accumulator function over a sequence. La valeur initiale spécifiée est utilisée comme valeur d'accumulation initiale.The specified seed value is used as the initial accumulator value.

Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>)

Applique une fonction d'accumulation sur une séquence.Applies an accumulator function over a sequence. La valeur initiale spécifiée est utilisée comme valeur d'accumulation initiale et la fonction spécifiée permet de sélectionner la valeur de résultat.The specified seed value is used as the initial accumulator value, and the specified function is used to select the result value.

All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Détermine si tous les éléments d'une séquence satisfont à une condition.Determines whether all elements of a sequence satisfy a condition.

Any<TSource>(IEnumerable<TSource>)

Détermine si une séquence contient des éléments.Determines whether a sequence contains any elements.

Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Détermine si des éléments d'une séquence satisfont à une condition.Determines whether any element of a sequence satisfies a condition.

Append<TSource>(IEnumerable<TSource>, TSource)

Ajoute une valeur à la fin de la séquence.Appends a value to the end of the sequence.

AsEnumerable<TSource>(IEnumerable<TSource>)

Retourne l’entrée typée comme IEnumerable<T>.Returns the input typed as IEnumerable<T>.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Calcule la moyenne d'une séquence de valeurs Decimal obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the average of a sequence of Decimal values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Calcule la moyenne d'une séquence de valeurs Double obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the average of a sequence of Double values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Calcule la moyenne d'une séquence de valeurs Int32 obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the average of a sequence of Int32 values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Calcule la moyenne d'une séquence de valeurs Int64 obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the average of a sequence of Int64 values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Calcule la moyenne d'une séquence de valeurs Decimal nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the average of a sequence of nullable Decimal values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Calcule la moyenne d'une séquence de valeurs Double nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the average of a sequence of nullable Double values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Calcule la moyenne d'une séquence de valeurs Int32 nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the average of a sequence of nullable Int32 values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Calcule la moyenne d'une séquence de valeurs Int64 nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the average of a sequence of nullable Int64 values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Calcule la moyenne d'une séquence de valeurs Single nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the average of a sequence of nullable Single values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Calcule la moyenne d'une séquence de valeurs Single obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the average of a sequence of Single values that are obtained by invoking a transform function on each element of the input sequence.

Cast<TResult>(IEnumerable)

Effectue un cast des éléments d'un IEnumerable vers le type spécifié.Casts the elements of an IEnumerable to the specified type.

Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Concatène deux séquences.Concatenates two sequences.

Contains<TSource>(IEnumerable<TSource>, TSource)

Détermine si une séquence contient un élément spécifié à l'aide du comparateur d'égalité par défaut.Determines whether a sequence contains a specified element by using the default equality comparer.

Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>)

Détermine si une séquence contient un élément spécifié à l'aide du IEqualityComparer<T> indiqué.Determines whether a sequence contains a specified element by using a specified IEqualityComparer<T>.

Count<TSource>(IEnumerable<TSource>)

Retourne le nombre total d'éléments dans une séquence.Returns the number of elements in a sequence.

Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Retourne un nombre qui représente les éléments de la séquence spécifiée qui satisfont à une condition.Returns a number that represents how many elements in the specified sequence satisfy a condition.

DefaultIfEmpty<TSource>(IEnumerable<TSource>)

Retourne les éléments de la séquence spécifiée ou la valeur par défaut du paramètre de type dans une collection de singletons si la séquence est vide.Returns the elements of the specified sequence or the type parameter's default value in a singleton collection if the sequence is empty.

DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource)

Retourne les éléments de la séquence spécifiée ou la valeur indiquée dans une collection de singletons si la séquence est vide.Returns the elements of the specified sequence or the specified value in a singleton collection if the sequence is empty.

Distinct<TSource>(IEnumerable<TSource>)

Retourne des éléments distincts d'une séquence et utilise le comparateur d'égalité par défaut pour comparer les valeurs.Returns distinct elements from a sequence by using the default equality comparer to compare values.

Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)

Retourne des éléments distincts d'une séquence et utilise le IEqualityComparer<T> spécifié pour comparer les valeurs.Returns distinct elements from a sequence by using a specified IEqualityComparer<T> to compare values.

ElementAt<TSource>(IEnumerable<TSource>, Int32)

Retourne l'élément à une position d'index spécifiée dans une séquence.Returns the element at a specified index in a sequence.

ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32)

Retourne l’élément situé à un index spécifié dans une séquence ou une valeur par défaut si l’index est hors limites.Returns the element at a specified index in a sequence or a default value if the index is out of range.

Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Produit la différence entre deux séquences à l'aide du comparateur d'égalité par défaut pour comparer les valeurs.Produces the set difference of two sequences by using the default equality comparer to compare values.

Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Produit la différence entre deux séquences à l'aide du IEqualityComparer<T> spécifié pour comparer les valeurs.Produces the set difference of two sequences by using the specified IEqualityComparer<T> to compare values.

First<TSource>(IEnumerable<TSource>)

Retourne le premier élément d'une séquence.Returns the first element of a sequence.

First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Retourne le premier élément d’une séquence à satisfaire à la condition spécifiée.Returns the first element in a sequence that satisfies a specified condition.

FirstOrDefault<TSource>(IEnumerable<TSource>)

Retourne le premier élément d’une séquence ou une valeur par défaut si la séquence ne contient aucun élément.Returns the first element of a sequence, or a default value if the sequence contains no elements.

FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Retourne le premier élément de la séquence à satisfaire à une condition ou une valeur par défaut si aucun élément correspondant n’est trouvé.Returns the first element of the sequence that satisfies a condition or a default value if no such element is found.

GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Regroupe les éléments d'une séquence selon la fonction de sélection de clé spécifiée.Groups the elements of a sequence according to a specified key selector function.

GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Regroupe les éléments d'une séquence selon la fonction de sélection de clé spécifiée et compare les clés à l'aide du comparateur indiqué.Groups the elements of a sequence according to a specified key selector function and compares the keys by using a specified comparer.

GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

Regroupe les éléments d'une séquence selon la fonction de sélection de clé spécifiée et projette les éléments de chaque groupe à l'aide de la fonction indiquée.Groups the elements of a sequence according to a specified key selector function and projects the elements for each group by using a specified function.

GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)

Regroupe les éléments d'une séquence selon une fonction de sélection de clé.Groups the elements of a sequence according to a key selector function. Les clés sont comparées à l'aide d'un comparateur et les éléments de chaque groupe sont projetés à l'aide d'une fonction spécifique.The keys are compared by using a comparer and each group's elements are projected by using a specified function.

GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>)

Regroupe les éléments d'une séquence selon la fonction de sélection de clé spécifiée et crée une valeur de résultat à partir de chaque groupe et de la clé correspondante.Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.

GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>)

Regroupe les éléments d'une séquence selon la fonction de sélection de clé spécifiée et crée une valeur de résultat à partir de chaque groupe et de la clé correspondante.Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. Les clés sont comparées à l'aide d'un comparateur spécifié.The keys are compared by using a specified comparer.

GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>)

Regroupe les éléments d'une séquence selon la fonction de sélection de clé spécifiée et crée une valeur de résultat à partir de chaque groupe et de la clé correspondante.Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. Les éléments de chaque groupe sont projetés à l'aide d'une fonction spécifique.The elements of each group are projected by using a specified function.

GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>, IEqualityComparer<TKey>)

Regroupe les éléments d'une séquence selon la fonction de sélection de clé spécifiée et crée une valeur de résultat à partir de chaque groupe et de la clé correspondante.Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. Les valeurs de clé sont comparées à l'aide du comparateur spécifié et les éléments de chaque groupe sont projetés à l'aide d'une fonction spécifique.Key values are compared by using a specified comparer, and the elements of each group are projected by using a specified function.

GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>)

Met en corrélation les éléments de deux séquences en fonction de l'égalité des clés et regroupe les résultats.Correlates the elements of two sequences based on equality of keys and groups the results. Le comparateur d'égalité par défaut est utilisé pour comparer les clés.The default equality comparer is used to compare keys.

GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>, IEqualityComparer<TKey>)

Met en corrélation les éléments de deux séquences en fonction de l'égalité des clés et regroupe les résultats.Correlates the elements of two sequences based on key equality and groups the results. Un IEqualityComparer<T> spécifié est utilisé pour comparer les clés.A specified IEqualityComparer<T> is used to compare keys.

Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Produit l'intersection de deux séquences à l'aide du comparateur d'égalité par défaut pour comparer les valeurs.Produces the set intersection of two sequences by using the default equality comparer to compare values.

Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Produit l'intersection entre deux séquences à l'aide du IEqualityComparer<T> spécifié pour comparer les valeurs.Produces the set intersection of two sequences by using the specified IEqualityComparer<T> to compare values.

Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>)

Met en corrélation les éléments de deux séquences en fonction des clés qui correspondent.Correlates the elements of two sequences based on matching keys. Le comparateur d'égalité par défaut est utilisé pour comparer les clés.The default equality comparer is used to compare keys.

Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>)

Met en corrélation les éléments de deux séquences en fonction des clés qui correspondent.Correlates the elements of two sequences based on matching keys. Un IEqualityComparer<T> spécifié est utilisé pour comparer les clés.A specified IEqualityComparer<T> is used to compare keys.

Last<TSource>(IEnumerable<TSource>)

Retourne le dernier élément d'une séquence.Returns the last element of a sequence.

Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Retourne le dernier élément d’une séquence à satisfaire à la condition spécifiée.Returns the last element of a sequence that satisfies a specified condition.

LastOrDefault<TSource>(IEnumerable<TSource>)

Retourne le dernier élément d’une séquence ou une valeur par défaut si la séquence ne contient aucun élément.Returns the last element of a sequence, or a default value if the sequence contains no elements.

LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Retourne le dernier élément d’une séquence à satisfaire à une condition ou une valeur par défaut si aucun élément correspondant n’est trouvé.Returns the last element of a sequence that satisfies a condition or a default value if no such element is found.

LongCount<TSource>(IEnumerable<TSource>)

Retourne un Int64 qui représente le nombre total d'éléments dans une séquence.Returns an Int64 that represents the total number of elements in a sequence.

LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Retourne un Int64 qui représente le nombre total d'éléments dans une séquence à satisfaire à une condition.Returns an Int64 that represents how many elements in a sequence satisfy a condition.

Max<TSource>(IEnumerable<TSource>)

Retourne la valeur maximale dans une séquence générique.Returns the maximum value in a generic sequence.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Decimal maximale.Invokes a transform function on each element of a sequence and returns the maximum Decimal value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Double maximale.Invokes a transform function on each element of a sequence and returns the maximum Double value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Int32 maximale.Invokes a transform function on each element of a sequence and returns the maximum Int32 value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Int64 maximale.Invokes a transform function on each element of a sequence and returns the maximum Int64 value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Decimal nullable maximale.Invokes a transform function on each element of a sequence and returns the maximum nullable Decimal value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Double nullable maximale.Invokes a transform function on each element of a sequence and returns the maximum nullable Double value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Int32 nullable maximale.Invokes a transform function on each element of a sequence and returns the maximum nullable Int32 value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Int64 nullable maximale.Invokes a transform function on each element of a sequence and returns the maximum nullable Int64 value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Single nullable maximale.Invokes a transform function on each element of a sequence and returns the maximum nullable Single value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Single maximale.Invokes a transform function on each element of a sequence and returns the maximum Single value.

Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)

Appelle une fonction de transformation sur chaque élément d'une séquence générique et retourne la valeur résultante maximale.Invokes a transform function on each element of a generic sequence and returns the maximum resulting value.

Min<TSource>(IEnumerable<TSource>)

Retourne la valeur minimale dans une séquence générique.Returns the minimum value in a generic sequence.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Decimal minimale.Invokes a transform function on each element of a sequence and returns the minimum Decimal value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Double minimale.Invokes a transform function on each element of a sequence and returns the minimum Double value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Int32 minimale.Invokes a transform function on each element of a sequence and returns the minimum Int32 value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Int64 minimale.Invokes a transform function on each element of a sequence and returns the minimum Int64 value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Decimal nullable minimale.Invokes a transform function on each element of a sequence and returns the minimum nullable Decimal value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Double nullable minimale.Invokes a transform function on each element of a sequence and returns the minimum nullable Double value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Int32 nullable minimale.Invokes a transform function on each element of a sequence and returns the minimum nullable Int32 value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Int64 nullable minimale.Invokes a transform function on each element of a sequence and returns the minimum nullable Int64 value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Single nullable minimale.Invokes a transform function on each element of a sequence and returns the minimum nullable Single value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Single minimale.Invokes a transform function on each element of a sequence and returns the minimum Single value.

Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)

Appelle une fonction de transformation sur chaque élément d'une séquence générique et retourne la valeur résultante minimale.Invokes a transform function on each element of a generic sequence and returns the minimum resulting value.

OfType<TResult>(IEnumerable)

Filtre les éléments d'un IEnumerable en fonction du type spécifié.Filters the elements of an IEnumerable based on a specified type.

OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Trie les éléments d'une séquence dans l'ordre croissant selon une clé.Sorts the elements of a sequence in ascending order according to a key.

OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

Trie les éléments d'une séquence dans l'ordre croissant à l'aide d'un comparateur spécifié.Sorts the elements of a sequence in ascending order by using a specified comparer.

OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Trie les éléments d'une séquence dans l'ordre décroissant selon une clé.Sorts the elements of a sequence in descending order according to a key.

OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

Trie les éléments d'une séquence dans l'ordre décroissant à l'aide d'un comparateur spécifié.Sorts the elements of a sequence in descending order by using a specified comparer.

Prepend<TSource>(IEnumerable<TSource>, TSource)

Ajoute une valeur au début de la séquence.Adds a value to the beginning of the sequence.

Reverse<TSource>(IEnumerable<TSource>)

Inverse l'ordre des éléments dans une séquence.Inverts the order of the elements in a sequence.

Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)

Projette chaque élément d’une séquence dans un nouveau formulaire.Projects each element of a sequence into a new form.

Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>)

Projette chaque élément d'une séquence dans un nouveau formulaire en incorporant l'index de l'élément.Projects each element of a sequence into a new form by incorporating the element's index.

SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>)

Projette chaque élément d'une séquence sur un IEnumerable<T> et aplatit les séquences résultantes en une seule séquence.Projects each element of a sequence to an IEnumerable<T> and flattens the resulting sequences into one sequence.

SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)

Projette chaque élément d'une séquence sur un IEnumerable<T> et aplatit les séquences résultantes en une seule séquence.Projects each element of a sequence to an IEnumerable<T>, and flattens the resulting sequences into one sequence. L'index de chaque élément source est utilisé dans le formulaire projeté de l'élément.The index of each source element is used in the projected form of that element.

SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)

Projette chaque élément d'une séquence sur un IEnumerable<T>, aplatit les séquences résultantes en une seule séquence et appelle une fonction de sélection de résultat sur chaque élément inclus.Projects each element of a sequence to an IEnumerable<T>, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein.

SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)

Projette chaque élément d'une séquence sur un IEnumerable<T>, aplatit les séquences résultantes en une seule séquence et appelle une fonction de sélection de résultat sur chaque élément inclus.Projects each element of a sequence to an IEnumerable<T>, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein. L'index de chaque élément source est utilisé dans le formulaire intermédiaire projeté de l'élément.The index of each source element is used in the intermediate projected form of that element.

SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Détermine si deux séquences sont égales par une comparaison des types d'élément réalisée à l'aide du comparateur d'égalité par défaut.Determines whether two sequences are equal by comparing the elements by using the default equality comparer for their type.

SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Détermine si deux séquences sont égales en comparant leurs éléments à l'aide d'un IEqualityComparer<T> spécifié.Determines whether two sequences are equal by comparing their elements by using a specified IEqualityComparer<T>.

Single<TSource>(IEnumerable<TSource>)

Retourne l’élément unique d’une séquence ou lève une exception si cette séquence ne contient pas un seul élément.Returns the only element of a sequence, and throws an exception if there is not exactly one element in the sequence.

Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Retourne le seul élément d’une séquence qui satisfait à une condition spécifique ou lève une exception si cette séquence contient plusieurs éléments respectant cette condition.Returns the only element of a sequence that satisfies a specified condition, and throws an exception if more than one such element exists.

SingleOrDefault<TSource>(IEnumerable<TSource>)

Retourne l'élément unique d'une séquence ou une valeur par défaut. Cette méthode lève une exception si cette séquence contient plusieurs éléments.Returns the only element of a sequence, or a default value if the sequence is empty; this method throws an exception if there is more than one element in the sequence.

SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Retourne l’élément unique d’une séquence ou une valeur par défaut si cette séquence ne contient pas d’élément respectant cette condition. Cette méthode lève une exception si cette séquence contient plusieurs éléments satisfaisant à cette condition.Returns the only element of a sequence that satisfies a specified condition or a default value if no such element exists; this method throws an exception if more than one element satisfies the condition.

Skip<TSource>(IEnumerable<TSource>, Int32)

Ignore un nombre spécifié d'éléments dans une séquence puis retourne les éléments restants.Bypasses a specified number of elements in a sequence and then returns the remaining elements.

SkipLast<TSource>(IEnumerable<TSource>, Int32)

Retourne une nouvelle collection énumérable qui contient les éléments de source avec les derniers éléments count de la collection source omise.Returns a new enumerable collection that contains the elements from source with the last count elements of the source collection omitted.

SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Ignore des éléments dans une séquence tant que la condition spécifiée a la valeur true, puis retourne les éléments restants.Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements.

SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)

Ignore des éléments dans une séquence tant que la condition spécifiée a la valeur true, puis retourne les éléments restants.Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements. L’index de l’élément est utilisé dans la logique de la fonction de prédicat.The element's index is used in the logic of the predicate function.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Calcule la somme d'une séquence de valeurs Decimal obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of Decimal values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Calcule la somme d'une séquence de valeurs Double obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of Double values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Calcule la somme d'une séquence de valeurs Int32 obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of Int32 values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Calcule la somme d'une séquence de valeurs Int64 obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of Int64 values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Calcule la somme d'une séquence de valeurs Decimal nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of nullable Decimal values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Calcule la somme d'une séquence de valeurs Double nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of nullable Double values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Calcule la somme d'une séquence de valeurs Int32 nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of nullable Int32 values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Calcule la somme d'une séquence de valeurs Int64 nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of nullable Int64 values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Calcule la somme d'une séquence de valeurs Single nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of nullable Single values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Calcule la somme d'une séquence de valeurs Single obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of Single values that are obtained by invoking a transform function on each element of the input sequence.

Take<TSource>(IEnumerable<TSource>, Int32)

Retourne un nombre spécifié d'éléments contigus à partir du début d'une séquence.Returns a specified number of contiguous elements from the start of a sequence.

TakeLast<TSource>(IEnumerable<TSource>, Int32)

Retourne une nouvelle collection énumérable qui contient les derniers éléments count de source.Returns a new enumerable collection that contains the last count elements from source.

TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Retourne des éléments d'une séquence tant que la condition spécifiée a la valeur true.Returns elements from a sequence as long as a specified condition is true.

TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)

Retourne des éléments d'une séquence tant que la condition spécifiée a la valeur true.Returns elements from a sequence as long as a specified condition is true. L’index de l’élément est utilisé dans la logique de la fonction de prédicat.The element's index is used in the logic of the predicate function.

ToArray<TSource>(IEnumerable<TSource>)

Crée un tableau à partir de IEnumerable<T>.Creates an array from a IEnumerable<T>.

ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Crée un Dictionary<TKey,TValue> à partir d'un IEnumerable<T> selon une fonction de sélection de clé spécifiée.Creates a Dictionary<TKey,TValue> from an IEnumerable<T> according to a specified key selector function.

ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Crée un Dictionary<TKey,TValue> à partir de IEnumerable<T> selon une fonction de sélection de clé spécifiée et un comparateur de clé.Creates a Dictionary<TKey,TValue> from an IEnumerable<T> according to a specified key selector function and key comparer.

ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

Crée un Dictionary<TKey,TValue> à partir de IEnumerable<T> selon des fonctions de sélection de clé et de sélection d'élément spécifiées.Creates a Dictionary<TKey,TValue> from an IEnumerable<T> according to specified key selector and element selector functions.

ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)

Crée un Dictionary<TKey,TValue> à partir de IEnumerable<T> selon une fonction de sélection de clé spécifiée, un comparateur et une fonction de sélection d'élément.Creates a Dictionary<TKey,TValue> from an IEnumerable<T> according to a specified key selector function, a comparer, and an element selector function.

ToHashSet<TSource>(IEnumerable<TSource>)

Crée un HashSet<T> à partir d’un IEnumerable<T>.Creates a HashSet<T> from an IEnumerable<T>.

ToHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)

Crée un HashSet<T> à partir d’un IEnumerable<T> en utilisant comparer pour comparer des clés.Creates a HashSet<T> from an IEnumerable<T> using the comparer to compare keys.

ToList<TSource>(IEnumerable<TSource>)

Crée un List<T> à partir d’un IEnumerable<T>.Creates a List<T> from an IEnumerable<T>.

ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Crée un Lookup<TKey,TElement> à partir d'un IEnumerable<T> selon une fonction de sélection de clé spécifiée.Creates a Lookup<TKey,TElement> from an IEnumerable<T> according to a specified key selector function.

ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Crée un Lookup<TKey,TElement> à partir de IEnumerable<T> selon une fonction de sélection de clé spécifiée et un comparateur de clé.Creates a Lookup<TKey,TElement> from an IEnumerable<T> according to a specified key selector function and key comparer.

ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

Crée un Lookup<TKey,TElement> à partir de IEnumerable<T> selon des fonctions de sélection de clé et de sélection d'élément spécifiées.Creates a Lookup<TKey,TElement> from an IEnumerable<T> according to specified key selector and element selector functions.

ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)

Crée une Lookup<TKey,TElement> à partir de IEnumerable<T> selon une fonction de sélection de clé spécifiée, un comparateur et une fonction de sélection d'élément.Creates a Lookup<TKey,TElement> from an IEnumerable<T> according to a specified key selector function, a comparer and an element selector function.

Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Produit l'union de deux séquences à l'aide du comparateur d'égalité par défaut.Produces the set union of two sequences by using the default equality comparer.

Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Produit l'union de deux séquences à l'aide d'un IEqualityComparer<T> spécifié.Produces the set union of two sequences by using a specified IEqualityComparer<T>.

Where<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Filtre une séquence de valeurs selon un prédicat.Filters a sequence of values based on a predicate.

Where<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)

Filtre une séquence de valeurs selon un prédicat.Filters a sequence of values based on a predicate. L'index de chaque élément est utilisé dans la logique de la fonction de prédicat.Each element's index is used in the logic of the predicate function.

Zip<TFirst,TSecond>(IEnumerable<TFirst>, IEnumerable<TSecond>)

Produit une séquence de tuples avec des éléments des deux séquences spécifiées.Produces a sequence of tuples with elements from the two specified sequences.

Zip<TFirst,TSecond,TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>)

Applique une fonction spécifiée aux éléments correspondants de deux séquences pour produire une séquence des résultats.Applies a specified function to the corresponding elements of two sequences, producing a sequence of the results.

AsParallel(IEnumerable)

Active la parallélisation d'une requête.Enables parallelization of a query.

AsParallel<TSource>(IEnumerable<TSource>)

Active la parallélisation d'une requête.Enables parallelization of a query.

Aggregate<TSource>(IQueryable<TSource>, Expression<Func<TSource,TSource,TSource>>)

Applique une fonction d'accumulation sur une séquence.Applies an accumulator function over a sequence.

Aggregate<TSource,TAccumulate>(IQueryable<TSource>, TAccumulate, Expression<Func<TAccumulate,TSource,TAccumulate>>)

Applique une fonction d'accumulation sur une séquence.Applies an accumulator function over a sequence. La valeur initiale spécifiée est utilisée comme valeur d'accumulation initiale.The specified seed value is used as the initial accumulator value.

Aggregate<TSource,TAccumulate,TResult>(IQueryable<TSource>, TAccumulate, Expression<Func<TAccumulate,TSource,TAccumulate>>, Expression<Func<TAccumulate,TResult>>)

Applique une fonction d'accumulation sur une séquence.Applies an accumulator function over a sequence. La valeur initiale spécifiée est utilisée comme valeur d'accumulation initiale et la fonction spécifiée permet de sélectionner la valeur de résultat.The specified seed value is used as the initial accumulator value, and the specified function is used to select the result value.

All<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)

Détermine si tous les éléments d'une séquence satisfont à une condition.Determines whether all the elements of a sequence satisfy a condition.

Any<TSource>(IQueryable<TSource>)

Détermine si une séquence contient des éléments.Determines whether a sequence contains any elements.

Any<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)

Détermine si des éléments d'une séquence satisfont à une condition.Determines whether any element of a sequence satisfies a condition.

Append<TSource>(IQueryable<TSource>, TSource)

Retourne une nouvelle séquence interrogeable qui contient les éléments de source plus le element spécifié ajouté à la fin.Returns a new queryable sequence that contains the elements from source plus the specified element appended at the end.

AsQueryable(IEnumerable)

Convertit un IEnumerable en IQueryable.Converts an IEnumerable to an IQueryable.

AsQueryable<TElement>(IEnumerable<TElement>)

Convertit un IEnumerable<T> générique en IQueryable<T> générique.Converts a generic IEnumerable<T> to a generic IQueryable<T>.

Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Decimal>>)

Calcule la moyenne d'une séquence de valeurs Decimal obtenue en appelant une fonction de projection sur chaque élément de la séquence d'entrée.Computes the average of a sequence of Decimal values that is obtained by invoking a projection function on each element of the input sequence.

Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Double>>)

Calcule la moyenne d'une séquence de valeurs Double obtenue en appelant une fonction de projection sur chaque élément de la séquence d'entrée.Computes the average of a sequence of Double values that is obtained by invoking a projection function on each element of the input sequence.

Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int32>>)

Calcule la moyenne d'une séquence de valeurs Int32 obtenue en appelant une fonction de projection sur chaque élément de la séquence d'entrée.Computes the average of a sequence of Int32 values that is obtained by invoking a projection function on each element of the input sequence.

Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int64>>)

Calcule la moyenne d'une séquence de valeurs Int64 obtenue en appelant une fonction de projection sur chaque élément de la séquence d'entrée.Computes the average of a sequence of Int64 values that is obtained by invoking a projection function on each element of the input sequence.

Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Decimal>>>)

Calcule la moyenne d'une séquence de valeurs Decimal nullables obtenue en appelant une fonction de projection sur chaque élément de la séquence d'entrée.Computes the average of a sequence of nullable Decimal values that is obtained by invoking a projection function on each element of the input sequence.

Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Double>>>)

Calcule la moyenne d'une séquence de valeurs Double nullables obtenue en appelant une fonction de projection sur chaque élément de la séquence d'entrée.Computes the average of a sequence of nullable Double values that is obtained by invoking a projection function on each element of the input sequence.

Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Int32>>>)

Calcule la moyenne d'une séquence de valeurs Int32 nullables obtenue en appelant une fonction de projection sur chaque élément de la séquence d'entrée.Computes the average of a sequence of nullable Int32 values that is obtained by invoking a projection function on each element of the input sequence.

Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Int64>>>)

Calcule la moyenne d'une séquence de valeurs Int64 nullables obtenue en appelant une fonction de projection sur chaque élément de la séquence d'entrée.Computes the average of a sequence of nullable Int64 values that is obtained by invoking a projection function on each element of the input sequence.

Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Single>>>)

Calcule la moyenne d'une séquence de valeurs Single nullables obtenue en appelant une fonction de projection sur chaque élément de la séquence d'entrée.Computes the average of a sequence of nullable Single values that is obtained by invoking a projection function on each element of the input sequence.

Average<TSource>(IQueryable<TSource>, Expression<Func<TSource,Single>>)

Calcule la moyenne d'une séquence de valeurs Single obtenue en appelant une fonction de projection sur chaque élément de la séquence d'entrée.Computes the average of a sequence of Single values that is obtained by invoking a projection function on each element of the input sequence.

Cast<TResult>(IQueryable)

Convertit les éléments d’un objet IQueryable vers le type spécifié.Converts the elements of an IQueryable to the specified type.

Concat<TSource>(IQueryable<TSource>, IEnumerable<TSource>)

Concatène deux séquences.Concatenates two sequences.

Contains<TSource>(IQueryable<TSource>, TSource)

Détermine si une séquence contient un élément spécifié à l'aide du comparateur d'égalité par défaut.Determines whether a sequence contains a specified element by using the default equality comparer.

Contains<TSource>(IQueryable<TSource>, TSource, IEqualityComparer<TSource>)

Détermine si une séquence contient un élément spécifié à l'aide du IEqualityComparer<T> indiqué.Determines whether a sequence contains a specified element by using a specified IEqualityComparer<T>.

Count<TSource>(IQueryable<TSource>)

Retourne le nombre total d'éléments dans une séquence.Returns the number of elements in a sequence.

Count<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)

Retourne le nombre d'éléments dans la séquence spécifiée qui satisfait à une condition.Returns the number of elements in the specified sequence that satisfies a condition.

DefaultIfEmpty<TSource>(IQueryable<TSource>)

Retourne les éléments de la séquence spécifiée ou la valeur par défaut du paramètre de type dans une collection de singletons si la séquence est vide.Returns the elements of the specified sequence or the type parameter's default value in a singleton collection if the sequence is empty.

DefaultIfEmpty<TSource>(IQueryable<TSource>, TSource)

Retourne les éléments de la séquence spécifiée ou la valeur indiquée dans une collection de singletons si la séquence est vide.Returns the elements of the specified sequence or the specified value in a singleton collection if the sequence is empty.

Distinct<TSource>(IQueryable<TSource>)

Retourne des éléments distincts d'une séquence et utilise le comparateur d'égalité par défaut pour comparer les valeurs.Returns distinct elements from a sequence by using the default equality comparer to compare values.

Distinct<TSource>(IQueryable<TSource>, IEqualityComparer<TSource>)

Retourne des éléments distincts d'une séquence et utilise le IEqualityComparer<T> spécifié pour comparer les valeurs.Returns distinct elements from a sequence by using a specified IEqualityComparer<T> to compare values.

ElementAt<TSource>(IQueryable<TSource>, Int32)

Retourne l'élément à une position d'index spécifiée dans une séquence.Returns the element at a specified index in a sequence.

ElementAtOrDefault<TSource>(IQueryable<TSource>, Int32)

Retourne l’élément situé à un index spécifié dans une séquence ou une valeur par défaut si l’index est hors limites.Returns the element at a specified index in a sequence or a default value if the index is out of range.

Except<TSource>(IQueryable<TSource>, IEnumerable<TSource>)

Produit la différence entre deux séquences à l'aide du comparateur d'égalité par défaut pour comparer les valeurs.Produces the set difference of two sequences by using the default equality comparer to compare values.

Except<TSource>(IQueryable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Produit la différence entre deux séquences à l'aide du IEqualityComparer<T> spécifié pour comparer les valeurs.Produces the set difference of two sequences by using the specified IEqualityComparer<T> to compare values.

First<TSource>(IQueryable<TSource>)

Retourne le premier élément d'une séquence.Returns the first element of a sequence.

First<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)

Retourne le premier élément d'une séquence qui satisfait à la condition spécifiée.Returns the first element of a sequence that satisfies a specified condition.

FirstOrDefault<TSource>(IQueryable<TSource>)

Retourne le premier élément d’une séquence ou une valeur par défaut si la séquence ne contient aucun élément.Returns the first element of a sequence, or a default value if the sequence contains no elements.

FirstOrDefault<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)

Retourne le premier élément d'une séquence qui satisfait à une condition spécifiée ou une valeur par défaut si aucun élément ne correspond.Returns the first element of a sequence that satisfies a specified condition or a default value if no such element is found.

GroupBy<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>)

Regroupe les éléments d'une séquence selon la fonction de sélection de clé spécifiée.Groups the elements of a sequence according to a specified key selector function.

GroupBy<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>, IEqualityComparer<TKey>)

Regroupe les éléments d'une séquence selon la fonction de sélection de clé spécifiée et compare les clés à l'aide du comparateur indiqué.Groups the elements of a sequence according to a specified key selector function and compares the keys by using a specified comparer.

GroupBy<TSource,TKey,TElement>(IQueryable<TSource>, Expression<Func<TSource,TKey>>, Expression<Func<TSource,TElement>>)

Regroupe les éléments d'une séquence selon la fonction de sélection de clé spécifiée et projette les éléments de chaque groupe à l'aide de la fonction indiquée.Groups the elements of a sequence according to a specified key selector function and projects the elements for each group by using a specified function.

GroupBy<TSource,TKey,TElement>(IQueryable<TSource>, Expression<Func<TSource,TKey>>, Expression<Func<TSource,TElement>>, IEqualityComparer<TKey>)

Groupe les éléments d'une séquence et projette les éléments pour chaque groupe en utilisant une fonction spécifiée.Groups the elements of a sequence and projects the elements for each group by using a specified function. Les valeurs de clés sont comparées à l'aide d'un comparateur spécifié.Key values are compared by using a specified comparer.

GroupBy<TSource,TKey,TResult>(IQueryable<TSource>, Expression<Func<TSource,TKey>>, Expression<Func<TKey,IEnumerable<TSource>,TResult>>)

Regroupe les éléments d'une séquence selon la fonction de sélection de clé spécifiée et crée une valeur de résultat à partir de chaque groupe et de la clé correspondante.Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.

GroupBy<TSource,TKey,TResult>(IQueryable<TSource>, Expression<Func<TSource,TKey>>, Expression<Func<TKey,IEnumerable<TSource>,TResult>>, IEqualityComparer<TKey>)

Regroupe les éléments d'une séquence selon la fonction de sélection de clé spécifiée et crée une valeur de résultat à partir de chaque groupe et de la clé correspondante.Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. Les clés sont comparées à l'aide d'un comparateur spécifié.Keys are compared by using a specified comparer.

GroupBy<TSource,TKey,TElement,TResult>(IQueryable<TSource>, Expression<Func<TSource,TKey>>, Expression<Func<TSource,TElement>>, Expression<Func<TKey,IEnumerable<TElement>,TResult>>)

Regroupe les éléments d'une séquence selon la fonction de sélection de clé spécifiée et crée une valeur de résultat à partir de chaque groupe et de la clé correspondante.Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. Les éléments de chaque groupe sont projetés à l'aide d'une fonction spécifique.The elements of each group are projected by using a specified function.

GroupBy<TSource,TKey,TElement,TResult>(IQueryable<TSource>, Expression<Func<TSource,TKey>>, Expression<Func<TSource,TElement>>, Expression<Func<TKey,IEnumerable<TElement>,TResult>>, IEqualityComparer<TKey>)

Regroupe les éléments d'une séquence selon la fonction de sélection de clé spécifiée et crée une valeur de résultat à partir de chaque groupe et de la clé correspondante.Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. Les clés sont comparées à l'aide du comparateur spécifié et les éléments de chaque groupe sont projetés à l'aide d'une fonction spécifique.Keys are compared by using a specified comparer and the elements of each group are projected by using a specified function.

GroupJoin<TOuter,TInner,TKey,TResult>(IQueryable<TOuter>, IEnumerable<TInner>, Expression<Func<TOuter,TKey>>, Expression<Func<TInner,TKey>>, Expression<Func<TOuter,IEnumerable<TInner>,TResult>>)

Met en corrélation les éléments de deux séquences en fonction de l'égalité des clés et regroupe les résultats.Correlates the elements of two sequences based on key equality and groups the results. Le comparateur d'égalité par défaut est utilisé pour comparer les clés.The default equality comparer is used to compare keys.

GroupJoin<TOuter,TInner,TKey,TResult>(IQueryable<TOuter>, IEnumerable<TInner>, Expression<Func<TOuter,TKey>>, Expression<Func<TInner,TKey>>, Expression<Func<TOuter,IEnumerable<TInner>,TResult>>, IEqualityComparer<TKey>)

Met en corrélation les éléments de deux séquences en fonction de l'égalité des clés et regroupe les résultats.Correlates the elements of two sequences based on key equality and groups the results. Un IEqualityComparer<T> spécifié est utilisé pour comparer les clés.A specified IEqualityComparer<T> is used to compare keys.

Intersect<TSource>(IQueryable<TSource>, IEnumerable<TSource>)

Produit l'intersection de deux séquences à l'aide du comparateur d'égalité par défaut pour comparer les valeurs.Produces the set intersection of two sequences by using the default equality comparer to compare values.

Intersect<TSource>(IQueryable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Produit l'intersection entre deux séquences à l'aide du IEqualityComparer<T> spécifié pour comparer les valeurs.Produces the set intersection of two sequences by using the specified IEqualityComparer<T> to compare values.

Join<TOuter,TInner,TKey,TResult>(IQueryable<TOuter>, IEnumerable<TInner>, Expression<Func<TOuter,TKey>>, Expression<Func<TInner,TKey>>, Expression<Func<TOuter,TInner,TResult>>)

Met en corrélation les éléments de deux séquences en fonction des clés qui correspondent.Correlates the elements of two sequences based on matching keys. Le comparateur d'égalité par défaut est utilisé pour comparer les clés.The default equality comparer is used to compare keys.

Join<TOuter,TInner,TKey,TResult>(IQueryable<TOuter>, IEnumerable<TInner>, Expression<Func<TOuter,TKey>>, Expression<Func<TInner,TKey>>, Expression<Func<TOuter,TInner,TResult>>, IEqualityComparer<TKey>)

Met en corrélation les éléments de deux séquences en fonction des clés qui correspondent.Correlates the elements of two sequences based on matching keys. Un IEqualityComparer<T> spécifié est utilisé pour comparer les clés.A specified IEqualityComparer<T> is used to compare keys.

Last<TSource>(IQueryable<TSource>)

Retourne le dernier élément d'une séquence.Returns the last element in a sequence.

Last<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)

Retourne le dernier élément d’une séquence à satisfaire à la condition spécifiée.Returns the last element of a sequence that satisfies a specified condition.

LastOrDefault<TSource>(IQueryable<TSource>)

Retourne le dernier élément d'une séquence ou une valeur par défaut si la séquence ne contient aucun élément.Returns the last element in a sequence, or a default value if the sequence contains no elements.

LastOrDefault<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)

Retourne le dernier élément d’une séquence à satisfaire à une condition ou une valeur par défaut si aucun élément correspondant n’est trouvé.Returns the last element of a sequence that satisfies a condition or a default value if no such element is found.

LongCount<TSource>(IQueryable<TSource>)

Retourne un Int64 qui représente le nombre total d'éléments dans une séquence.Returns an Int64 that represents the total number of elements in a sequence.

LongCount<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)

Retourne un Int64 qui représente le nombre d'éléments dans une séquence qui satisfont à une condition.Returns an Int64 that represents the number of elements in a sequence that satisfy a condition.

Max<TSource>(IQueryable<TSource>)

Retourne la valeur maximale dans un IQueryable<T>générique.Returns the maximum value in a generic IQueryable<T>.

Max<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,TResult>>)

Appelle une fonction de projection sur chaque élément d'un IQueryable<T> générique et retourne la valeur résultante maximale.Invokes a projection function on each element of a generic IQueryable<T> and returns the maximum resulting value.

Min<TSource>(IQueryable<TSource>)

Retourne la valeur minimale d'un IQueryable<T> générique.Returns the minimum value of a generic IQueryable<T>.

Min<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,TResult>>)

Appelle une fonction de projection sur chaque élément d'un IQueryable<T> générique et retourne la valeur résultante minimale.Invokes a projection function on each element of a generic IQueryable<T> and returns the minimum resulting value.

OfType<TResult>(IQueryable)

Filtre les éléments d'un IQueryable en fonction du type spécifié.Filters the elements of an IQueryable based on a specified type.

OrderBy<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>)

Trie les éléments d'une séquence dans l'ordre croissant selon une clé.Sorts the elements of a sequence in ascending order according to a key.

OrderBy<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>, IComparer<TKey>)

Trie les éléments d'une séquence dans l'ordre croissant à l'aide d'un comparateur spécifié.Sorts the elements of a sequence in ascending order by using a specified comparer.

OrderByDescending<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>)

Trie les éléments d'une séquence dans l'ordre décroissant selon une clé.Sorts the elements of a sequence in descending order according to a key.

OrderByDescending<TSource,TKey>(IQueryable<TSource>, Expression<Func<TSource,TKey>>, IComparer<TKey>)

Trie les éléments d'une séquence dans l'ordre décroissant à l'aide d'un comparateur spécifié.Sorts the elements of a sequence in descending order by using a specified comparer.

Prepend<TSource>(IQueryable<TSource>, TSource)

Retourne une nouvelle séquence interrogeable qui contient les éléments de source plus le element spécifié ajouté au début.Returns a new queryable sequence that contains the elements from source plus the specified element prepended at the beginning.

Reverse<TSource>(IQueryable<TSource>)

Inverse l'ordre des éléments dans une séquence.Inverts the order of the elements in a sequence.

Select<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,TResult>>)

Projette chaque élément d’une séquence dans un nouveau formulaire.Projects each element of a sequence into a new form.

Select<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,TResult>>)

Projette chaque élément d'une séquence dans un nouveau formulaire en incorporant l'index de l'élément.Projects each element of a sequence into a new form by incorporating the element's index.

SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>)

Projette chaque élément d'une séquence sur un IEnumerable<T> et combine les séquences résultantes en une séquence.Projects each element of a sequence to an IEnumerable<T> and combines the resulting sequences into one sequence.

SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>)

Projette chaque élément d'une séquence sur un IEnumerable<T> et combine les séquences résultantes en une séquence.Projects each element of a sequence to an IEnumerable<T> and combines the resulting sequences into one sequence. L'index de chaque élément source est utilisé dans le formulaire projeté de l'élément.The index of each source element is used in the projected form of that element.

SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>)

Projette chaque élément d'une séquence sur un IEnumerable<T> et appelle une fonction du sélecteur de résultat sur chaque élément obtenu.Projects each element of a sequence to an IEnumerable<T> and invokes a result selector function on each element therein. Les valeurs résultantes de chaque séquence intermédiaire sont combinées en une séquence unique, unidimensionnelle et retournées.The resulting values from each intermediate sequence are combined into a single, one-dimensional sequence and returned.

SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>)

Projette chaque élément d'une séquence en un IEnumerable<T> qui incorpore l'index de l'élément source qui l'a produit.Projects each element of a sequence to an IEnumerable<T> that incorporates the index of the source element that produced it. Une fonction de sélecteur du résultat est appelée sur chaque élément de chaque séquence intermédiaire, et les valeurs résultantes sont combinées en une séquence unique, unidimensionnelle et retournées.A result selector function is invoked on each element of each intermediate sequence, and the resulting values are combined into a single, one-dimensional sequence and returned.

SequenceEqual<TSource>(IQueryable<TSource>, IEnumerable<TSource>)

Détermine si deux séquences sont égales à l'aide du comparateur d'égalité par défaut pour comparer des éléments.Determines whether two sequences are equal by using the default equality comparer to compare elements.

SequenceEqual<TSource>(IQueryable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Détermine si deux séquences sont égales à l'aide d'un IEqualityComparer<T> spécifié pour comparer des éléments.Determines whether two sequences are equal by using a specified IEqualityComparer<T> to compare elements.

Single<TSource>(IQueryable<TSource>)

Retourne l’élément unique d’une séquence ou lève une exception si cette séquence ne contient pas un seul élément.Returns the only element of a sequence, and throws an exception if there is not exactly one element in the sequence.

Single<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)

Retourne le seul élément d’une séquence qui satisfait à une condition spécifique ou lève une exception si cette séquence contient plusieurs éléments respectant cette condition.Returns the only element of a sequence that satisfies a specified condition, and throws an exception if more than one such element exists.

SingleOrDefault<TSource>(IQueryable<TSource>)

Retourne l'élément unique d'une séquence ou une valeur par défaut. Cette méthode lève une exception si cette séquence contient plusieurs éléments.Returns the only element of a sequence, or a default value if the sequence is empty; this method throws an exception if there is more than one element in the sequence.

SingleOrDefault<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)

Retourne l’élément unique d’une séquence ou une valeur par défaut si cette séquence ne contient pas d’élément respectant cette condition. Cette méthode lève une exception si cette séquence contient plusieurs éléments satisfaisant à cette condition.Returns the only element of a sequence that satisfies a specified condition or a default value if no such element exists; this method throws an exception if more than one element satisfies the condition.

Skip<TSource>(IQueryable<TSource>, Int32)

Ignore un nombre spécifié d'éléments dans une séquence puis retourne les éléments restants.Bypasses a specified number of elements in a sequence and then returns the remaining elements.

SkipLast<TSource>(IQueryable<TSource>, Int32)

Retourne une nouvelle séquence interrogeable qui contient les éléments de source avec les derniers éléments count de la séquence interrogeable source omise.Returns a new queryable sequence that contains the elements from source with the last count elements of the source queryable sequence omitted.

SkipWhile<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)

Ignore des éléments dans une séquence tant que la condition spécifiée a la valeur true, puis retourne les éléments restants.Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements.

SkipWhile<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int32,Boolean>>)

Ignore des éléments dans une séquence tant que la condition spécifiée a la valeur true, puis retourne les éléments restants.Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements. L’index de l’élément est utilisé dans la logique de la fonction de prédicat.The element's index is used in the logic of the predicate function.

Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Decimal>>)

Calcule la somme de la séquence de valeurs Decimal obtenue en appelant une fonction de projection sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of Decimal values that is obtained by invoking a projection function on each element of the input sequence.

Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Double>>)

Calcule la somme de la séquence de valeurs Double obtenue en appelant une fonction de projection sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of Double values that is obtained by invoking a projection function on each element of the input sequence.

Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int32>>)

Calcule la somme de la séquence de valeurs Int32 obtenue en appelant une fonction de projection sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of Int32 values that is obtained by invoking a projection function on each element of the input sequence.

Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int64>>)

Calcule la somme de la séquence de valeurs Int64 obtenue en appelant une fonction de projection sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of Int64 values that is obtained by invoking a projection function on each element of the input sequence.

Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Decimal>>>)

Calcule la somme de la séquence des valeurs Decimal nullables obtenue en appelant une fonction de projection sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of nullable Decimal values that is obtained by invoking a projection function on each element of the input sequence.

Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Double>>>)

Calcule la somme de la séquence des valeurs Double nullables obtenue en appelant une fonction de projection sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of nullable Double values that is obtained by invoking a projection function on each element of the input sequence.

Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Int32>>>)

Calcule la somme de la séquence des valeurs Int32 nullables obtenue en appelant une fonction de projection sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of nullable Int32 values that is obtained by invoking a projection function on each element of the input sequence.

Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Int64>>>)

Calcule la somme de la séquence des valeurs Int64 nullables obtenue en appelant une fonction de projection sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of nullable Int64 values that is obtained by invoking a projection function on each element of the input sequence.

Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Nullable<Single>>>)

Calcule la somme de la séquence des valeurs Single nullables obtenue en appelant une fonction de projection sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of nullable Single values that is obtained by invoking a projection function on each element of the input sequence.

Sum<TSource>(IQueryable<TSource>, Expression<Func<TSource,Single>>)

Calcule la somme de la séquence de valeurs Single obtenue en appelant une fonction de projection sur chaque élément de la séquence d'entrée.Computes the sum of the sequence of Single values that is obtained by invoking a projection function on each element of the input sequence.

Take<TSource>(IQueryable<TSource>, Int32)

Retourne un nombre spécifié d'éléments contigus à partir du début d'une séquence.Returns a specified number of contiguous elements from the start of a sequence.

TakeLast<TSource>(IQueryable<TSource>, Int32)

Retourne une nouvelle séquence interrogeable qui contient les derniers éléments count de source.Returns a new queryable sequence that contains the last count elements from source.

TakeWhile<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)

Retourne des éléments d'une séquence tant que la condition spécifiée a la valeur true.Returns elements from a sequence as long as a specified condition is true.

TakeWhile<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int32,Boolean>>)

Retourne des éléments d'une séquence tant que la condition spécifiée a la valeur true.Returns elements from a sequence as long as a specified condition is true. L’index de l’élément est utilisé dans la logique de la fonction de prédicat.The element's index is used in the logic of the predicate function.

ThenBy<TSource,TKey>(IOrderedQueryable<TSource>, Expression<Func<TSource,TKey>>)

Réalise un classement des éléments d'une séquence dans l'ordre croissant selon une clé.Performs a subsequent ordering of the elements in a sequence in ascending order according to a key.

ThenBy<TSource,TKey>(IOrderedQueryable<TSource>, Expression<Func<TSource,TKey>>, IComparer<TKey>)

Réalise un classement des éléments d'une séquence dans l'ordre croissant à l'aide d'un comparateur spécifié.Performs a subsequent ordering of the elements in a sequence in ascending order by using a specified comparer.

ThenByDescending<TSource,TKey>(IOrderedQueryable<TSource>, Expression<Func<TSource,TKey>>)

Réalise un classement des éléments d'une séquence dans l'ordre décroissant selon une clé.Performs a subsequent ordering of the elements in a sequence in descending order, according to a key.

ThenByDescending<TSource,TKey>(IOrderedQueryable<TSource>, Expression<Func<TSource,TKey>>, IComparer<TKey>)

Réalise un classement des éléments d'une séquence dans l'ordre décroissant à l'aide d'un comparateur spécifié.Performs a subsequent ordering of the elements in a sequence in descending order by using a specified comparer.

Union<TSource>(IQueryable<TSource>, IEnumerable<TSource>)

Produit l'union de deux séquences à l'aide du comparateur d'égalité par défaut.Produces the set union of two sequences by using the default equality comparer.

Union<TSource>(IQueryable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Produit l'union de deux séquences à l'aide d'un IEqualityComparer<T> spécifié.Produces the set union of two sequences by using a specified IEqualityComparer<T>.

Where<TSource>(IQueryable<TSource>, Expression<Func<TSource,Boolean>>)

Filtre une séquence de valeurs selon un prédicat.Filters a sequence of values based on a predicate.

Where<TSource>(IQueryable<TSource>, Expression<Func<TSource,Int32,Boolean>>)

Filtre une séquence de valeurs selon un prédicat.Filters a sequence of values based on a predicate. L'index de chaque élément est utilisé dans la logique de la fonction de prédicat.Each element's index is used in the logic of the predicate function.

Zip<TFirst,TSecond>(IQueryable<TFirst>, IEnumerable<TSecond>)

Produit une séquence de tuples avec des éléments des deux séquences spécifiées.Produces a sequence of tuples with elements from the two specified sequences.

Zip<TFirst,TSecond,TResult>(IQueryable<TFirst>, IEnumerable<TSecond>, Expression<Func<TFirst,TSecond,TResult>>)

Fusionne deux séquences en utilisant la fonction de prédicat spécifiée.Merges two sequences by using the specified predicate function.

SortBy<T>(IQueryable<T>, String)

Spécifie un ordre de tri.Specifies a sort order.

Ancestors<T>(IEnumerable<T>)

Retourne une collection d'éléments qui contient les ancêtres de chaque nœud de la collection source.Returns a collection of elements that contains the ancestors of every node in the source collection.

Ancestors<T>(IEnumerable<T>, XName)

Retourne une collection d'éléments filtrée qui contient les ancêtres de chaque nœud de la collection source.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Seuls les éléments avec un XName correspondant sont inclus dans la collection.Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>)

Retourne une collection des nœuds descendants de chaque document et élément de la collection source.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>)

Retourne une collection d'éléments qui contient les éléments descendants de tous les éléments et tous les documents de la collection source.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

Descendants<T>(IEnumerable<T>, XName)

Retourne une collection d'éléments filtrée qui contient les éléments descendants de tous les éléments et tous les documents de la collection source.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Seuls les éléments avec un XName correspondant sont inclus dans la collection.Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>)

Retourne une collection des éléments enfants de chaque élément et document de la collection source.Returns a collection of the child elements of every element and document in the source collection.

Elements<T>(IEnumerable<T>, XName)

Retourne une collection filtrée des éléments enfants de chaque élément et document de la collection source.Returns a filtered collection of the child elements of every element and document in the source collection. Seuls les éléments avec un XName correspondant sont inclus dans la collection.Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>)

Retourne une collection de nœuds qui contient tous les nœuds de la collection source, triés selon l'ordre des documents.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>)

Retourne une collection des nœuds enfants de chaque document et élément de la collection source.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>)

Supprime chaque nœud de la collection source de son nœud parent.Removes every node in the source collection from its parent node.

S’applique à