Stack<T> Classe

Définition

Représente une collection d’instances à taille variable de type dernier entré, premier sorti (LIFO) du même type spécifié.Represents a variable size last-in-first-out (LIFO) collection of instances of the same specified type.

generic <typename T>
public ref class Stack : System::Collections::Generic::IEnumerable<T>, System::Collections::Generic::IReadOnlyCollection<T>, System::Collections::ICollection
[System.Runtime.InteropServices.ComVisible(false)]
[System.Serializable]
public class Stack<T> : System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.ICollection
type Stack<'T> = class
    interface seq<'T>
    interface ICollection
    interface IReadOnlyCollection<'T>
    interface IEnumerable
Public Class Stack(Of T)
Implements ICollection, IEnumerable(Of T), IReadOnlyCollection(Of T)

Paramètres de type

T

Spécifie le type d'éléments dans la pile.Specifies the type of elements in the stack.

Héritage
Stack<T>
Attributs
Implémente

Exemples

L’exemple de code suivant illustre plusieurs méthodes de Stack<T> la classe générique.The following code example demonstrates several methods of the Stack<T> generic class. L’exemple de code crée une pile de chaînes avec la capacité par défaut Push et utilise la méthode pour effectuer un push de cinq chaînes sur la pile.The code example creates a stack of strings with default capacity and uses the Push method to push five strings onto the stack. Les éléments de la pile sont énumérés, ce qui ne modifie pas l’état de la pile.The elements of the stack are enumerated, which does not change the state of the stack. La Pop méthode est utilisée pour dépiler la première chaîne de la pile.The Pop method is used to pop the first string off the stack. La Peek méthode est utilisée pour examiner l’élément suivant sur la pile, puis la méthode est Pop utilisée pour la dépiler.The Peek method is used to look at the next item on the stack, and then the Pop method is used to pop it off.

La ToArray méthode est utilisée pour créer un tableau et y copier les éléments de pile, puis le tableau est passé Stack<T> au constructeur qui prend IEnumerable<T>, en créant une copie de la pile avec l’ordre des éléments inversés.The ToArray method is used to create an array and copy the stack elements to it, then the array is passed to the Stack<T> constructor that takes IEnumerable<T>, creating a copy of the stack with the order of the elements reversed. Les éléments de la copie sont affichés.The elements of the copy are displayed.

Un tableau deux fois la taille de la pile est créé, et CopyTo la méthode est utilisée pour copier les éléments du tableau en commençant au milieu du tableau.An array twice the size of the stack is created, and the CopyTo method is used to copy the array elements beginning at the middle of the array. Le Stack<T> constructeur est de nouveau utilisé pour créer une copie de la pile avec l’ordre des éléments inversés ; ainsi, les trois éléments null sont à la fin.The Stack<T> constructor is used again to create a copy of the stack with the order of elements reversed; thus, the three null elements are at the end.

La Contains méthode est utilisée pour indiquer que la chaîne « quatre » se trouve dans la première copie de la pile, après laquelle Clear la méthode efface la copie et Count la propriété indique que la pile est vide.The Contains method is used to show that the string "four" is in the first copy of the stack, after which the Clear method clears the copy and the Count property shows that the stack is empty.

using System;
using System.Collections.Generic;

class Example
{
    public static void Main()
    {
        Stack<string> numbers = new Stack<string>();
        numbers.Push("one");
        numbers.Push("two");
        numbers.Push("three");
        numbers.Push("four");
        numbers.Push("five");

        // A stack can be enumerated without disturbing its contents.
        foreach( string number in numbers )
        {
            Console.WriteLine(number);
        }

        Console.WriteLine("\nPopping '{0}'", numbers.Pop());
        Console.WriteLine("Peek at next item to destack: {0}", 
            numbers.Peek());
        Console.WriteLine("Popping '{0}'", numbers.Pop());

        // Create a copy of the stack, using the ToArray method and the
        // constructor that accepts an IEnumerable<T>.
        Stack<string> stack2 = new Stack<string>(numbers.ToArray());

        Console.WriteLine("\nContents of the first copy:");
        foreach( string number in stack2 )
        {
            Console.WriteLine(number);
        }
        
        // Create an array twice the size of the stack and copy the
        // elements of the stack, starting at the middle of the 
        // array. 
        string[] array2 = new string[numbers.Count * 2];
        numbers.CopyTo(array2, numbers.Count);
        
        // Create a second stack, using the constructor that accepts an
        // IEnumerable(Of T).
        Stack<string> stack3 = new Stack<string>(array2);

        Console.WriteLine("\nContents of the second copy, with duplicates and nulls:");
        foreach( string number in stack3 )
        {
            Console.WriteLine(number);
        }

        Console.WriteLine("\nstack2.Contains(\"four\") = {0}", 
            stack2.Contains("four"));

        Console.WriteLine("\nstack2.Clear()");
        stack2.Clear();
        Console.WriteLine("\nstack2.Count = {0}", stack2.Count);
    }
}

