LINQ Join, Csoportosítás

Eddig áttekintettük az egyszerű műveletek sorozatát. A LINQ igazán akkor válik izgalmassá, mikor például több osztályból, listából kell adatokat összeszednünk egy új típusba.

Join

Ezt a műveletet join-nak vagy összekapcsolásnak nevezzük. A Join műveleteknek több fajtája van. Objektumok esetén a legkönnyebben az inner join művelet valósítható meg. Ez két típus metszetét jelenti. A többi join típus is támogatott, viszont ezekkel itt nem foglalkozunk. Ennek az oka az, hogy a Join műveletre leginkább SQL kiszolgálón végzett lekérdezéseknél van szükség. Az SQL szerverekhez készült LINQ keretrendszerek (Pl. Entity Framework) lehetőséget biztosítanak a további Join műveletek elvégzéséhez egyszerűen.

Nézzünk egy példát a join műveletre.

using System;
using System.Collections.Generic;
using System.Linq;

namespace PeldaLinqJoin
{
    struct Pelda
    {
        public int X { get; set; }
        public int Y { get; set; }
    }

    struct Pelda2
    {
        public int Y { get; set; }
        public int Z { get; set; }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var elemek = new List<Pelda>
            {
                new Pelda { X = 10, Y = 20 },
                new Pelda { X = 11, Y = 23 },
                new Pelda { X = 44, Y = 42 },
                new Pelda { X = 7, Y = 1 },
                new Pelda { X = 9, Y = 12 },
            };

            var elemek2 = new List<Pelda2>
            {
                new Pelda2 { Z = 88, Y = 20 },
                new Pelda2 { Z = 14, Y = 23 },
                new Pelda2 { Z = 63, Y = 42 },
                new Pelda2 { Z = 11, Y = 1 },
                new Pelda2 { Z = 4, Y = 12 },
            };

            var eredmeny = from elem in elemek
                           join elem2 in elemek2 on
                           elem.Y equals elem2.Y
                           select new
                           {
                               X = elem.X,
                               Y = elem.Y,
                               Z = elem2.Z
                           };

            //ugyan ez, lambda szintaxissal:
            var eredmeny2 = elemek.Join(elemek2, i => i.Y, j => j.Y, (i, j) => new
            {
                X = i.X,
                Y = i.Y,
                Z = j.Z
            });

            foreach (var item in eredmeny)
            {
                Console.WriteLine("{0}, {1}, {2}", item.X, item.Y, item.Z);
            }
            Console.ReadKey();
        }
    }
}

A program kimenete:

10, 20, 88
11, 23, 14
44, 42, 63
7, 1, 11
9, 12, 4

A példában látható módon az összekapcsolás első lépése a szokásos változó hivatkozás az első kollekcióból, majd jön a join kulcsszó, ami után szintén egy változót hivatkozunk be a második kollekcióból. Ezután meg kell adni az összekapcsolási feltételt. Ezt az on után kell megtenni. Jelen esetben itt az a feltételünk, hogy az Y változóknak meg kell egyeznie. Az összekapcsoláshoz minden esetben valamiféle egyenlőségre kell visszavezetnünk a feltételt. A feltétel közepén az Equals kulcsszónak kell állnia.

Lambda szintaxis esetén a Join metódus első paramétere a kapcsolni kívánt kollekció. Ezt követi két összekapcsolási kulcs kiválasztás. Az első kiválasztás az első kollekcióra érvényes, amin hívtuk a Join metódust, a második pedig a kapcsolni kívánt kollekcióra érvényes. Az utolsó paraméter pedig az eredmény leképezést valósítja meg.

Csoportosítás

Előfordulhat, hogy az adatainkat valamilyen szempont szerint csoportba kell rendeznünk és a létrejött csoportokon kell műveleteket végeznünk. Nézzünk egy példát a csoportosítás megvalósításra.

using System;
using System.Collections.Generic;
using System.Linq;

namespace PeldaLinqGroup
{
    struct Pelda
    {
        public int X { get; set; }
        public int Y { get; set; }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var elemek = new List<Pelda>
            {
                new Pelda { X = 33, Y = 11 },
                new Pelda { X = 88, Y = 12 },
                new Pelda { X = 44, Y = 11 },
                new Pelda { X = 7, Y = 12 },
                new Pelda { X = 9, Y = 11 },
            };

            var eredmeny = from elem in elemek
                           group elem
                           by elem.Y into csoport
                           select csoport;

            //ugyan ez, lambda szintaxissal:
            var eredmeny2 = elemek.GroupBy(i => i.Y);

            foreach (var group in eredmeny)
            {
                Console.WriteLine(group.Key);
                foreach (var item in group)
                {
                    Console.WriteLine("{0}, {1}", item.X, item.Y);
                }
            }
            Console.ReadKey();
        }
    }
}

A program kimenete:

11
33, 11
44, 11
9, 11
12
88, 12
7, 12

A csoportosítás query szintaxis esetén a group kulcsszóval kezdődik, ami után meg kell adnunk, hogy pontosan mit szeretnénk csoportba rendezni. A példa esetén a kiválasztott elem szerint csoportosítunk, de állhatna itt egy anonim osztályba leképezés is. Ezt követi a by kulcsszó, ami után meg kell adnunk, hogy mi szerint csoportosítunk, majd az into kulcsszó után meg kell adnunk a csoport nevét, amiből ki tudunk majd választani.

A lambda kifejezés szintaxisa látható módon jelen esetben sokkal egyszerűbb, mivel csak azt kell megadnunk, hogy mi szerint rendezünk csoportba, az eredmény pedig már a csoportok sorozata lesz.

Egy csoport egy kulcsból (Key) és az elemekből áll. A kulcs a csoportosítási változó típusát veszi fel, az elemek pedig a kiválasztás elemei lesznek. A példából látható, hogy a csoportok bejárásához két foreach ciklus szükséges.