linq
標準クエリ演算子

備考

連結操作

連結とは、あるシーケンスを別のシーケンスに追加する操作のことです。

連合

2つのシーケンスを連結して1つのシーケンスを形成します。

メソッドの構文

// Concat

var numbers1 = new int[] { 1, 2, 3 };
var numbers2 = new int[] { 4, 5, 6 };

var numbers = numbers1.Concat(numbers2);

// numbers = { 1, 2, 3, 4, 5, 6 }

クエリの構文

// Not applicable.

フィルタリング操作

フィルタリングは、指定された条件を満たす要素のみを含むように結果セットを制限する操作を指します。

どこで

述語関数に基づく値を選択します。

メソッドの構文

// Where

var numbers = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 };

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

// evens = { 2, 4, 6, 8 }

クエリの構文

// where

var numbers = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 };

var odds = from n in numbers
           where n % 2 != 0
           select n;

// odds = { 1, 3, 5, 7 }

OfType

指定した型にキャストできるかどうかによって値を選択します。

メソッドの構文

// OfType

var numbers = new object[] { 1, "one", 2, "two", 3, "three" };

var strings = numbers.OfType<string>();

// strings = { "one", "two", "three" }

クエリの構文

// Not applicable.

結合操作

2つのデータソースの結合は、あるデータソース内のオブジェクトと、別のデータソース内の共通の属性を共有するオブジェクトとの関連付けです。

参加する

キーセレクター関数に基づいて2つのシーケンスを結合し、値のペアを抽出します。

メソッドの構文

// Join

class Customer
{
    public int Id { get; set; }
    public string Name { get; set; }
}

class Order
{
    public string Description { get; set; }
    public int CustomerId { get; set; }
}
...

var customers = new Customer[] 
{
    new Customer { Id = 1, Name = "C1" },
    new Customer { Id = 2, Name = "C2" },
    new Customer { Id = 3, Name = "C3" }
};

var orders = new Order[]
{
    new Order { Description = "O1", CustomerId = 1 },
    new Order { Description = "O2", CustomerId = 1 },
    new Order { Description = "O3", CustomerId = 2 },
    new Order { Description = "O4", CustomerId = 3 },
};

var join = customers.Join(orders, c => c.Id, o => o.CustomerId, (c, o) => c.Name + "-" + o.Description);

// join = { "C1-O1", "C1-O2", "C2-O3", "C3-O4" }

クエリの構文

// join … in … on … equals …

var join = from c in customers
           join o in orders
           on c.Id equals o.CustomerId
           select o.Description + "-" + c.Name;

// join = { "O1-C1", "O2-C1", "O3-C2", "O4-C3" }

GroupJoin

キーセレクタ関数に基づいて2つのシーケンスを結合し、各要素の結果のマッチングをグループ化します。

メソッドの構文

// GroupJoin

var groupJoin = customers.GroupJoin(orders,
                                    c => c.Id, 
                                    o => o.CustomerId, 
                                    (c, ors) => c.Name + "-" + string.Join(",", ors.Select(o => o.Description)));

// groupJoin = { "C1-O1,O2", "C2-O3", "C3-O4" }

クエリの構文

// join … in … on … equals … into …

var groupJoin = from c in customers
                join o in orders               
                on c.Id equals o.CustomerId
                into customerOrders
                select string.Join(",", customerOrders.Select(o => o.Description)) + "-" + c.Name;

// groupJoin = { "O1,O2-C1", "O3-C2", "O4-C3" }

ジップ

指定された関数を2つのシーケンスの対​​応する要素に適用し、一連の結果を生成します。

var numbers = new [] { 1, 2, 3, 4, 5, 6 };
var words = new [] { "one", "two", "three" };

var numbersWithWords =
    numbers
    .Zip(
        words,
        (number, word) => new { number, word });

// Results

//| number | word   |
//| ------ | ------ |
//| 1      |  one   |
//| 2      |  two   |
//| 3      |  three |

投影操作

プロジェクションとは、オブジェクトを新しいフォームに変換する操作のことです。

選択

変換関数に基づく値を投影します。

メソッドの構文

// Select

var numbers = new int[] { 1, 2, 3, 4, 5 };

var strings = numbers.Select(n => n.ToString());

// strings = { "1", "2", "3", "4", "5" }

クエリの構文

// select

var numbers = new int[] { 1, 2, 3, 4, 5 };

var strings = from n in numbers
              select n.ToString();

// strings = { "1", "2", "3", "4", "5" }

SelectMany

