HTML5 Tanfolyam prezentációja

A két napos Microsoftban tartott HTML5 tanfolyam prezentációja.

A tartalomból:

• HTML5 alapjai
• Új elementek
• Audió és videó element
• Canvas
• Geolocation
• HTML5 vezérlők
• Validáció
• Local Storage
• History API
• CSS3
• Font-Face
• SVG
• Internet Explorer 9 kényelmi lehetőségei

Tanfolyam megrendelés

Az előadás prezentációt innen lehet letölteni.

Wolfeinstein 3D – HTML5-ben

A HTML5 vitathatatlanul a legújabb és legtöbbet halott webes prezentációs technológia. Nagyjából mindent meglehet vele oldani mint mondjuk az Adobe Flashel vagy a Microsoft Silverlighttal. Igaz a fejlesztés körülményes, de minden megoldható benne.

Íme egy retro game a Wolfeinstein 3D implementációja HTML5-ben.

http://www.nihilogic.dk/labs/wolf/ 

Sőt ha mi magunk is szeretnénk elkészíteni ezt a játékot és hozzá egyedi pályákat akkor ezt a tutorialt olvassuk el.

Tutorial 1. része

Tutorial 2. része

Bevezetés a LINQ világába–(4. rész)

Az alábbi fejezetek a “Bevezetés a LINQ világába” c. irományomból valóak. Ez egy saját kis jegyzet, reményeim szerint hasznát tudjátok venni. Amiben viszont én kérném a segítségeteket az az, hogy az írást javítsátok. Ha fogalmazási, stilisztikai vagy esetleg tartalmi hibát vélnétek felfedezni kérlek írjátok meg a kommentek között.
Segítségetek előre is köszönöm.

Linq To Object összetettebb metódusai

Az előzőekben már megismerkedtünk a Linq alapjaival. Itt az ideje megismerni a LINQ által nyújtott számtalan bővítő metódussal, ami könnyebbé és gyorsabbá teszik a fejlesztést és annak menetét. Ezek a bővítő metódusok, mind a System.Linq névtérben találhatók. Ezt a névteret a Visual Studio 2008 minden projectbe beteszi, ahol nagy valószínűséggel szükség lesz rá. (Pl: Console Application, Windows Forms stb)

A következő 2 részben a Linq speciális bővítő metódusaival fogunk megismerkedni. De ne gondoljuk azt, hogy ezek a bővítő metódusok csak Linq To Objectnél használhatók. Nagy részük ugyanúgy használható lesz Linq To Sql-nél vagy más Linq Providereknél is.

Ebben a tutorialban is az előzőekben megismert és létrehozott Person gyűjteményét vesszük alapul, a legtöbb feladatnál!

Set Operators

Halmaz műveleteket tudunk a segítségükkel elvégezni a gyűjteményeken és az adatainkon.

A Distinct segítségével, az adott halmazban ismétlődő elemeket csak egyszer szedjük ki. Tehát nem engedélyezzük az elemek duplikációját. Például, ha egy listában többször fordul elő a „Budapest” név akkor, azaz eredmény halmazban csak egyszer jelenik meg.

var res = (from c in persons           select c.City).Distinct();

var res = persons.Select(c => c.City).Distinct();

Mint látható ennek a bővítő metódusnak sincs Query Expressionos formája. Abban az esetben is sima bővítő metódusként funkcionál.

A Linq nyújt számunkra számos halmaz műveleti operátort is. A következő 3 ilyen metódust nézzük meg. Mégpedig az Unio-t (Union) Metszetet (Intersect) illetve a különbséget (Except)

Mielőtt belekezdenénk, hozzunk létre egy egyszerű int tömböt, amin dolgozni fogunk.

int[] halmaz1 = new int[] { 1, 2, 3 }; int[] halmaz2 = new int[] { 3, 4, 5 };

