from 子句 (C# 參考)

發行項
04/07/2023

查詢運算式的開頭必須是 from 子句。此外，查詢運算式可以包含子查詢，也是以 from 子句開頭。 from 子句指定下列內容：

會執行查詢或子查詢的資料來源。
本機「範圍變數」，代表來源序列中的每個項目。

範圍變數和資料來源都是強型別。 from 子句中參考的資料來源，必須有 IEnumerable、IEnumerable<T> 類型，或 IQueryable<T> 等衍生類型。

在下例中，numbers 是資料來源，而 num 是範圍變數。請注意，即使使用 var 關鍵字，這兩個變數都是強型別。

class LowNums
{
    static void Main()
    {
        // A simple data source.
        int[] numbers = [5, 4, 1, 3, 9, 8, 6, 7, 2, 0];

        // Create the query.
        // lowNums is an IEnumerable<int>
        var lowNums = from num in numbers
            where num < 5
            select num;

        // Execute the query.
        foreach (int i in lowNums)
        {
            Console.Write(i + " ");
        }
    }
}
// Output: 4 1 3 2 0

範圍變數

當資料來源實作 IEnumerable<T> 時，編譯器會推斷範圍變數的類型。例如，如果來源有類型 IEnumerable<Customer>，則範圍變數推斷為 Customer。必須明確指定類型的時機，是當來源為非泛型的 IEnumerable 類型時，如 ArrayList。如需詳細資訊，請參閱如何使用 LINQ 查詢 ArrayList (機器翻譯)。

在前例中，num 推斷為類型 int。因為範圍變數是強型別，所以您可以對它呼叫方法，或在其他作業中使用它。例如，不寫入 select num，而是可以寫入 select num.ToString() 讓查詢運算式傳回一串字串，不是整數序列。或者可以寫入 select num + 10 讓運算式傳回 14、11、13、12、10 序列。如需詳細資訊，請參閱 select 子句。

範圍變數就像 foreach 陳述式中的反覆項目變數，但有一個非常重要的差異：範圍變數從不真正儲存來源的資料。它只是用來提供語法上的便利性，為的是要讓查詢描述在執行查詢時會發生什麼。如需詳細資訊，請參閱 LINQ 查詢簡介 (C#)。

複合 from 子句

在某些情況下，來源序列中的每個項目自己本身可能就是序列或包含序列。例如，您的資料來源可能是 IEnumerable<Student>，其中序列中的每個學生物件都包含測驗分數的清單。若要存取每個 Student 項目內的內部清單，您可以使用複合 from 子句。技巧就像使用巢狀的 foreach 陳述式一樣。您可以將 where 或 orderby 子句新增至任一 from 子句來篩選結果。下例顯示一系列 Student 物件，每個都包含代表測試分數的整數內部 List。若要存取內部清單，請使用複合 from 子句。如有必要，您可以在兩個 from 子句之間插入子句。

class CompoundFrom
{
    // The element type of the data source.
    public class Student
    {
        public required string LastName { get; init; }
        public required List<int> Scores {get; init;}
    }

    static void Main()
    {

        // Use a collection initializer to create the data source. Note that
        // each element in the list contains an inner sequence of scores.
        List<Student> students =
        [
           new Student {LastName="Omelchenko", Scores= [97, 72, 81, 60]},
           new Student {LastName="O'Donnell", Scores= [75, 84, 91, 39]},
           new Student {LastName="Mortensen", Scores= [88, 94, 65, 85]},
           new Student {LastName="Garcia", Scores= [97, 89, 85, 82]},
           new Student {LastName="Beebe", Scores= [35, 72, 91, 70]}
        ];

        // Use a compound from to access the inner sequence within each element.
        // Note the similarity to a nested foreach statement.
        var scoreQuery = from student in students
                         from score in student.Scores
                            where score > 90
                            select new { Last = student.LastName, score };

        // Execute the queries.
        Console.WriteLine("scoreQuery:");
        // Rest the mouse pointer on scoreQuery in the following line to
        // see its type. The type is IEnumerable<'a>, where 'a is an
        // anonymous type defined as new {string Last, int score}. That is,
        // each instance of this anonymous type has two members, a string
        // (Last) and an int (score).
        foreach (var student in scoreQuery)
        {
            Console.WriteLine("{0} Score: {1}", student.Last, student.score);
        }
    }
}
/*
scoreQuery:
Omelchenko Score: 97
O'Donnell Score: 91
Mortensen Score: 94
Garcia Score: 97
Beebe Score: 91
*/

使用多個 from 子句執行聯結

複合 from 子句是用來存取單一資料來源中的內部集合。不過，查詢也可以包含多個 from 子句，從獨立的資料來源產生增補查詢。這項技術可讓您執行特定的聯結作業類型，這些是使用 join 子句都不可能執行的類型。

下例示範如何使用兩個 from 子句形成兩個資料來源的完整交叉聯結。

class CompoundFrom2
{
    static void Main()
    {
        char[] upperCase = ['A', 'B', 'C'];
        char[] lowerCase = ['x', 'y', 'z'];

        // The type of joinQuery1 is IEnumerable<'a>, where 'a
        // indicates an anonymous type. This anonymous type has two
        // members, upper and lower, both of type char.
        var joinQuery1 =
            from upper in upperCase
            from lower in lowerCase
            select new { upper, lower };

        // The type of joinQuery2 is IEnumerable<'a>, where 'a
        // indicates an anonymous type. This anonymous type has two
        // members, upper and lower, both of type char.
        var joinQuery2 =
            from lower in lowerCase
            where lower != 'x'
            from upper in upperCase
            select new { lower, upper };

        // Execute the queries.
        Console.WriteLine("Cross join:");
        // Rest the mouse pointer on joinQuery1 to verify its type.
        foreach (var pair in joinQuery1)
        {
            Console.WriteLine("{0} is matched to {1}", pair.upper, pair.lower);
        }

        Console.WriteLine("Filtered non-equijoin:");
        // Rest the mouse pointer over joinQuery2 to verify its type.
        foreach (var pair in joinQuery2)
        {
            Console.WriteLine("{0} is matched to {1}", pair.lower, pair.upper);
        }

        // Keep the console window open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
/* Output:
        Cross join:
        A is matched to x
        A is matched to y
        A is matched to z
        B is matched to x
        B is matched to y
        B is matched to z
        C is matched to x
        C is matched to y
        C is matched to z
        Filtered non-equijoin:
        y is matched to A
        y is matched to B
        y is matched to C
        z is matched to A
        z is matched to B
        z is matched to C
        */

如需使用多個 from 子句的聯結作業詳細資訊，請參閱執行左方外部聯結。

from 子句 (C# 參考)

範圍變數

複合 from 子句

使用多個 from 子句執行聯結

另請參閱

意見反應

其他資源