Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

OrderedParallelQuery<TSource> méthodes

.NET Framework (current version)
 

Date de publication : novembre 2016

Espace de noms:   System.Linq
Assembly:  System.Core (dans System.Core.dll)

NomDescription
System_CAPS_pubmethodEquals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.(Hérité de Object.)

System_CAPS_protmethodFinalize()

Autorise un objet à tenter de libérer des ressources et d'exécuter d'autres opérations de nettoyage avant qu'il ne soit récupéré par l'opération garbage collection. (Hérité de Object.)

System_CAPS_pubmethodGetEnumerator()

Retourne un énumérateur qui itère dans la séquence.(Remplace ParallelQuery<TSource>.GetEnumerator().)

System_CAPS_pubmethodGetHashCode()

Fait office de fonction de hachage par défaut.(Hérité de Object.)

System_CAPS_pubmethodGetType()

Obtient le Type de l'instance actuelle.(Hérité de Object.)

System_CAPS_protmethodMemberwiseClone()

Crée une copie superficielle du Object actuel.(Hérité de Object.)

System_CAPS_pubmethodToString()

Retourne une chaîne qui représente l'objet actuel.(Hérité de Object.)

NomDescription
System_CAPS_pubmethodAggregate<TSource>(Func<TSource, TSource, TSource>)

Surchargé. Applique en parallèle une fonction d'accumulation sur une séquence.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodAggregate<TSource, TAccumulate>(TAccumulate, Func<TAccumulate, TSource, TAccumulate>)

Surchargé. Applique en parallèle une fonction d'accumulation sur une séquence. La valeur initiale spécifiée est utilisée comme valeur d'accumulation initiale.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodAggregate<TSource, TAccumulate, TResult>(TAccumulate, Func<TAccumulate, TSource, TAccumulate>, Func<TAccumulate, TAccumulate, TAccumulate>, Func<TAccumulate, TResult>)

Surchargé. Applique en parallèle une fonction d'accumulation sur une séquence. Cette surcharge n'est pas disponible dans l'implémentation séquentielle.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodAggregate<TSource, TAccumulate, TResult>(TAccumulate, Func<TAccumulate, TSource, TAccumulate>, Func<TAccumulate, TResult>)

Surchargé. Applique en parallèle une fonction d'accumulation sur une séquence. 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.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodAggregate<TSource, TAccumulate, TResult>(Func<TAccumulate>, Func<TAccumulate, TSource, TAccumulate>, Func<TAccumulate, TAccumulate, TAccumulate>, Func<TAccumulate, TResult>)

Surchargé. Applique en parallèle une fonction d'accumulation sur une séquence. Cette surcharge n'est pas disponible dans l'implémentation séquentielle.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodAll<TSource>(Func<TSource, Boolean>)

Détermine en parallèle si tous les éléments d'une séquence satisfont à une condition.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodAny<TSource>()

Surchargé. Détermine si une séquence contient des éléments.(Défini par Enumerable.)

System_CAPS_pubmethodAny<TSource>(Func<TSource, Boolean>)

Surchargé. Détermine si les éléments d’une séquence satisfont à une condition.(Défini par Enumerable.)

System_CAPS_pubmethodAny<TSource>()

Surchargé. Détermine si une séquence parallèle contient des éléments.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodAny<TSource>(Func<TSource, Boolean>)

Surchargé. Détermine en parallèle si des éléments d'une séquence satisfont à une condition.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodAsEnumerable<TSource>()

Convertit un ParallelQuery<TSource> dans un IEnumerable<T> pour forcer l’évaluation séquentielle de la requête.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodAsOrdered()

Surchargé. Active le traitement d'une source de données en considérant qu'elle est ordonnée, en substituant la valeur par défaut indiquant non ordonnée. AsOrdered peut uniquement être appelé sur les séquences non génériques retournées par AsParallel, ParallelEnumerable.Range et ParallelEnumerable.Repeat.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodAsOrdered<TSource>()

Surchargé. Active le traitement d'une source de données en considérant qu'elle est ordonnée, en substituant la valeur par défaut indiquant non ordonnée. AsOrdered peut uniquement être appelé sur les séquences génériques retournées par AsParallel, ParallelEnumerable.Range et ParallelEnumerable.Repeat.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodAsParallel()

Surchargé. Active la parallélisation d'une requête.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodAsParallel<TSource>()

Surchargé. Active la parallélisation d'une requête.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodAsQueryable()

Surchargé. Convertit un IEnumerable à un IQueryable.(Défini par Queryable.)

System_CAPS_pubmethodAsQueryable<TSource>()

