List, classe générique (System.Collections.Generic)

Bibliothèque de classes .NET Framework 
List, classe générique 

Remarque : cette classe est nouvelle dans le .NET Framework version 2.0.

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.

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

SyntaxeSyntaxe


Visual Basic (Déclaration)
<SerializableAttribute> _
Public Class List(Of T)
    Implements IList(Of T), ICollection(Of T), _
    IEnumerable(Of T), IList, ICollection, _
    IEnumerable


Visual Basic (Utilisation)
Dim instance As List(Of T)


C#
[SerializableAttribute] 
public class List<T> : IList<T>, ICollection<T>, 
    IEnumerable<T>, IList, ICollection, IEnumerable


C++
[SerializableAttribute] 
generic<typename T>
public ref class List : IList<T>, ICollection<T>, 
    IEnumerable<T>, IList, ICollection, IEnumerable


J#
J#  prend en charge l'utilisation de types et de méthodes génériques mais pas la déclaration de nouveaux types et de méthodes génériques.


JScript
JScript ne prend pas en charge les types et les méthodes génériques.

Paramètres de type

 
T

Type d'éléments de la liste.

NotesNotes

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

La classe List 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, le comparateur d'égalité est la méthode Equals 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, le comparateur par défaut est la méthode CompareTo 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 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 n'est pas garanti. Vous devez trier le List avant d'exécuter des opérations (telles que BinarySearch) qui exigent le tri du List.

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.

List accepte référence Null (Nothing en Visual Basic) comme valeur valide pour les types référence et autorise les éléments en double.

Considérations sur les performances

Lorsque vous décidez s'il faut utiliser la classe List ou ArrayList, les deux ayant des fonctionnalités similaires, n'oubliez pas que la classe List 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, 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 pour ce type valeur. Cela signifie qu'un élément de liste d'un objet List ne doit pas être boxed 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 conversion 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. Sinon, les méthodes telles que Contains doivent appeler la méthode Object.Equals(Object) qui procède à une conversion 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 pour empêcher que les méthodes BinarySearch et Sort ne procèdent à une conversion boxing des éléments de liste. Si vous n'êtes pas le propriétaire du code source, passez un objet IComparer aux méthodes BinarySearch et Sort

Il vaut mieux utiliser l'implémentation spécifique au type de la classe List 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.

ExempleExemple

L'exemple de code suivant illustre de nombreuses propriétés et méthodes de la classe générique List. Le constructeur par défaut permet de créer une liste de chaînes d'une capacité de 0. La propriété Capacity s'affiche, 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.



Visual Basic
Imports System
Imports System.Collections.Generic

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs As New List(Of String)

        Console.WriteLine(vbLf & "Capacity: {0}", dinosaurs.Capacity)

        dinosaurs.Add("Tyrannosaurus")
        dinosaurs.Add("Amargasaurus")
        dinosaurs.Add("Mamenchisaurus")
        dinosaurs.Add("Deinonychus")
        dinosaurs.Add("Compsognathus")

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & "Capacity: {0}", dinosaurs.Capacity)
        Console.WriteLine("Count: {0}", dinosaurs.Count)

        Console.WriteLine(vbLf & "Contains(""Deinonychus""): {0}", _
            dinosaurs.Contains("Deinonychus"))

        Console.WriteLine(vbLf & "Insert(2, ""Compsognathus"")")
        dinosaurs.Insert(2, "Compsognathus")

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & "dinosaurs(3): {0}", dinosaurs(3))

        Console.WriteLine(vbLf & "Remove(""Compsognathus"")")
        dinosaurs.Remove("Compsognathus")

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        dinosaurs.TrimExcess()
        Console.WriteLine(vbLf & "TrimExcess()")
        Console.WriteLine("Capacity: {0}", dinosaurs.Capacity)
        Console.WriteLine("Count: {0}", dinosaurs.Count)

        dinosaurs.Clear()
        Console.WriteLine(vbLf & "Clear()")
        Console.WriteLine("Capacity: {0}", dinosaurs.Capacity)
        Console.WriteLine("Count: {0}", dinosaurs.Count)
    End Sub
