2 C# 1.0 C# 2.0 C# 3.0 Komponensek felügyelt környezetben • Property, delegate, event Típusbiztosabb, hatékonyabb nyelv • Generikus típusok, yield return

C# 3.0 és LINQ

Albert Istvá[email protected] Kompetencia KözpontBudapesti Műszaki és Gazdaságtudományi EgyetemAutomatizálási és Alkalmazott Informatikai Tanszék

2007. május 24., Budapest Lurdy HázVisual Studio "Orcas" Konferencia

mailto:[email protected]

2

Tartalom

C# 2.0 – rövid ismétlés

Lambda kifejezések, automatikus tulajdonságok

Bővítő metódusok, implicit típusú lokális változók

Objektum és gyűjtemény inicializálás

Névtelen típusok

Standard lekérdezések, LINQ to Objects

Nyelvbe ágyazott lekérdezések

Kifejezés fák

Összefoglalás

A C# evolúciója

C# 1.0

C# 2.0

C# 3.0

Komponensek felügyelt környezetben• Property, delegate, event

Típusbiztosabb, hatékonyabb nyelv• Generikus típusok, yield return


Ismerős alapokGenerikus típusok

Típusbiztosabb, hatékonyabb gyűjteményekDobozolás nélkül

Típussal paraméterezett …osztályok, interfészek, metódusok, delegate-ekTípuskésznyerek a bővebb funkcionalitáshoz

Általánosabb, típusfüggetlenebb de továbbra is típusbiztos programozás

demo