Surchargé. Convertit un type générique IEnumerable<T> générique IQueryable<T>.(Défini par Queryable.)

System_CAPS_pubmethodAsSequential<TSource>()

Convertit un ParallelQuery<TSource> dans un IEnumerable<T> pour forcer l’évaluation séquentielle de la requête.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodAsUnordered<TSource>()

Autorise une requête intermédiaire à être traitée comme si aucun classement n'était défini entre les éléments.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodAverage<TSource>(Func<TSource, Decimal>)

Surchargé. Calcule en parallèle la moyenne d'une séquence de valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodAverage<TSource>(Func<TSource, Double>)

Surchargé. Calcule en parallèle la moyenne d'une séquence de valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodAverage<TSource>(Func<TSource, Int32>)

Surchargé. Calcule en parallèle la moyenne d'une séquence de valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodAverage<TSource>(Func<TSource, Int64>)

Surchargé. Calcule en parallèle la moyenne d'une séquence de valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodAverage<TSource>(Func<TSource, Nullable<Decimal>>)

Surchargé. Calcule en parallèle la moyenne d'une séquence de valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodAverage<TSource>(Func<TSource, Nullable<Double>>)

Surchargé. Calcule en parallèle la moyenne d'une séquence de valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodAverage<TSource>(Func<TSource, Nullable<Int32>>)

Surchargé. Calcule en parallèle la moyenne d'une séquence de valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodAverage<TSource>(Func<TSource, Nullable<Int64>>)

Surchargé. Calcule en parallèle la moyenne d'une séquence de valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodAverage<TSource>(Func<TSource, Nullable<Single>>)

Surchargé. Calcule en parallèle la moyenne d'une séquence de valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodAverage<TSource>(Func<TSource, Single>)

Surchargé. Calcule en parallèle la moyenne d'une séquence de valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodCast<TResult>()

Convertit les éléments d’un IEnumerable au type spécifié.(Défini par Enumerable.)

System_CAPS_pubmethodConcat<TSource>(IEnumerable<TSource>)

Concatène deux séquences.(Défini par Enumerable.)

System_CAPS_pubmethodConcat<TSource>(IEnumerable<TSource>)

Obsolète. Surchargé. Cette surcharge Concat ne doit jamais être appelée. Cette méthode est marquée comme obsolète et lève toujours une exception NotSupportedException lorsqu’elle est appelée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodConcat<TSource>(ParallelQuery<TSource>)

Surchargé. Concatène deux séquences parallèles.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodContains<TSource>(TSource)

Surchargé. Détermine en parallèle si une séquence contient un élément spécifié à l'aide du comparateur d'égalité par défaut.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodContains<TSource>(TSource, IEqualityComparer<TSource>)

Surchargé. Détermine en parallèle si une séquence contient un élément spécifié en utilisant un IEqualityComparer<T>.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodCount<TSource>()

Surchargé. Retourne le nombre d'éléments d'une séquence parallèle.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodCount<TSource>(Func<TSource, Boolean>)

Surchargé. Retourne un nombre qui représente le nombre d'éléments de la séquence parallèle spécifiée qui satisfont à une condition.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodDefaultIfEmpty<TSource>()

Surchargé. Retourne les éléments de la séquence parallèle 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.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodDefaultIfEmpty<TSource>(TSource)

Surchargé. Retourne les éléments de la séquence parallèle spécifiée ou la valeur spécifiée dans une collection de singletons, si la séquence est vide.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodDistinct<TSource>()

Surchargé. Retourne des éléments distincts d'une séquence parallèle à l'aide du comparateur d'égalité par défaut pour comparer les valeurs.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodDistinct<TSource>(IEqualityComparer<TSource>)

Surchargé. Retourne des éléments distincts à partir d'une séquence parallèle et utilise le IEqualityComparer<T> spécifié pour comparer les valeurs.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodElementAt<TSource>(Int32)

Retourne l'élément à une position d'index spécifiée dans une séquence parallèle.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodElementAtOrDefault<TSource>(Int32)

Retourne l'élément situé à une position d'index spécifiée dans une séquence parallèle ou une valeur par défaut, si l'index est hors limites.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodExcept<TSource>(IEnumerable<TSource>)

Surchargé. Produit la différence définie entre deux séquences à l’aide du comparateur d’égalité par défaut pour comparer les valeurs.(Défini par Enumerable.)

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

Surchargé. Produit la différence définie entre deux séquences en utilisant le IEqualityComparer<T> pour comparer des valeurs.(Défini par Enumerable.)

System_CAPS_pubmethodExcept<TSource>(IEnumerable<TSource>)

