Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Método Stack<T>.GetEnumerator ()

 

Publicado: octubre de 2016

Devuelve un enumerador para la colección Stack<T>.

Espacio de nombres:   System.Collections.Generic
Ensamblado:  System (en System.dll)

public Stack<T>.Enumerator GetEnumerator()

Valor devuelto

Type: System.Collections.Generic.Stack<T>.Enumerator

Estructura Stack<T>.Enumerator para la colección Stack<T>.

El foreach instrucción del lenguaje C# (for each en C++, For Each en Visual Basic) oculta la complejidad de los enumeradores. Por lo tanto, se recomienda el uso de foreach, en lugar de manipular directamente el enumerador.

Los enumeradores pueden usarse para leer los datos de la colección, pero no para modificar la colección subyacente.

En principio, el enumerador se coloca antes del primer elemento de la colección. En esta posición, el valor de propiedad Current está sin definir. Por lo tanto, debe llamar a MoveNext para adelantar el enumerador hasta el primer elemento de la colección antes de leer el valor de Current.

Current devuelve el mismo objeto hasta que se llama a MoveNext. MoveNext establece Current en el siguiente elemento.

Si MoveNext pasa el final de la colección, el enumerador se coloca detrás del último elemento de la colección y MoveNext devuelve false. Mientras el enumerador permanezca en esta posición, las llamadas subsiguientes a MoveNext también devolver false. Si la última llamada a MoveNext devuelve false, Current no está definido. No puede volver a establecer la propiedad Current en el primer elemento de la colección, sino que debe crear una nueva instancia del enumerador.

Un enumerador es válido mientras la colección no cambie. Si se hacen cambios en la colección (como agregar, modificar o eliminar elementos), el enumerador queda invalidado permanentemente y su comportamiento es indefinido.

El enumerador no tiene acceso exclusivo a la colección y, por tanto, la enumeración en una colección no es intrínsicamente un procedimiento seguro para subprocesos. A fin de garantizar la seguridad de los subprocesos, se puede bloquear la colección durante toda la enumeración. Para permitir que varios subprocesos obtengan acceso de lectura y escritura a la colección, debe implementar su propia sincronización.

Las implementaciones de colecciones en predeterminadas System.Collections.Generic no están sincronizadas.

Este método es una operación o (1).

En el ejemplo de código siguiente se muestra que la Stack<T> clase genérica es enumerable. El foreach instrucción (For Each en Visual Basic, for each en C++) se utiliza para enumerar la cola.

El ejemplo de código crea una pila de cadenas con capacidad predeterminada y utiliza el Push método para insertar cinco cadenas en la pila. Se enumeran los elementos de la pila, que no cambia el estado de la pila. El Pop método se utiliza para extraer la primera cadena de la pila. El Peek método se utiliza para buscar el siguiente elemento en la pila y, a continuación, el Pop método se usa para extraer.

El ToArray método se usa para crear una matriz y copiar los elementos de la pila en él, a continuación, la matriz se pasa a la Stack<T> constructor que toma IEnumerable<T>, crear una copia de la pila con el orden de los elementos invertidos. Se muestran los elementos de la copia.

Dos veces el tamaño de la pila se crea una matriz y la CopyTo método se usa para copiar los elementos de matriz, empezando por el centro de la matriz. El Stack<T> constructor se utiliza de nuevo para crear una copia de la pila con el orden de los elementos invertidos; por lo tanto, los tres elementos null se encuentran al final.

El Contains método se usa para mostrar que la cadena "four" está en la primera copia de la pila, después del cual el Clear método borra la copia y el Count propiedad muestra que la pila está vacía.

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

Plataforma universal de Windows
Disponible desde 8
.NET Framework
Disponible desde 2.0
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0
Windows Phone
Disponible desde 8.1
Volver al principio
Mostrar: