LINQ

[C#/LINQ] OrderByメソッドの使い方 – データの昇順ソート

OrderByメソッドは、C#のLINQクエリでコレクションの要素を昇順にソートするために使用されます。

メソッドは、ソートの基準となるキーを指定するラムダ式を引数に取ります。

例えば、OrderBy(x => x.Property)のように記述し、Propertyに基づいて昇順に並べ替えます。

文字列や数値など、任意のプロパティを基準にソート可能です。

なお、降順にソートしたい場合はOrderByDescendingを使用します。

目次から探す

OrderByメソッドとは
OrderByメソッドの基本的な使い方
OrderByメソッドの具体例
OrderByと他のLINQメソッドの組み合わせ
OrderByDescendingとの違い
カスタム比較ロジックを使ったOrderBy
パフォーマンスに関する考慮点
応用例
まとめ

OrderByメソッドとは

C#のLINQ(Language Integrated Query)におけるOrderByメソッドは、コレクション内のデータを指定した条件に基づいて昇順にソートするためのメソッドです。

このメソッドは、配列やリストなどのコレクションに対して使用でき、特定のプロパティやフィールドに基づいてデータを並べ替えることができます。

OrderByメソッドは、データの整列を簡単に行えるため、データの表示や処理を行う際に非常に便利です。

例えば、ユーザーのリストを名前のアルファベット順に並べたり、商品の価格を安い順に並べたりすることができます。

LINQを使用することで、コードがシンプルになり、可読性が向上します。

このメソッドは、元のコレクションを変更せずに新しいソート済みのコレクションを返すため、安全に使用することができます。

これにより、データの整列を行った後も元のデータを保持することが可能です。

OrderByメソッドの基本的な使い方

単一プロパティでの昇順ソート

OrderByメソッドを使用して、コレクション内のオブジェクトを単一のプロパティに基づいて昇順にソートすることができます。

以下は、数値型のリストを昇順にソートする例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 5, 3, 8, 1, 4 };
        
        // 単一プロパティでの昇順ソート
        var sortedNumbers = numbers.OrderBy(n => n);
        
        foreach (var number in sortedNumbers)
        {
            Console.WriteLine(number);
        }
    }
}

この例では、整数のリストを昇順にソートしています。

OrderByメソッドは、指定したプロパティ(この場合は数値そのもの)に基づいて新しいコレクションを返します。

複数プロパティでの昇順ソート

複数のプロパティを使用して昇順にソートすることも可能です。

以下は、カスタムオブジェクトのリストを複数のプロパティに基づいてソートする例です。

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 = 25 }
        };
        
        // 複数プロパティでの昇順ソート
        var sortedPeople = people.OrderBy(p => p.Age).ThenBy(p => p.Name);
        
        foreach (var person in sortedPeople)
        {
            Console.WriteLine($"{person.Name}, {person.Age}");
        }
    }
}

Bob, 25
Charlie, 25
Alice, 30

この例では、年齢で昇順にソートし、同じ年齢の人がいる場合は名前でさらに昇順にソートしています。

匿名型を使ったソート

OrderByメソッドでは、匿名型を使用して複数のプロパティをまとめてソートすることもできます。

以下は、匿名型を使ったソートの例です。

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 = 25 }
        };

        // 匿名型を使ったソート
        var sortedPeople = people
            .Select(p => new { p.Name, p.Age })
            .OrderBy(p => p.Age).ThenBy(p => p.Name);

        foreach (var person in sortedPeople)
        {
            Console.WriteLine($"{person.Name}, {person.Age}");
        }
    }
}

Bob, 25
Charlie, 25
Alice, 30

この例では、Selectメソッドを使用して匿名型を作成し、その後OrderByメソッドでソートしています。

ソートの安定性について

OrderByメソッドは安定ソートを提供します。

これは、同じキーを持つ要素の順序が元のコレクションでの順序を保持することを意味します。

例えば、同じ年齢を持つ人がいる場合、元のリストでの順序がそのまま保持されます。

これにより、データの整列がより直感的で予測可能なものになります。

安定性は、特に複数のプロパティでソートする際に重要な特性です。

OrderByメソッドの具体例

数値型のリストを昇順にソートする例

数値型のリストをOrderByメソッドを使って昇順にソートする基本的な例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 7, 2, 9, 1, 5 };
        
        // 数値型のリストを昇順にソート
        var sortedNumbers = numbers.OrderBy(n => n);
        
        foreach (var number in sortedNumbers)
        {
            Console.WriteLine(number);
        }
    }
}

この例では、整数のリストを昇順にソートしています。

OrderByメソッドは、数値を基準に新しいコレクションを返します。

文字列型のリストを昇順にソートする例

文字列型のリストを昇順にソートする例です。

アルファベット順に並べ替えます。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<string> names = new List<string> { "Charlie", "Alice", "Bob", "Eve" };
        
        // 文字列型のリストを昇順にソート
        var sortedNames = names.OrderBy(name => name);
        
        foreach (var name in sortedNames)
        {
            Console.WriteLine(name);
        }
    }
}

Alice
Bob
Charlie
Eve

この例では、名前のリストをアルファベット順にソートしています。

OrderByメソッドは、文字列を基準に新しいコレクションを返します。

カスタムオブジェクトのプロパティを使ったソート例

カスタムオブジェクトのリストを特定のプロパティに基づいて昇順にソートする例です。

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 }
        };
        
        // カスタムオブジェクトのプロパティを使ったソート
        var sortedPeople = people.OrderBy(p => p.Age);
        
        foreach (var person in sortedPeople)
        {
            Console.WriteLine($"{person.Name}, {person.Age}");
        }
    }
}

Bob, 25
Alice, 30
Charlie, 35

この例では、Personオブジェクトのリストを年齢に基づいて昇順にソートしています。

null値を含むデータのソート

null値を含むデータをOrderByメソッドでソートする場合、null値の扱いに注意が必要です。

以下は、null値を含むリストを昇順にソートする例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<string> names = new List<string> { "Charlie", null, "Alice", "Bob", null, "Eve" };
        
        // null値を含むデータの昇順ソート
        var sortedNames = names.OrderBy(name => name);
        
        foreach (var name in sortedNames)
        {
            Console.WriteLine(name ?? "null");
        }
    }
}

null
null
Alice
Bob
Charlie
Eve

この例では、文字列のリストにnull値が含まれており、OrderByメソッドを使用して昇順にソートしています。

null値は最初に表示されます。

null値の扱いは、データの整列において重要なポイントです。

OrderByと他のLINQメソッドの組み合わせ

OrderByとWhereの組み合わせ

OrderByメソッドとWhereメソッドを組み合わせることで、特定の条件を満たすデータを昇順にソートすることができます。

以下は、年齢が30歳以上の人を昇順にソートする例です。

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 }
        };
        
        // OrderByとWhereの組み合わせ
        var sortedPeople = people
            .Where(p => p.Age >= 30)
            .OrderBy(p => p.Age);
        
        foreach (var person in sortedPeople)
        {
            Console.WriteLine($"{person.Name}, {person.Age}");
        }
    }
}

Alice, 30
Charlie, 35

この例では、Whereメソッドで年齢が30歳以上の人をフィルタリングし、その後OrderByメソッドで昇順にソートしています。

OrderByとSelectの組み合わせ

OrderByメソッドとSelectメソッドを組み合わせることで、特定のプロパティを選択しつつ、昇順にソートすることができます。

以下は、名前だけを選択して昇順にソートする例です。

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 }
        };
        
        // OrderByとSelectの組み合わせ
        var sortedNames = people
            .OrderBy(p => p.Name)
            .Select(p => p.Name);
        
        foreach (var name in sortedNames)
        {
            Console.WriteLine(name);
        }
    }
}

Alice
Bob
Charlie

この例では、OrderByメソッドで名前を昇順にソートし、Selectメソッドで名前だけを選択しています。

OrderByとGroupByの組み合わせ

OrderByメソッドとGroupByメソッドを組み合わせることで、グループ化したデータを昇順にソートすることができます。

以下は、年齢でグループ化し、各グループの名前を昇順にソートする例です。

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 = 30 },
            new Person { Name = "David", Age = 25 }
        };
        
        // OrderByとGroupByの組み合わせ
        var groupedPeople = people
            .GroupBy(p => p.Age)
            .OrderBy(g => g.Key);
        
        foreach (var group in groupedPeople)
        {
            Console.WriteLine($"Age: {group.Key}");
            foreach (var person in group.OrderBy(p => p.Name))
            {
                Console.WriteLine($"  {person.Name}");
            }
        }
    }
}

Age: 25
  Bob
  David
Age: 30
  Alice
  Charlie

この例では、年齢でグループ化し、各グループの年齢を昇順にソートしています。

その後、各グループ内の名前を昇順にソートしています。

OrderByとTake/Skipの組み合わせ

OrderByメソッドとTake/Skipメソッドを組み合わせることで、ソートしたデータの一部を取得することができます。