Obsolète. Surchargé. Cette surcharge Except ne doit jamais être appelée. Cette méthode est marquée comme obsolète et lève toujours une exception NotSupportedException lorsqu’elle est appelée.(Défini par ParallelEnumerable.)

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

Obsolète. Surchargé. Cette surcharge Except ne doit jamais être appelée. Cette méthode est marquée comme obsolète et lève toujours une exception NotSupportedException lorsqu’elle est appelée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodExcept<TSource>(ParallelQuery<TSource>)

Surchargé. Produit la différence définie entre deux séquences parallèles à l'aide du comparateur d'égalité par défaut pour comparer les valeurs.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodExcept<TSource>(ParallelQuery<TSource>, IEqualityComparer<TSource>)

Surchargé. Produit la différence définie entre deux séquences parallèles à l’aide du texte spécifié IEqualityComparer<T> pour comparer des valeurs.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodFirst<TSource>()

Surchargé. Retourne le premier élément d'une séquence parallèle.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodFirst<TSource>(Func<TSource, Boolean>)

Surchargé. Retourne le premier élément d'une séquence parallèle qui satisfait à une condition spécifiée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodFirstOrDefault<TSource>()

Surchargé. Retourne le premier élément d'une séquence parallèle ou une valeur par défaut, si la séquence ne contient aucun élément.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodFirstOrDefault<TSource>(Func<TSource, Boolean>)

Surchargé. Retourne le premier élément de la séquence parallèle qui satisfait à une condition ou une valeur par défaut, si aucun élément de ce type n'est trouvé.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodForAll<TSource>(Action<TSource>)

Appelle en parallèle l’action spécifiée pour chaque élément dans le source.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodGroupBy<TSource, TKey>(Func<TSource, TKey>)

Surchargé. Regroupe en parallèle les éléments d'une séquence selon la fonction de sélection de clé spécifiée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodGroupBy<TSource, TKey>(Func<TSource, TKey>, IEqualityComparer<TKey>)

Surchargé. Regroupe en parallèle les éléments d’une séquence selon une fonction de sélection de clé spécifiée et compare les clés en utilisant un IComparer<T>.(Défini par ParallelEnumerable.)

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

Surchargé. 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. Les clés sont comparées à l'aide d'un comparateur spécifié.(Défini par Enumerable.)

System_CAPS_pubmethodGroupBy<TSource, TKey, TElement>(Func<TSource, TKey>, Func<TSource, TElement>)

Surchargé. Regroupe en parallèle 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 d'une fonction indiquée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodGroupBy<TSource, TKey, TElement>(Func<TSource, TKey>, Func<TSource, TElement>, IEqualityComparer<TKey>)

Surchargé. Regroupe en parallèle les éléments d'une séquence selon une fonction de sélection de clé. 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.(Défini par ParallelEnumerable.)

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

Surchargé. Regroupe en parallèle 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.(Défini par ParallelEnumerable.)

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

Surchargé. Regroupe en parallèle 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. Les clés sont comparées à l'aide d'un comparateur spécifié.(Défini par ParallelEnumerable.)

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

Surchargé. 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. Les éléments de chaque groupe sont projetés à l'aide d'une fonction spécifique.(Défini par Enumerable.)

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

Surchargé. Regroupe en parallèle 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. Les éléments de chaque groupe sont projetés à l'aide d'une fonction spécifique.(Défini par ParallelEnumerable.)

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

Surchargé. 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. 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.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodGroupJoin<TSource, TInner, TKey, TResult>(IEnumerable<TInner>, Func<TSource, TKey>, Func<TInner, TKey>, Func<TSource, IEnumerable<TInner>, TResult>)

Surchargé. Met en corrélation les éléments de deux séquences en fonction de l’égalité des clés et regroupe les résultats. Le comparateur d'égalité par défaut est utilisé pour comparer les clés.(Défini par Enumerable.)

System_CAPS_pubmethodGroupJoin<TSource, TInner, TKey, TResult>(IEnumerable<TInner>, Func<TSource, TKey>, Func<TInner, TKey>, Func<TSource, IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>)

Surchargé. Met en corrélation les éléments de deux séquences en fonction de l’égalité des clés et regroupe les résultats. Un IEqualityComparer<T> est utilisé pour comparer les clés.(Défini par Enumerable.)

System_CAPS_pubmethodGroupJoin<TSource, TInner, TKey, TResult>(IEnumerable<TInner>, Func<TSource, TKey>, Func<TInner, TKey>, Func<TSource, IEnumerable<TInner>, TResult>)

