LINQ

【C#】LINQと変数の使い方完全攻略：let句とvar型推論でクエリを最適化

2025-05-20更新日: 2025-05-20

C#のLINQではクエリ内で使う変数が結果の可読性と性能を左右します。

from句の範囲変数は各要素を示し、let句で派生値を一時保存できます。

メソッド構文ならvar推論で型を省略でき、Select内で匿名型を返すと複数値をまとめられます。

遅延実行の性質により変数をループ外で再評価しない点に注意が必要です。

目次から探す

LINQにおける変数の役割
- 範囲変数の基本
- let句の目的
var型推論の基礎
let句の詳細
スコープとキャプチャ
遅延実行と評価タイミング
- IEnumerableとIQueryableの違い
- 外部変数の変化に伴う影響
パターン別サンプル
エラーパターン
スタイルチェックリスト
まとめ

LINQにおける変数の役割

LINQ(Language Integrated Query)を使う際に重要なポイントの一つが「変数の使い方」です。

特にクエリ構文で使われる範囲変数や、let句で導入する一時変数は、クエリの可読性やパフォーマンスに大きく影響します。

ここでは、LINQにおける変数の役割について詳しく解説いたします。

範囲変数の基本

LINQのクエリ構文では、from句で指定した変数を「範囲変数」と呼びます。

範囲変数は、データソースの各要素を表し、クエリ内でその要素にアクセスするための名前として使います。

範囲変数の理解は、LINQの基本を押さえるうえで欠かせません。

from句と範囲変数

from句はLINQクエリの出発点であり、データソースの各要素を順に取り出す役割を持ちます。

from句の後に続く変数名が範囲変数です。

範囲変数は、その後のwhere句やselect句などで使われ、データのフィルタリングや投影に利用されます。

例えば、以下のコードをご覧ください。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        var numbers = new List<int> { 1, 2, 3, 4, 5 };
        // from句で範囲変数numを定義し、偶数を抽出
        var evenNumbers = from num in numbers
                          where num % 2 == 0
                          select num;
        foreach (var n in evenNumbers)
        {
            Console.WriteLine(n);
        }
    }
}

2
4

この例では、numが範囲変数です。

numbersコレクションの各要素をnumに代入し、where句で偶数かどうかを判定しています。

範囲変数は、クエリの中でその要素を参照するための名前として機能します。

範囲変数は、クエリのスコープ内でのみ有効であり、同じクエリ内で複数のfrom句を使う場合は、それぞれ別の範囲変数を使う必要があります。

ラムダ式の引数名との違い

LINQにはクエリ構文のほかにメソッド構文もあり、こちらではラムダ式を使ってデータ操作を行います。

ラムダ式の引数名は範囲変数と似ていますが、役割やスコープに違いがあります。

例えば、先ほどの偶数抽出をメソッド構文で書くと以下のようになります。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        var numbers = new List<int> { 1, 2, 3, 4, 5 };
        // ラムダ式の引数numを使って偶数を抽出
        var evenNumbers = numbers.Where(num => num % 2 == 0);
        foreach (var n in evenNumbers)
        {
            Console.WriteLine(n);
        }
    }
}

2
4

ここでのnumはラムダ式の引数名であり、Whereメソッドに渡される匿名関数のパラメータです。

範囲変数と同様に、コレクションの各要素を表しますが、ラムダ式のスコープ内でのみ有効です。

範囲変数はクエリ構文の一部として使われ、SQLのような直感的な記述が可能です。

一方、ラムダ式の引数名はメソッドチェーンの中で使われ、より柔軟な操作が可能です。

どちらも要素を表す変数ですが、構文の違いにより使い分けられます。

let句の目的

LINQのクエリ構文にはlet句という便利な機能があります。

let句は、クエリ内で一時的な変数を定義し、計算結果を保存するために使います。

これにより、同じ計算を繰り返すことを避け、コードの可読性を高めることができます。

再計算の防止

let句を使う最大のメリットは、同じ計算を何度も繰り返さずに済むことです。

例えば、ある複雑な計算結果を複数の場所で使いたい場合、let句で一度計算して変数に代入しておくと、パフォーマンスの向上につながります。

以下の例をご覧ください。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        var words = new List<string> { "apple", "banana", "cherry" };
        // let句で単語の長さを一時変数lengthに保存
        var query = from word in words
                    let length = word.Length
                    where length > 5
                    select new { Word = word, Length = length };
        foreach (var item in query)
        {
            Console.WriteLine($"{item.Word} は長さ {item.Length} です。");
        }
    }
}

