Nota
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare ad accedere o modificare le directory.
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare a modificare le directory.
È possibile usare un iteratore per scorrere raccolte, ad esempio elenchi e matrici.
Un metodo iteratore o get una funzione di accesso esegue un'iterazione personalizzata su una raccolta. Un metodo iteratore usa l'istruzione yield return per restituire ogni elemento uno alla volta. Quando viene raggiunta un'istruzione yield return , viene memorizzata la posizione corrente nel codice. L'esecuzione viene riavviata da tale posizione alla successiva chiamata della funzione iteratore.
Si utilizza un iteratore dal codice client usando un'istruzione foreach o una query LINQ.
Nell'esempio seguente, la prima iterazione del foreach ciclo fa sì che l'esecuzione proceda nel SomeNumbers metodo iteratore fino a quando non viene raggiunta la prima yield return istruzione. Questa iterazione restituisce un valore pari a 3 e la posizione corrente nel metodo iteratore viene mantenuta. Nell'iterazione successiva del ciclo, l'esecuzione nel metodo iteratore continua da dove è stata interrotta, arrestando di nuovo quando raggiunge un'istruzione yield return . Questa iterazione restituisce un valore pari a 5 e la posizione corrente nel metodo iteratore viene nuovamente mantenuta. Il ciclo viene completato quando viene raggiunta la fine del metodo iteratore.
static void Main()
{
foreach (int number in SomeNumbers())
{
Console.Write(number.ToString() + " ");
}
// Output: 3 5 8
Console.ReadKey();
}
public static System.Collections.IEnumerable SomeNumbers()
{
yield return 3;
yield return 5;
yield return 8;
}
Il tipo restituito di un metodo iteratore o get di un accessore può essere IEnumerable, IEnumerable<T>, IEnumerator, o IEnumerator<T>.
È possibile usare un'istruzione yield break per terminare l'iterazione.
Annotazioni
Per tutti gli esempi in questo argomento, ad eccezione dell'esempio Simple Iterator, includere direttive using per i System.Collections e System.Collections.Generic namespace.
Iteratore semplice
Nell'esempio seguente è presente una singola yield return istruzione all'interno di un ciclo for . In Mainogni iterazione del corpo dell'istruzione foreach crea una chiamata alla funzione iteratore, che procede con l'istruzione successiva yield return .
static void Main()
{
foreach (int number in EvenSequence(5, 18))
{
Console.Write(number.ToString() + " ");
}
// Output: 6 8 10 12 14 16 18
Console.ReadKey();
}
public static System.Collections.Generic.IEnumerable<int>
EvenSequence(int firstNumber, int lastNumber)
{
// Yield even numbers in the range.
for (int number = firstNumber; number <= lastNumber; number++)
{
if (number % 2 == 0)
{
yield return number;
}
}
}
Creazione di una classe di raccolta
Nell'esempio seguente la DaysOfTheWeek classe implementa l'interfaccia IEnumerable , che richiede un GetEnumerator metodo . Il compilatore chiama in modo implicito il GetEnumerator metodo , che restituisce un oggetto IEnumerator.
Il GetEnumerator metodo restituisce ogni stringa una alla volta usando l'istruzione yield return .
static void Main()
{
DaysOfTheWeek days = new DaysOfTheWeek();
foreach (string day in days)
{
Console.Write(day + " ");
}
// Output: Sun Mon Tue Wed Thu Fri Sat
Console.ReadKey();
}
public class DaysOfTheWeek : IEnumerable
{
private string[] days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
public IEnumerator GetEnumerator()
{
for (int index = 0; index < days.Length; index++)
{
// Yield each day of the week.
yield return days[index];
}
}
}
Nell'esempio seguente viene creata una Zoo classe contenente una raccolta di animali.
L'istruzione foreach che fa riferimento all'istanza della classe (theZoo) chiama in modo implicito il GetEnumerator metodo . Le istruzioni foreach che fanno riferimento alle proprietà Birds e Mammals usano il metodo iteratore denominato AnimalsForType.
static void Main()
{
Zoo theZoo = new Zoo();
theZoo.AddMammal("Whale");
theZoo.AddMammal("Rhinoceros");
theZoo.AddBird("Penguin");
theZoo.AddBird("Warbler");
foreach (string name in theZoo)
{
Console.Write(name + " ");
}
Console.WriteLine();
// Output: Whale Rhinoceros Penguin Warbler
foreach (string name in theZoo.Birds)
{
Console.Write(name + " ");
}
Console.WriteLine();
// Output: Penguin Warbler
foreach (string name in theZoo.Mammals)
{
Console.Write(name + " ");
}
Console.WriteLine();
// Output: Whale Rhinoceros
Console.ReadKey();
}
public class Zoo : IEnumerable
{
// Private members.
private List<Animal> animals = new List<Animal>();
// Public methods.
public void AddMammal(string name)
{
animals.Add(new Animal { Name = name, Type = Animal.TypeEnum.Mammal });
}
public void AddBird(string name)
{
animals.Add(new Animal { Name = name, Type = Animal.TypeEnum.Bird });
}
public IEnumerator GetEnumerator()
{
foreach (Animal theAnimal in animals)
{
yield return theAnimal.Name;
}
}
// Public members.
public IEnumerable Mammals
{
get { return AnimalsForType(Animal.TypeEnum.Mammal); }
}
public IEnumerable Birds
{
get { return AnimalsForType(Animal.TypeEnum.Bird); }
}
// Private methods.
private IEnumerable AnimalsForType(Animal.TypeEnum type)
{
foreach (Animal theAnimal in animals)
{
if (theAnimal.Type == type)
{
yield return theAnimal.Name;
}
}
}
// Private class.
private class Animal
{
public enum TypeEnum { Bird, Mammal }
public string Name { get; set; }
public TypeEnum Type { get; set; }
}
}
Uso di iteratori con un elenco generico
Nell'esempio seguente la Stack<T> classe generica implementa l'interfaccia IEnumerable<T> generica. Il Push metodo assegna valori a una matrice di tipo T. Il GetEnumerator metodo restituisce i valori della matrice usando l'istruzione yield return .
Oltre al metodo generico GetEnumerator , è necessario implementare anche il metodo non generico GetEnumerator . Questo perché IEnumerable<T> eredita da IEnumerable. L'implementazione non generica rinvia all'implementazione generica.
Nell'esempio vengono usati iteratori denominati per supportare vari modi di iterare la stessa raccolta di dati. Questi iteratori denominati sono le TopToBottom proprietà e BottomToTop e il TopN metodo .
La BottomToTop proprietà usa un iteratore in un get accessor.
static void Main()
{
Stack<int> theStack = new Stack<int>();
// Add items to the stack.
for (int number = 0; number <= 9; number++)
{
theStack.Push(number);
}
// Retrieve items from the stack.
// foreach is allowed because theStack implements IEnumerable<int>.
foreach (int number in theStack)
{
Console.Write("{0} ", number);
}
Console.WriteLine();
// Output: 9 8 7 6 5 4 3 2 1 0
// foreach is allowed, because theStack.TopToBottom returns IEnumerable(Of Integer).
foreach (int number in theStack.TopToBottom)
{
Console.Write("{0} ", number);
}
Console.WriteLine();
// Output: 9 8 7 6 5 4 3 2 1 0
foreach (int number in theStack.BottomToTop)
{
Console.Write("{0} ", number);
}
Console.WriteLine();
// Output: 0 1 2 3 4 5 6 7 8 9
foreach (int number in theStack.TopN(7))
{
Console.Write("{0} ", number);
}
Console.WriteLine();
// Output: 9 8 7 6 5 4 3
Console.ReadKey();
}
public class Stack<T> : IEnumerable<T>
{
private T[] values = new T[100];
private int top = 0;
public void Push(T t)
{
values[top] = t;
top++;
}
public T Pop()
{
top--;
return values[top];
}
// This method implements the GetEnumerator method. It allows
// an instance of the class to be used in a foreach statement.
public IEnumerator<T> GetEnumerator()
{
for (int index = top - 1; index >= 0; index--)
{
yield return values[index];
}
}
IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
public IEnumerable<T> TopToBottom
{
get { return this; }
}
public IEnumerable<T> BottomToTop
{
get
{
for (int index = 0; index <= top - 1; index++)
{
yield return values[index];
}
}
}
public IEnumerable<T> TopN(int itemsFromTop)
{
// Return less than itemsFromTop if necessary.
int startIndex = itemsFromTop >= top ? 0 : top - itemsFromTop;
for (int index = top - 1; index >= startIndex; index--)
{
yield return values[index];
}
}
}
Informazioni sulla sintassi
Un iteratore può verificarsi come metodo o get accessor. Un iteratore non può essere usato in un evento, un costruttore di istanza, un costruttore statico o un finalizzatore statico.
È necessario che esista una conversione implicita dal tipo di espressione nell'istruzione yield return all'argomento di tipo per l'oggetto IEnumerable<T> restituito dall'iteratore.
In C# un metodo iteratore non può avere parametri in, refo out .
In C# yield non è una parola riservata e ha un significato speciale solo quando viene usato prima di una return parola chiave o break .
Implementazione tecnica
Anche se si scrive un iteratore come metodo, il compilatore lo traduce in una classe nidificata che è, di fatto, una macchina a stati. Questa classe tiene traccia della posizione dell'iteratore finché il foreach ciclo nel codice client continua.
Per vedere le operazioni del compilatore, è possibile usare lo strumento Ildasm.exe per visualizzare il codice del linguaggio intermedio comune generato per un metodo iteratore.
Quando si crea un iteratore per una classe o uno struct, non è necessario implementare l'intera IEnumerator interfaccia. Quando il compilatore rileva l'iteratore, genera automaticamente i Currentmetodi , MoveNexte Dispose dell'interfaccia IEnumerator o IEnumerator<T> .
Ad ogni iterazione del ciclo foreach (o alla chiamata diretta a IEnumerator.MoveNext), il corpo del codice dell'iteratore riprende dopo l'istruzione precedente yield return. Continua quindi con l'istruzione successiva yield return fino al raggiungimento della fine del corpo dell'iteratore o fino a quando non viene rilevata un'istruzione yield break .
Gli iteratori non supportano il IEnumerator.Reset metodo . Per ribadire fin dall'inizio, è necessario ottenere un nuovo iteratore. La chiamata Reset all'iteratore restituito da un metodo iteratore genera un'eccezione NotSupportedException.
Per altre informazioni, vedere Specifica del linguaggio C#.
Uso di iteratori
Gli iteratori consentono di mantenere la semplicità di un foreach ciclo quando è necessario usare codice complesso per popolare una sequenza di elenco. Ciò può essere utile quando si desidera eseguire le operazioni seguenti:
Modificare l'ordine dell'elenco dopo la prima iterazione del ciclo
foreach.Evitare di caricare completamente un elenco di grandi dimensioni prima della prima iterazione di un
foreachciclo. Un esempio è un recupero paginato per caricare un gruppo di righe di tabella. Un altro esempio è il EnumerateFiles metodo , che implementa gli iteratori in .NET.Incapsulare la compilazione dell'elenco nell'iteratore. Nel metodo iteratore è possibile compilare l'elenco e quindi restituire ogni risultato in un ciclo.
Vedere anche
Collabora con noi su GitHub
L'origine di questo contenuto è disponibile in GitHub, in cui è anche possibile creare ed esaminare i problemi e le richieste pull. Per ulteriori informazioni, vedere la guida per i collaboratori.
