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
