クエリ式の基本

この記事では、C# でのクエリ式に関連する基本概念について説明します。

クエリとは何か。またどのような働きをするのか

クエリとは、指定したデータ ソース (単一または複数) からどのようなデータを取得し、それらのデータをどのような形式と編成で返すかを説明した、命令のセットです。 クエリは、それが生成する結果とは区別されます。

一般に、ソース データは、同じ種類の要素のシーケンスとして論理的に編成されます。 たとえば、SQL データベース テーブルには、行のシーケンスが含まれています。 XML ファイルには、XML 要素の "シーケンス" があります (ただし、XML 要素はツリー構造で階層化されています)。 メモリ内コレクションには、オブジェクトのシーケンスが含まれています。

アプリケーションの観点から言うと、元のソース データの特定の型や構造体は重要ではありません。 アプリケーションは常に、ソース データを IEnumerable<T> または IQueryable<T> コレクションとして認識します。 たとえば、LINQ to XML では、ソース データは IEnumerable<XElement> として表示されます。

クエリはこのソース シーケンスに対して、次の 3 つのうちのいずれかを実行することが考えられます。

• 個々 の要素を変更することなく、要素のサブセットを取得して新しいシーケンスを生成する。 するとクエリでは、返されたシーケンスをさまざまな方法で並べ替えたりグループ化することができます (下の例では scores が int[] であると想定しています)。

  IEnumerable<int> highScoresQuery =
      from score in scores
      where score > 80
      orderby score descending
      select score;
  

• 上記の例のように要素のシーケンスを取得するが、それらを新しい型のオブジェクトに変換する。 たとえば、クエリでデータ ソース内の特定の顧客レコードから姓のみを取得することができます。 または、完全なレコードを取得し、それを使用して別のメモリ内オブジェクト型または XML データを構築してから、最終的な結果シーケンスを生成することもできます。 次の例では、int から string へのプロジェクションを行っています。 highScoresQuery の新しい型があることに注目してください。

  IEnumerable<string> highScoresQuery2 =
      from score in scores
      where score > 80
      orderby score descending
      select $"The score is {score}";
  

• ソース データに関するシングルトン値を取得します。次に例を示します。

  • 特定の条件に一致する要素の数。

  • 最大値または最小値を持つ要素。

  • 条件に一致する最初の要素や、指定された要素セット内の特定の値の合計。 たとえば、次のクエリは、整数配列 scores から、80 より大きいスコアの数を返します。

    var highScoreCount = (
        from score in scores
        where score > 80
        select score
    ).Count();
    

    上記の例では、Enumerable.Count メソッドに対する呼び出しの前に、クエリ式を囲むかっこが使用されています。 新しい変数を使用して具体的な結果を保存することもできます。

    IEnumerable<int> highScoresQuery3 =
        from score in scores
        where score > 80
        select score;
    
    var scoreCount = highScoresQuery3.Count();
    

上記の例では、Count に対する呼び出しの前でクエリが実行されています。これは、Count によって返された要素の数を確認するために、highScoresQuery が結果を反復処理する必要があるためです。

クエリ式とは何か

クエリ式とは、クエリ構文で表されたクエリのことです。 クエリ式は、ファーストクラスの言語コンストラクトです。 他の式と同様に、C# 式が有効な任意のコンテキストで使用できます。 クエリ式の構文は、SQL や XQuery などのような宣言型の構文で記述された、一連の句で構成されます。 各句には、1 つ以上の C# 式が含まれ、これらの式自体がクエリ式であるか、クエリ式を含んでいる場合があります。

クエリ式は、 句の で始まり、select 句またはグループ 句で終わる必要があります。 最初の from 句と最後の select または group 句の間には、次の省略可能句を 1 つ以上含めることができます: where、orderby、join、let、および別の from 句。 into キーワードを使用して、join 句または group 句の結果を有効にして、同じクエリ式内のより多くのクエリ句のソースとして機能することもできます。

クエリ変数

LINQ では、クエリの結果ではなく、クエリを格納する変数を、クエリ変数と呼びます。 具体的には、クエリ変数は常に列挙可能な型であり、foreach ステートメントまたは IEnumerator.MoveNext() メソッドの直接呼び出しで反復処理されると、要素のシーケンスが生成されます。

record City(string Name, long Population);
record Country(string Name, double Area, long Population, List<City> Cities);
record Product(string Name, string Category);