End Class

' 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


C#
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);
        }

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


C++
using namespace System;
using namespace System::Collections::Generic;

void main()
{
    List<String^>^ dinosaurs = gcnew 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();
    for each(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();
    for each(String^ dinosaur in dinosaurs )
    {
        Console::WriteLine(dinosaur);
    }

    Console::WriteLine("\ndinosaurs[3]: {0}", dinosaurs[3]);

    Console::WriteLine("\nRemove(\"Compsognathus\")");
    dinosaurs->Remove("Compsognathus");

    Console::WriteLine();
    for each(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
 */
Hiérarchie d'héritageHiérarchie d'héritage
System.Object
  System.Collections.Generic.List
Sécurité des threadsSécurité des threads

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.

List peut prendre simultanément en charge plusieurs lecteurs, tant que la collection n'est pas modifiée. L'énumération d'une collection n'est intrinsèquement pas une procédure thread-safe. Dans les cas rares où une énumération gère un ou plusieurs accès en écriture, la seule façon de garantir la sécurité des threads est de verrouiller la collection durant toute l'énumération. Pour permettre à plusieurs threads d'accéder en lecture et en écriture à la collection, vous devez implémenter votre propre synchronisation.

Plates-formesPlates-formes

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile pour Pocket PC, Windows Mobile pour Smartphone, Windows Server 2003, Windows XP Édition Media Center, Windows XP Professionnel Édition x64, Windows XP SP2, Windows XP Starter Edition

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

Informations de versionInformations de version

.NET Framework

Prise en charge dans : 2.0

.NET Compact Framework

Prise en charge dans : 2.0
Voir aussiVoir aussi

Ces informations proviennent du site de http://msdn2.microsoft.com
Source de cette page : http://msdn2.microsoft.com/fr-fr/library/6sh2ey19.aspx

Réseaux sociaux

Vous pouvez modifier vos préférences dans votre profil pour ne plus afficher les interactions avec les réseaux sociaux sur ces pages.

 

Nuage de mots clés

9 mots clés dont 0 définis manuellement (plus d'information...).

Avertissement

Cette page ne possède pas encore de mots clés manuels, ceci est donc un exemple automatique (les niveaux de pertinence sont fictifs, mais les liens sont valables). Pour tester le nuage avec une page qui contient des mots définis manuellement, vous pouvez cliquer ici.

Vous pouvez modifier vos préférences dans votre profil pour ne plus afficher le nuage de mots clés.

 

Astuce pour imprimer les couleurs des cellules de tableaux : http://www.gaudry.be/ast-rf-450.html
Aucun commentaire pour cette page

© Ce document issu de l′infobrol est enregistré sous le certificat Cyber PrInterDeposit Digital Numbertection. Enregistrement IDDN n° 5329-4433
Document créé le 22/10/06 22:57, dernière modification le Vendredi 17 Juin 2011, 12:11
Source du document imprimé : http://www.gaudry.be/dotnet-rf-6sh2ey19.html Document affiché 10 fois ce mois de Mai.
St.Gaudry©07.01.02
Outils (masquer)
||
Recherche (afficher)
Recherche :

Utilisateur (masquer)
Navigation (masquer)
Apparence (afficher)
Stats (afficher)
15832 documents
452 astuces.
549 niouzes.
3099 definitions.
447 membres.
8115 messages.

Document genere en :
0,76 seconde

Mises à jour :
Mises à jour du site
Citation (masquer)
Quand la tartine de Chuck Norris tombe, la confiture change de côté.

Anonyme [Chuck Norris fact]
 
l'infobrol
Nous sommes le Jeudi 31 Mai 2012, 00:45, toutes les heures sont au format GMT+1.00 Heure, heure d'été (+1)