Exporter (0) Imprimer
Développer tout
Cet article a fait l'objet d'une traduction automatique. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte. Informations supplémentaires.
Traduction
Source

List<T>, classe

Représente une liste fortement typée d'objets accessibles par index. Fournit des méthodes de recherche, de tri et de manipulation de listes.

System.Object
  System.Collections.Generic.List<T>
    En savoir plus...

Espace de noms :  System.Collections.Generic
Assembly :  mscorlib (dans mscorlib.dll)

[SerializableAttribute]
public class List<T> : IList<T>, ICollection<T>, 
	IList, ICollection, IReadOnlyList<T>, IReadOnlyCollection<T>, IEnumerable<T>, 
	IEnumerable

Paramètres de type

T

Type d'éléments de la liste.

Le type List<T> expose les membres suivants.

  NomDescription
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreList<T>()Initialise une nouvelle instance de la classe List<T> qui est vide et possède la capacité initiale par défaut.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreList<T>(IEnumerable<T>)Initialise une nouvelle instance de la classe List<T> qui contient des éléments copiés à partir de la collection spécifiée et qui possède une capacité suffisante pour accepter le nombre d'éléments copiés.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreList<T>(Int32)Initialise une nouvelle instance de la classe List<T> qui est vide et a la capacité initiale spécifiée.
Début

  NomDescription
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCapacityObtient ou définit le nombre total des éléments que la structure de données interne peut contenir sans redimensionnement.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCountObtient le nombre d'éléments contenus dans le List<T>.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreItemObtient ou définit l'élément situé à l'index spécifié.
Début

  NomDescription
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreAddAjoute un objet à la fin de List<T>.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreAddRangeAjoute les éléments de la collection spécifiée à la fin du List<T>.
Méthode publiquePris en charge par XNA FrameworkAsReadOnlyRetourne un wrapper IList<T> en lecture seule pour la collection actuelle.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreBinarySearch(T)Recherche un élément utilisant le comparateur par défaut dans le List<T> entièrement trié et retourne l'index de base zéro de l'élément.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreBinarySearch(T, IComparer<T>)Recherche un élément utilisant le comparateur spécifié dans le List<T> entièrement trié et retourne l'index de base zéro de l'élément.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreBinarySearch(Int32, Int32, T, IComparer<T>)Recherche un élément utilisant le comparateur spécifié dans une plage d'éléments du List<T> trié et retourne l'index de base zéro de l'élément.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreClearSupprime tous les éléments de List<T>.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreContainsDétermine si un élément est dans List<T>.
Méthode publiquePris en charge par XNA FrameworkConvertAll<TOutput>Convertit les éléments du List<T> actuel en un autre type et retourne une liste qui contient les éléments convertis.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCopyTo(T[])Copie l'ensemble du List<T> dans un tableau compatible unidimensionnel en commençant au début du tableau cible.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCopyTo(T[], Int32)Copie l'ensemble du List<T> vers un tableau compatible unidimensionnel, en commençant à l'index spécifié du tableau cible.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCopyTo(Int32, T[], Int32, Int32)Copie la plage d'éléments de List<T> dans un tableau compatible unidimensionnel en commençant à l'index spécifié du tableau cible.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreEquals(Object)Détermine si l'objet spécifié est identique à l'objet actuel. (Hérité de Object.)
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreExistsDétermine si le List<T> contient des éléments qui correspondent aux conditions définies par le prédicat spécifié.
Méthode protégéePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreFinalize 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.)
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreFindRecherche un élément qui correspond aux conditions définies par le prédicat spécifié et retourne la première occurrence dans le List<T> entier.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreFindAllRécupère tous les éléments qui correspondent aux conditions définies par le prédicat spécifié.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreFindIndex(Predicate<T>)Recherche un élément qui correspond aux conditions définies par le prédicat spécifié, et retourne l'index de base zéro de la première occurrence dans le List<T> entier.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreFindIndex(Int32, Predicate<T>)Recherche un élément qui correspond aux conditions définies par le prédicat spécifié et retourne l'index de base zéro de la première occurrence dans la plage d'éléments du List<T> qui s'étend de l'index spécifié au dernier élément.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreFindIndex(Int32, Int32, Predicate<T>)Recherche un élément qui correspond aux conditions définies par le prédicat spécifié et retourne l'index de base zéro de la première occurrence dans la plage d'éléments du List<T> qui commence à l'index spécifié et contient le nombre d'éléments spécifié.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreFindLastRecherche un élément qui correspond aux conditions définies par le prédicat spécifié et retourne la dernière occurrence dans le List<T> entier.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreFindLastIndex(Predicate<T>)Recherche un élément qui correspond aux conditions définies par le prédicat spécifié, et retourne l'index de base zéro de la dernière occurrence dans le List<T> entier.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreFindLastIndex(Int32, Predicate<T>)Recherche un élément qui correspond aux conditions définies par le prédicat spécifié et retourne l'index de base zéro de la dernière occurrence dans la plage d'éléments du List<T> qui s'étend du premier élément à l'index spécifié.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreFindLastIndex(Int32, Int32, Predicate<T>)Recherche un élément qui correspond aux conditions définies par le prédicat spécifié et retourne l'index de base zéro de la dernière occurrence dans la plage d'éléments du List<T> qui contient le nombre d'éléments spécifié et se termine à l'index spécifié.
Méthode publiquePris en charge par XNA FrameworkForEachExécute l'action spécifiée sur chaque élément du List<T>.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetEnumeratorRetourne un énumérateur qui itère au sein de List<T>.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetHashCodeSert de fonction de hachage par défaut. (Hérité de Object.)
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetRangeCrée une copie superficielle d'une plage d'éléments dans la source List<T>.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetTypeObtient le Type de l'instance actuelle. (Hérité de Object.)
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIndexOf(T)Recherche l'objet spécifié et retourne l'index de base zéro de la première occurrence dans l'ensemble du List<T>.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIndexOf(T, Int32)Recherche l'objet spécifié et retourne l'index de base zéro de la première occurrence dans la plage d'éléments du List<T> qui s'étend de l'index spécifié au dernier élément.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIndexOf(T, Int32, Int32)Recherche l'objet spécifié et retourne l'index de base zéro de la première occurrence dans la plage d'éléments du List<T> qui commence à l'index spécifié et qui contient le nombre d'éléments spécifié.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreInsertInsère un élément dans List<T> à l'index spécifié.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreInsertRangeInsère les éléments d'une collection List<T> à l'index spécifié.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreLastIndexOf(T)Recherche l'objet spécifié et retourne l'index de base zéro de la dernière occurrence dans l'ensemble du List<T>.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreLastIndexOf(T, Int32)Recherche l'objet spécifié et retourne l'index de base zéro de la dernière occurrence dans la plage d'éléments du List<T> qui s'étend du premier élément à l'index spécifié.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreLastIndexOf(T, Int32, Int32)Recherche l'objet spécifié et retourne l'index de base zéro de la dernière occurrence dans la plage d'éléments du List<T> qui contient le nombre spécifié d'éléments et se termine à l'index spécifié.
Méthode protégéePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMemberwiseCloneCrée une copie superficielle de l'objet Object actuel. (Hérité de Object.)
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreRemoveSupprime la première occurrence d'un objet spécifique de List<T>.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreRemoveAllSupprime tous les éléments qui correspondent aux conditions définies par le prédicat spécifié.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreRemoveAtSupprime l'élément au niveau de l'index spécifié de List<T>.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreRemoveRangeSupprime une plage d'éléments de List<T>.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreReverse()Inverse l'ordre des éléments dans l'intégralité de List<T>.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreReverse(Int32, Int32)Inverse l'ordre des éléments dans la plage spécifiée.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSort()Trie les éléments dans l'intégralité de List<T> à l'aide du comparateur par défaut.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSort(Comparison<T>)Trie les éléments dans l'intégralité de List<T> à l'aide du System.Comparison<T> spécifié.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSort(IComparer<T>)Trie les éléments dans l'intégralité de List<T> à l'aide du comparateur spécifié.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSort(Int32, Int32, IComparer<T>)Trie les éléments dans une plage d'éléments de List<T> à l'aide du comparateur spécifié.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToArrayCopie les éléments de List<T> vers un nouveau tableau.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToStringRetourne une chaîne qui représente l'objet actif. (Hérité de Object.)
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreTrimExcessAffecte à la capacité le nombre réel d'éléments dans List<T>, si ce nombre est inférieur à une valeur de seuil.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreTrueForAllDétermine si chaque élément de List<T> correspond aux conditions définies par le prédicat spécifié.
Début

  NomDescription
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreAggregate<T>(Func<T, T, T>)Surchargé. Applique une fonction d'accumulation sur une séquence. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreAggregate<T, TAccumulate>(TAccumulate, Func<TAccumulate, T, TAccumulate>)Surchargé. Applique 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 Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreAggregate<T, TAccumulate, TResult>(TAccumulate, Func<TAccumulate, T, TAccumulate>, Func<TAccumulate, TResult>)Surchargé. Applique 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 Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreAll<T>Détermine si tous les éléments d'une séquence satisfont à une condition. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreAny<T>()Surchargé. Détermine si une séquence contient des éléments. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreAny<T>(Func<T, Boolean>)Surchargé. Détermine si des éléments d'une séquence satisfont à une condition. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreAsEnumerable<T>Retourne l'entrée typée comme IEnumerable<T>. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreAsParallel()Surchargé. Active la parallélisation d'une requête. (Défini par ParallelEnumerable.)
Méthode d'extension publiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreAsParallel<T>()Surchargé. Active la parallélisation d'une requête. (Défini par ParallelEnumerable.)
Méthode d'extension publiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreAsQueryable()Surchargé. Convertit un IEnumerable en IQueryable. (Défini par Queryable.)
Méthode d'extension publiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreAsQueryable<T>()Surchargé. Convertit un IEnumerable<T> générique en IQueryable<T> générique. (Défini par Queryable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreAverage<T>(Func<T, Decimal>)Surchargé. 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. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreAverage<T>(Func<T, Nullable<Decimal>>)Surchargé. 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. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreAverage<T>(Func<T, Double>)Surchargé. 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. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreAverage<T>(Func<T, Nullable<Double>>)Surchargé. 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. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreAverage<T>(Func<T, Int32>)Surchargé. 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. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreAverage<T>(Func<T, Nullable<Int32>>)Surchargé. 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. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreAverage<T>(Func<T, Int64>)Surchargé. 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. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreAverage<T>(Func<T, Nullable<Int64>>)Surchargé. 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. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreAverage<T>(Func<T, Single>)Surchargé. 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. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreAverage<T>(Func<T, Nullable<Single>>)Surchargé. 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. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCast<TResult>Effectue un cast des éléments d'un IEnumerable vers le type spécifié. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreConcat<T>Concatène deux séquences. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreContains<T>(T)Surchargé. Détermine si une séquence contient un élément spécifié à l'aide du comparateur d'égalité par défaut. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreContains<T>(T, IEqualityComparer<T>)Surchargé. Détermine si une séquence contient un élément spécifié à l'aide du IEqualityComparer<T> indiqué. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCount<T>()Surchargé. Retourne le nombre total d'éléments dans une séquence. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCount<T>(Func<T, Boolean>)Surchargé. Retourne un nombre qui représente les éléments de la séquence spécifiée qui satisfont à une condition. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreDefaultIfEmpty<T>()Surchargé. 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. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreDefaultIfEmpty<T>(T)Surchargé. 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. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreDistinct<T>()Surchargé. Retourne des éléments distincts d'une séquence et utilise le comparateur d'égalité par défaut pour comparer les valeurs. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreDistinct<T>(IEqualityComparer<T>)Surchargé. Retourne des éléments distincts d'une séquence et utilise le IEqualityComparer<T> spécifié pour comparer les valeurs. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreElementAt<T>Retourne l'élément à une position d'index spécifiée dans une séquence. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreElementAtOrDefault<T>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. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreExcept<T>(IEnumerable<T>)Surchargé. Produit la différence entre deux séquences à l'aide du comparateur d'égalité par défaut pour comparer les valeurs. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreExcept<T>(IEnumerable<T>, IEqualityComparer<T>)Surchargé. Produit la différence entre deux séquences à l'aide du IEqualityComparer<T> spécifié pour comparer les valeurs. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreFirst<T>()Surchargé. Retourne le premier élément d'une séquence. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreFirst<T>(Func<T, Boolean>)Surchargé. Retourne le premier élément d'une séquence à satisfaire à la condition spécifiée. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreFirstOrDefault<T>()Surchargé. Retourne le premier élément d'une séquence ou une valeur par défaut si la séquence ne contient aucun élément. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreFirstOrDefault<T>(Func<T, Boolean>)Surchargé. 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é. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGroupBy<T, TKey>(Func<T, TKey>)Surchargé. Regroupe les éléments d'une séquence selon la fonction de sélection de clé spécifiée. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGroupBy<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>)Surchargé. 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é. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGroupBy<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>)Surchargé. 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. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGroupBy<T, TKey, TResult>(Func<T, TKey>, Func<TKey, IEnumerable<T>, 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. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGroupBy<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>, IEqualityComparer<TKey>)Surchargé. Regroupe 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 Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGroupBy<T, TKey, TResult>(Func<T, TKey>, Func<TKey, IEnumerable<T>, 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.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGroupBy<T, TKey, TElement, TResult>(Func<T, TKey>, Func<T, 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.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGroupBy<T, TKey, TElement, TResult>(Func<T, TKey>, Func<T, 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 Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGroupJoin<T, TInner, TKey, TResult>(IEnumerable<TInner>, Func<T, TKey>, Func<TInner, TKey>, Func<T, 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.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGroupJoin<T, TInner, TKey, TResult>(IEnumerable<TInner>, Func<T, TKey>, Func<TInner, TKey>, Func<T, 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> spécifié est utilisé pour comparer les clés. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIntersect<T>(IEnumerable<T>)Surchargé. Produit l'intersection de deux séquences à l'aide du comparateur d'égalité par défaut pour comparer les valeurs. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIntersect<T>(IEnumerable<T>, IEqualityComparer<T>)Surchargé. Produit l'intersection entre deux séquences à l'aide du IEqualityComparer<T> spécifié pour comparer les valeurs. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreJoin<T, TInner, TKey, TResult>(IEnumerable<TInner>, Func<T, TKey>, Func<TInner, TKey>, Func<T, TInner, TResult>)Surchargé. Met en corrélation les éléments de deux séquences en fonction des clés qui correspondent. Le comparateur d'égalité par défaut est utilisé pour comparer les clés. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreJoin<T, TInner, TKey, TResult>(IEnumerable<TInner>, Func<T, TKey>, Func<TInner, TKey>, Func<T, TInner, TResult>, IEqualityComparer<TKey>)Surchargé. Met en corrélation les éléments de deux séquences en fonction des clés qui correspondent. Un IEqualityComparer<T> spécifié est utilisé pour comparer les clés. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreLast<T>()Surchargé. Retourne le dernier élément d'une séquence. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreLast<T>(Func<T, Boolean>)Surchargé. Retourne le dernier élément d'une séquence à satisfaire à la condition spécifiée. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreLastOrDefault<T>()Surchargé. Retourne le dernier élément d'une séquence ou une valeur par défaut si la séquence ne contient aucun élément. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreLastOrDefault<T>(Func<T, Boolean>)Surchargé. 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é. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreLongCount<T>()Surchargé. Retourne un Int64 qui représente le nombre total d'éléments dans une séquence. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreLongCount<T>(Func<T, Boolean>)Surchargé. Retourne un Int64 qui représente le nombre total d'éléments dans une séquence à satisfaire à une condition. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMax<T>()Surchargé. Retourne la valeur maximale dans une séquence générique. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMax<T>(Func<T, Decimal>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Decimal maximale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMax<T>(Func<T, Nullable<Decimal>>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Decimal nullable maximale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMax<T>(Func<T, Double>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Double maximale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMax<T>(Func<T, Nullable<Double>>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Double nullable maximale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMax<T>(Func<T, Int32>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Int32 maximale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMax<T>(Func<T, Nullable<Int32>>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Int32 nullable maximale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMax<T>(Func<T, Int64>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Int64 maximale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMax<T>(Func<T, Nullable<Int64>>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Int64 nullable maximale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMax<T>(Func<T, Single>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Single maximale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMax<T>(Func<T, Nullable<Single>>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Single nullable maximale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMax<T, TResult>(Func<T, TResult>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence générique et retourne la valeur résultante maximale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMin<T>()Surchargé. Retourne la valeur minimale dans une séquence générique. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMin<T>(Func<T, Decimal>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Decimal minimale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMin<T>(Func<T, Nullable<Decimal>>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Decimal nullable minimale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMin<T>(Func<T, Double>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Double minimale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMin<T>(Func<T, Nullable<Double>>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Double nullable minimale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMin<T>(Func<T, Int32>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Int32 minimale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMin<T>(Func<T, Nullable<Int32>>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Int32 nullable minimale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMin<T>(Func<T, Int64>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Int64 minimale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMin<T>(Func<T, Nullable<Int64>>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Int64 nullable minimale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMin<T>(Func<T, Single>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Single minimale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMin<T>(Func<T, Nullable<Single>>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Single nullable minimale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMin<T, TResult>(Func<T, TResult>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence générique et retourne la valeur résultante minimale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreOfType<TResult>Filtre les éléments d'un IEnumerable en fonction du type spécifié. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreOrderBy<T, TKey>(Func<T, TKey>)Surchargé. Trie les éléments d'une séquence dans l'ordre croissant selon une clé. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreOrderBy<T, TKey>(Func<T, TKey>, IComparer<TKey>)Surchargé. Trie les éléments d'une séquence dans l'ordre croissant à l'aide d'un comparateur spécifié. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreOrderByDescending<T, TKey>(Func<T, TKey>)Surchargé. Trie les éléments d'une séquence dans l'ordre décroissant selon une clé. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreOrderByDescending<T, TKey>(Func<T, 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 Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreReverse<T>Inverse l'ordre des éléments dans une séquence. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSelect<T, TResult>(Func<T, TResult>)Surchargé. Projette chaque élément d'une séquence dans un nouveau formulaire. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSelect<T, TResult>(Func<T, Int32, TResult>)Surchargé. Projette chaque élément d'une séquence dans un nouveau formulaire en incorporant l'index de l'élément. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSelectMany<T, TResult>(Func<T, IEnumerable<TResult>>)Surchargé. Projette 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 Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSelectMany<T, TResult>(Func<T, Int32, IEnumerable<TResult>>)Surchargé. Projette 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 Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSelectMany<T, TCollection, TResult>(Func<T, Int32, IEnumerable<TCollection>>, Func<T, 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élection 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.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSelectMany<T, TCollection, TResult>(Func<T, IEnumerable<TCollection>>, Func<T, 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élection de résultat sur chaque élément inclus. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSequenceEqual<T>(IEnumerable<T>)Surchargé. 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. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSequenceEqual<T>(IEnumerable<T>, IEqualityComparer<T>)Surchargé. Détermine si deux séquences sont égales en comparant leurs éléments à l'aide d'un IEqualityComparer<T> spécifié. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSingle<T>()Surchargé. Retourne l'élément unique d'une séquence ou lève une exception si cette séquence ne contient pas un seul et unique élément. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSingle<T>(Func<T, Boolean>)Surchargé. 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. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSingleOrDefault<T>()Surchargé. 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. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSingleOrDefault<T>(Func<T, Boolean>)Surchargé. 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. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSkip<T>Ignore un nombre spécifié d'éléments dans une séquence puis retourne les éléments restants. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSkipWhile<T>(Func<T, Boolean>)Surchargé. 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. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSkipWhile<T>(Func<T, Int32, Boolean>)Surchargé. 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. L'index de l'élément est utilisé dans la logique de la fonction de prédicat. (Défini par Enumerable.)
Méthode d'extension publiqueSubscribe<T>(IObserver<T>)Surchargé. (Défini par Observable.)
Méthode d'extension publiqueSubscribe<T>(IObserver<T>, IScheduler)Surchargé. (Défini par Observable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSum<T>(Func<T, Decimal>)Surchargé. 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. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSum<T>(Func<T, Nullable<Decimal>>)Surchargé. 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. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSum<T>(Func<T, Double>)Surchargé. 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. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSum<T>(Func<T, Nullable<Double>>)Surchargé. 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. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSum<T>(Func<T, Int32>)Surchargé. 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. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSum<T>(Func<T, Nullable<Int32>>)Surchargé. 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. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSum<T>(Func<T, Int64>)Surchargé. 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. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSum<T>(Func<T, Nullable<Int64>>)Surchargé. 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. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSum<T>(Func<T, Single>)Surchargé. 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. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSum<T>(Func<T, Nullable<Single>>)Surchargé. 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. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreTake<T>Retourne un nombre spécifié d'éléments contigus à partir du début d'une séquence. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreTakeWhile<T>(Func<T, Boolean>)Surchargé. Retourne des éléments d'une séquence tant que la condition spécifiée a la valeur true. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreTakeWhile<T>(Func<T, Int32, Boolean>)Surchargé. Retourne des éléments d'une séquence 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 Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToArray<T>Crée un tableau à partir de IEnumerable<T>. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToDictionary<T, TKey>(Func<T, TKey>)Surchargé. Crée un Dictionary<TKey, TValue> à partir d'un IEnumerable<T> selon une fonction de sélection de clé spécifiée. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToDictionary<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>)Surchargé. 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é. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToDictionary<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>)Surchargé. 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. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToDictionary<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>, IEqualityComparer<TKey>)Surchargé. 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. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToList<T>Crée un List<T> à partir de IEnumerable<T>. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToLookup<T, TKey>(Func<T, TKey>)Surchargé. Crée une Lookup<TKey, TElement> à partir de IEnumerable<T> selon une fonction de sélection de clé spécifiée. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToLookup<T, TKey>(Func<T, TKey>, IEqualityComparer<TKey>)Surchargé. 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é. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToLookup<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>)Surchargé. 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. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToLookup<T, TKey, TElement>(Func<T, TKey>, Func<T, TElement>, IEqualityComparer<TKey>)Surchargé. 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. (Défini par Enumerable.)
Méthode d'extension publiqueToObservable<T>()Surchargé. (Défini par Observable.)
Méthode d'extension publiqueToObservable<T>(IScheduler)Surchargé. (Défini par Observable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreUnion<T>(IEnumerable<T>)Surchargé. Produit l'union de deux séquences à l'aide du comparateur d'égalité par défaut. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreUnion<T>(IEnumerable<T>, IEqualityComparer<T>)Surchargé. Produit l'union de deux séquences à l'aide d'un IEqualityComparer<T> spécifié. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreWhere<T>(Func<T, Boolean>)Surchargé. Filtre une séquence de valeurs selon un prédicat. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreWhere<T>(Func<T, Int32, Boolean>)Surchargé. Filtre 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 Enumerable.)
Méthode d'extension publiquePris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreZip<T, TSecond, TResult>Applique une fonction spécifiée aux éléments correspondants de deux séquences pour produire une séquence des résultats. (Défini par Enumerable.)
Début

  NomDescription
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreICollection.CopyToCopie les éléments de ICollection dans Array, en commençant à un index particulier de Array.
Implémentation d'interface explicitePropriété privéePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreICollection<T>.IsReadOnlyObtient une valeur indiquant si ICollection<T> est en lecture seule.
Implémentation d'interface explicitePropriété privéePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreICollection.IsSynchronizedObtient une valeur indiquant si l'accès à ICollection est synchronisé (thread-safe).
Implémentation d'interface explicitePropriété privéePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreICollection.SyncRootObtient un objet qui peut être utilisé pour synchroniser l'accès à ICollection.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIEnumerable<T>.GetEnumeratorRetourne un énumérateur qui itère au sein d'une collection.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIEnumerable.GetEnumeratorRetourne un énumérateur qui itère au sein d'une collection.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIList.AddAjoute un élément à IList.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIList.ContainsDétermine si la IList contient une valeur spécifique.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIList.IndexOfDétermine l'index d'un élément spécifique de IList.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIList.InsertInsère un élément dans la IList au niveau de l'index spécifié.
Implémentation d'interface explicitePropriété privéePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIList.IsFixedSizeObtient une valeur indiquant si IList est de taille fixe.
Implémentation d'interface explicitePropriété privéePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIList.IsReadOnlyObtient une valeur indiquant si IList est en lecture seule.
Implémentation d'interface explicitePropriété privéePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIList.ItemObtient ou définit l'élément situé à l'index spécifié.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIList.RemoveSupprime la première occurrence d'un objet spécifique de IList.
Début

La classe List<T> est l'équivalent générique de la classe ArrayList. Elle implémente l'interface générique IList<T> à l'aide d'un tableau dont la taille augmente dynamiquement selon les besoins.

Ajoutez des éléments à un List<T> en utilisant les méthodes Add ou AddRange .

La classe List<T> utilise à la fois un comparateur d'égalité et un comparateur de classement.

  • Les méthodes telles que Contains, IndexOf, LastIndexOf et Remove utilisent un comparateur d'égalité pour les éléments de liste. Le comparateur d'égalité par défaut pour le type T est déterminé comme suit. Si le type T implémente l'interface générique IEquatable<T>, le comparateur d'égalité est la méthode Equals(T) de cette interface ; sinon, le comparateur d'égalité par défaut est Object.Equals(Object).

  • Les méthodes telles que BinarySearch et Sort utilisent un comparateur de classement pour les éléments de liste. Le comparateur par défaut pour le type T est déterminé comme suit. Si le type T implémente l'interface générique IComparable<T>, le comparateur par défaut est la méthode CompareTo(T) de cette interface ; sinon, si le type T implémente l'interface IComparable non générique, le comparateur par défaut est la méthode CompareTo(Object) de cette interface. Si le type T n'implémente aucune interface, il n'y a aucun comparateur par défaut et un délégué de comparateur de comparaison doit être fourni explicitement.

Le tri du List<T> n'est pas garanti. Vous devez trier le List<T> avant d'exécuter des opérations (telles que BinarySearch) qui exigent le tri du List<T>.

Il est possible d'accéder aux éléments de cette collection en utilisant un index d'entiers. Les index de cette collection sont des index de base zéro.

Pour les objets List<T> très grands, vous pouvez augmenter la capacité maximale à 2 milliards d'éléments sur un système 64 bits en définissant l'attribut enabled de l'élément de configuration gcAllowVeryLargeObjects à true dans l'environnement d'exécution.

List<T> accepte null comme valeur valide pour les types référence et autorise les éléments en double.

Pour une version immuable de la classe List<T>, consultez ImmutableList.

Considérations sur les performances

Lorsque vous décidez s'il faut utiliser la classe List<T> ou ArrayList, les deux ayant des fonctionnalités similaires, n'oubliez pas que la classe List<T> s'exécute mieux dans la plupart des cas et est de type sécurisé. Si un type référence est utilisé pour le type T de la classe List<T>, le comportement des deux classes est identique. Toutefois, si un type valeur est utilisé pour le type T, vous devez prendre en compte les problèmes d'implémentation et de boxing.

Si un type valeur est utilisé pour le type T, le compilateur génère spécifiquement une implémentation de la classe List<T> pour ce type valeur. Cela signifie qu'un élément de liste d'un objet List<T> ne doit pas faire l'objet d'un boxing avant que l'élément ne puisse être utilisé, et après la création d'environ 500 éléments de liste, la mémoire économisée sans boxing des éléments de liste est supérieure à celle qui est utilisée pour générer l'implémentation de la classe.

Vérifiez que le type valeur utilisé pour le type T implémente l'interface générique IEquatable<T>. Sinon, les méthodes telles que Contains doivent appeler la méthode Object.Equals(Object) qui procède à un boxing de l'élément de liste affecté. Si le type valeur implémente l'interface IComparable et que vous êtes le propriétaire du code source, implémentez également l'interface générique IComparable<T> pour empêcher que les méthodes BinarySearch et Sort ne procèdent à un boxing des éléments de liste. Si vous n'êtes pas le propriétaire du code source, passez un objet IComparer<T> aux méthodes BinarySearch et Sort

Il vaut mieux utiliser l'implémentation spécifique au type de la classe List<T> plutôt que d'utiliser la classe ArrayList ou d'écrire vous-même une collection de wrappers fortement typés. La raison est que votre implémentation doit faire ce que le .NET Framework fait déjà pour vous, et le Common Language Runtime peut partager le code de langue et les métadonnées intermédiaires de Microsoft, ce qui n'est pas le cas pour votre implémentation.

L'exemple suivant montre comment ajouter, supprimer, et insérer un objet business simple dans List<T>.


using System;
using System.Collections.Generic;
// Simple business object. A PartId is used to identify the type of part 
// but the part name can change. 
public class Part : IEquatable<Part>
    {
        public string PartName { get; set; }

        public int PartId { get; set; }

        public override string ToString()
        {
            return "ID: " + PartId + "   Name: " + PartName;
        }
        public override bool Equals(object obj)
        {
            if (obj == null) return false;
            Part objAsPart = obj as Part;
            if (objAsPart == null) return false;
            else return Equals(objAsPart);
        }
        public override int GetHashCode()
        {
            return PartId;
        }
        public bool Equals(Part other)
        {
            if (other == null) return false;
            return (this.PartId.Equals(other.PartId));
        }
    // Should also override == and != operators.

    }
public class Example
{
    public static void Main()
    {
        // Create a list of parts.
        List<Part> parts = new List<Part>();

        // Add parts to the list.
        parts.Add(new Part() {PartName="crank arm", PartId=1234});
        parts.Add(new Part() { PartName = "chain ring", PartId = 1334 });
        parts.Add(new Part() { PartName = "regular seat", PartId = 1434 });
         parts.Add(new Part() { PartName = "banana seat", PartId = 1444 });
        parts.Add(new Part() { PartName = "cassette", PartId = 1534 });
        parts.Add(new Part() { PartName = "shift lever", PartId = 1634 }); ;

        // Write out the parts in the list. This will call the overridden ToString method
        // in the Part class.
        Console.WriteLine();
        foreach (Part aPart in parts)
        {
            Console.WriteLine(aPart);
        }


        // Check the list for part #1734. This calls the IEquitable.Equals method
        // of the Part class, which checks the PartId for equality.
        Console.WriteLine("\nContains(\"1734\"): {0}",
        parts.Contains(new Part {PartId=1734, PartName="" }));

        // Insert a new item at position 2.
        Console.WriteLine("\nInsert(2, \"1834\")");
        parts.Insert(2, new Part() { PartName = "brake lever", PartId = 1834 });


        //Console.WriteLine();
        foreach (Part aPart in parts)
        {
            Console.WriteLine(aPart);
        }

        Console.WriteLine("\nParts[3]: {0}", parts[3]);

        Console.WriteLine("\nRemove(\"1534\")");

        // This will remove part 1534 even though the PartName is different,
        // because the Equals method only checks PartId for equality.
        parts.Remove(new Part(){PartId=1534, PartName="cogs"});

        Console.WriteLine();
        foreach (Part aPart in parts)
        {
            Console.WriteLine(aPart);
        }
        Console.WriteLine("\nRemoveAt(3)");
        // This will remove the part at index 3.
        parts.RemoveAt(3);

        Console.WriteLine();
        foreach (Part aPart in parts)
        {
            Console.WriteLine(aPart);
        }

            /*

             ID: 1234   Name: crank arm
             ID: 1334   Name: chain ring
             ID: 1434   Name: regular seat
             ID: 1444   Name: banana seat
             ID: 1534   Name: cassette
             ID: 1634   Name: shift lever

             Contains("1734"): False

             Insert(2, "1834")
             ID: 1234   Name: crank arm
             ID: 1334   Name: chain ring
             ID: 1834   Name: brake lever
             ID: 1434   Name: regular seat
             ID: 1444   Name: banana seat
             ID: 1534   Name: cassette
             ID: 1634   Name: shift lever

             Parts[3]: ID: 1434   Name: regular seat

             Remove("1534")

             ID: 1234   Name: crank arm
             ID: 1334   Name: chain ring
             ID: 1834   Name: brake lever
             ID: 1434   Name: regular seat
             ID: 1444   Name: banana seat
             ID: 1634   Name: shift lever

             RemoveAt(3)

             ID: 1234   Name: crank arm
             ID: 1334   Name: chain ring
             ID: 1834   Name: brake lever
             ID: 1444   Name: banana seat
             ID: 1634   Name: shift lever


         */

    }
}


L'exemple suivant illustre de nombreuses propriétés et méthodes de la classe générique List<T> de type String. (Pour obtenir un exemple d'un List<T> de types complexes, consultez la méthode Contains.)

Le constructeur par défaut est utilisé pour créer une liste de chaînes de la capacité par défaut. La propriété Capacity est affichée, puis la méthode Add est utilisée pour ajouter plusieurs éléments. Les éléments sont répertoriés, et la propriété Capacity s'affiche à nouveau, avec la propriété Count, pour indiquer que la capacité a été augmentée en fonction des besoins.

La méthode Contains permet de tester la présence d'un élément dans la liste, la méthode Insert permet d'insérer un nouvel élément au milieu de la liste, et le contenu de la liste s'affiche une nouvelle fois.

La propriété Item par défaut (l'indexeur de C#) permet de récupérer un élément, la méthode Remove permet de supprimer la première instance de l'élément dupliqué ajouté précédemment, et le contenu s'affiche une nouvelle fois. La méthode Remove supprime toujours la première instance qu'elle rencontre.

La méthode TrimExcess permet de réduire la possibilité de correspondre au nombre, et les propriétés Capacity et Count sont affichées. Si la capacité inutilisée avait été inférieure à 10 % de la capacité totale, la liste n'aurait pas été redimensionnée.

Enfin, la méthode Clear permet de supprimer tous les éléments de la liste, et les propriétés Capacity et Count sont affichées.


using System;
using System.Collections.Generic;

public class Example
{
    public static void Main()
    {
        List<string> dinosaurs = new List<string>();

        Console.WriteLine("\nCapacity: {0}", dinosaurs.Capacity);

        dinosaurs.Add("Tyrannosaurus");
        dinosaurs.Add("Amargasaurus");
        dinosaurs.Add("Mamenchisaurus");
        dinosaurs.Add("Deinonychus");
        dinosaurs.Add("Compsognathus");
        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine("\nCapacity: {0}", dinosaurs.Capacity);
        Console.WriteLine("Count: {0}", dinosaurs.Count);

        Console.WriteLine("\nContains(\"Deinonychus\"): {0}",
            dinosaurs.Contains("Deinonychus"));

        Console.WriteLine("\nInsert(2, \"Compsognathus\")");
        dinosaurs.Insert(2, "Compsognathus");

        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }

        // Shows accessing the list using the Item property.
        Console.WriteLine("\ndinosaurs[3]: {0}", dinosaurs[3]);

        Console.WriteLine("\nRemove(\"Compsognathus\")");
        dinosaurs.Remove("Compsognathus");

        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }

        dinosaurs.TrimExcess();
        Console.WriteLine("\nTrimExcess()");
        Console.WriteLine("Capacity: {0}", dinosaurs.Capacity);
        Console.WriteLine("Count: {0}", dinosaurs.Count);

        dinosaurs.Clear();
        Console.WriteLine("\nClear()");
        Console.WriteLine("Capacity: {0}", dinosaurs.Capacity);
        Console.WriteLine("Count: {0}", dinosaurs.Count);
    }
}