/* This code example produces the following output:

five
four
three
two
one

Popping 'five'
Peek at next item to destack: four
Popping 'four'

Contents of the first copy:
one
two
three

Contents of the second copy, with duplicates and nulls:
one
two
three




stack2.Contains("four") = False

stack2.Clear()

stack2.Count = 0
 */
Imports System.Collections.Generic

Module Example

    Sub Main

        Dim numbers As New Stack(Of String)
        numbers.Push("one")
        numbers.Push("two")
        numbers.Push("three")
        numbers.Push("four")
        numbers.Push("five")

        ' A stack can be enumerated without disturbing its contents.
        For Each number As String In numbers
            Console.WriteLine(number)
        Next

        Console.WriteLine(vbLf & "Popping '{0}'", numbers.Pop())
        Console.WriteLine("Peek at next item to pop: {0}", _
            numbers.Peek())    
        Console.WriteLine("Popping '{0}'", numbers.Pop())

        ' Create another stack, using the ToArray method and the
        ' constructor that accepts an IEnumerable(Of T). Note that
        ' the order of items on the new stack is reversed.
        Dim stack2 As New Stack(Of String)(numbers.ToArray())

        Console.WriteLine(vbLf & "Contents of the first copy:")
        For Each number As String In stack2
            Console.WriteLine(number)
        Next
        
        ' Create an array twice the size of the stack, compensating
        ' for the fact that Visual Basic allocates an extra array 
        ' element. Copy the elements of the stack, starting at the
        ' middle of the array. 
        Dim array2((numbers.Count * 2) - 1) As String
        numbers.CopyTo(array2, numbers.Count)
        
        ' Create a second stack, using the constructor that accepts an
        ' IEnumerable(Of T). The elements are reversed, with the null
        ' elements appearing at the end of the stack when enumerated.
        Dim stack3 As New Stack(Of String)(array2)

        Console.WriteLine(vbLf & _
            "Contents of the second copy, with duplicates and nulls:")
        For Each number As String In stack3
            Console.WriteLine(number)
        Next

        Console.WriteLine(vbLf & "stack2.Contains(""four"") = {0}", _
            stack2.Contains("four"))

        Console.WriteLine(vbLf & "stack2.Clear()")
        stack2.Clear()
        Console.WriteLine(vbLf & "stack2.Count = {0}", _
            stack2.Count)
    End Sub
End Module

' This code example produces the following output:
'
'five
'four
'three
'two
'one
'
'Popping 'five'
'Peek at next item to pop: four
'Popping 'four'
'
'Contents of the first copy:
'one
'two
'three
'
'Contents of the second copy, with duplicates and nulls:
'one
'two
'three
'
'
'
'
'stack2.Contains("four") = False
'
'stack2.Clear()
'
'stack2.Count = 0

Remarques

Stack<T>est implémenté en tant que tableau.Stack<T> is implemented as an array.

Les piles et les files d’attente sont utiles lorsque vous avez besoin d’un stockage temporaire pour les informations. autrement dit, lorsque vous souhaitez ignorer un élément après avoir récupéré sa valeur.Stacks and queues are useful when you need temporary storage for information; that is, when you might want to discard an element after retrieving its value. Utilisez Queue<T> si vous avez besoin d’accéder aux informations dans l’ordre dans lequel elles sont stockées dans la collection.Use Queue<T> if you need to access the information in the same order that it is stored in the collection. Utilisez System.Collections.Generic.Stack<T> si vous avez besoin d’accéder aux informations dans l’ordre inverse.Use System.Collections.Generic.Stack<T> if you need to access the information in reverse order.