Obsolète. Surchargé. Cette surcharge GroupJoin ne doit jamais être appelée. Cette méthode est marquée comme obsolète et lève toujours une exception NotSupportedException lorsqu’elle est appelée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodGroupJoin<TSource, TInner, TKey, TResult>(IEnumerable<TInner>, Func<TSource, TKey>, Func<TInner, TKey>, Func<TSource, IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>)

Obsolète. Surchargé. Cette surcharge GroupJoin ne doit jamais être appelée. Cette méthode est marquée comme obsolète et lève toujours une exception NotSupportedException lorsqu’elle est appelée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodGroupJoin<TSource, TInner, TKey, TResult>(ParallelQuery<TInner>, Func<TSource, TKey>, Func<TInner, TKey>, Func<TSource, IEnumerable<TInner>, TResult>)

Surchargé. Met en corrélation en parallèle les éléments de deux séquences en fonction de l'égalité des clés et regroupe les résultats. Le comparateur d'égalité par défaut est utilisé pour comparer les clés.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodGroupJoin<TSource, TInner, TKey, TResult>(ParallelQuery<TInner>, Func<TSource, TKey>, Func<TInner, TKey>, Func<TSource, IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>)

Surchargé. Met en corrélation en parallèle les éléments de deux séquences en fonction de l'égalité des clés et regroupe les résultats. Un IEqualityComparer<T> est utilisé pour comparer les clés.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodIntersect<TSource>(IEnumerable<TSource>)

Surchargé. Produit l’intersection définie de deux séquences à l’aide du comparateur d’égalité par défaut pour comparer les valeurs.(Défini par Enumerable.)

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

Surchargé. Produit l’intersection définie de deux séquences en utilisant le IEqualityComparer<T> pour comparer des valeurs.(Défini par Enumerable.)

System_CAPS_pubmethodIntersect<TSource>(IEnumerable<TSource>)

Obsolète. Surchargé. Cette surcharge Intersect ne doit jamais être appelée. Cette méthode est marquée comme obsolète et lève toujours une exception NotSupportedException lorsqu’elle est appelée.(Défini par ParallelEnumerable.)

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

Obsolète. Surchargé. Cette surcharge Intersect ne doit jamais être appelée. Cette méthode est marquée comme obsolète et lève toujours une exception NotSupportedException lorsqu’elle est appelée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodIntersect<TSource>(ParallelQuery<TSource>)

Surchargé. Produit l'intersection définie de deux séquences parallèles à l'aide du comparateur d'égalité par défaut pour comparer les valeurs.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodIntersect<TSource>(ParallelQuery<TSource>, IEqualityComparer<TSource>)

Surchargé. Produit l'intersection définie de deux séquences parallèles à l'aide de l'IEqualityComparer{T} spécifié pour comparer les valeurs.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodJoin<TSource, TInner, TKey, TResult>(IEnumerable<TInner>, Func<TSource, TKey>, Func<TInner, TKey>, Func<TSource, TInner, TResult>)

Surchargé. Met en corrélation les éléments de deux séquences selon des clés correspondantes. Le comparateur d'égalité par défaut est utilisé pour comparer les clés.(Défini par Enumerable.)

System_CAPS_pubmethodJoin<TSource, TInner, TKey, TResult>(IEnumerable<TInner>, Func<TSource, TKey>, Func<TInner, TKey>, Func<TSource, TInner, TResult>, IEqualityComparer<TKey>)

Surchargé. Met en corrélation les éléments de deux séquences selon des clés correspondantes. Un IEqualityComparer<T> est utilisé pour comparer les clés.(Défini par Enumerable.)

System_CAPS_pubmethodJoin<TSource, TInner, TKey, TResult>(IEnumerable<TInner>, Func<TSource, TKey>, Func<TInner, TKey>, Func<TSource, TInner, TResult>)

Obsolète. Surchargé. Cette surcharge Join ne doit jamais être appelée. Cette méthode est marquée comme obsolète et lève toujours une exception NotSupportedException lorsqu’elle est appelée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodJoin<TSource, TInner, TKey, TResult>(IEnumerable<TInner>, Func<TSource, TKey>, Func<TInner, TKey>, Func<TSource, TInner, TResult>, IEqualityComparer<TKey>)

Obsolète. Surchargé. Cette surcharge Join ne doit jamais être appelée. Cette méthode est marquée comme obsolète et lève toujours une exception NotSupportedException lorsqu’elle est appelée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodJoin<TSource, TInner, TKey, TResult>(ParallelQuery<TInner>, Func<TSource, TKey>, Func<TInner, TKey>, Func<TSource, TInner, TResult>)