変換関数に基づく値のシーケンスをプロジェクトし、それらを1つのシーケンスにフラット化します。

メソッドの構文

// SelectMany

class Customer
{
    public Order[] Orders { get; set; }
}

class Order
{
    public Order(string desc) { Description = desc; }
    public string Description { get; set; }
}
...

var customers = new Customer[] 
{
    new Customer { Orders = new Order[] { new Order("O1"), new Order("O2") } },
    new Customer { Orders = new Order[] { new Order("O3") } },
    new Customer { Orders = new Order[] { new Order("O4") } },
};

var orders = customers.SelectMany(c => c.Orders);

// orders = { Order("O1"), Order("O3"), Order("O3"), Order("O4") }

クエリの構文

// multiples from

var orders = from c in customers
             from o in c.Orders
             select o;

// orders = { Order("O1"), Order("O3"), Order("O3"), Order("O4") }

並べ替え操作

ソート操作は、1つまたは複数の属性に基づいてシーケンスの要素を順序付けます。

OrderBy

値を昇順にソートします。

メソッドの構文

// OrderBy

var numbers = new int[] { 5, 4, 8, 2, 7, 1, 9, 3, 6 };

var ordered = numbers.OrderBy(n => n);

// ordered = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }

クエリの構文

// orderby

var numbers = new int[] { 5, 4, 8, 2, 7, 1, 9, 3, 6 };

var ordered = from n in numbers
              orderby n
              select n;

// ordered = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }

OrderByDescending

値を降順でソートします。

メソッドの構文

// OrderByDescending

var numbers = new int[] { 5, 4, 8, 2, 7, 1, 9, 3, 6 };

var ordered = numbers.OrderByDescending(n => n);

// ordered = { 9, 8, 7, 6, 5, 4, 3, 2, 1 }

クエリの構文

// orderby

var numbers = new int[] { 5, 4, 8, 2, 7, 1, 9, 3, 6 };

var ordered = from n in numbers
              orderby n descending
              select n;

// ordered = { 9, 8, 7, 6, 5, 4, 3, 2, 1 }

次に、

昇順で2番目のソートを実行します。

メソッドの構文

// ThenBy

string[] words = { "the", "quick", "brown", "fox", "jumps" };

var ordered = words.OrderBy(w => w.Length).ThenBy(w => w[0]);

// ordered = { "fox", "the", "brown", "jumps", "quick" }

クエリの構文

// orderby …, …

string[] words = { "the", "quick", "brown", "fox", "jumps" };

var ordered = from w in words
              orderby w.Length, w[0]
              select w;

// ordered = { "fox", "the", "brown", "jumps", "quick" }

その後、

降順でセカンダリソートを実行します。

メソッドの構文

// ThenByDescending

string[] words = { "the", "quick", "brown", "fox", "jumps" };

var ordered = words.OrderBy(w => w[0]).ThenByDescending(w => w.Length);

// ordered = { "brown", "fox", "jumps", "quick", "the" }

クエリの構文

// orderby …, … descending

string[] words = { "the", "quick", "brown", "fox", "jumps" };

var ordered = from w in words
              orderby w.Length, w[0] descending
              select w;

// ordered = { "the", "fox", "quick", "jumps", "brown" }

逆

コレクション内の要素の順序を元に戻します。

メソッドの構文

// Reverse

var numbers = new int[] { 1, 2, 3, 4, 5 };

var reversed = numbers.Reverse();

// reversed = { 5, 4, 3, 2, 1 }

クエリの構文

// Not applicable.

変換操作

変換操作は入力オブジェクトのタイプを変更します。

AsEnumerable

IEnumerableとして型指定された入力を返します。

メソッドの構文

// AsEnumerable

int[] numbers = { 1, 2, 3, 4, 5 };

var nums = numbers.AsEnumerable();

// nums: static type is IEnumerable<int>

クエリの構文

// Not applicable.

AsQueryable

IEnumerableをIQueryableに変換します。

メソッドの構文

// AsQueryable

int[] numbers = { 1, 2, 3, 4, 5 };

var nums = numbers.AsQueryable();

// nums: static type is IQueryable<int>

クエリの構文

// Not applicable.

キャスト

コレクションの要素を指定された型にキャストします。

メソッドの構文

// Cast

var numbers = new object[] { 1, 2, 3, 4, 5 };

var nums = numbers.Cast<int>();

// nums: static type is IEnumerable<int>

クエリの構文

// Use an explicitly typed range variable.

var numbers = new object[] { 1, 2, 3, 4, 5 };

var nums = from int n in numbers select n;

