LINQ

[C#] LINQの基本的な使い方を初心者向けに解説

2025-01-18更新日: 2025-01-18

LINQ(Language Integrated Query)は、C#でコレクションやデータベースなどのデータソースに対してクエリを記述するための機能です。

LINQを使うと、SQLのようなクエリをC#コード内で簡潔に書けます。

基本的な使い方として、where句で条件を指定し、select句で結果を取得します。

例えば、List<int>から偶数を抽出するには、var result = numbers.Where(n => n % 2 == 0).ToList();のように書きます。

LINQはメソッド構文とクエリ構文の2種類があります。

目次から探す

LINQとは何か
LINQの基本構文
LINQの基本操作
LINQのデータソース
LINQの応用例
LINQのパフォーマンスと最適化
LINQのエラーハンドリング
まとめ

LINQとは何か

LINQ(Language Integrated Query)は、C#をはじめとする.NET言語に組み込まれたクエリ言語です。

データベース、XML、コレクションなど、さまざまなデータソースに対して一貫した方法でクエリを実行できるのが特徴です。

LINQを使用することで、データの取得や操作を簡潔に記述でき、可読性が向上します。

LINQは、メソッド構文とクエリ構文の2つのスタイルで記述でき、開発者は好みに応じて選択できます。

これにより、データ操作の際に複雑なSQL文を書く必要がなくなり、C#の文法に馴染んだ形でデータを扱うことが可能です。

LINQは、特にデータのフィルタリング、並べ替え、集計などの操作を簡単に行えるため、データ処理の効率を大幅に向上させることができます。

LINQの基本構文

メソッド構文とクエリ構文の違い

LINQには主に2つの構文スタイルがあります。

メソッド構文は、LINQメソッドをチェーンして呼び出すスタイルで、可読性が高く、直感的に理解しやすいです。

一方、クエリ構文はSQLに似た文法で、より複雑なクエリを記述する際に便利です。

以下にそれぞれの特徴を示します。

構文スタイル	特徴
メソッド構文	メソッドをチェーンして記述。可読性が高い。
クエリ構文	SQLに似た文法。複雑なクエリに適している。

LINQの基本的なメソッド

LINQには多くの便利なメソッドがありますが、ここでは基本的なメソッドをいくつか紹介します。

Whereメソッド

Whereメソッドは、条件に合致する要素をフィルタリングするために使用します。

以下はその例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
        
        // 2以上の数をフィルタリング
        var result = numbers.Where(n => n >= 2);
        
        foreach (var number in result)
        {
            Console.WriteLine(number);
        }
    }
}

Selectメソッド

Selectメソッドは、要素を変換するために使用します。

以下はその例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
        
        // 各数を2倍にする
        var result = numbers.Select(n => n * 2);
        
        foreach (var number in result)
        {
            Console.WriteLine(number);
        }
    }
}

OrderByメソッド

OrderByメソッドは、要素を昇順に並べ替えるために使用します。

以下はその例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 5, 3, 1, 4, 2 };
        
        // 昇順に並べ替え
        var result = numbers.OrderBy(n => n);
        
        foreach (var number in result)
        {
            Console.WriteLine(number);
        }
    }
}

GroupByメソッド

GroupByメソッドは、要素を特定のキーでグループ化するために使用します。

以下はその例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<string> fruits = new List<string> { "apple", "banana", "apple", "orange", "banana" };
        
        // フルーツをグループ化
        var result = fruits.GroupBy(f => f);
        
        foreach (var group in result)
        {
            Console.WriteLine($"{group.Key}: {group.Count()}");
        }
    }
}

apple: 2
banana: 2
orange: 1

クエリ構文の書き方

クエリ構文は、SQLに似た文法でLINQクエリを記述します。

以下はその基本的な書き方の例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
        
        // クエリ構文を使用して2以上の数を取得
        var result = from n in numbers
                     where n >= 2
                     select n;
        
        foreach (var number in result)
        {
            Console.WriteLine(number);
        }
    }
}

メソッドチェーンの使い方

メソッドチェーンは、複数のLINQメソッドを連続して呼び出すことで、より複雑なクエリを簡潔に記述する方法です。

以下はその例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
        
        // WhereとSelectをメソッドチェーンで使用
        var result = numbers.Where(n => n >= 2).Select(n => n * 2);
        
        foreach (var number in result)
        {
            Console.WriteLine(number);
        }
    }
}

メソッドチェーンを使用することで、クエリをより効率的に記述でき、可読性も向上します。

LINQの基本操作

フィルタリング(Where)

Whereメソッドは、コレクション内の要素を条件に基づいてフィルタリングするために使用します。

特定の条件を満たす要素だけを抽出することができます。

以下はその例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
        
        // 3以上の数をフィルタリング
        var result = numbers.Where(n => n >= 3);
        
        foreach (var number in result)
        {
            Console.WriteLine(number);
        }
    }
}

3
4
5

投影(Select)

Selectメソッドは、コレクション内の要素を変換するために使用します。

特定のプロパティや計算結果を取得することができます。

以下はその例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<string> names = new List<string> { "Alice", "Bob", "Charlie" };
        
        // 各名前の長さを取得
        var result = names.Select(name => name.Length);
        
        foreach (var length in result)
        {
            Console.WriteLine(length);
        }
    }
}

5
3
7

並べ替え(OrderBy, OrderByDescending)

OrderByメソッドは、要素を昇順に並べ替えるために使用します。

一方、OrderByDescendingメソッドは、要素を降順に並べ替えます。

以下はその例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 5, 3, 1, 4, 2 };
        
        // 昇順に並べ替え
        var ascending = numbers.OrderBy(n => n);
        Console.WriteLine("昇順:");
        foreach (var number in ascending)
        {
            Console.WriteLine(number);
        }
        // 降順に並べ替え
        var descending = numbers.OrderByDescending(n => n);
        Console.WriteLine("降順:");
        foreach (var number in descending)
        {
            Console.WriteLine(number);
        }
    }
}

昇順:
1
2
3
4
5
降順:
5
4
3
2
1

グループ化(GroupBy)

GroupByメソッドは、要素を特定のキーでグループ化するために使用します。

これにより、同じキーを持つ要素をまとめることができます。

以下はその例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<string> fruits = new List<string> { "apple", "banana", "apple", "orange", "banana" };
        
        // フルーツをグループ化
        var result = fruits.GroupBy(f => f);
        
        foreach (var group in result)
        {
            Console.WriteLine($"{group.Key}: {group.Count()}");
        }
    }
}

apple: 2
banana: 2
orange: 1

集計(Count, Sum, Average)

LINQでは、Count、Sum、Averageなどのメソッドを使用して、コレクションの要素に対する集計を行うことができます。

以下はその例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
        
        // 要素の数を取得
        int count = numbers.Count();
        Console.WriteLine($"要素の数: {count}");
        // 要素の合計を取得
        int sum = numbers.Sum();
        Console.WriteLine($"合計: {sum}");
        // 要素の平均を取得
        double average = numbers.Average();
        Console.WriteLine($"平均: {average}");
    }
}

要素の数: 5
合計: 15
平均: 3

これらの基本操作を使用することで、LINQを活用してデータの取得や操作を効率的に行うことができます。

LINQのデータソース

配列やリストに対するLINQ

LINQは、配列やリストなどのコレクションに対して簡単にクエリを実行できます。

以下は、配列に対してLINQを使用する例です。

using System;
using System.Linq;
class Program
{
    static void Main()
    {
        int[] numbers = { 1, 2, 3, 4, 5 };
        // 配列の要素をフィルタリング
        var result = numbers.Where(n => n > 2);
        foreach (var number in result)
        {
            Console.WriteLine(number);
        }
    }
}

3
4
5