Surchargé. Met en corrélation en parallèle les éléments de deux séquences selon des clés correspondantes. Le comparateur d'égalité par défaut est utilisé pour comparer les clés.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodJoin<TSource, TInner, TKey, TResult>(ParallelQuery<TInner>, Func<TSource, TKey>, Func<TInner, TKey>, Func<TSource, TInner, TResult>, IEqualityComparer<TKey>)

Surchargé. Met en corrélation en parallèle les éléments de deux séquences selon des clés correspondantes. Un IEqualityComparer<T> est utilisé pour comparer les clés.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodLast<TSource>()

Surchargé. Retourne le dernier élément d'une séquence parallèle.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodLast<TSource>(Func<TSource, Boolean>)

Surchargé. Retourne le dernier élément d'une séquence parallèle qui satisfait à une condition spécifiée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodLastOrDefault<TSource>()

Surchargé. Retourne le dernier élément d'une séquence parallèle ou une valeur par défaut, si la séquence ne contient aucun élément.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodLastOrDefault<TSource>(Func<TSource, Boolean>)

Surchargé. Retourne le dernier élément d'une séquence parallèle qui satisfait à une condition ou une valeur par défaut, si aucun élément de ce type n'est trouvé.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodLongCount<TSource>()

Surchargé. Retourne un Int64 qui représente le nombre total d'éléments dans une séquence parallèle.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodLongCount<TSource>(Func<TSource, Boolean>)

Surchargé. Retourne un Int64 qui représente le nombre total d'éléments dans une séquence parallèle qui satisfont à une condition.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodMax<TSource>()

Surchargé. Retourne la valeur maximale dans une séquence parallèle de valeurs.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodMax<TSource>(Func<TSource, Decimal>)

Surchargé. Appelle en parallèle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur maximale.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodMax<TSource>(Func<TSource, Double>)

Surchargé. Appelle en parallèle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur maximale.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodMax<TSource>(Func<TSource, Int32>)

Surchargé. Appelle en parallèle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur maximale.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodMax<TSource>(Func<TSource, Int64>)

Surchargé. Appelle en parallèle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur maximale.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodMax<TSource>(Func<TSource, Nullable<Decimal>>)

Surchargé. Appelle en parallèle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur maximale.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodMax<TSource>(Func<TSource, Nullable<Double>>)

Surchargé. Appelle en parallèle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur maximale.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodMax<TSource>(Func<TSource, Nullable<Int32>>)

Surchargé. Appelle en parallèle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur maximale.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodMax<TSource>(Func<TSource, Nullable<Int64>>)

Surchargé. Appelle en parallèle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur maximale.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodMax<TSource>(Func<TSource, Nullable<Single>>)

Surchargé. Appelle en parallèle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur maximale.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodMax<TSource>(Func<TSource, Single>)

Surchargé. Appelle en parallèle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur maximale.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodMax<TSource, TResult>(Func<TSource, TResult>)

Surchargé. Appelle en parallèle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur maximale.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodMin<TSource>()

Surchargé. Retourne la valeur minimale dans une séquence parallèle de valeurs.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodMin<TSource>(Func<TSource, Decimal>)

Surchargé. Appelle en parallèle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur minimale.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodMin<TSource>(Func<TSource, Double>)

Surchargé. Appelle en parallèle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur minimale.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodMin<TSource>(Func<TSource, Int32>)

Surchargé. Appelle en parallèle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur minimale.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodMin<TSource>(Func<TSource, Int64>)

Surchargé. Appelle en parallèle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur minimale.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodMin<TSource>(Func<TSource, Nullable<Decimal>>)

Surchargé. Appelle en parallèle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur minimale.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodMin<TSource>(Func<TSource, Nullable<Double>>)

Surchargé. Appelle en parallèle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur minimale.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodMin<TSource>(Func<TSource, Nullable<Int32>>)

Surchargé. Appelle en parallèle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur minimale.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodMin<TSource>(Func<TSource, Nullable<Int64>>)

Surchargé. Appelle en parallèle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur minimale.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodMin<TSource>(Func<TSource, Nullable<Single>>)

Surchargé. Appelle en parallèle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur minimale.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodMin<TSource>(Func<TSource, Single>)

Surchargé. Appelle en parallèle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur minimale.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodMin<TSource, TResult>(Func<TSource, TResult>)

Surchargé. Appelle en parallèle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur minimale.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodOfType<TResult>()

Filtre les éléments d’un IEnumerable basé sur un type spécifié.(Défini par Enumerable.)

System_CAPS_pubmethodOrderBy<TSource, TKey>(Func<TSource, TKey>)