Utilisez les System.Collections.Concurrent.ConcurrentStack<T> types System.Collections.Concurrent.ConcurrentQueue<T> et lorsque vous devez accéder simultanément à la collection à partir de plusieurs threads.Use the System.Collections.Concurrent.ConcurrentStack<T> and System.Collections.Concurrent.ConcurrentQueue<T> types when you need to access the collection from multiple threads concurrently.

Une utilisation courante de System.Collections.Generic.Stack<T> est de conserver les États des variables pendant les appels à d’autres procédures.A common use for System.Collections.Generic.Stack<T> is to preserve variable states during calls to other procedures.

Trois opérations principales peuvent être effectuées sur un System.Collections.Generic.Stack<T> et ses éléments :Three main operations can be performed on a System.Collections.Generic.Stack<T> and its elements:

La capacité d’un Stack<T> est le nombre d’éléments que Stack<T> peut contenir.The capacity of a Stack<T> is the number of elements the Stack<T> can hold. À mesure que des éléments sont Stack<T>ajoutés à un, la capacité est automatiquement augmentée en fonction des besoins en réallouant le tableau interne.As elements are added to a Stack<T>, the capacity is automatically increased as required by reallocating the internal array. La capacité peut être réduite en appelant TrimExcess.The capacity can be decreased by calling TrimExcess.

Si Count est inférieur à la capacité de la pile, Push est une opération O (1).If Count is less than the capacity of the stack, Push is an O(1) operation. Si la capacité doit être augmentée pour s’adapter au nouvel élément Push , devient une opérationnO (), nCountest.If the capacity needs to be increased to accommodate the new element, Push becomes an O(n) operation, where n is Count. Popest une opération O (1).Pop is an O(1) operation.

Stack<T>accepte null comme valeur valide pour les types référence et autorise les éléments en double.Stack<T> accepts null as a valid value for reference types and allows duplicate elements.

Constructeurs

Stack<T>()

Initialise une nouvelle instance de la classe Stack<T> qui est vide et possède la capacité initiale par défaut.Initializes a new instance of the Stack<T> class that is empty and has the default initial capacity.

Stack<T>(IEnumerable<T>)

Initialise une nouvelle instance de la classe Stack<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.Initializes a new instance of the Stack<T> class that contains elements copied from the specified collection and has sufficient capacity to accommodate the number of elements copied.

Stack<T>(Int32)

Initialise une nouvelle instance de la classe Stack<T> qui est vide et possède une capacité égale à la plus grande valeur parmi la capacité initiale spécifiée et la capacité initiale par défaut.Initializes a new instance of the Stack<T> class that is empty and has the specified initial capacity or the default initial capacity, whichever is greater.

Propriétés

Count

Obtient le nombre d'éléments contenus dans le Stack<T>.Gets the number of elements contained in the Stack<T>.

Méthodes

Clear()

Supprime tous les objets du Stack<T>.Removes all objects from the Stack<T>.

Contains(T)

Détermine si le Stack<T> contient un élément.Determines whether an element is in the Stack<T>.

CopyTo(T[], Int32)

Copie Stack<T> dans un Array unidimensionnel existant commençant à l'index de tableau spécifié.Copies the Stack<T> to an existing one-dimensional Array, starting at the specified array index.

Equals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
GetEnumerator()

Retourne un énumérateur pour Stack<T>.Returns an enumerator for the Stack<T>.

GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
Peek()

Retourne l'objet situé en haut de Stack<T> sans le supprimer.Returns the object at the top of the Stack<T> without removing it.

Pop()

Supprime et retourne l'objet en haut de Stack<T>.Removes and returns the object at the top of the Stack<T>.

Push(T)

Insère un objet en haut de Stack<T>.Inserts an object at the top of the Stack<T>.

ToArray()

Copie Stack<T> vers un nouveau tableau.Copies the Stack<T> to a new array.

ToString()

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(Hérité de Object)
TrimExcess()

Définit la capacité au nombre réel d'éléments dans Stack<T>, si ce nombre est inférieur à 90 pour cent de capacité actuelle.Sets the capacity to the actual number of elements in the Stack<T>, if that number is less than 90 percent of current capacity.

TryPeek(T)
TryPop(T)

Implémentations d’interfaces explicites

ICollection.CopyTo(Array, Int32)

Copie les éléments de ICollection dans Array, à partir d'un index particulier de Array.Copies the elements of the ICollection to an Array, starting at a particular Array index.