リストに対しても同様にLINQを使用できます。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<string> fruits = new List<string> { "apple", "banana", "cherry", "date" };
        // リストの要素をフィルタリング
        var result = fruits.Where(f => f.StartsWith("b"));
        foreach (var fruit in result)
        {
            Console.WriteLine(fruit);
        }
    }
}

banana

辞書型に対するLINQ

LINQは、辞書型(Dictionary)に対しても使用できます。

辞書のキーや値に基づいてクエリを実行することができます。

以下はその例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        Dictionary<string, int> ages = new Dictionary<string, int>
        {
            { "Alice", 30 },
            { "Bob", 25 },
            { "Charlie", 35 }
        };
        // 年齢が30以上の人をフィルタリング
        var result = ages.Where(pair => pair.Value >= 30);
        foreach (var person in result)
        {
            Console.WriteLine($"{person.Key}: {person.Value}");
        }
    }
}

Alice: 30
Charlie: 35

カスタムオブジェクトに対するLINQ

LINQは、カスタムオブジェクトのリストに対しても使用できます。

以下は、カスタムクラスを使用した例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}
class Program
{
    static void Main()
    {
        List<Person> people = new List<Person>
        {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 25 },
            new Person { Name = "Charlie", Age = 35 }
        };
        // 年齢が30以上の人をフィルタリング
        var result = people.Where(p => p.Age >= 30);
        foreach (var person in result)
        {
            Console.WriteLine($"{person.Name}: {person.Age}");
        }
    }
}

Alice: 30
Charlie: 35

データベースに対するLINQ(LINQ to SQL)

LINQ to SQLを使用すると、データベースに対してLINQクエリを実行できます。

これにより、SQL文を直接書くことなく、C#の文法でデータベース操作が可能になります。

以下はその基本的な例です。

using System;
using System.Data.Linq;
using System.Linq;
class Program
{
    static void Main()
    {
        // データベースコンテキストの作成
        DataContext db = new DataContext("YourConnectionString");
        // テーブルからデータを取得
        var result = from person in db.GetTable<Person>()
                     where person.Age >= 30
                     select person;
        foreach (var person in result)
        {
            Console.WriteLine($"{person.Name}: {person.Age}");
        }
    }
}

この例では、YourConnectionStringを実際のデータベース接続文字列に置き換える必要があります。

LINQ to SQLを使用することで、データベースの操作がより直感的に行えるようになります。

これらのデータソースに対するLINQの使用方法を理解することで、さまざまなデータに対して効率的にクエリを実行できるようになります。

LINQの応用例

複数条件でのフィルタリング

LINQを使用すると、複数の条件を組み合わせて要素をフィルタリングすることができます。

以下は、年齢と名前の条件を組み合わせた例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}
class Program
{
    static void Main()
    {
        List<Person> people = new List<Person>
        {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 25 },
            new Person { Name = "Charlie", Age = 35 },
            new Person { Name = "David", Age = 28 }
        };
        // 年齢が30以上かつ名前が"A"で始まる人をフィルタリング
        var result = people.Where(p => p.Age >= 30 && p.Name.StartsWith("A"));
        foreach (var person in result)
        {
            Console.WriteLine($"{person.Name}: {person.Age}");
        }
    }
}

Alice: 30

複雑なオブジェクトのクエリ

LINQは、複雑なオブジェクトのプロパティに基づいてクエリを実行することもできます。

以下は、ネストされたオブジェクトを持つクエリの例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Address
{
    public string City { get; set; }
}
class Person
{
    public string Name { get; set; }
    public Address Address { get; set; }
}
class Program
{
    static void Main()
    {
        List<Person> people = new List<Person>
        {
            new Person { Name = "Alice", Address = new Address { City = "Tokyo" } },
            new Person { Name = "Bob", Address = new Address { City = "Osaka" } },
            new Person { Name = "Charlie", Address = new Address { City = "Tokyo" } }
        };
        // 東京に住んでいる人をフィルタリング
        var result = people.Where(p => p.Address.City == "Tokyo");
        foreach (var person in result)
        {
            Console.WriteLine(person.Name);
        }
    }
}