Unionnal két halmaz közös részét csak egyszer veszi. Azaz azok az elemek, amik az első illetve a második halmazban is szerepelnek csak egyszer fognak szerepelni az eredmény halmazban.

var union = halmaz1.Union(halmaz2);

Ebben az esetben az eredmény az: 1,2,3,4,5. Azaz a 3-as csak egyszer fordul elő.

Metszet (Intersect) képzésnél, eredményhalmazunkban azok az elemek fognak szerepelni, amelyek minden kiinduló halmazban szerepeltek.

var intersect = halmaz1.Intersect(halmaz2);

Ebben az esetben az eredmény halmaznak egyetlen eleme van mégpedig a 3-as.

A különbség (Except) műveletnél, azok az elemek fogják az eredményt képezni, amelyek szerepelnek az első halmazban, de a másodikban nem! A különbségképzésnél figyeljünk oda, hogy mikor melyik halmazt vesszük alapul. Ugyanis nem mindegy, hogy melyik halmaz melyiknek a különbsége.

var except = halmaz1.Except(halmaz2);

Ebben az estben az eredmények a következők: 1, 2

var except = halmaz2.Except(halmaz1);

Míg ebben az estben az eredmények: 4, 5

Természetesen nem csak egyszerű tömbökön tudunk ezekkel az operátorokkal dolgozni, hanem komplexebb típusokon is.

Aggregation Operators

Aggregációs kifejezésekkel összesített adatokat tudunk lekérdezni a segítségével. Ezen kifejezésekkel egyszerűsíthetik az elemek megszámolását, összegképezését, átlagát stb.

A Count bővítő metódus egyszerűen végighalad egy szekvencián és visszaadja a szekvencia elemeinek a számát.

var count = halmaz1.Count();

A LongCount hasonló képen működik, mint a Count azzal a különbséggel, hogy visszatérési értéke egy 64 bites integer lesz (long), ezáltal engedélyezve a ~2 milliárdnál nagyobb elemszámokat.

A SUM metódus az adott elemek összegét számolja ki.

var sum = halmaz1.Sum();

Eredmény: 6

Persze mint a többi kifejezésnél ezek a metódusok se csak az egyszerű elemekre használhatók. Nézzük meg például, hogy a Person listánk 4 felhasználójának mennyi az életkoruk összesen. Ebben az esetben a selectorral határozzuk meg, hogy melyik elemet szeretnénk summázni.

var sumResult = persons.Sum(s => s.Age);

Eredmény: 105

Mint látható ebben a kifejezésben speciálisan kiválasztottuk azt az elemet, amit summázni szeretnénk, hisz ha nem tettük volna meg akkor a Person Lista objektumait próbálná meg.

Az Average bővítő metódussal az elemek átlagát számolhatjuk ki. Itt is mint a többi aggregáló kifejezésnél használhatjuk a selector-t

var avg = halmaz1.Average();

Eredmény: 2

var avgResult = persons.Average(s => s.Age);

Eredmény: 26,25

Ha túl nagy a számok összege, akkor OverflowExcelptiont dobhat!

A Minimummal az adott gyűjtemény legkisebb elemét kérdezhetjük le.

var min = halmaz1.Min();

Eredmény: 1

var minResult = persons.Min(s => s.Age);

Eredmény: 25

Maximummal értelemszerűen a gyűjtemény legnagyobb elemét kérdezzük le.

var max = halmaz1.Max()

Eredmény: 5

var maxResult = persons.Max(s => s.Age);

Eredmény: 28