banana は長さ 6 です。
cherry は長さ 6 です。

この例では、word.Lengthの計算結果をlengthという一時変数に保存しています。

where句とselect句の両方でlengthを使うため、word.Lengthを2回計算する必要がなくなります。

これにより、計算コストが削減され、コードも読みやすくなります。

可読性向上

let句は、複雑な式を分割して名前を付けることで、クエリの可読性を大幅に向上させます。

特に長い式やネストした計算を扱う場合、let句を使うことで処理の意味が明確になり、メンテナンスしやすくなります。

例えば、以下のような例を考えてみましょう。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        var products = new List<(string Name, decimal Price, int Quantity)>
        {
            ("Pen", 120m, 10),
            ("Notebook", 250m, 5),
            ("Eraser", 80m, 20)
        };
        // let句で合計金額を計算し、一時変数totalPriceに保存
        var query = from product in products
                    let totalPrice = product.Price * product.Quantity
                    where totalPrice > 1000m
                    select new { product.Name, totalPrice };
        foreach (var item in query)
        {
            Console.WriteLine($"{item.Name} の合計金額は {item.totalPrice} 円です。");
        }
    }
}

Pen の合計金額は 1200 円です。

この例では、product.Price * product.Quantityという計算をlet句でtotalPriceに代入しています。

これにより、where句とselect句で同じ計算を繰り返すことなく、コードの意味が明確になります。

let句を使わずに同じ処理を書くと、計算式が複数回現れてしまい、可読性が低下しやすいです。

let句はこうした問題を解決し、クエリの構造を整理するのに役立ちます。

var型推論の基礎

C#のvarキーワードは、変数宣言時に型を明示せずにコンパイラに型を推論させる機能です。

LINQのクエリ結果や匿名型を扱う際に特に便利で、コードの簡潔化や柔軟なデータ操作を実現します。

型決定の仕組み

varを使うと、コンパイラが右辺の式から変数の型を自動的に推論します。

例えば、以下のコードではnumbersの型はList<int>であり、varを使うことで明示的にList<int>と書かなくても同じ意味になります。

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        var numbers = new List<int> { 1, 2, 3 };
        Console.WriteLine(numbers.GetType());
    }
}

