List<T>.Capacity Propriété

Définition

Espace de noms:

System.Collections.Generic

Assembly:

System.Collections.dll

Source:

List.cs

Obtient ou définit le nombre total des éléments que la structure de données interne peut contenir sans redimensionnement.

C#

public int Capacity { get; set; }

Valeur de propriété

Int32

Nombre d'éléments que List<T> peut contenir avant que le redimensionnement soit nécessaire.

Exceptions

ArgumentOutOfRangeException

La valeur affectée à Capacity est inférieure à Count.

OutOfMemoryException

Il n’y a pas assez de mémoire disponible sur le système.

Exemples

L’exemple suivant montre comment case activée la capacité et le nombre d’un List<T> qui contient un objet métier simple, et illustre l’utilisation de la méthode pour supprimer une TrimExcess capacité supplémentaire.

C#

using System;
using System.Collections.Generic;
// Simple business object. A PartId is used to identify a part
// but the part name be different for the same Id.
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 base.GetHashCode();
    }
    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()
    {
        List<Part> parts = new List<Part>();

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

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

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

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

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

        parts.Clear();
        Console.WriteLine("\nClear()");
        Console.WriteLine("Capacity: {0}", parts.Capacity);
        Console.WriteLine("Count: {0}", parts.Count);
    }
    /*
     This code example produces the following output.
            Capacity: 0

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

            Capacity: 8
            Count: 5

            TrimExcess()
            Capacity: 5
            Count: 5

            Clear()
            Capacity: 5
            Count: 0
     */
}

L’exemple suivant montre la Capacity propriété à plusieurs points de la vie d’une liste. Le constructeur sans paramètre est utilisé pour créer une liste de chaînes d’une capacité de 0, et la Capacity propriété est affichée pour illustrer cela. Une fois que la Add méthode a été utilisée pour ajouter plusieurs éléments, les éléments sont répertoriés, puis la Capacity propriété est à nouveau affichée, avec la Count propriété, pour montrer que la capacité a été augmentée en fonction des besoins.

La Capacity propriété s’affiche à nouveau après l’utilisation de la TrimExcess méthode pour réduire la capacité à correspondre au nombre. Enfin, la Clear méthode est utilisée pour supprimer tous les éléments de la liste, et les Capacity propriétés et Count sont à nouveau affichées.

C#

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

Remarques

Capacity est le nombre d’éléments que le peut stocker avant que le List<T> redimensionnement ne soit requis, tandis que Count est le nombre d’éléments qui se trouvent réellement dans le List<T>.

Capacity est toujours supérieur ou égal à Count. Si Count elle dépasse lors de Capacity l’ajout d’éléments, la capacité est augmentée en réaffectant automatiquement le tableau interne avant de copier les anciens éléments et d’ajouter les nouveaux éléments.

Si la capacité est considérablement supérieure au nombre et que vous souhaitez réduire la mémoire utilisée par , vous pouvez réduire la List<T>capacité en appelant la TrimExcess méthode ou en définissant explicitement la Capacity propriété sur une valeur inférieure. Lorsque la valeur de Capacity est définie explicitement, le tableau interne est également réaffecté pour prendre en charge la capacité spécifiée, et tous les éléments sont copiés.

La récupération de la valeur de cette propriété est une opération O(1) ; la définition de la propriété est une opération O(n), où n est la nouvelle capacité.

S’applique à

Voir aussi

• Count