Ha a gyűjtemény nem valósítja meg az IComperable<Tsource> interface-t akkor a műveletek eredménye egy ArgumentException lesz. (Az alábbi hibaüzenetet kapjuk: At least one object must implement IComparable.”

Például: Az alábbi kifejezés a fentebb említett hibát dobhatja:

var exp = (from c in persons            select c).Min();

Generation Operators

A Range segítségével egy olyan enumerációt készíthetünk amely, egy start elemtől megy, egy maghatározott count elemig.

Például: Az alábbi kód, egy olyan gyűjteményt készít ami 2000-től tartalmazó számokat tartalmazza 2009-el bezárólag.

var res = Enumerable.Range(2000, 10);

Az Empty segítségével egy megadott elemből készít enumerációt. Akkor lehet hasznos, ha inicializálni szeretnénk egy gyűjteményt.

var person = Enumerable.Empty<Person>();

Bevezetés a LINQ világába–(3. rész) Linq To Objects

Az alábbi fejezetek a “Bevezetés a LINQ világába” c. irományomból valóak. Ez egy saját kis jegyzet, reményeim szerint hasznát tudjátok venni. Amiben viszont én kérném a segítségeteket az az, hogy az írást javítsátok. Ha fogalmazási, stilisztikai vagy esetleg tartalmi hibát vélnétek felfedezni kérlek írjátok meg a kommentek között.
Segítségetek előre is köszönöm.

Linq To Objects

A következő fejezetben a Linq To Object-tel fogunk megismerkedni. A nyelvbe ágyazott lekérdezés segítségével egyszerűen tudunk objektumokból, gyűjteményekből lekérdezni számunkra szükséges információkat, anélkül, hogy extra erőt fordítanánk ezen adatok kinyerésére (speciális metódusok írására stb.). Persze van egy minimális overheadje, de cserébe az egyszerűséget és az átláthatóságot kapjuk tőle. Sok vita kering az interneten arról, hogy használjuk vagy ne használjuk a LINQ-t, mert tény, hogy lassúbb tud lenni (nem mindig), mintha mi írnánk meg például egy speciális sorba rendezést, de cserébe az egyszerűséget kapjuk. Lehet mérlegelni, hogy mikor melyiket használjuk. Én azt vallom, hogy kis- és közepes alkalmazásoknál célszerű a Linq használata, hisz nem vesztünk vele akkor teljesítményt, viszont olyan Enterprise-alkalmazásoknál, ahol a válaszidő 0,001 másodperce is lényeges, célszerűbb saját Enterprise-megoldás után nézni. Talán nem a legjobb hasonlat, de ez olyan, mint a managelt―nem managelt világ összehasonlítása. Tudjuk, hogy (nagyrészt) az unmanaged kód gyorsabb, de viszonylag nehéz benne dolgozni, míg a managed világban minden a kezünk alá van adva, és segíti a munkánkat, hogy hatékonyabban és gyorsabban tudjunk dolgozni.

Linq To Object alapvető metódusai

A következő demoban egy gyűjtemény elemein fogjuk megismerni a Linq To Objects-et.

1. Készítsünk egy új Console Application-t, és legyen a neve, mondjuk, ConsoleLinq.

2. Adjunk hozzá egy új osztályt, amelynek a neve Person lesz.

(Solution Explorer -> Add -> Class)

3. A Person osztály az alábbi elemeket fogja tartalmazni

public class Person {     public int Id { get; set; }     public string Name { get; set; }     public int Age { get; set; }     public string City { get; set; }     public string Job { get; set; } }

4. Térjünk vissza a Program.cs -hez és Main-be készítsünk egy Listát, amely Person objektumokat tartalmaz.

List<Person> persons = new List<Person>();

5. Ezt követően adjunk ehhez a listához 4 elemet.

Person p1 = new Person { Id = 1, Name = "Attila", Age = 25, City = "Budapest", Job = "Devloper" }; persons.Add(p1);   Person p2 = new Person { Id = 2, Name = "Gergő", Age = 26, City = "Miskolc", Job = "IT" }; persons.Add(p2);   Person p3 = new Person { Id = 3, Name = "Szabolcs",  Age = 28, City = "Üröm", Job = "Manager" }; persons.Add(p3);   Person p4 = new Person { Id = 4, Name = "David", Age = 26, City = "Budapest", Job = "Trainer" }; persons.Add(p4);

Látható, hogy az objektumok adatainak megadásánál a C# 3.0-nál bevezetett object initializer-t használtuk. (Ezt a gyűjtemény feltöltésénél is megtehettük volna.)

6. Most, hogy már megvagyunk a lista feltöltésével, itt az ideje lekérdezni a benne található elemeket. A lekérdezést értelemszerűen a select utasítással tudjuk megtenni. Mint tudjuk a Query Expressiont a fordító bővítő metódusos kifejezésé alakítja.

Ezért a lekérdezéseknél, mindkét alakját megnézzük a lekérdezésnek. Igazából teljesen mindegy, hogy melyiket használjuk, vegyük azt, amelyik jólesik. Összetettebb lekérdezéseknél talán a Query Expression-ös módszer átláthatóbb, mint a bővítő metódusos, de ez is csak megszokás kérdése.

7. Első lépésként kérdezzük le a gyűjtemény összes elemét.

var res = from c in persons           select c;

Ne feledjük a két kifejezés ekvivalens!

var res = persons.Select(c => c);

8. Kiíratni pl. a következőképpen lehet az eredményt.

foreach (var item in res) {     Console.WriteLine(item.Name + ": " + item.Age); }

Helytakarékosság végett csak ennél a példánál mutatom be az eredmények kiíratását. A többinél ugyanezzel az analógiával kell kiíratni az eredményeket. Csak figyeljünk oda, hogy amikor lekérdeztünk, az mivel tér vissza!

9. A lista összes elemét le tudjuk kérdezni; de mi van akkor, ha minket a Person listából csak a felhasználók állásai érdekelnek? Tehát a többi felesleges információ nem érdekes. Természetesen ezt is le tudjuk kérdezni az alábbi módon:

var res = from c in persons           select c.Job;

var res = persons.Select(c => c.Job);

10. Egy elemet egyszerű lekérdezni, de mi van akkor, ha minket mondjuk a Personok nevei és életkora érdekel? Ilyenkor felmerül az ötlet, hogy például vesszővel válasszuk el az elemeket, és soroljuk fel. Hát ez az, ami NEM így működik. Ilyenkor szükségünk lesz egy átmeneti osztályra.

Hozzunk létre egy átmeneti TempPerson osztályt.

public class TempPerson {     public string Name { get; set; }     public int Age { get; set; } }

11. Kérdezzük le a Person Listában található emberek nevét és korát:

var res = from c in persons           select new TempPerson           {               Name = c.Name,               Age = c.Age           };

var res = persons.Select(c => new TempPerson { Name = c.Name, Age = c.Age });

12. Ez szép, de mindig egy-egy átmeneti osztályt létrehozni egyetlen lekérdezés kedvéért elég macerás. Ezért létrehozták a C# 3.0-ban az Anonymus-típusokat ― ezzel is egyszerűsítve a Linq-t használók dolgát. Kérdezzük ugyanúgy le a Personok neveit és életkorait, csak immár Anonymus-típust felhasználva.

var res = from c in persons           select new           {               Name = c.Name,               Age = c.Age           };

var res = persons.Select(c => new { Name = c.Name, Age = c.Age });

Figyeljük meg, hogy a new kulcsszó után nem áll osztálynév. Így ő egy Anonymus-típus lesz. Óvatosan bánjunk az Anonymus-típussal, őket se használjuk ész nélkül, s ugyanígy a var-t se!

 

13. Lekérdezni már tudunk, de a lekérdezés mit se érne, ha nem tudnánk szűkíteni valamilyen módon az eredményhalmazt. Erre lesz tökéletes társ a Where kulcsszó.

Kérdezzük le azokat a Personokat, akik budapestiek.

var res = from c in persons           where c.City == "Budapest"           select c;

var res = persons.Where(c => c.City == "Budapest");

14. Ha már tudunk szűrni, akkor itt az ideje sorba rendezni az elemeket mind növekvő, mind csökkenő sorrendben. Rendezzük név szerint növekvő sorrendbe a felhasználókat.

var res = from c in persons           orderby c.Name           select c;

var res = persons.OrderByDescending(c => c.Name).Select(c => c);

15. Ugyan ez a lekérdezés csökkenő sorrendben a következőképpen néz ki:

var res = from c in persons           orderby c.Name descending           select c;

var res = persons.OrderByDescending(c => c.Name).Select(c => c);

Figyeljük meg, hogy Query Expression-nél csak egy descending kulcsszavat raktunk az orderby után, míg a bővítő metódusánál ez már nem az OrderBy metódust hívta meg egy külön paraméterrel, hanem az OrderByDescending metódust.

16. Gyakori szkenárió az is, hogy a sorba rendezés után további elemeket is szeretnénk sorba rendezni. Ezt a ThenBy, ThenByDescending bővítő metódussal érhetjük el. Query Expression-nél egyszerűen csak egy vessző után felsoroljuk a következő elemeket, amiket rendezni szeretnénk.

var res = from c in persons           orderby c.Name, c.Age           select c;

var res = persons.OrderBy(c => c.Name).ThenBy(c => c.Age).Select(c => c);

17. Hasznos, bár kevésbé gyakori eset, amikor a lekérdezett elemek sorrendjét meg szeretnénk fordítani. Azaz, hogy az eddig az eredmény listában lévő elem az első elem legyen. Erre lesz hasznos társ a Reveres bővítő metódus. Ez a metódus azért is különleges, mert nincs Query Expression-ös alakja. Azaz csak úgy tudjuk Query Expression esetében meghívni, ha bővítő metódusként használjuk az alábbi módon (ilyenkor a kifejezést zárójelbe rakjuk):

var res = (from c in persons            orderby c.Age            select c).Reverse();

var res = persons.OrderBy(c => c.Age).Select(c => c).Reverse();

Bevezetés a LINQ világába – (2. rész)

Az alábbi fejezetek a “Bevezetés a LINQ világába” c. irományomból valóak. Ez egy saját kis jegyzet, reményeim szerint hasznát tudjátok venni. Amiben viszont én kérném a segítségeteket az az, hogy az írást javítsátok. Ha fogalmazási, stilisztikai vagy esetleg tartalmi hibát vélnétek felfedezni kérlek írjátok meg a kommentek között.
Segítségetek előre is köszönöm.

Ahhoz, hogy értsük, hogy mi és miért született meg a nyelvben, illetve hogy ezeket később rendeltetésszerűen használjuk, nézzük át a C# 3.0-nak az újdonságait.

C# 3.0 újdonságai

A C# 3.0 -ban többek között az alábbi újdonságok jelentek meg:

• Automatikus tulajdonságok
• Implicit típusú lokális változók
• Bővítő metódusok
• Objektumok és gyűjtemény-inicializálók
• Lambda kifejezések
• Anonymous típusok

Miután elkezdtük használni a LINQ-t, látni fogjuk, hogy mennyi helyen is használjuk fel ezeket az újdonságokat. Hisz az első pillanatban, amikor olvassuk, illetve tapasztaljuk őket, felmerülhet a kérdés, hogy miért kellett ez a nyelvnek; de a végén, amikor már komplexebb linq kifejezéseket is írunk, kikristályosodik, hogy ezeknek a nyelvi újításoknak mégis mi a létjogosultsága.

Nézzünk meg néhány fontosabb újdonságot közelebbről.

Automatikus tulajdonságok

Szinte minden osztálynál készítünk tulajdonságokat, mégis elég hosszadalmas gépelést kell elvégeznünk ahhoz, hogy mi egy property-t létrehozzunk. Pl. az alábbi ábra bal oldalán a korábbi módszer látható, míg a jobb oldalon az új, automatikus tulajdonság. Tehát az automatikus tulajdonság segítségével sokkal egyszerűbben tudunk létrehozni egy-egy property-t.

Látható, hogy most már nem kell külön kiírni a getter és a setter részt. Ha egyszerű tulajdonságról van szó, elég csak get-et és set-et írni, a fordító a háttérben úgyis legenerálja a bal oldali kifejezést. Ha csak olvashatóvá szeretnénk tenni a tulajdonságot, akkor a set kulcsszó elé írjunk a private kulcsszót. Fontos, hogy a get és/vagy a set rész nem hagyható le!

Amennyiben Visual Studio-t használunk, és gyorsan szeretnénk egy új automatikus tulajdonságot létrehozni, írjuk be a prop szót, majd kétszer egymás után nyomjuk le a Tab billentyűt.

Implicit típusú lokális változók

Ennek a nyelvi újdonságnak a segítségével immár nem kell kiírnunk a változó típusát (ha annak már van értéke)

Például eddig, ha egy változót deklaráltunk, akkor az így nézett ki:

int i = 10; string s = "alma"; List<Char> chList = new List<char>(); Exception e = new Exception();

Mostantól viszont elég a bal oldali kifejezés elé a var kulcsszót kiírni.

var i = 10; var s = "alma"; var chList = new List<char>(); var e = new Exception();

A fordító ugyanis megállapítja, hogy mi van a kifejezés jobb oldalán, és annak a típusával helyettesíti be a bal oldalt.

Ezzel első ránézésre megint csak időt spórolunk, hisz most már nem kell kiírni, hogy List<Char>, vagy egyéb bonyolultabb típusneveket, hanem elég csak a var kulcsszóval ellátni, ami csak 3 karakter. De ne gondoljuk azt, hogy ez a var olyan, mint amit más fejlesztők a JavaScriptben megszokhattak. Azaz, ha van egy var i = 1; kifejezés, és hirtelen azt mondjuk, hogy i=”béka”, akkor a fordító rögtön szólni fog, hogy ezt mi nem tehetjük meg, hisz az i típusa int, amit hirtelen nem alakíthatunk át string-gé. Tehát ettől a var szótól még ugyanúgy típusos a nyelv, csak a szintaktika lett kicsit lazább.

Persze a var-t ne használjuk mindig, minden körülmény között, mert a kódolvashatóságot bizony ronthatja. Viszont látni fogjuk, hogy nélküle a Linq-t elég nehézkes lenne kezelni. Gondoljunk egy olyan esetre, amikor egy adatbázisban olyan összetett lekérdezést csinálunk, amely típusának a megállapítása nem triviális ― ilyenkor a var használata erősen javallott.

Bővítő metódusok

A bővítő metódusok segítségével meglévő osztályokat tudunk kiterjeszteni, származtatás nélkül!

Hogy elképzeljük, miért is jó ez, nézzük meg az alábbi példát.

Tegyük fel, hogy van egy A osztályunk. Szeretnénk kibővíteni a képességeit azáltal, hogy megírunk egy-két plusz függvényt hozzá. Ha nem tudunk hozzáférni az A osztály kódjához, mert mondjuk csak egy DLL-ben áll rendelkezésünkre, akkor az objektum-orientált paradigma szerint a természetes lépés az, hogy származtatunk belőle egy B osztályt, és odapakoljuk az új függvényeinket.

Na de mi történik akkor, ha az osztályt a készítője ellátta a sealed kulcsszóval? Akkor bizony nincs származtatás! Nem hagytak nekünk más választást, mint szögre akasztani OO elveinket, és kétségbeesésünkben definiálni egy statikus osztályt, amiben elhelyezzük a statikus függvényeinket, melyek paraméterként kaphatják az A osztály egy példányát. Érezzük, hogy ez minden, csak nem az igazi. Nem kapcsolódik a függvényünk az osztályhoz, senki más nem fog tudni a függvényeinkről, csak mi (nincs intellisense se) stb. Pedig nem járunk messze a megoldástól, első pillantásra a bővítő függvények is valami ilyesmit csinálnak.

Bővítő metódus létrehozásának lépései:

1. Publikus statikus függvény, statikus osztályban
2. Az első paraméter a bővítendő osztály típusa
3. Megelőzi a ”this” kulcsszó
4. Csak publikus adattagokhoz fér hozzá

Bővítő függvények készítésekor az első paramétert megelőzi a this kulcsszó, ezzel jelezvén, hogy az első paraméterként megjelölt típus nem más, mint az a típus, amit kiterjeszt!

A compiler fordításkor átnézi az összes statikus osztályt bővítő függvények után kutatva, és fordítási időben elvégzi a szükséges kiterjesztéseket. Érték- és referencia-típusokat is egyaránt bővíthetünk. Az ajánlás szerint érdemes egy külön namespace-ben egy statikus osztályba pakolni az ilyen bővítő függvényeket, és inkább usingolni a namespace-t a projektünkben.

Maga a System.Linq névteret is, ha usingoljuk, a tömbök extra funkcionalitást kapnak tőle. Tudunk rájuk szűrni egyszerűen, aggregációkat végezhetünk, stb. Gondoljunk csak bele, hogy új funkcionalitással látnánk el egy eddig megírt osztályt, de valahogy úgy, hogy ne írjunk a kódjába, hisz problémát okozhat a visszafelé kompatibilitás. Ugyanez volt a .NET esetén is. Csináljunk új funkciókat, amire szüksége lehet a fejlesztőknek. Igen ám, de ha belepiszkálunk a kódba, akkor új verziót kell kiadni, és az visszafelé nem lesz kompatibilis. Erre is tökéletes megoldást nyújthatnak a bővítő metódusok.

A LINQ is ennek tudatában működik, hisz ha írunk egy Linq kifejezést, azt a compiler fordítási időben bővítő metódusokká alakítja.

Az alábbi ábra is ezt a folyamatot szemlélteti. Látható még, hogy ennél az egy kifejezésnél mennyi nyelvi újítást használ fel a rendszer.

A C# 3.0-nak még rengeteg olyan újdonsága van, ami a Linq miatt került a nyelvbe, ezekkel és a Linq-val a következő fejezetben foglalkozunk.

Bevezetés a LINQ világába– (1.rész)

Az alábbi fejezetek a “Bevezetés a LINQ világába” c. irományomból  valóak. Ez egy saját kis jegyzet, reményeim szerint hasznát tudjátok venni. Amiben viszont én kérném a segítségeteket az az, hogy az írást javítsátok. Ha fogalmazási, stilisztikai vagy esetleg tartalmi hibát vélnétek felfedezni kérlek írjátok meg a kommentek között.
Segítségetek előre is köszönöm.

Mi is az a Linq?

Ma, amikor az alkalmazások többségében adatokat kezelünk, legyen szó adatbázisról, XML fájlról vagy akár egyszerű objektumról, még mindig meg kell küzdenünk azzal, hogy milyen az adatforrásunk, és hogy milyen egyedi nyelvvel, szintaktikával kezelhetjük őket. Így ha kiválasztunk egy adatforrást, például egy Microsoft SQL Server-t, akkor értenünk kell a T-SQL nyelvet, ha Oracle az adatforrás, akkor az ő nyelvén kell érteni, míg ha XML, akkor pedig ismernünk kell az XML egyedi struktúráját és lelkivilágát. Nincs egy egységes nyelv és környezet arra, hogy ugyanazzal a szintaktikával és módszertannal tudjuk lekérdezni egy meghatározott adatforrásból érkező adatokat. Ez így volt addig, míg meg nem jelent a LINQ.

A webet böngészve rengeteg megközelítést találunk arra, hogy mi is az a LINQ. Az alábbi definíciók kb. jól behatárolják azt, hogy mi is ez az új technológia.

• A Linq egy egységes programozási modell, bármilyen adatforrásra nézve. A Linq lehetőséget biztosít, hogy egységes módon kérdezzünk le és módosítsunk adatokat, függetlenül az adatforrástól.
• A Linq egy Tool, amelynek segítségével SQL lekérdezéseket ágyazhatunk be a kódunkba.
• A Linq egy új, adat absztrakciós réteg.

Mind a 3 definíció helyes, és jó képet ad arról, hogy mi is ez a technológia.

A LINQ a Language Integrated Query rövidítése. Ahogy a neve is sugallja, Nyelvbe Ágyazott Lekérdezés, amivel magába a programozási nyelvbe ― amely legyen az C#, VB vagy bármilyen más .NET nyelv ― ágyazhatunk be a lekérdezéseinket.

 

Egy kedves kollégám szerint azért nincs a LINQ-nak a magyar nyelvben külön rövidítése, mert a Nyelvbe Ágyazott Lekérdezés magyar rövidítése a NYÁL lenne.

 

Linq története

A Linq első változata (Technology Preview) 2005 szeptemberében jelent meg. Már akkor nagyon ígéretes kezdeményezés volt, de a 2007. novemberi megjelenése után már kétség se férhetett a Linq létjogosultságához. Az első változata csak néhány adatforrást támogatott. Ezek az alábbiak voltak:

• Linq To Objects
• Linq To ADO.NET
• Linq To SQL
• Linq To Dataset
• Linq To Entities
• Linq To XML

A Linq To Entities csak az ADO.NET Entity Framework-el jött ki 2008-ban. A Visual Studio 2010-től már alapból használható.

Persze a Linq megjelenése óta eltelt már jó néhány év, és mivel bárki fejleszthet magának Linq providert, ezért a netet böngészve találhatunk néhány nagyon jó Linq Providert. Pl: Linq To Sharepoint, Linq To Facebook, Linq To Bing vagy a nagy kedvenc magyar kezdeményezés, a Linq To C#.

A Linq egyik fontos tulajdonsága, hogy csak olyan sorozatokon, gyűjteményeken használható, amely megvalósítja az IEnumerable<T> vagy az IQueryable<T> interface-t. Ezek a sorozatok a lekérdezések végén egyszerűen átalakíthatók tömbökké (.ToArray()) vagy listákká (.ToList()).

Ahhoz, hogy a Linq megszülessen, a C# nyelven jó néhány változást kellett eszközölni. Maga a CLR (Common Language Runtime) nem változott, csak a nyelvi szintaktikán történtek változások. Tehát ami most a 3.0-ba belekerült, azt eddig is meg lehetett oldani, csak legfeljebb körülményesebb módon.

Ahhoz, hogy értsük, hogy mi és miért született meg a nyelvben, illetve hogy ezeket később rendeltetésszerűen használjuk, nézzük át a C# 3.0-nak az újdonságait.

Windows Phone 7 + Azure Service–DEMO (Hosszú)

Ebben a majdnem 1 óra 20 perces demoban egy komplex Windows Phone 7 kliens alkalmazást és egy Windows Azure web alkalmazást készítünk el.

A Windows Azure-os web alkalmazás egy Music Store menedzsment felületét reprezentálja. Az adatainkat SQL Azureban tároljuk, a zene fájlokat pedig a BLOB-ban helyezzük el. A Windows Phone 7-es kliensből pedig lekérdezzük az adatokat egy Windows Communication Foundation-ös szolgáltatás segítségével, majd ha a felhasználó úgy kívánja meghallgathatja az adott zene számot (ami persze a BLOB-ban van). A zene lejátszáshoz itt az XNA Frameworkot is felhasználjuk.

A demo viszonylag hosszú, majdnem egy egész estés mozifilm 🙂 Jó szórakozást hozzá és kitartást hozzá.