Surchargé. Trie en parallèle les éléments d'une séquence dans l'ordre croissant selon une clé.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodOrderBy<TSource, TKey>(Func<TSource, TKey>, IComparer<TKey>)

Surchargé. Trie en parallèle les éléments d'une séquence dans l'ordre croissant à l'aide d'un comparateur spécifié.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodOrderByDescending<TSource, TKey>(Func<TSource, TKey>)

Surchargé. Trie en parallèle les éléments d'une séquence dans l'ordre décroissant selon une clé.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodOrderByDescending<TSource, TKey>(Func<TSource, TKey>, IComparer<TKey>)

Surchargé. Trie les éléments d'une séquence dans l'ordre décroissant à l'aide d'un comparateur spécifié.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodReverse<TSource>()

Inverse l'ordre des éléments dans une séquence parallèle.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodSelect<TSource, TResult>(Func<TSource, TResult>)

Surchargé. Projette en parallèle chaque élément d'une séquence dans un nouveau formulaire.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodSelect<TSource, TResult>(Func<TSource, Int32, TResult>)

Surchargé. Projette en parallèle chaque élément d'une séquence dans un nouveau formulaire en incorporant l'index de l'élément.(Défini par ParallelEnumerable.)

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

Surchargé. Projette en parallèle chaque élément d’une séquence sur un IEnumerable<T> et aplatit les séquences résultantes en une seule séquence.(Défini par ParallelEnumerable.)

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

Surchargé. Projette en parallèle chaque élément d’une séquence sur un IEnumerable<T> et aplatit les séquences résultantes en une seule séquence. L'index de chaque élément source est utilisé dans le formulaire projeté de l'élément.(Défini par ParallelEnumerable.)

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

Surchargé. 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électeur de résultat sur chaque élément inclus.(Défini par Enumerable.)

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

Surchargé. 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électeur de résultat sur chaque élément inclus. L'index de chaque élément source est utilisé dans le formulaire intermédiaire projeté de l'élément.(Défini par Enumerable.)

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

Surchargé. 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électeur de résultat sur chaque élément inclus.(Défini par ParallelEnumerable.)

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

Surchargé. 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électeur de résultat sur chaque élément inclus. L'index de chaque élément source est utilisé dans le formulaire intermédiaire projeté de l'élément.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodSequenceEqual<TSource>(IEnumerable<TSource>)

Surchargé. Détermine si deux séquences sont égales en comparant les éléments à l’aide du comparateur d’égalité par défaut pour ce type.(Défini par Enumerable.)

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

Surchargé. Détermine si deux séquences sont égales en comparant leurs éléments en utilisant un IEqualityComparer<T>.(Défini par Enumerable.)

System_CAPS_pubmethodSequenceEqual<TSource>(IEnumerable<TSource>)

Obsolète. Surchargé. Cette surcharge SequenceEqual ne doit jamais être appelée. Cette méthode est marquée comme obsolète et lève toujours une exception NotSupportedException lorsqu’elle est appelée.(Défini par ParallelEnumerable.)

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

Obsolète. Surchargé. Cette surcharge SequenceEqual ne doit jamais être appelée. Cette méthode est marquée comme obsolète et lève toujours une exception NotSupportedException lorsqu’elle est appelée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodSequenceEqual<TSource>(ParallelQuery<TSource>)

Surchargé. Détermine si deux séquences parallèles sont égales par une comparaison des types d'élément réalisée à l'aide du comparateur d'égalité par défaut.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodSequenceEqual<TSource>(ParallelQuery<TSource>, IEqualityComparer<TSource>)

Surchargé. Détermine si deux séquences parallèles sont égales par une comparaison des élément réalisée à l'aide d'un IEqualityComparer{T} spécifié.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodSingle<TSource>()

Surchargé. Retourne l'élément unique d'une séquence parallèle ou lève une exception, si cette séquence ne contient pas exactement un élément.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodSingle<TSource>(Func<TSource, Boolean>)

Surchargé. Retourne le seul élément d'une séquence parallèle qui satisfait à une condition spécifiée ou lève une exception, si cette séquence contient plusieurs éléments de ce type.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodSingleOrDefault<TSource>()

Surchargé. Retourne l'élément unique d'une séquence parallèle ou une valeur par défaut, si la séquence est vide. Cette méthode lève une exception si cette séquence contient plusieurs éléments.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodSingleOrDefault<TSource>(Func<TSource, Boolean>)

Surchargé. Retourne l'élément unique d'une séquence parallèle qui satisfait à une condition spécifiée ou une valeur par défaut, si cette séquence ne contient aucun élément de ce type. Cette méthode lève une exception si cette séquence contient plusieurs éléments qui satisfont à cette condition.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodSkip<TSource>(Int32)