// nums: static type is IEnumerable<int>

OfType

指定した型にキャストできるかどうかによって、値をフィルタリングします。

メソッドの構文

// OfType

var objects = new object[] { 1, "one", 2, "two", 3, "three" };

var numbers = objects.OfType<int>();

// nums = { 1, 2, 3 }

クエリの構文

// Not applicable.

ToArray

コレクションを配列に変換します。

メソッドの構文

// ToArray

var numbers = Enumerable.Range(1, 5);

int[] array = numbers.ToArray();

// array = { 1, 2, 3, 4, 5 }

クエリの構文

// Not applicable.

ToList

コレクションをリストに変換します。

メソッドの構文

// ToList

var numbers = Enumerable.Range(1, 5);

List<int> list = numbers.ToList();

// list = { 1, 2, 3, 4, 5 }

クエリの構文

// Not applicable.

ToDictionary

キーセレクター機能に基づいて要素を辞書に挿入します。

メソッドの構文

// ToDictionary

var numbers = new int[] { 1, 2, 3 };

var dict = numbers.ToDictionary(n => n.ToString());

// dict = { "1" => 1, "2" => 2, "3" => 3 }

クエリの構文

// Not applicable.

集約操作

集約演算は、値の集合から単一の値を計算します。

集計

コレクションの値に対してカスタム集計操作を実行します。

メソッドの構文

// Aggregate

var numbers = new int[] { 1, 2, 3, 4, 5 };

var product = numbers.Aggregate(1, (acc, n) => acc * n);

// product = 120

クエリの構文

// Not applicable.

平均

値のコレクションの平均値を計算します。

メソッドの構文

// Average

var numbers = new int[] { 1, 2, 3, 4, 5 };

var average = numbers.Average();

// average = 3

クエリの構文

// Not applicable.

カウント

コレクション内の要素をカウントし、オプションで述語関数を満たす要素のみをカウントします。

メソッドの構文

// Count

var numbers = new int[] { 1, 2, 3, 4, 5 };

int count = numbers.Count(n => n % 2 == 0);

// count = 2

クエリの構文

// Not applicable.

ロングカウント

大量のコレクション内の要素をカウントし、オプションで述語関数を満たす要素のみをカウントします。

メソッドの構文

// LongCount

var numbers = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

long count = numbers.LongCount();

// count = 10

クエリの構文

// Not applicable.

最大

コレクション内の最大値を決定します。コレクションが空の場合は例外をスローします。

メソッドの構文

// Max

var numbers = new int[] { 1, 2, 3, 4, 5 };

var max = numbers.Max();

// max = 5

クエリの構文

// Not applicable.

分

コレクション内の最小値を決定します。コレクションが空の場合は例外をスローします。

メソッドの構文

// Min

var numbers = new int[] { 1, 2, 3, 4, 5 };

var min = numbers.Min();

// min = 1

クエリの構文

// Not applicable.

Min / MaxOrDefault

他のLinQ拡張とは異なり、 Min()とMax()は例外なしで過負荷を持ちません。したがって、 Min()またはMax()呼び出す前に、 IEnumerableをAny()チェックする必要があります。

// Max

var numbers = new int[] { };

var max = numbers.Any() ? numbers.Max() : 0;

// max = 0

和

コレクション内の値の合計を計算します。

メソッドの構文

// Sum

var numbers = new int[] { 1, 2, 3, 4, 5 };

var sum = numbers.Sum();

// sum = 15

クエリの構文

// Not applicable.

数量演算

数量化演算子は、シーケンス内の要素の一部またはすべてが条件を満たすかどうかを示すブール値を返します。

すべて

シーケンス内のすべての要素が条件を満たすかどうかを決定します。

メソッドの構文

// All

var numbers = new int[] { 1, 2, 3, 4, 5 };

bool areLessThan10 = numbers.All(n => n < 10);

// areLessThan10 = true

クエリの構文

// Not applicable.

どれか

シーケンス内の要素が条件を満たすかどうかを判定します。

メソッドの構文

// Any

var numbers = new int[] { 1, 2, 3, 4, 5 };

bool anyOneIsEven = numbers.Any(n => n % 2 == 0);

// anyOneIsEven = true

クエリの構文

// Not applicable.

含有

シーケンスに指定された要素が含まれているかどうかを判定します。

メソッドの構文

// Contains

var numbers = new int[] { 1, 2, 3, 4, 5 };

bool appears = numbers.Contains(10);

// appears = false

クエリの構文

// Not applicable.

グループ化操作

