日: 2012年7月27日

小ネタだ（しかし、重要）。
書いたクエリはすぐには実行されず、列挙を行った時点（おおよそ、IEnumerable<T>.GetEnumerator()を呼び出した時点）で、実際にクエリが評価される。LINQメソッドの中には、その場で評価が実行されるものもある。例えば、ToList()がそうだ。

// 何の抽出かな？
int[] years = new int[] { ... };
IEnumerable<int> query =
    from year in years
    // letはクエリ内の一時変数のようなもの。
    // SQL Serverのクエリなら、同じ式を多量に記述してもクエリオプティマイザが検出して重複を取り除くが、
    // LINQ（LINQ to Object）はそこまでやらないので、letを使うと良い場合がある。
    // （ここではそのような深い意味はない）
    let mod4 = (year % 4) == 0
    let mod100 = (year % 100) == 0
    let mod400 = (year % 400) == 0
    where mod400 || (!mod100 && mod4)
    select year;

// クエリを実行してList<T>に格納する
List<int> leapYears = query.ToList();

ToList()の部分は、以下のような事をしている。

List<int> leapYears = new List<int>();
foreach (int value in query)
{
    leapYears.Add(value);
}

あるいは、もっとこう。

List<int> leapYears = new List<int>(query);

後者ならかなり短く記述出来るわけだが、ToList()を使う利点は、LINQのメソッド連結式の延長上で書けるからだ。例えば、

// 2000年より前のうるう年を昇順にしてList<int>に入れて返す
List<int> results =
    // メソッド連結式（Where()とOrderBy()はデリゲートで評価結果を得る。最後にToList()する）
    query.Where(delegate(value) { return value < 2000; }).
        OrderBy(delegate(value) { return value; }).
        ToList();

もちろん、ToList()のところを、new List<int>(…)と書いたって良いのだが、Visual Studio上でこれを書けば、何を言っているのか分かると思う。要するに「すらすら書ける」ということだ。

さて、「すらすら書く」ためには、LINQの標準メソッド群でも、やや不足を感じることがある。
例えば、ToDictionary()を使えば、Dictionary<T, U>に変換できるのだが、SortedDictionaryが欲しい場合には、ToSortedDictionary()なるものを期待しても、そういうメソッドはない。
某サイトでは、一旦ToDictionary()で辞書を生成した後、SortedDictionaryのコンストラクタに渡して生成する例が掲載されていた。しかし、それではDictionaryは完全に無駄だ。Dictionaryは内部でハッシュコード取得と分散を行っているはずなので、そのコストはドブに捨てる事になる。そして、やはりすらすらとは書けない。

そこで、無いものは作ってしまえ、と。

// staticクラスでなければならない
public static class CollectionExtensions
{
    // staticメソッドの第一引数にthisを付けることで、「拡張メソッド」となる。
    // Func<V, T>はジェネリックデリゲートで、V型引数を取り、T型を返すメソッドを受け入れる
    public static SortedDictionary<T, U> ToSortedDictionary<T, U, V>(
        this IEnumerable<V> enumerable,
        Func<V, T> keySelector, Func<V, U> valueSelector)
    {
        // 入れ物を作って...
        SortedDictionary<T, U> dictionary = new SortedDictionary<T, U>();

        // 列挙しながらセレクタを通してキーと値を取得して格納
        foreach (V entry in enumerable)
        {
            dictionary.Add(keySelector(entry), valueSelector(entry));
        }
        return dictionary;
    }
}

セレクタとして受け入れるデリゲートの部分は、.NET 2.0世代の知識では少し理解が厳しいかもしれない。まず、ToDictionary()がどのように使われるのかを確認しておく。

// 適当な数列
int[] values = new int[] { ...};
// 数列を文字列化したものとペアで保存する
Dictionary<int, string> results =
    // 条件式がなくても全く問題なし
    (from value in values
    // 匿名クラスを使って、一時的にクラスに値を保存する
     select new { Arg1 = value, Arg2 = value.ToString() }).
    // 匿名クラスから値を取り出してDictionaryにする。
    // "entry"は、式内でのみ有効な引数（上の匿名クラスのインスタンスが渡って来る）
    ToDictionary(delegate(entry) { return entry.Arg1; }, delegate(entry) { return entry.Arg2; });

匿名クラスというのは、名前の無い、初期化だけが出来るクラスの事で、new 文の後ろのブロックで読み取り専用フィールドを定義・生成出来る。上記ではArg1とArg2を宣言して、それぞれ値を代入した。
匿名クラスには名前がないので、コード上で型名を書くことが出来ない。しかし、上の式を見れば、巧妙にクラス名を避けている事が分かる（ここから、何故”var”が必要になったかが分かれば、良い洞察だ :-)
そして、今やToSortedDictionary()という武器が手に入ったので、以下のように書けばよい。

SortedDictionary<int, string> results =
    (from value in values
     select new { Arg1 = value, Arg2 = value.ToString() }).
    ToSortedDictionary(delegate(entry) { return entry.Arg1; }, delegate(entry) { return entry.Arg2; });

晴れて、イメージ通りのToSortedDictionary()が得られた。
しかし、私はToDictionary()にもやや納得が行かない部分があった。一旦匿名クラスに値を入れ、その後セレクタを使って再度辞書に入れ直すという部分だ。どうもスマートじゃない。
無い道具は作ってしまえ、と。

// 初めからKeyValuePairでいいじゃん？
public static SortedDictionary<T, U> ToSortedDictionary<T, U>(
    this IEnumerable<KeyValuePair<T, U>> enumerable)
{
    // 入れ物を作って...
    SortedDictionary<T, U> dictionary = new SortedDictionary<T, U>();

    // 列挙しながらそのまま格納
    foreach (KeyValuePair&lt;T, U&gt;  entry in enumerable)
    {
        dictionary.Add(entry.Key, entry.Value);
    }
    return dictionary;
}

そうすると、クエリ側にはKeyValuePairを書かなければならなくなる。これをどう捉えるかだが、直後に辞書に入れると分かっているなら、KeyValuePairで生成した方がすっきりするのが私流。

SortedDictionary<int, string> results =
    (from value in values
     select new KeyValuePair<int, string>(value, value.ToString())).
    ToSortedDictionary();

言わずもがな、ToDictionary()にも同じものが作れるよね？
し・か・も！ この拡張メソッドはIEnumerable<KeyValuePair<T, U>>を実装する、全てのクラスで使えるのだ。それはつまり、Dictionary<T, U>とSortedDictionary<T, U>そのものだ。

Dictionary<int, string> hashed = new Dictionary<int, string>();

// .. 辞書にいろいろ追加

// DictionaryをSortedDictionaryに変換
SortedDictionary<int, string> sorted = hashed.ToSortedDictionary();

// SortedDictionaryをDictionaryに変換
Dictionary<int, string> dictionary = sorted.ToDictionary();

もちろん、辞書じゃなくてもOKだ。

// IEnumerable<KeyValuePair<T, U>>を実装していればいいのだから...
List<KeyValuePair<int, string>> list = new List<KeyValuePair<int, string>>();

// ..

// ListをSortedDictionaryに変換
SortedDictionary<int, string> sorted = list.ToSortedDictionary();

// ListをDictionaryに変換
Dictionary<int, string> dictionary = list.ToDictionary();

なんだか、色々な事に使えそうな気がして来ないだろうか？
つづく