108 lines
4.7 KiB
Plaintext
108 lines
4.7 KiB
Plaintext
A linq to objects az IEnumerable<T> és IEnumerable interfészeket megvalósító (foreach ciklussal bejárható) kollekció esetén működnek.
|
|
A megvalósítás a Syste.Linq névtérben kapott helyet, amit alapvetően nem kell használatba vennünk, mert ha egy új osztályt készítünk sablon alapján visual studioban akkor alapértelmezetten használatba lesz véve.
|
|
|
|
A linq szintaxisai:
|
|
Lambda:
|
|
elemek.Where(i => i.X > 10).Select(i => i.x);
|
|
querry:
|
|
var eredmeny = from elem in elemek
|
|
where elem.x > 10
|
|
select elem.x;
|
|
|
|
|
|
A sql utasítások közül a group by is használható.
|
|
|
|
Mint látható a rendezést az orderby kulcsszó valósítja meg,
|
|
amit a tulajdonság neve követ, ami alapján rendezni akarunk.
|
|
Ezután vagy az ascending, vagy a descending kulcsszónak kell következnie attól függően, hogy növekvő, vagy csökkenő sorrendben szeretnénk az adatokat kiírni. A lambda szintaxis esetén az OrderBy és az OrderByDescendinget alkalmazzuk.
|
|
|
|
Csoportosítás (good bye)
|
|
|
|
A csoportosítás query szintaxis esetén a group kulcsszóval kezdődik, amiután meg kell adnunk, hogy pontosan mit szeretnénk csoportba rendezni.
|
|
A példa esetén a kiválasztott elem szerint csoportosítsunk, de állhatna itt egy anonim osztályba leképzé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 elemekből áll.
|
|
|
|
JOIN
|
|
|
|
Ezt a műveletet join nak vagy összekapcsolásnak nevezzük. A join műveleteknek több fajtája van. Objeltumok esetén a legkönnyebb at inner mjoin művelet valósítható meg. Et két típus metszetét jelenti.
|
|
|
|
SOROZAT ÉS ELEM MŰVELETEK
|
|
csak lambda szintaxissal alkalmazhatóak
|
|
|
|
kihagyás Skip()
|
|
Take() //csak adott számú elem kiválasztása
|
|
|
|
var eredmeny = elemek.Skip(2).Take(3);
|
|
|
|
|
|
|
|
Elemek kiválasztása:
|
|
First()
|
|
Ha nincs elem akkor kivételt dob
|
|
FirstOrDefault()
|
|
Kivétel esetén a típus alapértelmezett értékét dobja vissza
|
|
Last()
|
|
LastOrDefault()
|
|
|
|
ElementAt(index)
|
|
ElementAtOrDefault(index)
|
|
|
|
Ismétlődések kiszűrése
|
|
Ismétlődés kiszűrésére a Distinct metódus alkalmazható.
|
|
Alkalmazásának feltétele, hogy ha a típusunk egy összetett típus, ami több elemet tartalmaz, akkor rendelkezzen egy megfelelően felülírt Equals metódussal.
|
|
Alternatívként adhatunk meg egy IEqualityComparer<T> interface metódus-t megvalósító típus példányt.
|
|
|
|
var egyedix = elemek.DistinctBy(i => i.x);
|
|
|
|
Aggregáló műveletek
|
|
Ha kollekció eredményének számosságára vagyunk kíváncsiak, akkor a Count() metódus alkalmazhatjuk.
|
|
var parosx = elemek.Count(i => i.X%2 ==0);
|
|
|
|
Feltételek esetén, ha azt szeretnénk kiértékelni, hogy egyáltalán van e eredménye a keresésnek, akkor a Cpunt() > 0 kifejezés erősen kerülendő, mert ez végig megy a kollekción és végigszámolja az elemeket.
|
|
Helyette az Any() metódust használjuk, ami eleve erre lett kitalálva.
|
|
Az Any() igaz értéket ad vissza, ha az IEnumerable<T> típisusnk tartalmaz elemeket.
|
|
Paraméterrel is kiegészíthetjük.
|
|
Ebben az esetben azt mondja meg, hogy a kollekció tartalmaz-e a feltételnek megfelelő elemet.
|
|
|
|
Ha egy kollekció esetén minimum vagy maximum értékre vagyunk kíváncsiak, akkor a Min() és Max() metódusokat alkalmazhatjuk.
|
|
Ha a kollekció szám típusokból áll, akkor paraméter nem kell adnunk.
|
|
Ellenkező esetben kell egy kifejezés, ami megmondja, hogy mi alapján számolódjon meg a min és max érték.
|
|
Átlagosra hasonló működéssel az Avg() metódus alkalmazható.
|
|
|
|
var MaxX = elemek.Max( i => i.X);
|
|
|
|
var MinY = elemek.Min( i => i.Y);
|
|
|
|
vor avg = elemek.Avg( i => i.Y * i.X);
|
|
|
|
int[] ints1 = {5,56,535434,435473854,45};
|
|
int[] ints2 = {58,56448,38647,4,45,5,6,56};
|
|
|
|
//unió
|
|
IEnumerable<int> union = ints1.Union(ints2);
|
|
|
|
//metszet
|
|
IEnumerable<int> intersect = ints1.Intersect(ints2);
|
|
|
|
// különbség
|
|
IEnumerable<int> except = ints1.Except(ints2);
|
|
|
|
//Concat
|
|
var concatenated = ints1.Concat(ints2);
|
|
|
|
Ha olyan módon szeretnénk összefűzni elemeket, hogy 1 elemet szeretnénk venni az első kollekcióóból, majd egy elemet szeretnénk a második kollekcióból.
|
|
Erre a zip művelet képes
|
|
ami a ValueTuple formában adja vissza az elemeket.
|
|
|
|
var result = a.zip(b);
|
|
|
|
szeletelés
|
|
Chunk műveletet, amivel egy IEnumerable<T> típust fel tudunk szeletelni több, megadott maximum elemszámú T típusú tömbre.
|
|
int[] a = {1,2,3,4};
|
|
IEnumerable<int[]> result = a.chunk(2);
|
|
//[1,2] és [3,4] tömböket produkál
|