static readonly City[] cities = [
    new City("Tokyo", 37_833_000),
    new City("Delhi", 30_290_000),
    new City("Shanghai", 27_110_000),
    new City("São Paulo", 22_043_000),
    new City("Mumbai", 20_412_000),
    new City("Beijing", 20_384_000),
    new City("Cairo", 18_772_000),
    new City("Dhaka", 17_598_000),
    new City("Osaka", 19_281_000),
    new City("New York-Newark", 18_604_000),
    new City("Karachi", 16_094_000),
    new City("Chongqing", 15_872_000),
    new City("Istanbul", 15_029_000),
    new City("Buenos Aires", 15_024_000),
    new City("Kolkata", 14_850_000),
    new City("Lagos", 14_368_000),
    new City("Kinshasa", 14_342_000),
    new City("Manila", 13_923_000),
    new City("Rio de Janeiro", 13_374_000),
    new City("Tianjin", 13_215_000)
];

static readonly Country[] countries = [
    new Country ("Vatican City", 0.44, 526, [new City("Vatican City", 826)]),
    new Country ("Monaco", 2.02, 38_000, [new City("Monte Carlo", 38_000)]),
    new Country ("Nauru", 21, 10_900, [new City("Yaren", 1_100)]),
    new Country ("Tuvalu", 26, 11_600, [new City("Funafuti", 6_200)]),
    new Country ("San Marino", 61, 33_900, [new City("San Marino", 4_500)]),
    new Country ("Liechtenstein", 160, 38_000, [new City("Vaduz", 5_200)]),
    new Country ("Marshall Islands", 181, 58_000, [new City("Majuro", 28_000)]),
    new Country ("Saint Kitts & Nevis", 261, 53_000, [new City("Basseterre", 13_000)])
];

次のコード例は、データ ソース、フィルター句、および並べ替え句がそれぞれ 1 つずつあり、ソース要素の変換がない、簡単なクエリ式を示したものです。 select 句でクエリが終わっています。

// Data source.
int[] scores = [90, 71, 82, 93, 75, 82];

// Query Expression.
IEnumerable<int> scoreQuery = //query variable
    from score in scores //required
    where score > 80 // optional
    orderby score descending // optional
    select score; //must end with select or group

// Execute the query to produce the results
foreach (var testScore in scoreQuery)
{
    Console.WriteLine(testScore);
}

// Output: 93 90 82 82

上記の例では、scoreQuery が クエリ変数です。クエリ変数は単にクエリと呼ばれることもあります。 クエリ変数には、foreach ループで生成された実際の結果データは格納されません。 また、foreach ステートメントの実行時に、クエリ結果はクエリ変数 scoreQuery を通じて返されません。 結果は、反復変数 testScore を通じて返されます。 scoreQuery 変数は 2 番目の foreach ループで反復処理できます。 この変数もデータ ソースも変更されていなければ、同じ結果が生成されます。

クエリ変数には、クエリ構文、メソッド構文、またはそれら 2 つの組合せで表現されたクエリを格納できます。 次の例では、queryMajorCities と queryMajorCities2 の両方がクエリ変数です。

City[] cities = [
    new City("Tokyo", 37_833_000),
    new City("Delhi", 30_290_000),
    new City("Shanghai", 27_110_000),
    new City("São Paulo", 22_043_000)
];

//Query syntax
IEnumerable<City> queryMajorCities =
    from city in cities
    where city.Population > 30_000_000
    select city;

// Execute the query to produce the results
foreach (City city in queryMajorCities)
{
    Console.WriteLine(city);
}

// Output:
// City { Name = Tokyo, Population = 37833000 }
// City { Name = Delhi, Population = 30290000 }

// Method-based syntax
IEnumerable<City> queryMajorCities2 = cities.Where(c => c.Population > 30_000_000);
// Execute the query to produce the results
foreach (City city in queryMajorCities2)
{
    Console.WriteLine(city);
}
// Output:
// City { Name = Tokyo, Population = 37833000 }
// City { Name = Delhi, Population = 30290000 }

これに対し、次の 2 つの例は、それぞれクエリで初期化されているものの、クエリ変数ではない変数を示しています。 これらは結果を格納するため、クエリ変数ではありません。

var highestScore = (
    from score in scores
    select score
).Max();

// or split the expression
IEnumerable<int> scoreQuery =
    from score in scores
    select score;

var highScore = scoreQuery.Max();
// the following returns the same result
highScore = scores.Max();

var largeCitiesList = (
    from country in countries
    from city in country.Cities
    where city.Population > 10000
    select city
).ToList();