グループ化とは、各グループの要素が共通の属性を共有するように、データをグループにまとめる操作のことです。

GroupBy

共通の属性を共有する要素をグループ化します。

メソッドの構文

// GroupBy

class Order
{
    public string Customer { get; set; }
    public string Description { get; set; }
}
...

var orders = new Order[] 
{
    new Order { Customer = "C1", Description = "O1" },
    new Order { Customer = "C2", Description = "O2" },
    new Order { Customer = "C3", Description = "O3" },
    new Order { Customer = "C1", Description = "O4" },
    new Order { Customer = "C1", Description = "O5" },
    new Order { Customer = "C3", Description = "O6" },
};

var groups = orders.GroupBy(o => o.Customer);

// groups: { (Key="C1", Values="O1","O4","O5"), (Key="C2", Values="O2"), (Key="C3", Values="O3","O6") }

クエリの構文

// group … by

var groups = from o in orders
             group o by o.Customer;

// groups: { (Key="C1", Values="O1","O4","O5"), (Key="C2", Values="O2"), (Key="C3", Values="O3","O6") }

見上げる

キーセレクター関数に基づいて要素を1対多の辞書に挿入します。

メソッドの構文

// ToLookUp

var ordersByCustomer = orders.ToLookup(o => o.Customer);

// ordersByCustomer = ILookUp<string, Order>
// {
//     "C1" => { Order("01"), Order("04"), Order("05") },
//     "C2" => { Order("02") },
//     "C3" => { Order("03"), Order("06") }
// }

クエリの構文

// Not applicable.

パーティション操作

パーティショニングとは、入力シーケンスを2つのセクションに分割し、要素を並べ替えずにセクションの1つを戻す操作を指します。

スキップ

シーケンス内の指定された位置まで要素をスキップします。

メソッドの構文

// Skip

var numbers = new int[] { 1, 2, 3, 4, 5 };

var skipped = numbers.Skip(3);

// skipped = { 4, 5 }

クエリの構文

// Not applicable.

SkipWhile

要素が条件を満たさなくなるまで述語関数に基づいて要素をスキップします。

メソッドの構文

// Skip

var numbers = new int[] { 1, 3, 5, 2, 1, 3, 5 };

var skipLeadingOdds = numbers.SkipWhile(n => n % 2 != 0);

// skipLeadingOdds = { 2, 1, 3, 5 }

クエリの構文

// Not applicable.

取る

シーケンス内の指定された位置まで要素を受け取ります。

メソッドの構文

// Take

var numbers = new int[] { 1, 2, 3, 4, 5 };

var taken = numbers.Take(3);

// taken = { 1, 2, 3 }

クエリの構文

// Not applicable.

TakeWhile

要素が条件を満たさなくなるまで、述語関数に基づいて要素を取ります。

メソッドの構文

// TakeWhile

var numbers = new int[] { 1, 3, 5, 2, 1, 3, 5 };

var takeLeadingOdds = numbers.TakeWhile(n => n % 2 != 0);

// takeLeadingOdds = { 1, 3, 5 }

クエリの構文

// Not applicable.

生成操作

世代とは、一連の新しい値を作成することです。

DefaultIfEmpty

空のコレクションを既定値のシングルトンコレクションに置き換えます。

メソッドの構文

// DefaultIfEmpty

var nums = new int[0];

var numbers = nums.DefaultIfEmpty();

// numbers = { 0 }

クエリの構文

// Not applicable.

空の

空のコレクションを返します。

メソッドの構文

// Empty

var empty = Enumerable.Empty<string>();

// empty = IEnumerable<string> { }

クエリの構文

// Not applicable.

範囲

一連の数値を含むコレクションを生成します。

メソッドの構文

// Range

var range = Enumerable.Range(1, 5);

// range = { 1, 2, 3, 4, 5 }

クエリの構文

// Not applicable.

繰り返す

1つの繰り返し値を含むコレクションを生成します。

メソッドの構文

// Repeat

var repeats = Enumerable.Repeat("s", 3);

// repeats = { "s", "s", "s" }

クエリの構文

// Not applicable.

操作を設定する

集合演算は、同一または別個の集合（または集合）内の同等の要素の有無に基づく結果集合を生成する問合せ演算を指す。

独特な

コレクションから重複した値を削除します。

メソッドの構文

// Distinct

var numbers = new int[] { 1, 2, 3, 1, 2, 3 };

var distinct = numbers.Distinct();

// distinct = { 1, 2, 3 }

クエリの構文

// Not applicable.

例外

