Enumeratory#
Enumerator to podobny koncept do iteratorów z C++. Enumerator to kursor działający w trybie “tylko do odczytu”, który pozwala na jednokierunkowe przeglądanie sekwencji wartości.
Żeby obiekt można było nazwać enumeratorem, musi on posiadać publiczną bezparametrową metodę bool MoveNext() i właściwość Current. Najczęściej implementuje się interfejs System.Collections.Generic.IEnumerator<T> (lub rzadziej System.Collections.IEnumerator), który dostarcza wspomnianą metodę i właściwość.
Definicja tych interfejsów wygląda następująco:
public interface IEnumerator
{
bool MoveNext();
object Current { get; }
void Reset();
}
public interface IEnumerator<out T> : IDisposable, IEnumerator
{
T Current { get; }
}Często metody Reset się nie implementuje, to jest rzuca ona wyjątek NotSupportedException.
Typ enumerowalny#
Typ enumerowalny to z kolei obiekt, który jest w stanie stworzyć nowy enumerator. Musi mieć publiczną metodę GetEnumerator(), która zwraca enumerator (może to być metoda rozszerzająca). I tu znów najczęściej implementuje się systemowy interfejs System.Collections.Generic.IEnumerable<T> (lub rzadziej System.Collections.IEnumerable).
public interface IEnumerable
{
IEnumerator GetEnumerator();
}
public interface IEnumerable<out T> : IEnumerable
{
IEnumerator<T> GetEnumerator();
}Pętla foreach#
Wszystkie systemowe kolekcje, tablice i stringi są enumerowalne. Wszystko, co jest enumerowalne, może być użyte wewnątrz pętli foreach:
List<int> collection = [1, 2, 3, 4, 5, 6, 7, 8];
foreach(int item in collection)
{
Console.WriteLine(item);
}Pętla foreach jest cukrem składniowym, kompilator przekształca tę instrukcję następująco:
List<int>.Enumerator enumerator = collection.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
var item = enumerator.Current;
Console.WriteLine(item);
}
}
finally
{
enumerator.Dispose();
}foreach opiera się na wzorcu: kompilator używa metody GetEnumerator dostępnej dla statycznego typu kolekcji. List<T> zwraca własny publiczny enumerator, strukturę List<T>.Enumerator, dzięki czemu nie ma alokacji na stercie ani wywołań przez interfejs. Gdyby kolekcja była znana tylko jako IEnumerable<int>, enumerator miałby typ IEnumerator<int>.
Metoda iterująca#
Korutyna to specjalny rodzaj funkcji, która ma zdolność do wstrzymania swojego działania w dowolnym momencie i zwrócenia kontroli do kodu, który ją wywołał, a następnie, po jakimś czasie, wznowienia działania.
Metody iterujące to jeden z dwóch przykładów korutyn w C#. Taka metoda musi zwracać IEnumerable<T> lub IEnumerator<T> (lub IEnumerable lub IEnumerator) i używać instrukcji yield. Taka metoda jest przez kompilator traktowana w szczególny sposób. Kompilator w jej miejsce tworzy maszynę stanów, która zapamiętuje stan iteracji, czyli zmienne lokalne oraz informację o miejscu wstrzymania.
public static IEnumerable<int> Fibonacci(int count)
{
for (int i = 0, prev = 1, curr = 1; i < count; i++)
{
yield return prev;
(prev, curr) = (curr, prev + curr);
}
}Taka maszyna stanów wygląda następująco dla tej metody:
[CompilerGenerated]
private sealed class <Fibonacci>d__1 : IEnumerable<int>, IEnumerable, IEnumerator<int>, IEnumerator, IDisposable
{
private int <>1__state;
private int <>2__current;
private int <>l__initialThreadId;
private int count;
public int <>3__count;
private int <i>5__1;
private int <prev>5__2;
private int <curr>5__3;
int IEnumerator<int>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
[return: Nullable(0)]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <Fibonacci>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
<>l__initialThreadId = Environment.CurrentManagedThreadId;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
}
private bool MoveNext()
{
int num = <>1__state;
if (num != 0)
{
if (num != 1)
{
return false;
}
<>1__state = -1;
int num2 = <curr>5__3;
int num3 = (<curr>5__3 = <prev>5__2 + <curr>5__3);
<prev>5__2 = num2;
<i>5__1++;
}
else
{
<>1__state = -1;
<i>5__1 = 0;
<prev>5__2 = 1;
<curr>5__3 = 1;
}
if (<i>5__1 < count)
{
<>2__current = <prev>5__2;
<>1__state = 1;
return true;
}
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
[DebuggerHidden]
IEnumerator<int> IEnumerable<int>.GetEnumerator()
{
<Fibonacci>d__1 <Fibonacci>d__;
if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
{
<>1__state = 0;
<Fibonacci>d__ = this;
}
else
{
<Fibonacci>d__ = new <Fibonacci>d__1(0);
}
<Fibonacci>d__.count = <>3__count;
return <Fibonacci>d__;
}
[DebuggerHidden]
IEnumerator IEnumerable.GetEnumerator()
{
return ((IEnumerable<int>)this).GetEnumerator();
}
}Samo wywołanie metody iterującej powoduje tylko stworzenie maszyny stanów - żaden fragment kodu metody nie jest jeszcze wykonywany. Kod metody iterującej jest wykonywany dopiero po wywołaniu MoveNext na enumeratorze - za każdym razem od miejsca, w którym został ostatnio wstrzymany. Obliczana jest następna wartość, instrukcja yield return zwraca obliczoną wartość przez zapis jej do właściwości Current i kontrola wraca do wywołującego.
Istnieje także instrukcja yield break, która również zwraca kontrolę do wywołującego, ale sprawia, że MoveNext zwraca false, oznaczając brak dalszych elementów.
public static IEnumerable<int> Fibonacci(int count)
{
for (int i = 0, prev = 1, curr = 1; i < count; i++)
{
if (i > 45) yield break;
yield return prev;
(prev, curr) = (curr, prev + curr);
}
}Kompozycja metod iterujących#
Metody iterujące można ze sobą składać. Załóżmy, że mamy dwie metody:
public static IEnumerable<int> Fibonacci(int n)
{
int current = 0, next = 1;
for (int i = 0; i < n; i++)
{
yield return current;
(current, next) = (next, current + next);
}
}
public static IEnumerable<int> Odds(IEnumerable<int> sequence)
{
foreach (var item in sequence)
{
if (item % 2 == 1) yield return item;
}
}Można je ze sobą składać w następujący sposób:
var sequence = Odds(Fibonacci(10));
Console.WriteLine("Odd elements of the fibonacci sequence:");
foreach (var item in sequence)
{
Console.WriteLine(item);
}Przepływ kontroli przedstawia diagram sekwencji:
sequenceDiagram
participant Main
participant Odds
participant Fibonacci
activate Main
Main->>Odds: MoveNext()
deactivate Main
activate Odds
Odds->>Fibonacci: MoveNext()
deactivate Odds
activate Fibonacci
Fibonacci->>Odds: 0
deactivate Fibonacci
activate Odds
Odds->>Fibonacci: MoveNext()
deactivate Odds
activate Fibonacci
Fibonacci->>Odds: 1
deactivate Fibonacci
activate Odds
Odds->>Main: 1
deactivate Odds
activate Main
Main->>Odds: MoveNext()
deactivate Main
activate Odds
Odds->>Fibonacci: MoveNext()
deactivate Odds
activate Fibonacci
Fibonacci->>Odds: 1
deactivate Fibonacci
activate Odds
Odds->>Main: 1
deactivate Odds
activate Main
Main->>Odds: MoveNext()
deactivate Main
activate Odds
Odds->>Fibonacci: MoveNext()
deactivate Odds
activate Fibonacci
Fibonacci->>Odds: 2
deactivate Fibonacci
activate Odds
Odds->>Fibonacci: MoveNext()
deactivate Odds
activate Fibonacci
Fibonacci->>Odds: 3
deactivate Fibonacci
activate Odds
Odds->>Main: 3
deactivate Odds
activate Main
Main->>Odds: ...
deactivate MainMetoda Odds jest filtrem dla sekwencji Fibonacci, na tej zasadzie opiera się większość metod LINQ.
Kod źródłowy - IteratorMethods
Implementacja własnego typu enumerowalnego#
Żeby nasz własny typ był enumerowalny, najprościej jest zaimplementować interfejs IEnumerable<T>. Najczęściej metodę GetEnumerator implementuje się jako iterującą z wykorzystaniem instrukcji yield.
public class Stack<T> : IEnumerable<T>
{
private T[] _items = new T[8];
public int Count { get; private set; }
public void Push(T item)
{
if (_items.Length == Count)
{
Array.Resize(ref _items, _items.Length * 2);
}
_items[Count++] = item;
}
public T Pop()
{
if (Count == 0)
{
throw new InvalidOperationException("Stack is empty");
}
return _items[--Count];
}
public IEnumerator<T> GetEnumerator()
{
int count = Count;
while (count-- > 0)
{
yield return _items[count];
}
}
IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
}Takiego enumerowalnego stosu z powodzeniem można użyć w instrukcji foreach:
Stack<string> stack = new Stack<string>();
stack.Push("The");
stack.Push("quick");
stack.Push("brown");
stack.Push("fox");
stack.Push("jumps");
stack.Push("over");
stack.Push("the");
stack.Push("lazy");
stack.Push("dog");
foreach (var str in stack)
{
Console.WriteLine(str);
}Kod źródłowy - EnumerableStack