System.Collections.Generic.List`1[System.Int32]

このように、varはコンパイル時に右辺の型を解析し、変数の型を決定します。

型が推論できない場合や、右辺がnullの場合はコンパイルエラーになります。

LINQのクエリでは、特に匿名型を返す場合に型名が存在しないため、varが必須となります。

例えば、

var query = from num in numbers
            select new { Number = num, Square = num * num };

このqueryの型は匿名型のシーケンスであり、明示的に型を書くことができません。

varを使うことで匿名型を扱うことが可能になります。

varを使うメリット

コードの簡潔化

varを使うことで、冗長な型宣言を省略でき、コードがすっきりします。

特に長い名前空間や複雑な型を扱う場合に効果的です。

// 明示的な型宣言
Dictionary<string, List<int>> dict = new Dictionary<string, List<int>>();
// varを使った宣言
var dict = new Dictionary<string, List<int>>();

後者の方が読みやすく、記述量も減ります。

LINQのクエリ結果も複雑な型になることが多いため、varを使うことでコードの可読性が向上します。

匿名型との連携

匿名型は名前のない型であり、通常の型宣言では扱えません。

varは匿名型を受け取る唯一の方法です。

var person = new { Name = "Alice", Age = 30 };
Console.WriteLine($"{person.Name} は {person.Age} 歳です。");

匿名型のプロパティにアクセスできるのはvarで型推論された変数だけです。

これにより、匿名型を使った柔軟なデータ構造の操作が可能になります。

varを使わない場面

可読性の懸念

varは便利ですが、使いすぎると変数の型が一目でわからず、コードの可読性が低下することがあります。

特に右辺の式が複雑で型が推論しにくい場合や、初見のコードで型を把握しづらい場合は、明示的に型を書く方が望ましいです。

// 可読性が低い例
var result = SomeComplexMethodCall();
// 明示的に型を書く例
List<string> result = SomeComplexMethodCall();

このように、変数の型がすぐにわかる方がメンテナンスしやすいケースもあります。

API設計時の考慮

公開APIの設計やライブラリ開発では、明示的な型宣言が推奨されます。

varはローカル変数の型推論に限定されており、メソッドの戻り値やパラメータの型には使えません。

APIの利用者が型を明確に理解できるように、公開インターフェースでは型を明示することが重要です。

また、APIのドキュメント生成や型安全性の観点からも、明示的な型指定が望まれます。

varはあくまでローカルスコープ内の利便性向上のための機能であることを意識しましょう。

let句の詳細

LINQのlet句は、クエリ式の中で一時的な変数を定義し、計算結果を保存するために使います。

これにより、同じ計算を繰り返すことを防ぎ、クエリの可読性やパフォーマンスを向上させることが可能です。

基本構文

let句はfrom句やwhere句の間に挿入して使います。

構文は以下のようになります。

from <範囲変数> in <データソース>
let <一時変数> = <式>
where <条件>
select <結果>

一時変数の導入

let句を使うと、計算結果を一時変数に代入してクエリ内で再利用できます。

例えば、文字列の長さを一時変数に保存し、複数の場所で使う例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        var words = new List<string> { "apple", "banana", "cherry" };
        var query = from word in words
                    let length = word.Length  // 一時変数lengthに文字列長を保存
                    where length > 5          // lengthを使ってフィルタリング
                    select new { Word = word, Length = length };
        foreach (var item in query)
        {
            Console.WriteLine($"{item.Word} は長さ {item.Length} です。");
        }
    }
}

banana は長さ 6 です。
cherry は長さ 6 です。

この例では、word.Lengthの計算をlengthに一度だけ行い、where句とselect句で使い回しています。

これにより、同じ計算を繰り返すことを防ぎ、コードの効率と可読性が向上します。

複数let句の連鎖

let句は複数連続して使うことも可能です。

複雑な計算を段階的に分割し、名前を付けて整理できます。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        var numbers = new List<int> { 1, 2, 3, 4, 5 };
        var query = from num in numbers
                    let square = num * num               // 1段階目の計算
                    let cube = square * num              // 2段階目の計算
                    where cube > 10
                    select new { Number = num, Square = square, Cube = cube };
        foreach (var item in query)
        {
            Console.WriteLine($"{item.Number} の2乗は {item.Square}、3乗は {item.Cube} です。");
        }
    }
}

3 の2乗は 9、3乗は 27 です。
4 の2乗は 16、3乗は 64 です。
5 の2乗は 25、3乗は 125 です。

このように、let句を連鎖させることで、複雑な計算を段階的に分けて扱えます。

各一時変数はクエリ内でスコープを持ち、後続のlet句やwhere句、select句で利用可能です。

パフォーマンス影響

再評価回避

let句を使うことで、同じ式の再評価を防げます。

例えば、計算コストの高い処理を複数回呼び出す代わりに、一度だけ計算して結果を変数に保存します。

これにより、パフォーマンスが向上します。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static int ExpensiveCalculation(int x)
    {
        Console.WriteLine($"計算中: {x}");
        return x * x;
    }
    static void Main()
    {
        var numbers = new List<int> { 2, 3, 4 };
        var query = from num in numbers
                    let square = ExpensiveCalculation(num)  // 一度だけ計算
                    where square > 5
                    select new { num, square };
        foreach (var item in query)
        {
            Console.WriteLine($"{item.num} の2乗は {item.square} です。");
        }
    }
}

計算中: 2
計算中: 3
計算中: 4
3 の2乗は 9 です。
4 の2乗は 16 です。

ExpensiveCalculationは各要素に対して一度だけ呼ばれています。

もしlet句を使わずにwhere句とselect句で同じ計算を繰り返すと、計算が複数回実行されてしまいます。

メモリ負荷の削減

let句で一時変数を使うと、計算結果を保持するためのメモリが必要になりますが、同時に計算の重複を防ぐため、全体としては効率的です。

特に大規模なデータセットや複雑な計算を扱う場合、let句の活用はパフォーマンスとメモリ使用のバランスを取るうえで有効です。

他構文との比較

let句とSelect新投影

let句はクエリ構文の一部ですが、同じ処理はメソッド構文のSelectメソッドを使って実現できます。

Selectで中間結果を新しい匿名型に投影し、次の処理に渡す方法です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        var words = new List<string> { "apple", "banana", "cherry" };
        var query = words
                    .Select(word => new { Word = word, Length = word.Length })  // let句の代わり
                    .Where(x => x.Length > 5)
                    .Select(x => new { x.Word, x.Length });
        foreach (var item in query)
        {
            Console.WriteLine($"{item.Word} は長さ {item.Length} です。");
        }
    }
}

banana は長さ 6 です。
cherry は長さ 6 です。

この例では、Selectで一時的な匿名型を作成し、Lengthを計算して保存しています。

let句と同様の役割を果たしますが、メソッドチェーンの形で記述されます。

let句とメソッドチェーン

let句はクエリ構文の中で一時変数を定義するのに対し、メソッド構文ではSelectを使って中間結果を新しい型に投影し、次の処理に渡します。

両者は機能的に等価ですが、書き方や可読性に違いがあります。

特徴	let句(クエリ構文)	Select(メソッド構文)
書き方	SQLライクで直感的	メソッドチェーンで柔軟
一時変数の定義	`let`句で明示的に定義	`Select`で匿名型に投影
可読性	複雑なクエリで読みやすい	小規模な処理や動的なチェーンに適している
匿名型の扱い	可能	可能
パフォーマンス	同等	同等

用途や好みに応じて使い分けると良いでしょう。

クエリ構文に慣れている場合はlet句が自然で、メソッド構文に慣れている場合はSelectを使った中間投影が使いやすいです。

スコープとキャプチャ

LINQを使う際に理解しておきたい重要なポイントの一つが「スコープ」と「変数のキャプチャ」です。

特にクエリ式(クエリ構文)とラムダ式(メソッド構文)ではスコープの扱いに違いがあり、これが原因で意図しない動作やバグが発生することがあります。

クエリ式とラムダ式のスコープ差

クエリ式(fromやletなどを使う構文)とラムダ式(WhereやSelectなどのメソッドチェーンで使う匿名関数)では、範囲変数のスコープの扱いが異なります。

クエリ式では、各from句やlet句で定義された変数は、そのクエリの中で新しいスコープを持ちます。

つまり、同じ名前の変数を別のfrom句で再定義しても、それぞれ独立した変数として扱われます。

一方、ラムダ式では、外側の変数を内部の匿名関数が「キャプチャ」します。

キャプチャされた変数は、ラムダ式が実行される時点の変数の状態に依存します。

これが原因で、ループ内でラムダ式を作成すると、すべてのラムダ式が同じ変数を参照してしまうことがあります。

この違いを理解しないと、特にループ内でのクエリ作成時に意図しない結果を招くことがあります。

ループ変数キャプチャ問題

バグを生むコード例

以下のコードは、ループ内でラムダ式を作成し、そのラムダ式を使ってフィルタリングを行う例です。

しかし、期待した結果にならず、すべてのラムダ式が最後のループ変数の値を参照してしまいます。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        var numbers = new List<int> { 1, 2, 3 };
        var predicates = new List<Func<int, bool>>();
        // ループ内でラムダ式を作成し、リストに追加
        for (int i = 0; i < numbers.Count; i++)
        {
            predicates.Add(x => x == numbers[i]);
        }
        // 各ラムダ式でフィルタリングを試みる
        foreach (var predicate in predicates)
        {
            var filtered = numbers.Where(predicate);
            Console.WriteLine(string.Join(", ", filtered));
        }
    }
}

3
3
3

期待される出力はそれぞれ「1」「2」「3」ですが、実際にはすべて「3」となっています。

これは、ラムダ式がループ変数iをキャプチャしており、ループ終了後のiの値(3)を参照しているためです。

修正パターン

この問題を解決するには、ループ内でキャプチャする変数を新たに作成し、その変数をラムダ式に渡す方法があります。

こうすることで、各ラムダ式が独立した変数を参照するようになります。

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        var numbers = new List<int> { 1, 2, 3 };
        var predicates = new List<Func<int, bool>>();

        // ループ内でラムダ式を作成し、リストに追加
        for (int i = 0; i < numbers.Count; i++)
        {
            // ここでループ変数 i の値をローカル変数 currentIndex にコピーする
            int currentIndex = i;
            predicates.Add(x => x == numbers[currentIndex]);
        }

        // 各ラムダ式でフィルタリングを試みる
        foreach (var predicate in predicates)
        {
            var filtered = numbers.Where(predicate);
            Console.WriteLine(string.Join(", ", filtered));
        }
    }
}

1
2
3

このように、currentという新しい変数を作ることで、各ラムダ式がそれぞれの値を正しくキャプチャし、期待通りの動作になります。

非同期クエリでの注意

非同期処理とLINQを組み合わせる場合も、変数のスコープとキャプチャに注意が必要です。

特にasyncメソッド内でループを回しながら非同期にクエリを作成・実行する場合、キャプチャされた変数の値が変わってしまうことがあります。

例えば、非同期ループ内で変数をキャプチャしたままawaitを使うと、ループ変数の値が変わってしまい、意図しない結果になることがあります。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
class Program
{
    static async Task Main()
    {
        var numbers = new List<int> { 1, 2, 3 };
        var tasks = new List<Task>();
        for (int i = 0; i < numbers.Count; i++)
        {
            // ループ変数をキャプチャしたまま非同期処理を開始
            tasks.Add(Task.Run(async () =>
            {
                await Task.Delay(100);
                Console.WriteLine(numbers[i]);
            }));
        }
        await Task.WhenAll(tasks);
    }
}

このコードはコンパイルエラーになります。

iはループ変数であり、ラムダ式内でキャプチャされているため、非同期処理のタイミングで値が変わる可能性があるためです。

修正するには、ループ内で新しい変数に代入してからキャプチャします。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
class Program
{
    static async Task Main()
    {
        var numbers = new List<int> { 1, 2, 3 };
        var tasks = new List<Task>();
        for (int i = 0; i < numbers.Count; i++)
        {
            int current = i;  // 新しい変数に代入
            tasks.Add(Task.Run(async () =>
            {
                await Task.Delay(100);
                Console.WriteLine(numbers[current]);
            }));
        }
        await Task.WhenAll(tasks);
    }
}

1
2
3

このように、非同期処理でも変数のキャプチャに注意し、ループ変数を新しい変数に代入してから使うことが重要です。

これにより、意図しない値の参照やバグを防げます。

遅延実行と評価タイミング

LINQのクエリは基本的に「遅延実行(Lazy Evaluation)」の仕組みを持っています。

これは、クエリを定義した時点では実際の処理は行われず、データが必要になったタイミングで初めて実行されることを意味します。

遅延実行の理解は、LINQの動作やパフォーマンスを正しく把握するうえで非常に重要です。

IEnumerableとIQueryableの違い

LINQの遅延実行は、主にIEnumerable<T>とIQueryable<T>という2つのインターフェースで異なる挙動を示します。

IEnumerable<T>

主にメモリ上のコレクションに対して使われます。

クエリはC#のコードとして実行され、遅延実行されます。

実際に列挙(foreachなど)されるまで処理は行われません。

例：List<T>, Arrayなど。

IQueryable<T>

主にデータベースやリモートのデータソースに対して使われます。

クエリは式ツリーとして表現され、実行時にデータソースに最適化されたクエリ(例：SQL)に変換されます。

こちらも遅延実行ですが、実行タイミングや最適化の仕組みが異なります。

例：Entity FrameworkのDbSet<T>。

この違いにより、IEnumerable<T>はメモリ内での操作が中心で、IQueryable<T>は外部データソースへの問い合わせに適しています。

どちらも遅延実行ですが、IQueryable<T>はクエリの翻訳や最適化が加わるため、実行タイミングやパフォーマンスに影響を与えます。

外部変数の変化に伴う影響

LINQのクエリは遅延実行のため、クエリ定義時ではなく実行時に外部変数の値を参照します。

これにより、クエリ実行前後で外部変数の値が変わると、結果が変化することがあります。

実行前後の値変化

以下の例では、クエリを定義した後に外部変数thresholdの値を変更しています。

クエリは遅延実行されるため、実際に列挙する時点のthresholdの値が使われます。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        var numbers = new List<int> { 1, 5, 10, 15 };
        int threshold = 10;
        var query = from num in numbers
                    where num > threshold
                    select num;
        threshold = 5;  // クエリ定義後に値を変更
        foreach (var n in query)
        {
            Console.WriteLine(n);
        }
    }
}

10
15

この例では、thresholdを10で定義した後に5に変更していますが、クエリの実行時にthresholdは5として評価されます。

そのため、num > 5の条件でフィルタリングされ、10と15が出力されます。

この挙動は便利な反面、意図しない結果を招くこともあるため注意が必要です。

ToListでの即時評価

遅延実行を制御するために、ToList()やToArray()などのメソッドを使うと、クエリの結果を即時に評価(実行)し、結果をメモリ上に格納します。

これにより、外部変数の変更による影響を防ぐことができます。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        var numbers = new List<int> { 1, 5, 10, 15 };
        int threshold = 10;
        var query = from num in numbers
                    where num > threshold
                    select num;
        var resultList = query.ToList();  // 即時評価
        threshold = 5;  // 変更しても影響なし
        foreach (var n in resultList)
        {
            Console.WriteLine(n);
        }
    }
}

この例では、ToList()でクエリを即時評価しているため、thresholdが10の時点で結果が確定します。

thresholdを5に変更しても、resultListの内容は変わりません。

ToList()を使うことで、遅延実行のタイミングを制御し、外部変数の影響を受けない安定した結果を得ることができます。

ただし、即時評価はメモリ使用量が増える可能性があるため、必要に応じて使い分けることが重要です。

パターン別サンプル

LINQのlet句や匿名型、Join句を活用した具体的なパターンを示すことで、実践的な使い方を理解しやすくなります。

ここでは、フィルタリングにおけるlet句の利用例、グループ化と匿名型の組み合わせ、そしてJoinでの中間変数活用のサンプルを紹介します。

フィルタリングにおけるlet句

let句は、フィルタリング条件で複雑な計算を一時変数に保存し、再利用する際に便利です。

以下の例では、文字列の長さをlet句で計算し、その長さを使ってフィルタリングと結果の投影を行っています。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        var fruits = new List<string> { "apple", "banana", "cherry", "date", "fig" };
        var query = from fruit in fruits
                    let length = fruit.Length  // 文字列長を一時変数に保存
                    where length >= 5          // 長さが5以上のものをフィルタリング
                    select new { Fruit = fruit, Length = length };
        foreach (var item in query)
        {
            Console.WriteLine($"{item.Fruit} は長さ {item.Length} です。");
        }
    }
}

apple は長さ 5 です。
banana は長さ 6 です。
cherry は長さ 6 です。

この例では、fruit.Lengthをlet句で一度計算し、where句とselect句の両方で使い回しています。

計算の重複を避け、コードの可読性も向上しています。

グループ化と匿名型

LINQのgroup句と匿名型を組み合わせることで、グループ化したデータをわかりやすくまとめることができます。

以下の例では、学生のリストを年齢でグループ化し、各グループの学生名を匿名型でまとめています。

using System;
using System.Collections.Generic;
using System.Linq;
class Student
{
    public string Name { get; set; }
    public int Age { get; set; }
}
class Program
{
    static void Main()
    {
        var students = new List<Student>
        {
            new Student { Name = "Alice", Age = 20 },
            new Student { Name = "Bob", Age = 21 },
            new Student { Name = "Charlie", Age = 20 },
            new Student { Name = "David", Age = 22 }
        };
        var query = from student in students
                    group student by student.Age into ageGroup
                    select new
                    {
                        Age = ageGroup.Key,
                        Names = ageGroup.Select(s => s.Name).ToList()
                    };
        foreach (var group in query)
        {
            Console.WriteLine($"年齢 {group.Age} の学生: {string.Join(", ", group.Names)}");
        }
    }
}

年齢 20 の学生: Alice, Charlie
年齢 21 の学生: Bob
年齢 22 の学生: David

この例では、group句で年齢ごとに学生をまとめ、匿名型でAgeとそのグループに属する学生名のリストを保持しています。

匿名型を使うことで、複数の値を簡潔にまとめて扱えます。

Joinでの中間変数活用

Join句を使う際に、let句や匿名型を活用して中間変数を作ることで、結合結果をわかりやすく整理できます。

以下の例では、社員と部署のリストを部署IDで結合し、部署名と社員名を匿名型でまとめています。

using System;
using System.Collections.Generic;
using System.Linq;
class Employee
{
    public int Id { get; set; }
    public string Name { get; set; }
    public int DepartmentId { get; set; }
}
class Department
{
    public int Id { get; set; }
    public string DepartmentName { get; set; }
}
class Program
{
    static void Main()
    {
        var employees = new List<Employee>
        {
            new Employee { Id = 1, Name = "John", DepartmentId = 1 },
            new Employee { Id = 2, Name = "Jane", DepartmentId = 2 },
            new Employee { Id = 3, Name = "Mike", DepartmentId = 1 }
        };
        var departments = new List<Department>
        {
            new Department { Id = 1, DepartmentName = "Sales" },
            new Department { Id = 2, DepartmentName = "HR" }
        };
        var query = from emp in employees
                    join dept in departments on emp.DepartmentId equals dept.Id
                    let deptName = dept.DepartmentName  // 中間変数に部署名を保存
                    select new { EmployeeName = emp.Name, Department = deptName };
        foreach (var item in query)
        {
            Console.WriteLine($"{item.EmployeeName} は {item.Department} 部署に所属しています。");
        }
    }
}

John は Sales 部署に所属しています。
Jane は HR 部署に所属しています。
Mike は Sales 部署に所属しています。

この例では、joinで社員と部署を結合し、let句で部署名を一時変数deptNameに保存しています。

これにより、select句でわかりやすく結果をまとめられます。

中間変数を使うことで、複雑な結合結果も整理しやすくなります。

エラーパターン

LINQやlet句、var型推論を使う際に遭遇しやすいエラーや問題点を理解しておくことは、トラブルシューティングや安定したコード作成に役立ちます。

ここでは、型推論失敗によるコンパイルエラー、let句でのNull参照問題、そして遅延実行を忘れたことによる問題について詳しく解説します。

型推論失敗のコンパイルエラー

varキーワードを使う際、コンパイラは右辺の式から型を推論しますが、推論できない場合はコンパイルエラーになります。

特に、右辺がnullや複数の型が混在する場合に発生しやすいです。

以下の例は、varで型推論が失敗する典型的なケースです。

using System;
class Program
{
    static void Main()
    {
        var value = null;  // コンパイルエラー：型を推論できない
        Console.WriteLine(value);
    }
}

このコードはコンパイルエラーになります。

nullだけでは型が特定できないためです。

解決策は、明示的に型を指定することです。

string value = null;  // 明示的に型を指定
Console.WriteLine(value);

また、LINQのクエリで匿名型を返す場合はvarが必須ですが、複数の異なる型を混在させると推論できずエラーになります。

var list = new object[] { 1, "string", 3.14 };
var query = from item in list
            select item;  // 推論はobject型になるが、操作によってはエラーの可能性あり

このように、型推論が失敗する場合は、右辺の式を見直すか、明示的に型を指定することが必要です。

let句でのNull参照

let句で一時変数に代入した値がnullの場合、その後のクエリ内でNull参照例外が発生することがあります。

特に、let句の値を使ってメソッドを呼び出す際に注意が必要です。

以下の例では、let句でnullが代入され、その後のToUpper()呼び出しで例外が発生します。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        var words = new List<string> { "apple", null, "banana" };
        var query = from word in words
                    let upper = word.ToUpper()  // nullのとき例外発生
                    select upper;
        foreach (var item in query)
        {
            Console.WriteLine(item);
        }
    }
}

実行するとNullReferenceExceptionが発生します。

対策としては、let句の式でnullチェックを行うか、where句でnullを除外してから処理する方法があります。

var query = from word in words
            where word != null
            let upper = word.ToUpper()
            select upper;

または、let句内で安全に処理する方法もあります。

var query = from word in words
            let upper = word == null ? null : word.ToUpper()
            select upper;

このように、let句でのNull参照を防ぐためには、nullの可能性を考慮したコードを書くことが重要です。

遅延実行忘れによる問題

LINQのクエリは遅延実行されるため、クエリを定義しただけでは処理は実行されません。

これを理解せずに、クエリの結果を期待してすぐに使おうとすると、意図しない動作やバグが発生します。

例えば、以下のコードはクエリを定義しただけで、実際には何も処理されていません。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        var numbers = new List<int> { 1, 2, 3 };
        var query = numbers.Where(n => n > 1);
        // ここではまだクエリは実行されていない
        numbers.Add(4);  // クエリ実行前にコレクションを変更
        foreach (var n in query)
        {
            Console.WriteLine(n);
        }
    }
}

2
3
4

この例では、queryはnumbersの要素が2以上のものを選ぶクエリですが、numbers.Add(4)で4を追加した後にクエリを実行しています。

遅延実行のため、追加後の状態でクエリが評価され、4も結果に含まれます。

遅延実行を忘れて、クエリの結果を固定したい場合は、ToList()やToArray()で即時評価を行う必要があります。

var result = numbers.Where(n => n > 1).ToList();  // 即時評価
numbers.Add(4);  // 追加してもresultには影響しない
foreach (var n in result)
{
    Console.WriteLine(n);
}

2
3

遅延実行の特性を理解せずに使うと、データの変更がクエリ結果に影響を与え、バグの原因となるため注意が必要です。

スタイルチェックリスト

LINQやC#のコードを書く際に、可読性や保守性を高めるためのスタイルガイドは重要です。

ここでは、範囲変数の命名規約、varの使用判断基準、let句の採用基準、そしてパフォーマンス測定の手順について解説します。

命名規約と範囲変数

範囲変数はLINQクエリ内でデータソースの各要素を表す変数です。

命名規約を守ることで、コードの意図が明確になり、読みやすくなります。

短く意味のある名前を使う

範囲変数は通常、短く簡潔な名前を使います。

例えば、コレクションがstudentsならstudent、ordersならorderと単数形で命名します。

var query = from student in students
            where student.Age > 20
            select student;

単一文字は避けるが、慣例的に使う場合もある

小規模なクエリや簡単な処理ではxやnなど単一文字を使うこともありますが、複雑なクエリでは避けるべきです。

var evens = numbers.Where(n => n % 2 == 0);

同じクエリ内で重複しない名前を使う

複数のfrom句がある場合は、それぞれ異なる名前を付けて混乱を避けます。

意味のない名前は避ける

itemやobjなどの曖昧な名前は、可能な限り具体的な名前に置き換えましょう。

var使用の判断基準

varは型推論を利用してコードを簡潔にしますが、使いどころを誤ると可読性が低下します。

以下の基準を参考に使い分けましょう。

右辺の型が明確な場合はvarを使う

例えば、new演算子でインスタンス化している場合や、LINQの匿名型を扱う場合はvarが適しています。

var list = new List<int>();
var query = from s in students select s;

右辺の型が不明瞭な場合は明示的に型を書く

メソッド呼び出しの戻り値が複雑でわかりにくい場合は、型を明示して可読性を保ちます。

IEnumerable<Student> students = GetStudents();

匿名型や複雑な型を扱う場合はvar必須

匿名型は型名がないため、var以外での宣言はできません。

一貫性を保つ

プロジェクトやチームのコーディング規約に従い、varの使用ルールを統一しましょう。

let句採用の判断基准

let句はクエリ内で一時変数を作り、計算結果を再利用するために使います。

採用するかどうかの基準は以下の通りです。

同じ計算式を複数回使う場合はletを使う

計算コストの高い式や複雑な式を繰り返す場合、letで一時変数に保存して効率化します。

可読性向上のために式を分割したい場合

長い式やネストした式を分割し、意味のある名前を付けることでクエリの理解が容易になります。

パフォーマンスに影響がある場合

計算の重複を避けることで、パフォーマンス改善が期待できる場合は積極的に使います。

単純な式や一度しか使わない場合は無理に使わない

簡単な式で一度しか使わない場合は、let句を使わずに直接書いた方がコードがすっきりします。

パフォーマンス測定手順

LINQクエリのパフォーマンスを測定し、最適化するための基本的な手順は以下の通りです。

ベンチマーク環境の準備

実行環境を一定に保ち、外部要因の影響を減らします。

可能ならば、BenchmarkDotNetなどのベンチマークツールを使うと正確です。

測定対象のクエリを用意

比較したいクエリや処理を用意し、同じデータセットで実行します。

遅延実行に注意

LINQは遅延実行なので、測定前にToList()やToArray()で即時評価を行い、正確な実行時間を計測します。

複数回の実行で平均を取る

一回の実行だけでなく複数回実行し、平均や中央値を計算して安定した結果を得ます。

メモリ使用量も確認

実行時間だけでなく、メモリ消費量も測定し、総合的なパフォーマンスを評価します。

結果の分析と改善

測定結果をもとに、let句の有無やvarの使い方、クエリの構造を見直し、必要に応じて最適化を行います。

ドキュメント化

測定結果と改善内容を記録し、チームで共有して再利用できるようにします。

これらの手順を踏むことで、LINQクエリのパフォーマンスを正しく評価し、効果的な最適化が可能になります。

まとめ

この記事では、LINQにおける変数の使い方を中心に、let句やvar型推論の基礎から応用まで詳しく解説しました。

範囲変数の役割やlet句による一時変数の活用、varの適切な使い方、スコープやキャプチャの注意点、遅延実行の仕組みと評価タイミング、さらに具体的なパターン別サンプルやよくあるエラー例、スタイルガイドまで幅広く理解できます。

これにより、LINQクエリの可読性とパフォーマンスを最適化し、堅牢で保守しやすいコードを書く力が身につきます。

参考文献

実行時の状態に基づいて LINQ クエリを作成する方法 – C# | Microsoft Learn