Alice
Charlie

LINQでの結合操作(Join)

LINQでは、異なるコレクションを結合することもできます。

以下は、2つのリストを結合する例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}
class Pet
{
    public string OwnerName { get; set; }
    public string PetName { get; set; }
}
class Program
{
    static void Main()
    {
        List<Person> people = new List<Person>
        {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 25 }
        };
        List<Pet> pets = new List<Pet>
        {
            new Pet { OwnerName = "Alice", PetName = "Cat" },
            new Pet { OwnerName = "Bob", PetName = "Dog" }
        };
        // 人とペットを結合
        var result = from person in people
                     join pet in pets on person.Name equals pet.OwnerName
                     select new { person.Name, pet.PetName };
        foreach (var item in result)
        {
            Console.WriteLine($"{item.Name}のペット: {item.PetName}");
        }
    }
}

Aliceのペット: Cat
Bobのペット: Dog

LINQでのサブクエリ

LINQでは、サブクエリを使用して、より複雑なデータ取得が可能です。

以下は、サブクエリを使用した例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}
class Program
{
    static void Main()
    {
        List<Person> people = new List<Person>
        {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 25 },
            new Person { Name = "Charlie", Age = 35 }
        };
        // 平均年齢以上の人を取得
        double averageAge = people.Average(p => p.Age);
        var result = people.Where(p => p.Age > averageAge);
        foreach (var person in result)
        {
            Console.WriteLine($"{person.Name}: {person.Age}");
        }
    }
}

Charlie: 35

LINQでの遅延実行

LINQは遅延実行をサポートしており、クエリは実際にデータが必要になるまで実行されません。

これにより、パフォーマンスが向上する場合があります。

以下はその例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
        // Whereメソッドを使用して遅延実行
        var result = numbers.Where(n => n > 2);
        // 実行はここで行われる
        foreach (var number in result)
        {
            Console.WriteLine(number);
        }
    }
}

3
4
5

遅延実行により、クエリの実行を必要なときに行うことができ、無駄な計算を避けることができます。

これらの応用例を通じて、LINQの強力な機能を活用する方法を理解できるでしょう。

LINQのパフォーマンスと最適化

遅延実行と即時実行の違い

LINQには、遅延実行と即時実行の2つの実行モデルがあります。

遅延実行は、クエリが実際に必要になるまで実行されない仕組みです。

これにより、クエリの結果が必要なときにのみ計算され、無駄な処理を避けることができます。

一方、即時実行は、クエリが定義された時点で即座に実行され、結果が返されます。

以下は、遅延実行と即時実行の例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
        // 遅延実行
        var delayedExecution = numbers.Where(n => n > 2);
        
        // 実行はここで行われる
        foreach (var number in delayedExecution)
        {
            Console.WriteLine(number);
        }
        // 即時実行
        var immediateExecution = numbers.Where(n => n > 2).ToList();
        Console.WriteLine($"即時実行の結果数: {immediateExecution.Count}");
    }
}

3
4
5
即時実行の結果数: 3

効率的なクエリの書き方

効率的なクエリを書くためには、以下のポイントに注意することが重要です。

必要なデータのみを取得: 不要なデータを取得しないように、フィルタリングを行いましょう。
メソッドチェーンを活用: 複数のLINQメソッドを組み合わせて、クエリを簡潔に記述します。
適切なメソッドを選択: 例えば、Any()メソッドを使用して存在確認を行うことで、全要素を取得する必要がなくなります。

以下は、効率的なクエリの例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
        // 存在確認を行う
        bool hasGreaterThanThree = numbers.Any(n => n > 3);
        Console.WriteLine($"3より大きい数は存在するか: {hasGreaterThanThree}");
    }
}

3より大きい数は存在するか: True

大規模データに対するLINQの注意点

大規模データに対してLINQを使用する際は、パフォーマンスに注意が必要です。

以下の点に留意しましょう。

メモリ使用量: 大量のデータを一度にメモリに読み込むと、メモリ不足になる可能性があります。

必要に応じて、データを分割して処理することを検討してください。

クエリの最適化: 複雑なクエリは、実行時間が長くなることがあります。

クエリをシンプルに保ち、必要なデータのみを取得するようにしましょう。

データベースとの連携: LINQ to SQLやEntity Frameworkを使用する場合、データベースのインデックスを適切に設定することで、クエリのパフォーマンスを向上させることができます。

ToList()やToArray()の使いどころ

ToList()やToArray()メソッドは、LINQクエリの結果を即時に実行し、コレクションに変換するために使用されます。

これらのメソッドを使用する際のポイントは以下の通りです。

結果を再利用する場合: クエリの結果を何度も使用する場合は、ToList()やToArray()を使用して結果をキャッシュすることが有効です。
遅延実行を解除する場合: クエリの結果を即時に取得したい場合は、これらのメソッドを使用します。

以下は、ToList()を使用した例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
        // クエリを即時実行し、結果をリストに変換
        var resultList = numbers.Where(n => n > 2).ToList();
        // 結果を表示
        foreach (var number in resultList)
        {
            Console.WriteLine(number);
        }
    }
}

3
4
5

これらのポイントを考慮することで、LINQを使用したデータ処理のパフォーマンスを向上させることができます。

LINQのエラーハンドリング

クエリ実行時の例外処理

LINQクエリを実行する際には、さまざまな理由で例外が発生する可能性があります。

たとえば、データソースが空である場合や、クエリの条件が不正な場合などです。

これらの例外を適切に処理するためには、try-catchブロックを使用します。

以下は、クエリ実行時の例外処理の例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<int> numbers = null; // nullのリスト
        try
        {
            // クエリを実行
            var result = numbers.Where(n => n > 2).ToList();
        }
        catch (Exception ex)
        {
            // 例外をキャッチして表示
            Console.WriteLine($"エラーが発生しました: {ex.Message}");
        }
    }
}

エラーが発生しました: Value cannot be null. (Parameter 'source')

Null値の扱い

LINQでは、コレクション内にNull値が含まれている場合、クエリの実行時にエラーが発生することがあります。

Null値を適切に処理するためには、Whereメソッドを使用してNullチェックを行うことが重要です。

以下は、Null値を含むリストに対するLINQクエリの例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<string> names = new List<string> { "Alice", null, "Bob", "Charlie", null };
        // Nullでない名前をフィルタリング
        var result = names.Where(name => name != null);
        foreach (var name in result)
        {
            Console.WriteLine(name);
        }
    }
}

Alice
Bob
Charlie

型変換エラーの対処法

LINQを使用する際、型変換エラーが発生することがあります。

たとえば、数値型のデータを文字列型に変換する場合などです。

これを防ぐためには、TryParseメソッドを使用して安全に変換を行うことが推奨されます。

以下は、型変換エラーの対処法の例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<string> numbers = new List<string> { "1", "2", "three", "4", "5" };
        // 型変換エラーを避けるためにTryParseを使用
        var result = numbers.Select(num =>
        {
            int parsedNumber;
            return int.TryParse(num, out parsedNumber) ? parsedNumber : (int?)null;
        }).Where(n => n.HasValue).Select(n => n.Value);
        foreach (var number in result)
        {
            Console.WriteLine(number);
        }
    }
}

この例では、TryParseを使用して文字列を整数に変換し、変換に失敗した場合はnullを返しています。

これにより、型変換エラーを回避し、正常にクエリを実行することができます。

これらのエラーハンドリングのテクニックを使用することで、LINQを使用したデータ処理の信頼性を向上させることができます。