public class List<T> {T[] array = new T[10]; // tárolópublic void Add( T item ) { this.array[count++] = item; }

Ismerős alapokSorozatok – IEnumerable<T>

Egyszerű sorozat (szekvencia) építésFordító trükk

Felfüggesztett végrehajtás - késleltett kiértékelés(Speciális coroutine támogatás)

demo

public IEnumerable<T> Filter() {foreach( T t in this )

if( t.ToString().StartsWith( "S" ) )yield return t; }

...

static void Main() { ...foreach( int i in list.Filter() )

Console.WriteLine( i ); }

Ismerős alapokNévtelen metódusok

Tipikus hivatkozás egyszer használatos kódra

Implementáció (kód) átadása metódusnak

demo

public IEnumerable<T> Filter( Predicate<T> filter ) {foreach( T t in this )

if( filter( t ) )yield return t; }

...

static void Main() { ...foreach( int i in list .Filter( delegate( string s ) { return s.StartsWith( "S" ); } ) )

Console.WriteLine( i ); }

7

Tartalom





Névtelen típusok



Kifejezés fák

Összefoglalás

Lambda kifejezések

Névtelen metódusok még rövidebb szintaktikával

Ugyanaz mint:

‘s’ típusát kitalálja a környezetből !

Több paraméter esetén a szintaktika

Paraméter nélkül is írható

demo

delegate( string s ) { return s.StartsWith( "S" ); }

s => s.StartsWith( "S" )

( x, y ) => Math.Sqrt( x * x + y * y )

() => 42

Automatikus tulajdonságokAutomatic properties

A hozzá tartozó mező nem érhető el Get ÉS set is kell egyszerre !A láthatóság különbözhet

demo

public class List<T> {public int Count { get; private set; }public void Add( T item ){ this.array[Count++] = item; }

private int <>field0;

public int Count { get { return <>field0; } private set { <>field0 = value; } }

Bővítő metódusokExtension methods

Meglévő osztály kiterjesztése

T lehet generikus osztály vagy interfész isMostantól minden sorozat szűrhető

demo

namespace linqSample.Utils { public static class Helper { static public IEnumerable<T> Filter( this IEnumerable<T> seq, Predicate<T> filter ) { ... }

Statikus bővítő metódus

A bővítendő típus a ‘this’ kulcsszó utánA névtérben

lévő összes bővítőmetódus engedélyezése using linqSample.Utils;

Implicit típusú lokális változókLocal Variable Type Inference

Nem kell kiírni a lokális változó típusátA változó típusa a jobb oldali kifejezés típusa lesz

var == „a jobb oldal típusa”

demo

List<string> list = new List<string>();foreach( string x in list.Filter( s => s.StartsWith( "S" ) ) )

var list = new List<string>();foreach( var x in list.Filter( s => s.StartsWith( "S" ) ) )

12

Tartalom





Névtelen típusok



Kifejezés fák

Összefoglalás

Objektum inicializálókObject initializers

Objektumok inicializálása ha nincs megfelelő konstruktor

Mezők és tulajdonságok beállítása

Kifejezésben is használható

demo

var b=new Music{ Title="Soul Bop",Length=591 }

new Music { Title = "Soul Bop", Length = 591 } . Dump();

list.Add( new Music { Title = "Soul Bop", Length = 591 } );

var b0=new Music();b0.Title="Soul Bop";b0.Length=591;var b = b0;

Beágyazott tagokra is

Összetett típusú tagok inicializálásaCsak a tulajdonságok beállítása

Új objektum létrehozása értékadással

demo

new Music { Title = "Soul Bop", Length = 591, Album = { Artist = "Bill Evans", Year = 2000 } }

new Music { Title = "Soul Bop", Length = 591, Album = new Album{ Artist = "Bill Evans", Year = 2000 } }

Gyűjtemények inicializálása

Hasonló a tömb inicializáláshoz

Publikus Add metódust hívTöbb paraméteres Add metódust is támogat, pl:

Új implicit tömb inicializálás

demo

var szamok = new Dictionary<int, string> { { 0, "nulla" }, { 1, "egy" }, { 2, "kettő" } };

var v = new [ ] { 1, 1.5, 2.3 }; // double [ ]

var list = new List<Music> { new Music { Title = "Soul Bop", Length = 591 }, new Music { Title = "Hangin' in the City", Length = 397 } };

Névtelen osztályok

Az osztály az inicializáláskor kapott tagokat kapjaTulajdonságokToString(), Equals( object ), GetHashCode()

Azonos típus- és névsorrend ugyanazt a típust hivatkozza

var list = new [ ] {new { Title = "Soul Bop", Length = 591 },new { Title = "Hangin' in the City", Length = 397 } };

foreach( var x in list.Filter( s => s.Length < 300 ) )Console.WriteLine( x );

demo

17

Tartalom





Névtelen típusok



Kifejezés fák

Összefoglalás

Standard lekérdezések Standard Query Operators

Sorozatokon (sequence, IEnumerable<T>) működnekA sorozat egyszerűen átalakítható: ToList(), ToArray(), ...

A System.Linq.Enumerable statikus osztály bővítő metódusaiból állnak

System.Core.dll, .NET 2.0-val is működik

JellemzőikTipikusan késői kiértékeléssel dolgoznak (yield)

• Kivételek, például Reverse(), OrderBy(), stb.

Összefűzhetőek, mégis hatékonyakMegmarad a jó olvashatóság, komponálhatóság

demo

A LINQ To Objects műveletei

Szűrés Where

Projekció Select, SelectMany

Rendezés OrderBy, ThenBy

Csoportosítás GroupBy

Joinok Join, GroupJoin

Quantifiers Any, All

Particionálás Take, Skip, TakeWhile, SkipWhile

Halmazműveletek Distinct, Union, Intersect, Except

Elemek First, Last, Single, ElementAt

Aggregáció Count, Sum, Min, Max, Average

Konverzió ToArray, ToList, ToDictionary

Kasztolás OfType<T>, Cast<T>

demo

20

Tartalom





Névtelen típusok



Kifejezés fák

Összefoglalás

from m in list where m.Title.StartsWith( "S" ) select m. Title;

list.Where( m => m. Title.StartsWith( "S" ) ) .Select( m => m.Title);

LekérdezésekQuery Expressions

Lekérdezések nyelvi szinten (C# 3.0, VB 9.0)

A nyelvbe ágyazott lekérdezéseket metódushívásokká alakítja a fordító

demo

A lekérdezések mintája

from id in source{ from id in source | join id in source on expr equals expr [ into id ] | let id = expr | where condition | orderby ordering, ordering, … } select expr | group expr by key[ into id query ]

from-mal kezdődik

További from, join, let, where, vagy

orderby

Végül select by group byOpcionálisan

into-val folytatható

A Query Expression Pattern

metódusai

Where

Select, SelectMany

OrderBy, OrderByDescending, ThenBy, ThenByDescending

GroupBy

Join, GroupJoin

Cast<T>

Késleltetett kiértékelés mégegyszerDeferred Query Execution

list

TitleLengthID select

m => m.Title

cimek

m => m.Title.StartsWith("S”)

where

var list = new List<Music> { ... };

q.ToList();

var q = from m in list where m.Title.StartsWith( "S" ) select m.Title;

var q = list.Where( m => m.Title.StartsWith( "S" ) ) . Select( m => m.Title);

24

Tartalom





Névtelen típusok



Kifejezés fák

Összefoglalás

LINQ to ...

Mi kell ahhoz, hogy elvégezzük az átalakítást?Leképezés: osztály – tábla, tag – oszlop, stb.A szűrési feltétel eredeti, értelmezhető formában

• Nem lefordítva IL kódra

Expression<T> : a kód adatként látszikahol T a kifejezésre jellemző metódusreferencia

from m in list where m.Title.StartsWith( "S" ) select m.Title;

SELECT Title FROM Musicok WHERE Title LIKE ‘S%’

Kifejezés fák – kódból adatExpression Trees

Expression<Predicate<Music>> expr = m => m.Title.StartsWith( "S" );

public delegate bool Predicate<T>( T obj );

ParameterExpression p= Expression.Parameter(typeof(Music),"m");

expr=Expression.Lambda<Predicate<Music>>( Expression.Call(Expression.Property(p, GetMethod(Music.get_Title)),

GetMethod(string.StartsWith), new Expression [ ] {Expression.Constant("S", typeof(string)) }),

new ParameterExpression [ ] { p });

27

Expression, Queryable, IQueryableA Queryable hasonló az Enumerable-höz, de:

IQueryable<> interfész : IEnumerable<>, és:Lehetővé teszi a kifejezések összefűzését is, például:

A Queryable osztály bővítő metódusai segítségével a teljes kifejezés eljut az adatforrásig (list, DataTable, stb.)Végül a forrás alakítja át a kifejezést, például T-SQL-lé

public static IQueryable <TSource> Where <TSource>(this IQueryable <TSource> source, Expression < Func <TSource, bool> > predicate);

list . Where(…) . Take(…) . Select (…); // végül egy Expression lesz

28

LINQ to Desktop Search

OLEDB provideren keresztül, tipikus lekérdezés:

1. A Queryable . Where ( … ) átadja a szűrőt• Építjük és eltároljuk az egészet kifejezést

2. Enumerálásnál átalakítjuk WDS lekérdezéssé

3. Végrehajtjuk a lekérdezést OLEDB-n keresztül• Lezárjuk a kapcsolatot

demo

SELECT System.Title, System.Media.Duration FROM SystemIndex WHERE System.Title = 'Soul Bop'

Egy kifejezés fa, bejárása

29

demo

new WDS() . Where( m => m.Title.StartsWith( "S" ) && m.Length > 300 );

MethodCallWhere

Object (root)WDS

LambdaExpm => …

GreaterThan… > …

MemberAccessm.Length

Constant300

MethodCall….StartsWith( … )

MemberAccessm.Title

Constant“S”

AndAlso… && …

… WHERESystem.Title LIKE 'S%’

AND….Duration > 300

LINQ architektúra

System.Linq.Enumerabledelegate alapú

A forrás IEnumerable<T>

System.Linq.Queryablekifejezésfa alapú

A forrás IQueryable<T>

SQL DataSetObjektumok Egyéb...

from m in list where m.Title.StartsWith( "S" ) select m.Title;

var q = list.Where( m => m.Title.StartsWith( "S" ) ) . Select( m => m.Title);

31

Tartalom





Névtelen típusok



Kifejezés fák

Összefoglalás

var q = from m in list where m.Title.StartsWith( "S" ) select new { m.Title, m.Length };

var q = list.Where( m => m.Length.StartsWith( "S" ) ) .Select( m => new { m.Title, m.Length } );

C# 3.0

Bővítő metódusok

Lambda kifejezések

Lekérdezések

Objektum inicializálók

Névtelen típusok

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

A másfajta megközelítés előnyei

Bizonyos feladatoknál kisebb hiba százalék

Tömörebb kódDE csak addig tömörítsük, amíg ...

Jobban átlátható, karbantartható

Néha párhuzamosíthatóAkár keretrendszer szinten (PLINQ)

Nyelvi szintű integráció más területekkelRelációs adatok, XML, AD, ...

A LINQ projekt

Objektumok

<book> <title/> <author/> <year/> <price/></book>

XML

.NET Language Integrated Query

C# 3.0 VB 9.0 más nyelvek…

Relációs adatbázisok

LINQ toObjects

LINQ toSQL

LINQ toXML

LINQ toEntities

LINQ toDataSets

A .NET 3.5 és a jövő

LINQ to Objects: ez volt most

LINQ to XML: jön a szünet után

LINQ in Visual Basic: még egy óra

LINQ to DataSet: még ebéd előtt

LINQ to SQL: ebéd után

LINQ to Entities: mielőtt haza mennénkLINQ to SharePoint: ...

LINQ to LDAP (Active Directory): ...

LINQ to WMI: …

Paralell LINQ: egy év múlva (?)

36

Összefoglalás

Nem kell használniDe már most is lehet a .NET 2.0-ban VS 2005-telÚgy nőtt az absztrakciós szint, hogy ‘megmaradt az alja’

Apró lépések a nyelvbenyield return, extension methods, lambda expr., var, stb.

Néhány osztály a Framework-benSystem.Linq.Enumerable (.Where, .OrderBy, ...)

Egy kis transzformációfrom x in ... where ... select ...

A mennyiség végül új minőséggé válik (G. Kasparov)

37

További információk

Fejlesztői Portál – devPORTAL{..}http://www.devportal.hu

LINQ Project honlaphttp://msdn2.microsoft.com/en-us/netframework/aa904594.aspx

101 LINQ Sampleshttp://msdn2.microsoft.com/en-us/vcsharp/aa336746.aspx

LINQ Project Forumhttp://forums.microsoft.com/msdn/showforum.aspx?forumid=123&siteid=1

Anders Hejlsberg interjú a LINQ-rőlhttp://channel9.msdn.com/showpost.aspx?postid=114680

Visual Studio Code Name „Orcas” letöltésekhttp://msdn2.microsoft.com/en-us/vstudio/aa700831.aspx

http://www.devportal.hu/

http://msdn2.microsoft.com/en-us/netframework/aa904594.aspx





http://msdn2.microsoft.com/en-us/vcsharp/aa336746.aspx





http://forums.microsoft.com/msdn/showforum.aspx?forumid=123&siteid=1

http://channel9.msdn.com/showpost.aspx?postid=114680





http://msdn2.microsoft.com/en-us/vstudio/aa700831.aspx



38

Kérdések és válaszok

Kérjük írja meg részletes véleményét az előadással kapcsolatban az értékelőlapon!

Quicksort C# 3.0-ban

Func<intlist, intlist> Sort = xs => xs.Case( () => xs, ( head,tail ) => ( Sort( tail.Where( x => x < head ) ) )

.Concat ( Single( head ) )

.Concat ( Sort( tail.Where( x => x >= head ) ) ) );

type inference

összefűzés

magasabb rendű funkció

típussal paraméterezett funkció

rekurzió szűrés

lambda kifejezés

© 2007 Microsoft Corporation. Minden jog fenntartva.Az előadás csupán tájékoztató jellegű, a Microsoft Magyarország a benne szereplő esetleges hibákért vagy tévedésekért semmilyen felelősséget nem vállal.

Documents

2 C# 1.0 C# 2.0 C# 3.0 Komponensek felügyelt környezetben • Property, delegate, event Típusbiztosabb, hatékonyabb nyelv • Generikus típusok, yield return