ICollection.IsSynchronized

Obtient une valeur indiquant si l'accès à ICollection est synchronisé (thread-safe).Gets a value indicating whether access to the ICollection is synchronized (thread safe).

ICollection.SyncRoot

Obtient un objet qui peut être utilisé pour synchroniser l'accès à ICollection.Gets an object that can be used to synchronize access to the ICollection.

IEnumerable.GetEnumerator()

Retourne un énumérateur qui itère au sein d’une collection.Returns an enumerator that iterates through a collection.

IEnumerable<T>.GetEnumerator()

Retourne un énumérateur qui itère au sein de la collection.Returns an enumerator that iterates through the collection.

Méthodes d’extension

CopyToDataTable<T>(IEnumerable<T>)

Retourne un DataTable qui contient des copies des objets DataRow, à partir d'un objet d'entrée IEnumerable<T> où le paramètre générique T est DataRow.Returns a DataTable that contains copies of the DataRow objects, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)

Copie les objets DataRow vers le DataTable spécifié, à partir d'un objet d'entrée IEnumerable<T> où le paramètre générique T est DataRow.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)

Copie les objets DataRow vers le DataTable spécifié, à partir d'un objet d'entrée IEnumerable<T> où le paramètre générique T est DataRow.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

Cast<TResult>(IEnumerable)

Effectue un cast des éléments d'un IEnumerable vers le type spécifié.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtre les éléments d'un IEnumerable en fonction du type spécifié.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Active la parallélisation d'une requête.Enables parallelization of a query.

AsQueryable(IEnumerable)

Convertit un IEnumerable en IQueryable.Converts an IEnumerable to an IQueryable.

Ancestors<T>(IEnumerable<T>)

Retourne une collection d'éléments qui contient les ancêtres de chaque nœud de la collection source.Returns a collection of elements that contains the ancestors of every node in the source collection.

Ancestors<T>(IEnumerable<T>, XName)

Retourne une collection d'éléments filtrée qui contient les ancêtres de chaque nœud de la collection source.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Seuls les éléments avec un XName correspondant sont inclus dans la collection.Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>)

Retourne une collection des nœuds descendants de chaque document et élément de la collection source.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>)

Retourne une collection d'éléments qui contient les éléments descendants de tous les éléments et tous les documents de la collection source.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

Descendants<T>(IEnumerable<T>, XName)

Retourne une collection d'éléments filtrée qui contient les éléments descendants de tous les éléments et tous les documents de la collection source.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Seuls les éléments avec un XName correspondant sont inclus dans la collection.Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>)

Retourne une collection des éléments enfants de chaque élément et document de la collection source.Returns a collection of the child elements of every element and document in the source collection.

Elements<T>(IEnumerable<T>, XName)

Retourne une collection filtrée des éléments enfants de chaque élément et document de la collection source.Returns a filtered collection of the child elements of every element and document in the source collection. Seuls les éléments avec un XName correspondant sont inclus dans la collection.Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>)

Retourne une collection de nœuds qui contient tous les nœuds de la collection source, triés selon l'ordre des documents.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>)

Retourne une collection des nœuds enfants de chaque document et élément de la collection source.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>)

Supprime chaque nœud de la collection source de son nœud parent.Removes every node in the source collection from its parent node.

S’applique à

Cohérence de thread

Les membres statiques publics (Shared dans Visual Basic) de ce type sont thread-safe.Public static (Shared in Visual Basic) members of this type are thread safe. Il n'est pas garanti que les membres d'instance soient thread-safe.Any instance members are not guaranteed to be thread safe.

Un Stack<T> peut prendre en charge plusieurs lecteurs simultanément, à condition que la collection ne soit pas modifiée.A Stack<T> can support multiple readers concurrently, as long as the collection is not modified. Même dans ce cas, l’énumération d’une collection n’est intrinsèquement pas une procédure thread-safe.Even so, enumerating through a collection is intrinsically not a thread-safe procedure. Pour garantir la sécurité des threads pendant l'énumération, vous pouvez verrouiller la collection tout au long de cette opération.To guarantee thread safety during enumeration, you can lock the collection during the entire enumeration. Pour permettre à plusieurs threads d’accéder en lecture et en écriture à la collection, vous devez implémenter votre propre synchronisation.To allow the collection to be accessed by multiple threads for reading and writing, you must implement your own synchronization.

Voir aussi