// or split the expression
IEnumerable<City> largeCitiesQuery =
    from country in countries
    from city in country.Cities
    where city.Population > 10000
    select city;
var largeCitiesList2 = largeCitiesQuery.ToList();

クエリ変数の明示的型指定と暗黙的型指定

このドキュメントでは通常、明示的な型のクエリ変数で説明を行います。これは、クエリ変数と select 句の関係を示すためです。 ただし、 var キーワードを使用すれば、コンパイル時にクエリ変数 (またはその他のローカル変数) の型を推論するようにコンパイラに指示することもできます。 たとえば、この記事で先に示したクエリの例は、暗黙的な型指定を使用して表現することもできます。

var queryCities =
    from city in cities
    where city.Population > 100000
    select city;

前の例で、var の使用は省略可能です。 queryCities は、暗黙的または明示的に型指定された IEnumerable<City> です。

クエリ式を開始する

クエリ式は、from 句で始める必要があります。 この句では、データ ソースと範囲変数を指定します。 範囲変数は、ソース シーケンスが走査されるときの、ソース シーケンス内の連続する各要素を表します。 範囲変数は、データ ソース内の要素の型に基づいて厳密に型指定されます。 次の例では、countries が Country オブジェクトの配列であるため、範囲変数も Country として型指定されています。 範囲変数は厳密に型指定されるので、ドット演算子を使用して、その型の利用可能なメンバーにアクセスすることができます。

IEnumerable<Country> countryAreaQuery =
    from country in countries
    where country.Area > 20 //sq km
    select country;

範囲変数は、クエリがセミコロンまたは 継続 句のいずれかで終了するまで、範囲内にあります。

クエリ式には、複数の from 句を含めることができます。 ソース シーケンス内の各要素がそれ自体コレクションであるか、コレクションを含んでいる場合は、さらに from 句を使用します。 たとえば、Country オブジェクトのコレクションがあり、各オブジェクトに、City という名前の Cities オブジェクトのコレクションが格納されているとします。 その場合、各 City 内の Country オブジェクトを照会するには、次のように 2 つの from 句を使用します。

IEnumerable<City> cityQuery =
    from country in countries
    from city in country.Cities
    where city.Population > 10000
    select city;

詳細については、句の を参照してください。

クエリ式を終了する

クエリ式は、group 句または select 句のいずれかで終わる必要があります。

group 句

group 句は、指定したキーによって編成されたグループのシーケンスを生成するために使用します。 キーには、任意のデータ型を指定できます。 たとえば、次のクエリを実行すると、1 つ以上の Country オブジェクトが含まれ、国の名前の最初の文字を値とする char 型がキーである、グループのシーケンスが作成されます。

var queryCountryGroups =
    from country in countries
    group country by country.Name[0];

グループ化の詳細については、グループ句を参照してください。

select 句

select 句は、その他すべての型のシーケンスを生成するために使用します。 シンプルな select 句は、データ ソース内に含まれるオブジェクトと同じ型のオブジェクトのシーケンスを生成します。 この例では、データ ソースに Country オブジェクトが含まれています。 orderby 句は要素を新しい順序に並べ替え、select 句は並べ替えられた Country オブジェクトのシーケンスを生成します。

IEnumerable<Country> sortedQuery =
    from country in countries
    orderby country.Area
    select country;

select 句は、ソース データを新しい型のシーケンスに変換するために使用できます。 この変換は、プロジェクションとも呼ばれます。 次の例では、select 句は元の要素内にあるフィールドのサブセットのみを含んだ、匿名型のシーケンスをプロジェクトします。 新しいオブジェクトは、オブジェクト初期化子を使用して初期化されます。

var queryNameAndPop =
    from country in countries
    select new
    {
        Name = country.Name,
        Pop = country.Population
    };

したがって、この例では、クエリによって匿名型が生成されるため、var が必要です。

句を使用してソースデータを変換するさまざまな方法の詳細については、および のセレクト句を参照してください。

から への継続

into 句または select 句で group キーワードを使用すると、クエリを格納する一時的な識別子を作成できます。 グループ化または選択操作の後にクエリで追加のクエリ操作を実行する必要がある場合は、into 句を使用します。 次の例では、1 千万という範囲の人口で countries をグループ化しています。 これらのグループが作成された後、さらに句を使用して一部のグループをフィルターし、グループを昇順で並べ替えます。 これらの追加操作を実行するには、countryGroup で表される継続が必要です。

