Gewusst wie: Zugreifen auf Auflistungsklassen mit foreach (C#-Programmierhandbuch)How to: Access a Collection Class with foreach (C# Programming Guide)

Das folgende Codebeispiel zeigt, wie Sie eine nicht generische Auflistungsklasse schreiben, die mit foreach verwendet werden kann.The following code example illustrates how to write a non-generic collection class that can be used with foreach. Das Beispiel definiert eine Zeichenfolgen-Tokenisierungsklasse.The example defines a string tokenizer class.

Hinweis

Das Beispiel stellt nur die empfohlene Vorgehensweise dar, wenn Sie keine generische Auflistungsklasse verwenden können.This example represents recommended practice only when you cannot use a generic collection class. Ein Beispiel wie eine typsichere generische Auflistungsklasse implementiert wird, die IEnumerable<T> unterstützt, finden Sie unter Iterators (Iteratoren).For an example of how to implement a type-safe generic collection class that supports IEnumerable<T>, see Iterators.

Im Beispiel verwendet das folgende Codesegment die Tokens-Klasse, um den Satz „Dies ist ein Beispielsatz“.In the example, the following code segment uses the Tokens class to break the sentence "This is a sample sentence." in Token aufzuteilen, indem „ “ und „-“ als Trennzeichen verwendet werden.into tokens by using ' ' and '-' as separators. Der Code zeigt anschließend diese Tokens mithilfe einer foreach-Anweisung an.The code then displays those tokens by using a foreach statement.

Tokens f = new Tokens("This is a sample sentence.", new char[] {' ','-'});

// Display the tokens.
foreach (string item in f)
{
    System.Console.WriteLine(item);
}

BeispielExample

Die Tokens-Klasse verwendet intern ein Array, um die Token zu speichern.Internally, the Tokens class uses an array to store the tokens. Da Arrays IEnumerator und IEnumerable implementieren, hätte das Codebeispiel die Enumerationsmethoden des Arrays (GetEnumerator, MoveNext, Reset und Current) verwenden können, anstatt sie in der Klasse Tokens zu definieren.Because arrays implement IEnumerator and IEnumerable, the code example could have used the array's enumeration methods (GetEnumerator, MoveNext, Reset, and Current) instead of defining them in the Tokens class. Die Methodendefinitionen sind im Beispiel enthalten, um zu verdeutlichen, wie sie definiert sind und was jede Definition tut.The method definitions are included in the example to clarify how they are defined and what each does.

using System.Collections;

// Declare the Tokens class. The class implements the IEnumerable interface.
public class Tokens : IEnumerable
{
    private string[] elements;

    Tokens(string source, char[] delimiters)
    {
        // The constructor parses the string argument into tokens.
        elements = source.Split(delimiters);
    }

    // The IEnumerable interface requires implementation of method GetEnumerator.
    public IEnumerator GetEnumerator()
    {
        return new TokenEnumerator(this);
    }


    // Declare an inner class that implements the IEnumerator interface.
    private class TokenEnumerator : IEnumerator
    {
        private int position = -1;
        private Tokens t;

        public TokenEnumerator(Tokens t)
        {
            this.t = t;
        }

        // The IEnumerator interface requires a MoveNext method.
        public bool MoveNext()
        {
            if (position < t.elements.Length - 1)
            {
                position++;
                return true;
            }
            else
            {
                return false;
            }
        }

        // The IEnumerator interface requires a Reset method.
        public void Reset()
        {
            position = -1;
        }

        // The IEnumerator interface requires a Current method.
        public object Current
        {
            get
            {
                return t.elements[position];
            }
        }
    }


    // Test the Tokens class.
    static void Main()
    {
        // Create a Tokens instance.
        Tokens f = new Tokens("This is a sample sentence.", new char[] {' ','-'});

        // Display the tokens.
        foreach (string item in f)
        {
            System.Console.WriteLine(item);
        }
    }
}
/* Output:
    This
    is
    a
    sample
    sentence.  
*/

In C# muss eine Auflistungsklasse nicht IEnumerable und IEnumerator implementieren, um mit foreach kompatibel zu sein.In C#, it is not necessary for a collection class to implement IEnumerable and IEnumerator to be compatible with foreach. Wenn die Klasse über die erforderlichen Elemente GetEnumerator, MoveNext, Reset und Current verfügt, wird sie mit foreach arbeiten.If the class has the required GetEnumerator, MoveNext, Reset, and Current members, it will work with foreach. Das Auslassen der Schnittstellen hat den Vorteil, dass Sie einen Rückgabetyp für Current definieren können, der spezifischer als Object ist.Omitting the interfaces has the advantage of enabling you to define a return type for Current that is more specific than Object. Dadurch wird Typsicherheit bereitgestellt.This provides type safety.

Ändern Sie z.B. die folgenden Zeilen im vorherigen Beispiel.For example, change the following lines in the previous example.

// Change the Tokens class so that it no longer implements IEnumerable.  
public class Tokens  
{  
    // . . .  

    // Change the return type for the GetEnumerator method.  
    public TokenEnumerator GetEnumerator()  
    {   }  

    // Change TokenEnumerator so that it no longer implements IEnumerator.  
    public class TokenEnumerator  
    {  
        // . . .  

        // Change the return type of method Current to string.  
        public string Current  
        {   }  
    }  
 }  

Da Current eine Zeichenfolge zurückgibt, kann der Compiler erkennen, wenn ein nicht kompatibler Typ in einer foreach-Anweisung verwendet wird, so wie in folgendem Code dargestellt.Because Current returns a string, the compiler can detect when an incompatible type is used in a foreach statement, as shown in the following code.

// Error: Cannot convert type string to int.  
foreach (int item in f)    

Wenn IEnumerator und foreach ausgelassen werden, besteht der Nachteil darin, dass die Auflistungsklasse nicht länger mit den IEnumerable-Anweisungen oder entsprechenden Anweisungen anderer Common Language Runtime-Sprachen interoperabel ist.The disadvantage of omitting IEnumerable and IEnumerator is that the collection class is no longer interoperable with the foreach statements, or equivalent statements, of other common language runtime languages.

Siehe auchSee Also

System.Collections.Generic
C#-ReferenzC# Reference
C#-ProgrammierhandbuchC# Programming Guide
ArraysArrays
SammlungenCollections