List<T>.Capacity Eigenschaft

Definition

Namespace:

System.Collections.Generic

Assembly:

System.Collections.dll

Quelle:

List.cs

Ruft die Gesamtzahl der Elemente ab, die die interne Datenstruktur ohne Änderung der Größe aufnehmen kann, oder legt diese Anzahl fest.

C#

public int Capacity { get; set; }

Eigenschaftswert

Int32

Die Anzahl der Elemente, die List<T> enthalten kann, bevor eine Größenanpassung erforderlich ist.

Ausnahmen

ArgumentOutOfRangeException

Capacity ist auf einen Wert festgelegt, der kleiner als Count ist.

OutOfMemoryException

Im System ist nicht genügend Arbeitsspeicher verfügbar.

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie Sie die Kapazität und Anzahl eines List<T> -Objekts überprüfen, das ein einfaches Geschäftsobjekt enthält, und veranschaulicht die Verwendung der TrimExcess -Methode zum Entfernen zusätzlicher Kapazität.

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

Das folgende Beispiel zeigt die Capacity -Eigenschaft an mehreren Punkten im Leben einer Liste. Der parameterlose Konstruktor wird verwendet, um eine Liste von Zeichenfolgen mit einer Kapazität von 0 zu erstellen, und die Capacity -Eigenschaft wird angezeigt, um dies zu veranschaulichen. Nachdem die Add -Methode zum Hinzufügen mehrerer Elemente verwendet wurde, werden die Elemente aufgelistet, und dann wird die Capacity -Eigenschaft zusammen mit der Count -Eigenschaft erneut angezeigt, um zu zeigen, dass die Kapazität bei Bedarf erhöht wurde.

Die Capacity -Eigenschaft wird erneut angezeigt, nachdem die TrimExcess -Methode verwendet wurde, um die Kapazität für die Übereinstimmung mit der Anzahl zu verringern. Schließlich wird die Clear -Methode verwendet, um alle Elemente aus der Liste zu entfernen, und die Capacity Eigenschaften und Count werden erneut angezeigt.

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

Hinweise

Capacity ist die Anzahl der Elemente, die gespeichert List<T> werden können, bevor eine Größenänderung erforderlich ist, während Count die Anzahl der Elemente, die sich tatsächlich im befinden, entspricht List<T>.

Capacity ist immer größer als oder gleich Count. Wenn Count beim Hinzufügen von Elementen überschritten Capacity wird, wird die Kapazität erhöht, indem das interne Array automatisch neu zugeordnet wird, bevor die alten Elemente kopiert und die neuen Elemente hinzugefügt werden.

Wenn die Kapazität deutlich größer als die Anzahl ist und Sie den vom List<T>verwendeten Arbeitsspeicher verringern möchten, können Sie die Kapazität verringern, indem Sie die TrimExcess -Methode aufrufen oder die Capacity Eigenschaft explizit auf einen niedrigeren Wert festlegen. Wenn der Wert von Capacity explizit festgelegt wird, wird auch das interne Array neu zugeordnet, um die angegebene Kapazität aufzunehmen, und alle Elemente werden kopiert.

Das Abrufen des Werts dieser Eigenschaft ist ein O(1)-Vorgang. Das Festlegen der Eigenschaft ist ein O(n)-Vorgang, wobei n die neue Kapazität ist.

Gilt für:

Weitere Informationen

• Count