// percentileQuery is an IEnumerable<IGrouping<int, Country>>
var percentileQuery =
    from country in countries
    let percentile = (int)country.Population / 1_000
    group country by percentile into countryGroup
    where countryGroup.Key >= 20
    orderby countryGroup.Key
    select countryGroup;

// grouping is an IGrouping<int, Country>
foreach (var grouping in percentileQuery)
{
    Console.WriteLine(grouping.Key);
    foreach (var country in grouping)
    {
        Console.WriteLine(country.Name + ":" + country.Population);
    }
}

詳細については、 into を参照してください。

フィルター処理、並べ替え、および結合

開始の from 句と、終了の select またはgroup句の間には、その他のすべての省略可能句 (where、join、orderby、from、let) を必要に応じて使用できます。 省略可能な句はいずれも、クエリ本体で 0 回または複数回使用できます。

where 句

where 句は、1 つ以上の述語式に基づいて、ソース データから要素を除外するために使用します。 次の例では、where 句に 1 つの述語と 2 つの条件があります。

IEnumerable<City> queryCityPop =
    from city in cities
    where city.Population is < 15_000_000 and > 10_000_000
    select city;

詳細については、「where 句」を参照してください。

orderby 句

orderby 句は、結果を昇順または降順で並べ替えるために使用します。 第 2 の並べ替え順序を指定することもできます。 次の例では、country プロパティを使用して、Area オブジェクトに対する 第 1 の並べ替えを実行しています。 その後、Population プロパティを使用して第 2 の並べ替えを実行しています。

IEnumerable<Country> querySortedCountries =
    from country in countries
    orderby country.Area, country.Population descending
    select country;

ascending キーワードは省略可能です。順序が指定されていない場合は、これが既定の並べ替え順序になります。 詳しくは、「orderby 句」をご覧ください。

join 句

join 句は、各要素内の指定したキー間での等値比較に基づいて、1 つのデータ ソースの要素を別のデータ ソースの要素と関連付けたり、組み合わせたりするために使用します。 LINQ では、join 操作は要素の型が異なるオブジェクトのシーケンスに対して実行されます。 2 つのシーケンスを結合した後には、select または group ステートメント使用して、出力シーケンスに格納する要素を指定する必要があります。 また、匿名型を使用して、関連付けられた各要素セットのプロパティを、出力シーケンス用の新しい型に結合することもできます。 次の例では、prod プロパティが Category 文字列配列のいずれかのカテゴリに一致する categories オブジェクトを関連付けます。 Category が categories 内のどの文字列とも一致しない製品は除外されます。select ステートメントにより、cat と prod の両方からプロパティが取得された新しい型のプロジェクションが行われます。

var categoryQuery =
    from cat in categories
    join prod in products on cat equals prod.Category
    select new
    {
        Category = cat,
        Name = prod.Name
    };

join キーワードを使用して、into 操作の結果を一時変数に格納することで、グループ結合を実行することもできます。 詳細については、結合句を参照してください。

let 句

let 句は、式の結果 (メソッド呼び出しなど) を新しい範囲変数に格納するために使用します。 次の例では、範囲変数 firstName に、Split によって返される文字列配列の最初の要素が格納されています。

string[] names = ["Svetlana Omelchenko", "Claire O'Donnell", "Sven Mortensen", "Cesar Garcia"];
IEnumerable<string> queryFirstNames =
    from name in names
    let firstName = name.Split(' ')[0]
    select firstName;

foreach (var s in queryFirstNames)
{
    Console.Write(s + " ");
}

//Output: Svetlana Claire Sven Cesar

詳細については、「let 句」を参照してください。

クエリ式におけるサブクエリ

クエリ句には、それ自体にクエリ式を含めることができます。これは、サブクエリとも呼ばれます。 各サブクエリは、独自の from 句で始まり、最初の from 句で必ずしも同じデータ ソースを指しているとは限りません。 たとえば、次のクエリは、select ステートメントで grouping 操作の結果を取得するために使用されるクエリ式を示しています。

var queryGroupMax =
    from student in students
    group student by student.Year into studentGroup
    select new
    {
        Level = studentGroup.Key,
        HighestScore = (
            from student2 in studentGroup
            select student2.ExamScores.Average()
        ).Max()
    };

詳細については、「グループ化操作でのサブクエリの実行」を参照してください。

関連項目

• クエリ キーワード (LINQ)
• 標準クエリ演算子の概要