Stack<T>.GetEnumerator メソッド

定義

Stack<T> の列挙子を返します。Returns an enumerator for the Stack<T>.

public:
 System::Collections::Generic::Stack<T>::Enumerator GetEnumerator();
public System.Collections.Generic.Stack<T>.Enumerator GetEnumerator ();
member this.GetEnumerator : unit -> System.Collections.Generic.Stack<'T>.Enumerator
Public Function GetEnumerator () As Stack(Of T).Enumerator

戻り値

Stack<T>.Enumerator

Stack<T>.EnumeratorStack<T>An Stack<T>.Enumerator for the Stack<T>.

次のコード例は、ジェネリッククラスが列挙可能であることを示して Stack<T> います。The following code example demonstrates that the Stack<T> generic class is enumerable. foreachステートメント ( For Each for each C++ の Visual Basic) は、キューを列挙するために使用されます。The foreach statement (For Each in Visual Basic, for each in C++) is used to enumerate the queue.

このコード例では、既定の容量を持つ文字列のスタックを作成し、メソッドを使用して Push 5 つの文字列をスタックにプッシュします。The code example creates a stack of strings with default capacity and uses the Push method to push five strings onto the stack. スタックの要素が列挙され、スタックの状態が変更されることはありません。The elements of the stack are enumerated, which does not change the state of the stack. メソッドは、 Pop スタックから最初の文字列をポップするために使用されます。The Pop method is used to pop the first string off the stack. メソッドは、 Peek スタック上の次の項目を確認するために使用され、その後、メソッドを Pop 使用してポップします。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.

ToArrayメソッドは、配列を作成してスタック要素をコピーするために使用されます。次に、によって取得されるコンストラクターに配列が渡され Stack<T> ます。その後 IEnumerable<T> 、要素の順序を逆にしてスタックのコピーが作成されます。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. コピーの要素が表示されます。The elements of the copy are displayed.

スタックのサイズの2倍の配列が作成され、メソッドを使用して配列 CopyTo の途中から配列の要素がコピーされます。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. Stack<T>コンストラクターは、要素の順序を逆にしてスタックのコピーを作成するために再び使用されます。したがって、3つの null 要素が末尾にあります。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.

メソッドは、 Contains 文字列 "4" がスタックの最初のコピーに含まれていることを示すために使用されます。その後、 Clear メソッドはコピーをクリアし、 Count プロパティはスタックが空であることを示します。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

注釈

C# 言語の foreach ステートメント (C++ では for each、Visual Basic では For Each) では、列挙子の複雑さが隠されています。The foreach statement of the C# language (for each in C++, For Each in Visual Basic) hides the complexity of the enumerators. したがって、列挙子を直接操作するのではなく、foreach を使用することをお勧めします。Therefore, using foreach is recommended, instead of directly manipulating the enumerator.

列挙子を使用すると、コレクション内のデータを読み取ることができますが、基になるコレクションを変更することはできません。Enumerators can be used to read the data in the collection, but they cannot be used to modify the underlying collection.

最初、列挙子はコレクションの先頭の要素の前に位置付けられます。Initially, the enumerator is positioned before the first element in the collection. この位置では、Current が未定義です。At this position, Current is undefined. そのため、MoveNext の値を読み取る前に、Current を呼び出して列挙子をコレクションの最初の要素に進める必要があります。Therefore, you must call MoveNext to advance the enumerator to the first element of the collection before reading the value of Current.

Current は、MoveNext が呼び出されるまでは同じオブジェクトを返します。Current returns the same object until MoveNext is called. MoveNext は、Current を次の要素に進めます。MoveNext sets Current to the next element.

MoveNext がコレクションの末尾を通過した場合、列挙子がコレクション内の最後の要素の後に配置され、MoveNextfalse を返します。If MoveNext passes the end of the collection, the enumerator is positioned after the last element in the collection and MoveNext returns false. 列挙子がこの位置にある場合、後続の MoveNext 呼び出しも false を返します。When the enumerator is at this position, subsequent calls to MoveNext also return false. の最後の呼び出しが返された場合 MoveNext falseCurrent が未定義になります。If the last call to MoveNext returned false, Current is undefined. Current を、再度、コレクションの最初の要素に設定することはできません。列挙子の新しいインスタンスを作成する必要があります。You cannot set Current to the first element of the collection again; you must create a new enumerator instance instead.

列挙子は、コレクションが変更されない限り有効です。An enumerator remains valid as long as the collection remains unchanged. 要素の追加、変更、削除などの変更がコレクションに対して行われた場合、列挙子はなりに無効化され、次のまたはの呼び出しでがスローされ MoveNext IEnumerator.Reset InvalidOperationException ます。If changes are made to the collection, such as adding, modifying, or deleting elements, the enumerator is irrecoverably invalidated and the next call to MoveNext or IEnumerator.Reset throws an InvalidOperationException.

列挙子はコレクションに排他アクセスできないため、コレクションの列挙処理は本質的にスレッド セーフな処理ではありません。The enumerator does not have exclusive access to the collection; therefore, enumerating through a collection is intrinsically not a thread-safe procedure. 列挙処理でスレッド セーフを確保するには、列挙処理が終わるまでコレクションをロックできます。To guarantee thread safety during enumeration, you can lock the collection during the entire enumeration. コレクションに対し複数のスレッドがアクセスして読み取りや書き込みを行うことができるようにするには、独自に同期化を実装する必要があります。To allow the collection to be accessed by multiple threads for reading and writing, you must implement your own synchronization.

のコレクションの既定の実装 System.Collections.Generic は同期されていません。Default implementations of collections in System.Collections.Generic are not synchronized.

このメソッドは、O(1) 操作です。This method is an O(1) operation.

適用対象

こちらもご覧ください