/* This code example produces the following output:

Capacity: 0

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Deinonychus
Compsognathus

Capacity: 8
Count: 5

Contains("Deinonychus"): True

Insert(2, "Compsognathus")

Tyrannosaurus
Amargasaurus
Compsognathus
Mamenchisaurus
Deinonychus
Compsognathus

dinosaurs[3]: Mamenchisaurus

Remove("Compsognathus")

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Deinonychus
Compsognathus

TrimExcess()
Capacity: 5
Count: 5

Clear()
Capacity: 5
Count: 0
 */


.NET Framework

Pris en charge dans : 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Pris en charge dans : 4, 3.5 SP1

Bibliothèque de classes portable

Pris en charge dans : Bibliothèque de classes portable

.NET pour les applications du Windows Store

Pris en charge dans : Windows 8

.NET pour les applications Windows Phone

Pris en charge dans : Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (rôle principal du serveur non pris en charge), Windows Server 2008 R2 (rôle principal du serveur pris en charge avec SP1 ou version ultérieure ; Itanium non pris en charge)

Le .NET Framework ne prend pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

Les membres statiques publics (Shared en Visual Basic) de ce type sont thread-safe. Il n'est pas garanti que les membres d'instance soient thread-safe.

Il est sécurisé d'exécuter des opérations de lecture multiples sur un List<T>, mais cela peut entraîner des problèmes si la collection est modifiée pendant qu'elle est lue. Pour garantir la sécurité des threads, verrouiller la collection pendant une opération de lecture ou d'écriture. Pour permettre à plusieurs threads d'accéder en lecture et en écriture à la collection, vous devez implémenter votre propre synchronisation. Pour les collections avec la synchronisation intégrée, consultez les classes dans l'espace de noms System.Collections.Concurrent. Pour une alternative d'une sécurité de thread propre, consultez la classe ImmutableList.

Ajouts de la communauté

AJOUTER
Microsoft réalise une enquête en ligne pour recueillir votre opinion sur le site Web de MSDN. Si vous choisissez d’y participer, cette enquête en ligne vous sera présentée lorsque vous quitterez le site Web de MSDN.

Si vous souhaitez y participer,
Afficher:
© 2015 Microsoft