セットの差を返します。これは、2つ目のコレクションに表示されない1つのコレクションの要素を意味します。

メソッドの構文

// Except

var numbers1 = new int[] { 1, 2, 3, 4, 5 };
var numbers2 = new int[] { 4, 5, 6, 7, 8 };

var except = numbers1.Except(numbers2);

// except = { 1, 2, 3 }

クエリの構文

// Not applicable.

交差点

セット交差点を返します。これは、2つのコレクションのそれぞれに表示される要素を意味します。

メソッドの構文

// Intersect

var numbers1 = new int[] { 1, 2, 3, 4, 5 };
var numbers2 = new int[] { 4, 5, 6, 7, 8 };

var intersect = numbers1.Intersect(numbers2);

// intersect = { 4, 5 }

クエリの構文

// Not applicable.

連合

2つのコレクションのいずれかに表示されるユニークな要素を意味する集合体を返します。

メソッドの構文

// Union

var numbers1 = new int[] { 1, 2, 3, 4, 5 };
var numbers2 = new int[] { 4, 5, 6, 7, 8 };

var union = numbers1.Union(numbers2);

// union = { 1, 2, 3, 4, 5, 6, 7, 8 }

クエリの構文

// Not applicable.

等価操作

対応する要素が等しく、同じ数の要素を有する2つの系列は等しいと考えられる。

SequenceEqual

ペアごとに要素を比較して2つのシーケンスが等しいかどうかを判定します。

メソッドの構文

// SequenceEqual

var numbers1 = new int[] { 1, 2, 3, 4, 5 };
var numbers2 = new int[] { 1, 2, 3, 4, 5 };

var equals = numbers1.SequenceEqual(numbers2);

// equals = true

クエリの構文

// Not Applicable.

要素の操作

要素操作は、シーケンスから単一の特定の要素を返します。

ElementAt

コレクション内の指定されたインデックスにある要素を返します。

メソッドの構文

// ElementAt

var strings = new string[] { "zero", "one", "two", "three" };

var str = strings.ElementAt(2);

// str = "two"

クエリの構文

// Not Applicable.

ElementAtOrDefault

コレクション内の指定されたインデックスにある要素を返します。インデックスが範囲外の場合にはデフォルト値を返します。

メソッドの構文

// ElementAtOrDefault

var strings = new string[] { "zero", "one", "two", "three" };

var str = strings.ElementAtOrDefault(10);

// str = null

クエリの構文

// Not Applicable.

最初

コレクションの最初の要素、または条件を満たす最初の要素を返します。

メソッドの構文

// First

var numbers = new int[] { 1, 2, 3, 4, 5 };

var first = strings.First();

// first = 1

クエリの構文

// Not Applicable.

FirstOrDefault

コレクションの最初の要素、または条件を満たす最初の要素を返します。そのような要素が存在しない場合は、デフォルト値を返します。

メソッドの構文

// FirstOrDefault

var numbers = new int[] { 1, 2, 3, 4, 5 };

var firstGreaterThanTen = strings.FirstOrDefault(n => n > 10);

// firstGreaterThanTen = 0

クエリの構文

// Not Applicable.

最終

コレクションの最後の要素、または条件を満たす最後の要素を返します。

メソッドの構文

// Last

var numbers = new int[] { 1, 2, 3, 4, 5 };

var last = strings.Last();

// last = 5

クエリの構文

// Not Applicable.

LastOrDefault

コレクションの最後の要素、または条件を満たす最後の要素を返します。そのような要素が存在しない場合は、デフォルト値を返します。

メソッドの構文

// LastOrDefault

var numbers = new int[] { 1, 2, 3, 4, 5 };

var lastGreaterThanTen = strings.LastOrDefault(n => n > 10);

// lastGreaterThanTen = 0

クエリの構文

// Not Applicable.

シングル

コレクションの唯一の要素、または条件を満たす唯一の要素を返します。

メソッドの構文

// Single

var numbers = new int[] { 1 };

var single = strings.Single();

// single = 1

クエリの構文

// Not Applicable.

SingleOrDefault

コレクションの唯一の要素、または条件を満たす唯一の要素を返します。そのような要素が存在しない場合、またはコレクションに厳密に1つの要素が含まれていない場合は、デフォルト値を返します。

メソッドの構文

// SingleOrDefault

var numbers = new int[] { 1, 2, 3, 4, 5 };

var singleGreaterThanFour = strings.SingleOrDefault(n => n > 4);

// singleGreaterThanFour = 5

クエリの構文

// Not Applicable.