Ignore un nombre spécifié d'éléments dans une séquence parallèle, puis retourne les éléments restants.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodSkipWhile<TSource>(Func<TSource, Boolean>)

Surchargé. Ignore des éléments dans une séquence parallèle tant que la condition spécifiée a la valeur True, puis retourne les éléments restants.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodSkipWhile<TSource>(Func<TSource, Int32, Boolean>)

Surchargé. Ignore des éléments dans une séquence parallèle tant que la condition spécifiée a la valeur True, puis retourne les éléments restants. L’index de l’élément est utilisé dans la logique de la fonction de prédicat.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodSum<TSource>(Func<TSource, Decimal>)

Surchargé. Calcule en parallèle la somme de la séquence de valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodSum<TSource>(Func<TSource, Double>)

Surchargé. Calcule en parallèle la somme de la séquence de valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodSum<TSource>(Func<TSource, Int32>)

Surchargé. Calcule en parallèle la somme de la séquence de valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodSum<TSource>(Func<TSource, Int64>)

Surchargé. Calcule en parallèle la somme de la séquence de valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodSum<TSource>(Func<TSource, Nullable<Decimal>>)

Surchargé. Calcule en parallèle la somme de la séquence de valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodSum<TSource>(Func<TSource, Nullable<Double>>)

Surchargé. Calcule en parallèle la somme de la séquence de valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodSum<TSource>(Func<TSource, Nullable<Int32>>)

Surchargé. Calcule en parallèle la somme de la séquence de valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodSum<TSource>(Func<TSource, Nullable<Int64>>)

Surchargé. Calcule en parallèle la somme de la séquence de valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodSum<TSource>(Func<TSource, Nullable<Single>>)

Surchargé. Calcule en parallèle la somme de la séquence de valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodSum<TSource>(Func<TSource, Single>)

Surchargé. Calcule en parallèle la somme de la séquence de valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodTake<TSource>(Int32)

Retourne un nombre spécifié d'éléments contigus à partir du début d'une séquence parallèle.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodTakeWhile<TSource>(Func<TSource, Boolean>)

Surchargé. Retourne des éléments d'une séquence parallèle tant que la condition spécifiée a la valeur True.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodTakeWhile<TSource>(Func<TSource, Int32, Boolean>)

Surchargé. Retourne des éléments d'une séquence parallèle tant que la condition spécifiée a la valeur True. L'index de l'élément est utilisé dans la logique de la fonction de prédicat.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodThenBy<TSource, TKey>(Func<TSource, TKey>)

Surchargé. Réalise en parallèle un classement des éléments d'une séquence dans l'ordre croissant selon une clé.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodThenBy<TSource, TKey>(Func<TSource, TKey>, IComparer<TKey>)

Surchargé. Réalise en parallèle un classement des éléments d'une séquence dans l'ordre croissant à l'aide d'un comparateur spécifié.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodThenByDescending<TSource, TKey>(Func<TSource, TKey>)

Surchargé. Réalise en parallèle un classement des éléments d'une séquence dans l'ordre décroissant selon une clé.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodThenByDescending<TSource, TKey>(Func<TSource, TKey>, IComparer<TKey>)

Surchargé. Réalise en parallèle un classement des éléments d'une séquence dans l'ordre décroissant à l'aide d'un comparateur spécifié.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodToArray<TSource>()

Crée un tableau d’un ParallelQuery<TSource>.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodToDictionary<TSource, TKey>(Func<TSource, TKey>)

Surchargé. Crée un Dictionary<TKey, TValue> d’un ParallelQuery<TSource> selon une fonction de sélection de clé spécifiée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodToDictionary<TSource, TKey>(Func<TSource, TKey>, IEqualityComparer<TKey>)

Surchargé. Crée un Dictionary<TKey, TValue> d’un ParallelQuery<TSource> selon un comparateur de fonction et la clé de sélection de clé spécifiée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodToDictionary<TSource, TKey, TElement>(Func<TSource, TKey>, Func<TSource, TElement>)

Surchargé. Crée un Dictionary<TKey, TValue> d’un ParallelQuery<TSource> en fonction de sélection de clé spécifiée et les fonctions de sélecteur d’élément.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodToDictionary<TSource, TKey, TElement>(Func<TSource, TKey>, Func<TSource, TElement>, IEqualityComparer<TKey>)

Surchargé. Crée un Dictionary<TKey, TValue> d’un ParallelQuery<TSource> selon une fonction de sélection de clé spécifiée, un comparateur et une fonction de sélection d’élément.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodToList<TSource>()

