イテレータ

概要

C# の foreach 構文は、コレクションクラスの利用者側から見ると非常に便利な機能です。しかしながら、実装側から見た場合、IEnumerableやIEnumeratorインタフェースを実装する必要があり、結構面倒な作業が必要でした。

この実装側の労力を軽減するために、C# 2.0ではイテレータ構文というものが追加されました。

イテレータブロック

クラス中にイテレータブロック（iterator block）と言うものを定義することで、foreach 文で利用可能なコレクションクラスを簡単に実装することができます。イテレータブロックは、以下のように、一見すると通常のメソッドと似ています。

using System.Collections.Generic;

class TestEnumerable
{
  // ↓これがイテレータブロック。IEnubrable を実装するクラスを自動生成してくれる。
  static public IEnumerable<int> FromTo(int from, int to)
  {
    while(from <= to)
      yield return from++;
  }

  static void Main(string[] args)
  {
    // ↓こんな感じで使う。
    foreach(int i in FromTo(10, 20))
    {
      Console.Write("{0}\n", i);
    }
  }
}

メソッドとの違いは以下の通りです。

戻り値の型が以下のうちのいずれか
- System.Collections.IEnumerator
- System.Collections.Generic.IEnumerator<T>
- System.Collections.IEnumerable
- System.Collections.Generic.IEnumerable<T>
return の変わりに yield return というキーワードを使う。
break の変わりに yield break というキーワードを使う。

上述の例の通り、イテレータブロック中で、yield return 文ば呼ばれるたびに、 foreach 文中で使われる値を1つ得ます。 for 文や while 文を使わず、ベタに yield return を並べても OK です。

static public IEnumerable GetEnumerable(int from, int to)
{
  yield return 1;
  yield return 3.14;
  yield return "文字列";
  yield return new System.Drawing.Point(1, 2);
  yield return 1.0f;
}

イテレータブロックは静的（static）なものでもインスタンス（非 static）でも、どちらでも定義できます。また、プロパティ風の記述も可能です。上述の例は static なメソッドですが、以下のような非 static なプロパティ風の定義も可能です。

class FromTo
{
  int from, to;
  public FromTo(int from, int to){this.from = from; this.to = to;}

  public IEnumerable<int> Enumerable
  {
    get
    {
      while(from <= to)
        yield return from++;
    }
  }
}

  static void Main(string[] args)
  {
    foreach(int i in new FromTo(10, 20).Enumerable)
    {
      Console.Write("{0}\n", i);
    }
  }
}

GetEnumerator

「コレクションクラスの自作」で説明したように、通常、foreach 文で利用できるコレクションクラスを自作するには、 IEnumerable インタフェースを継承し、 GetEnumerator メソッドをオーバーライドします。

C# 2.0 ではこのような方法の他に、 GetEnumerator と言う名前のイテレータブロックを定義することでもコレクションクラスを作成できます。ここでは、「ジェネリクス」で例に挙げた Stack クラスにイテレータを追加してみましょう。

class Stack<Type>
{
  Type[] buf;
  int top;
  public Stack(int max) { this.buf = new Type[max]; this.top = 0; }
  public void Push(Type item) { this.buf[this.top++] = item; }
  public Type Pop() { return this.buf[--this.top]; }

  public IEnumerator<Type> GetEnumerator()
  {
    for (int i = this.top - 1; i >= 0; --i)
      yield return buf[i];
  }
}

サンプル

「foreach」で挙げた例を、ジェネリックスとイテレータを用いて書き直してみます。

using System;
using System.Collections.Generic;

/// <summary>
/// 片方向連結リストクラス
/// </summary>
class LinearList<T>
{
  /// <summary>
  /// 連結リストのセル
  /// </summary>
  private class Cell
  {
    public T value;
    public Cell next;

    public Cell(T value, Cell next)
    {
      this.value = value;
      this.next = next;
    }
  }

  private Cell head;

  public LinearList()
  {
    this.head = null;
  }

  /// <summary>
  /// リストに新しい要素を追加
  /// </summary>
  public void Add(T value)
  {
    this.head = new Cell(value, head);
  }

  /// <summary>
  /// 列挙子を取得
  /// </summary>
  public IEnumerator<T> GetEnumerator()
  {
    for(Cell c = this.head; c != null; c = c.next)
    {
      yield return c.value;
    }
  }
}

class ForeachSample
{
  static void Main()
  {
    LinearList<int> list = new LinearList<int>();

    for(int i=0; i<10; ++i)
    {
      list.Add(i * (i + 1) / 2);
    }

    foreach(int s in list)
    {
      Console.Write(s + " ");
    }
  }
}

45 36 28 21 15 10 6 3 1 0