以下は、年齢で昇順にソートした後、上位2人を取得する例です。

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 }
        };
        
        // OrderByとTake/Skipの組み合わせ
        var topTwoPeople = people
            .OrderBy(p => p.Age)
            .Take(2);
        
        foreach (var person in topTwoPeople)
        {
            Console.WriteLine($"{person.Name}, {person.Age}");
        }
    }
}

Bob, 25
David, 28

この例では、OrderByメソッドで年齢を昇順にソートし、Takeメソッドで上位2人を取得しています。

Skipメソッドを使用することで、特定の数の要素をスキップすることも可能です。

これにより、ページング処理などが簡単に実装できます。

OrderByDescendingとの違い

OrderByDescendingの基本構文

OrderByDescendingメソッドは、コレクション内のデータを指定した条件に基づいて降順にソートするためのメソッドです。

基本的な構文は以下の通りです。

var sortedCollection = collection.OrderByDescending(item => item.Property);

ここで、collectionはソート対象のコレクション、item.Propertyはソートの基準となるプロパティです。

降順にソートされた新しいコレクションが返されます。

以下は、数値型のリストを降順にソートする例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 5, 3, 8, 1, 4 };
        
        // OrderByDescendingを使用して降順にソート
        var sortedNumbers = numbers.OrderByDescending(n => n);
        
        foreach (var number in sortedNumbers)
        {
            Console.WriteLine(number);
        }
    }
}

この例では、整数のリストを降順にソートしています。

OrderByとOrderByDescendingの使い分け

OrderByメソッドとOrderByDescendingメソッドは、ソートの順序が異なるため、使用する場面が異なります。

OrderByは昇順にソートし、OrderByDescendingは降順にソートします。

OrderBy: 昇順にソートしたい場合に使用します。
OrderByDescending: 降順にソートしたい場合に使用します。

例えば、年齢を昇順にソートしたい場合はOrderByを使用し、年齢を降順にソートしたい場合はOrderByDescendingを使用します。

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 }
        };
        
        // 昇順にソート
        var sortedAscending = people.OrderBy(p => p.Age);
        
        // 降順にソート
        var sortedDescending = people.OrderByDescending(p => p.Age);
        
        Console.WriteLine("昇順:");
        foreach (var person in sortedAscending)
        {
            Console.WriteLine($"{person.Name}, {person.Age}");
        }
        
        Console.WriteLine("降順:");
        foreach (var person in sortedDescending)
        {
            Console.WriteLine($"{person.Name}, {person.Age}");
        }
    }
}

昇順:
Bob, 25
Alice, 30
Charlie, 35
降順:
Charlie, 35
Alice, 30
Bob, 25

昇順と降順を組み合わせたソート

OrderByメソッドとOrderByDescendingメソッドを組み合わせることで、複数のプロパティに基づいて昇順と降順を同時に適用することができます。

以下は、年齢を昇順にソートし、同じ年齢の人を名前で降順にソートする例です。

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 = 30 },
            new Person { Name = "David", Age = 25 }
        };
        
        // 昇順と降順を組み合わせたソート
        var sortedPeople = people
            .OrderBy(p => p.Age)
            .ThenByDescending(p => p.Name);
        
        foreach (var person in sortedPeople)
        {
            Console.WriteLine($"{person.Name}, {person.Age}");
        }
    }
}

David, 25
Bob, 25
Charlie, 30
Alice, 30

この例では、年齢を昇順にソートし、同じ年齢の人がいる場合は名前を降順にソートしています。

これにより、データの整列がより柔軟に行えるようになります。

カスタム比較ロジックを使ったOrderBy

IComparerを使ったカスタムソート

C#では、IComparerインターフェースを実装することで、カスタムの比較ロジックを定義し、OrderByメソッドで使用することができます。

以下は、年齢を基準にしたカスタムソートの例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}
class AgeComparer : IComparer<Person>
{
    public int Compare(Person x, Person y)
    {
        // 年齢で比較
        return x.Age.CompareTo(y.Age);
    }
}
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 }
        };
        
        // IComparerを使ったカスタムソート
        var sortedPeople = people.OrderBy(p => p, new AgeComparer());
        
        foreach (var person in sortedPeople)
        {
            Console.WriteLine($"{person.Name}, {person.Age}");
        }
    }
}

Bob, 25
Alice, 30
Charlie, 35

この例では、AgeComparerクラスを作成し、IComparerインターフェースを実装しています。

OrderByメソッドでこのカスタム比較ロジックを使用して、年齢に基づいて昇順にソートしています。

カルチャに依存した文字列のソート