Crée un List<T> d’un ParallelQuery<TSource>.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodToLookup<TSource, TKey>(Func<TSource, TKey>)

Surchargé. Crée un ILookup<TKey, TElement> d’un ParallelQuery<TSource> selon une fonction de sélection de clé spécifiée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodToLookup<TSource, TKey>(Func<TSource, TKey>, IEqualityComparer<TKey>)

Surchargé. Crée un ILookup<TKey, TElement> d’un ParallelQuery<TSource> selon un comparateur de fonction et la clé de sélection de clé spécifiée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodToLookup<TSource, TKey, TElement>(Func<TSource, TKey>, Func<TSource, TElement>)

Surchargé. Crée un ILookup<TKey, TElement> d’un ParallelQuery<TSource> en fonction de sélection de clé spécifiée et les fonctions de sélecteur d’élément.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodToLookup<TSource, TKey, TElement>(Func<TSource, TKey>, Func<TSource, TElement>, IEqualityComparer<TKey>)

Surchargé. Crée un ILookup<TKey, TElement> d’un ParallelQuery<TSource> selon une fonction de sélection de clé spécifiée, un comparateur et une fonction de sélection d’élément.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodUnion<TSource>(IEnumerable<TSource>)

Surchargé. Produit l’union définie de deux séquences à l’aide du comparateur d’égalité par défaut.(Défini par Enumerable.)

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

Surchargé. Produit l’union définie de deux séquences en utilisant un IEqualityComparer<T>.(Défini par Enumerable.)

System_CAPS_pubmethodUnion<TSource>(IEnumerable<TSource>)

Obsolète. Surchargé. Cette surcharge Union ne doit jamais être appelée. Cette méthode est marquée comme obsolète et lève toujours une exception NotSupportedException lorsqu’elle est appelée.(Défini par ParallelEnumerable.)

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

Obsolète. Surchargé. Cette surcharge Union ne doit jamais être appelée. Cette méthode est marquée comme obsolète et lève toujours une exception NotSupportedException lorsqu’elle est appelée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodUnion<TSource>(ParallelQuery<TSource>)

Surchargé. Produit l'union définie de deux séquences parallèles à l'aide du comparateur d'égalité par défaut.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodUnion<TSource>(ParallelQuery<TSource>, IEqualityComparer<TSource>)

Surchargé. Produit l'union définie de deux séquences parallèles à l'aide d'un IEqualityComparer{T} spécifié.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodWhere<TSource>(Func<TSource, Boolean>)

Surchargé. Filtre en parallèle une séquence de valeurs selon un prédicat.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodWhere<TSource>(Func<TSource, Int32, Boolean>)

Surchargé. Filtre en parallèle une séquence de valeurs selon un prédicat. L’index de chaque élément est utilisé dans la logique de la fonction de prédicat.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodWithCancellation<TSource>(CancellationToken)

Définit le CancellationToken à associer à la requête.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodWithDegreeOfParallelism<TSource>(Int32)

Définit le degré de parallélisme à utiliser dans une requête. Le degré de parallélisme est le nombre maximal de tâches simultanément exécutées qui seront utilisées pour traiter la requête.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodWithExecutionMode<TSource>(ParallelExecutionMode)

Définit le mode d'exécution de la requête.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodWithMergeOptions<TSource>(ParallelMergeOptions)

Définit les options de fusion pour cette requête, qui spécifient comment la requête mettra la sortie en mémoire tampon.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodZip<TSource, TSecond, TResult>(IEnumerable<TSecond>, Func<TSource, TSecond, TResult>)

Applique une fonction spécifiée pour les éléments de deux séquences, produire une séquence de résultats correspondants.(Défini par Enumerable.)

System_CAPS_pubmethodZip<TSource, TSecond, TResult>(IEnumerable<TSecond>, Func<TSource, TSecond, TResult>)

Obsolète. Surchargé. Cette surcharge Zip ne doit jamais être appelée. Cette méthode est marquée comme obsolète et lève toujours une exception NotSupportedException lorsqu’elle est appelée.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodZip<TSource, TSecond, TResult>(ParallelQuery<TSecond>, Func<TSource, TSecond, TResult>)

Surchargé. Fusionne en parallèle deux séquences à l’aide de la fonction de prédicat spécifiée.(Défini par ParallelEnumerable.)

NomDescription
System_CAPS_pubinterfaceSystem_CAPS_privmethodIEnumerable.GetEnumerator()

Retourne un énumérateur qui itère dans la séquence.(Hérité de ParallelQuery.)

Retour au début
Afficher: