a záradékból (C# hivatkozás)

Cikk
12/15/2023

A lekérdezési kifejezésnek záradékkal from kell kezdődnie. Emellett a lekérdezési kifejezések al lekérdezéseket is tartalmazhatnak, amelyek szintén záradékkal from kezdődnek. A from záradék a következőket adja meg:

Az az adatforrás, amelyen a lekérdezést vagy az al lekérdezést futtatni fogja.
Egy helyi tartományváltozó , amely a forrásütemezés egyes elemeit jelöli.

A tartományváltozó és az adatforrás is erősen be van állítva. A záradékban from hivatkozott adatforrásnak olyan típusúnak IEnumerablevagy származtatott típusnak kell lennie, IEnumerable<T>mint például IQueryable<T>.

Az alábbi példában numbers az adatforrás és num a tartományváltozó látható. Vegye figyelembe, hogy mindkét változó erősen be van állítva annak ellenére, hogy a var kulcsszót használja.

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

A tartományváltozó

A fordító a tartományváltozó típusára következtet az adatforrás implementálásakor IEnumerable<T>. Ha például a forrásnak van egy típusa IEnumerable<Customer>, akkor a tartományváltozó a következőre lesz következtetve Customer. Csak akkor kell explicit módon megadnia a típust, ha a forrás nem általános IEnumerable típus, például ArrayList. További információ: Tömblista lekérdezése LINQ-val.

Az előző példában num a rendszer a típusra intkövetkeztet. Mivel a tartományváltozó erősen be van állítva, meghívhat metódusokat rajta, vagy más műveletekben is használhatja. Írás helyett select numpéldául azt select num.ToString() is megteheti, hogy a lekérdezési kifejezés egész számok helyett sztringsorozatot ad vissza. Vagy írhat select num + 10 , hogy a kifejezés a 14, 11, 13, 12, 10 sorozatot adja vissza. További információkért lásd a select záradékot.

A tartományváltozó olyan, mint egy foreach utasítás iterációs változója, kivéve egy nagyon fontos különbséget: a tartományváltozók valójában soha nem tárolnak adatokat a forrásból. Ez csak egy szintaktikai kényelem, amely lehetővé teszi, hogy a lekérdezés leírja, mi fog történni a lekérdezés végrehajtásakor. További információ: Bevezetés a LINQ-lekérdezések (C#) használatába.

Összetett záradékokból

Bizonyos esetekben előfordulhat, hogy a forrásütemezés minden eleme vagy sorozat, vagy egy sorozatot tartalmaz. Előfordulhat például, hogy az adatforrás olyan IEnumerable<Student> , ahol a sorozat minden tanulói objektuma tartalmazza a teszteredmények listáját. Az egyes Student elemek belső listájának eléréséhez összetett from záradékokat használhat. A technika olyan, mint beágyazott foreach utasítások használata. Az eredmények szűréséhez hozzáadhatja a hol vagy az orderby záradékokat bármelyik from záradékhoz. Az alábbi példa egy objektumsorozatot Student mutat be, amelyek mindegyike a teszteredményeket képviselő egész számok belső List részét tartalmazza. A belső lista eléréséhez használjon összetett from záradékot. Szükség esetén beszúrhat záradékokat a két from záradék közé.

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
*/

Több záradék használata illesztések végrehajtásához

A rendszer összetett from záradékot használ egy adatforrás belső gyűjteményeinek eléréséhez. A lekérdezések azonban több from záradékot is tartalmazhatnak, amelyek kiegészítő lekérdezéseket hoznak létre független adatforrásokból. Ez a technika lehetővé teszi bizonyos típusú illesztési műveletek végrehajtását, amelyek nem végezhetők el az illesztési záradék használatával.

Az alábbi példa bemutatja, hogyan használható két from záradék két adatforrás teljes keresztcsatlakozásához.

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
        */

További információ a több from záradékot használó illesztési műveletekről: Bal oldali külső illesztések végrehajtása.

Megosztás a következőn keresztül:

a záradékból (C# hivatkozás)

A tartományváltozó

Összetett záradékokból

Több záradék használata illesztések végrehajtásához

Lásd még

Visszajelzés

További források