カルチャに依存した文字列のソートを行う場合、StringComparerクラスを使用することができます。

以下は、特定のカルチャに基づいて文字列をソートする例です。

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
class Program
{
    static void Main()
    {
        List<string> names = new List<string> { "apple", "Banana", "orange", "grape" };
        
        // カルチャに依存した文字列のソート
        var sortedNames = names.OrderBy(name => name, StringComparer.Create(CultureInfo.CurrentCulture, true));
        
        foreach (var name in sortedNames)
        {
            Console.WriteLine(name);
        }
    }
}

apple
Banana
grape
orange

この例では、StringComparer.Createメソッドを使用して、現在のカルチャに基づいて文字列をソートしています。

第二引数にtrueを指定することで、大文字と小文字を区別しないソートが行われます。

大文字・小文字を無視したソート

大文字・小文字を無視してソートする場合も、StringComparerクラスを使用することができます。

以下は、大文字・小文字を無視して文字列をソートする例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<string> names = new List<string> { "apple", "Banana", "orange", "Grape" };
        
        // 大文字・小文字を無視したソート
        var sortedNames = names.OrderBy(name => name, StringComparer.OrdinalIgnoreCase);
        
        foreach (var name in sortedNames)
        {
            Console.WriteLine(name);
        }
    }
}

apple
Banana
Grape
orange

この例では、StringComparer.OrdinalIgnoreCaseを使用して、大文字・小文字を無視して文字列をソートしています。

これにより、”Grape”と”grape”が同じ扱いでソートされます。

カスタム比較ロジックを使用することで、さまざまな条件に基づいた柔軟なソートが可能になります。

パフォーマンスに関する考慮点

大規模データセットでのOrderByのパフォーマンス

OrderByメソッドは、コレクション内のデータをソートするために使用されますが、大規模データセットに対して使用する場合、パフォーマンスに影響を与える可能性があります。

特に、データセットが非常に大きい場合、ソート処理にかかる時間が増加し、アプリケーションの応答性が低下することがあります。

時間計算量: OrderByメソッドは、通常O(n log n)の時間計算量を持つソートアルゴリズムを使用します。

データセットが大きくなると、ソートにかかる時間が指数関数的に増加します。

メモリ使用量: 大規模なデータセットをソートする際には、メモリの使用量も考慮する必要があります。

特に、元のコレクションを変更せずに新しいコレクションを返すため、追加のメモリが必要になります。

大規模データセットを扱う場合は、必要なデータのみをフィルタリングしてからソートすることや、ソートの必要がない場合は他の方法でデータを処理することを検討することが重要です。

データベースクエリにおけるOrderByの最適化

データベースからデータを取得する際にOrderByメソッドを使用する場合、クエリの最適化が重要です。

LINQ to SQLやEntity Frameworkを使用している場合、OrderByメソッドはSQLのORDER BY句に変換されます。

インデックスの利用: データベースのテーブルにインデックスを作成することで、OrderByのパフォーマンスを向上させることができます。

インデックスがある場合、データベースはソートを効率的に行うことができます。

クエリの最適化: 不要なデータを取得しないように、Where句でフィルタリングを行った後にOrderByを適用することで、データの量を減らし、パフォーマンスを向上させることができます。

以下は、Entity Frameworkを使用した例です。

using (var context = new MyDbContext())
{
    var sortedPeople = context.People
        .Where(p => p.Age >= 30) // フィルタリング
        .OrderBy(p => p.Age)     // ソート
        .ToList();
}

このように、フィルタリングを先に行うことで、ソート対象のデータを減らし、パフォーマンスを向上させることができます。

メモリ内コレクションとデータベースクエリの違い

メモリ内コレクションとデータベースクエリでは、OrderByメソッドのパフォーマンスに関する考慮点が異なります。

メモリ内コレクション: メモリ内のデータをソートする場合、全てのデータがメモリに存在するため、ソート処理は迅速に行われますが、大規模データセットの場合はメモリの制約に注意が必要です。

メモリが不足すると、パフォーマンスが低下する可能性があります。

データベースクエリ: データベースからデータを取得する場合、データベースのパフォーマンスやインデックスの有無が重要です。

データベースは、ディスクI/Oやネットワーク遅延の影響を受けるため、メモリ内コレクションよりも遅くなることがあります。

このため、データの量や処理の内容に応じて、メモリ内で処理するか、データベースで処理するかを選択することが重要です。

特に、データベースから大量のデータを取得してメモリ内で処理する場合は、パフォーマンスに注意を払う必要があります。

応用例

OrderByを使ったページング処理

