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

Stack<T>.Peek, méthode

Retourne l'objet situé en haut de Stack<T> sans le supprimer.

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

public T Peek()

Valeur de retour

Type : T
Objet situé en haut de Stack<T>.

ExceptionCondition
InvalidOperationException

Stack<T> est vide.

Cette méthode est analogue à la méthode Pop, mais Peek ne modifie pas Stack<T>.

Si le type T est un type référence, null peut faire l'objet d'un push sur Stack<T> en tant qu'espace réservé, si nécessaire.

Cette méthode est une opération O(1).

L'exemple de code suivant illustre plusieurs méthodes de la classe générique Stack<T>, notamment la méthode Peek.

L'exemple de code crée une pile de chaînes avec une capacité par défaut et utilise la méthode Push pour insérer cinq chaînes dans la pile. Les éléments de la pile sont énumérés, ce qui ne modifie pas l'état de la pile. La méthode Pop permet de dépiler la première chaîne. La méthode Peek permet d'afficher l'élément suivant sur la pile, et la méthode Pop permet de dépiler cet élément.

La méthode ToArray permet de créer un tableau et d'y copier les éléments de la pile. Ce tableau est ensuite passé au constructeur Stack<T> qui accepte IEnumerable<T>, créant ainsi une copie de la pile dont l'ordre des éléments est inversé. Les éléments de la copie s'affichent.

Un tableau représentant deux fois la taille de la pile est créé, et la méthode CopyTo est utilisée pour copier les éléments du tableau commençant au milieu du tableau. Le constructeur Stack<T> est utilisé à nouveau pour créer une copie de la pile dont l'ordre des éléments est inversé ; par conséquent, les trois éléments null figurent à la fin.

La méthode Contains permet d'indiquer que la chaîne "four" figure dans la première copie de la pile. La méthode Clear efface ensuite la copie et la propriété Count indique que la pile est vide.


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


.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.

Ajouts de la communauté

AJOUTER
Afficher:
© 2014 Microsoft