OrderByメソッドを使用して、データのページング処理を行うことができます。

ページングは、大量のデータを小さな部分に分割して表示するための手法です。

以下は、ページサイズを指定してデータを取得する例です。

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 },
            new Person { Name = "Eve", Age = 22 }
        };
        int pageSize = 2; // 1ページあたりのデータ数
        int pageNumber = 1; // 取得するページ番号
        // OrderByを使ったページング処理
        var pagedPeople = people
            .OrderBy(p => p.Age)
            .Skip((pageNumber - 1) * pageSize) // スキップするデータ数
            .Take(pageSize); // 取得するデータ数
        foreach (var person in pagedPeople)
        {
            Console.WriteLine($"{person.Name}, {person.Age}");
        }
    }
}

Eve, 22
Bob, 25

この例では、年齢で昇順にソートした後、指定したページサイズに基づいてデータを取得しています。

OrderByを使ったランキングの作成

OrderByメソッドを使用して、スコアやポイントに基づいたランキングを作成することができます。

以下は、スコアに基づいて昇順にソートし、ランキングを表示する例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Player
{
    public string Name { get; set; }
    public int Score { get; set; }
}
class Program
{
    static void Main()
    {
        List<Player> players = new List<Player>
        {
            new Player { Name = "Alice", Score = 150 },
            new Player { Name = "Bob", Score = 200 },
            new Player { Name = "Charlie", Score = 100 }
        };
        // OrderByを使ったランキングの作成
        var rankedPlayers = players
            .OrderByDescending(p => p.Score)
            .Select((p, index) => new { Rank = index + 1, p.Name, p.Score });
        foreach (var player in rankedPlayers)
        {
            Console.WriteLine($"Rank: {player.Rank}, Name: {player.Name}, Score: {player.Score}");
        }
    }
}

Rank: 1, Name: Bob, Score: 200
Rank: 2, Name: Alice, Score: 150
Rank: 3, Name: Charlie, Score: 100

この例では、スコアを降順にソートし、各プレイヤーにランキングを付与しています。

OrderByを使った重複データの処理

OrderByメソッドを使用して、重複データを処理することも可能です。

以下は、重複を排除し、昇順にソートする例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<string> names = new List<string> { "Alice", "Bob", "Charlie", "Alice", "David", "Bob" };
        // OrderByを使った重複データの処理
        var distinctSortedNames = names
            .Distinct() // 重複を排除
            .OrderBy(name => name); // 昇順にソート
        foreach (var name in distinctSortedNames)
        {
            Console.WriteLine(name);
        }
    }
}

Alice
Bob
Charlie
David

この例では、Distinctメソッドを使用して重複を排除し、その後OrderByメソッドで昇順にソートしています。

OrderByを使ったカスタムフィルタリング

OrderByメソッドを使用して、特定の条件に基づいたカスタムフィルタリングを行うことができます。

以下は、特定の条件を満たすデータを昇順にソートする例です。

using System;
using System.Collections.Generic;
using System.Linq;
class Product
{
    public string Name { get; set; }
    public decimal Price { get; set; }
}
class Program
{
    static void Main()
    {
        List<Product> products = new List<Product>
        {
            new Product { Name = "Laptop", Price = 1000 },
            new Product { Name = "Smartphone", Price = 500 },
            new Product { Name = "Tablet", Price = 300 },
            new Product { Name = "Monitor", Price = 200 }
        };
        // OrderByを使ったカスタムフィルタリング
        var filteredProducts = products
            .Where(p => p.Price < 600) // 価格が600未満の製品をフィルタリング
            .OrderBy(p => p.Price); // 昇順にソート
        foreach (var product in filteredProducts)
        {
            Console.WriteLine($"{product.Name}, {product.Price}");
        }
    }
}

Tablet, 300
Monitor, 200
Smartphone, 500

この例では、価格が600未満の製品をフィルタリングし、その後OrderByメソッドで昇順にソートしています。

これにより、特定の条件に基づいたデータの整列が可能になります。

まとめ

この記事では、C#のLINQにおけるOrderByメソッドの使い方やその応用例について詳しく解説しました。

具体的には、データの昇順ソートの基本から、ページング処理やランキングの作成、重複データの処理、カスタムフィルタリングに至るまで、さまざまなシナリオでの活用方法を紹介しました。

OrderByメソッドは、データの整列を簡単に行える強力なツールであり、特に大規模データセットやデータベースクエリにおいてもその効果を発揮します。

これを活用することで、より効率的なデータ処理が可能になりますので、ぜひ実際のプロジェクトで試してみてください。