C# Language Evolution

2,036 views
1,900 views

Published on

Elementi di C# 1.0
Delegati ed eventi. Eccezioni. Enumeratori.
Elementi di C# 2.0
Static Classes. Generics e collezioni generiche.Nullable Types. Partial Types e Partial Classes. Anonymous Methods.Iteratori,
Elementi di C# 3.0
Auto-implemented properties.Object Initializers e Collection Initializers. Implicit Typed Variables. Anonymous Types.Extension Methods. Lambda Expression.

Published in: Technology, Business
1 Comment
3 Likes
Statistics
Notes
  • For brief description of C# Nullable type please refer
    http://bimbim.in/post/2010/08/31/Nullable-Types-in-C-sharp-net.aspx
       Reply 
    Are you sure you want to  Yes  No
    Your message goes here
No Downloads
Views
Total views
2,036
On SlideShare
0
From Embeds
0
Number of Embeds
11
Actions
Shares
0
Downloads
54
Comments
1
Likes
3
Embeds 0
No embeds

No notes for slide

C# Language Evolution

  1. 1. C# LANGUAGE EVOLUTION
  2. 2. Agenda Introduzione al .NET Framework – Marco Parenzan  C# Language Enhancements Evolution  What is new in C# 1.x  What is new in C# 2.0  What is new in C# 3.0
  3. 3. C# LANGUAGE EVOLUTION What is new in C# 1.x
  4. 4. Novità in C# 1.0 Introduzione al .NET Framework – Marco Parenzan  Reference Types  Enum  Value Types  Delegates  Tipi primitivi  Eventi  Struct  Eccezioni  Class e Ereditarietà  Enumeratori  Proprietà  Attributi  Namespace
  5. 5. Reference Types Introduzione al .NET Framework – Marco Parenzan  Una qualsiasi dichiarazione di tipo fatta con la parola class indica un Reference Type  Il riferimento è a una istanza di quel tipo  L’istanza viene creata con l’operatore new  Allocazione nel managed heap  L’assegnazione tra variabili di tipo Reference implica la copia del riferimento, non dell’oggetto riferito  Una variabile di un reference type accetta null  Invalida il riferimento  Valore di default per una variabile  Non distrugge l’oggetto (Garbage Collection)  Far riferimento ad una variabile null solleva una NullReferenceException  Gli array e le stringhe sono reference types
  6. 6. Value Types Introduzione al .NET Framework – Marco Parenzan  Nel caso di local variables, parameters, loop counters, un programma ne può fare un uso intensivo  Problemi  Allocazione  Accesso  Rilascio  Uso dello stack  Allocazione e rilascio automatico  Accesso alla memoria efficiente  I value types contengono i valori direttamente, non i riferimenti  Int, char, byte, TimeSpan sono value types primitivi  Se ne possono definire di custom tramite struct
  7. 7. Tipi primitivi Introduzione al .NET Framework – Marco Parenzan  I tipi primitivi sono strutture definite nel namespace System  È possibile usare il loro nome o il loroBoolean bool Boolean char Char alias C# character sbyte SByte byte Byte short Int16 structure name Int32 i = 4; ushort UInt16 C# alias int j; integer int Int32 same type so uint UInt32 j = i; can interoperate long Int64 ulong UInt64 float Single floating point double Double decimal Decimal
  8. 8. struct Introduzione al .NET Framework – Marco Parenzan  Possono avere proprietà, metodi, costruttori, membri, implementare interfacce  Non possono:  Ereditarietà per classe  Valori inizializzati alla definizione  Non possono avere un custom default constructor (senza parametri)  Un costruttore deve esplicitamente inizializzare tutte le variabili
  9. 9. class e ereditarietà Introduzione al .NET Framework – Marco Parenzan  Class per definire reference type  Ereditarietà  Single rooted  Multiple Interface  “base” per referenziare la classe base  Le classi non sono polimorfiche di default  I membri non sono virtuali di default  Necessaria la parola chiave virtual  Per identificare un tipo si usa l’operatore is  <variable> is <type>
  10. 10. Proprietà Introduzione al .NET Framework – Marco Parenzan  Le proprietà combinano la sintassi delle variabili membro con il controllo delle funzioni membro  Permettono di associare ad un nome (con un tipo) le due funzioni accessorie  Syntactic Sugar  Permettono di definire  Readonly properties  Guarded properties  Calculated properties
  11. 11. Namespace Introduzione al .NET Framework – Marco Parenzan  Qualificano un insieme di classi sotto un unico nome contenitore  Nome COMPLETO della classe: nome del namespace + nome della classe  Livelli>1  Si definiscono in namespace {}  Permettono di disambiguare classi con lo stesso nome  È possibile usare sempre i nomi qualificati  È possibile importare un namespace con la parola chiave using  Permette di definire alias sul namespace: using <alias> = <namespace>  <alias>.<nome classe>  Permette di definire alias sulla classe: using <aliasclasse> = <namespace>.<classe>  <aliasclasse>  È possibile usare la parola using sia dentro che fuori del namespace  La differenza diventa “importante” nel caso nello stesso file ci siano più definizioni di namespace  Spesso non succede  Esiste un “global” namespace
  12. 12. Enum Introduzione al .NET Framework – Marco Parenzan  La parola chiave enum è usata per definire il nuovo tipo  Contiene un insieme di costanti simboliche  È possibile definire variabili di un tipo enum, usando I valori definiti in essa  Di default usa (implicitamente) il tipo int  È possibile fare il cast (esplicito) da/verso il tipo implicito  È possibile specificare un altro tipo primitivo (a parte char)  È possibile assegnare dei valori diretti  È possibile modificare la sequenza dei numeri
  13. 13. Delegate Introduzione al .NET Framework – Marco Parenzan  La parola riservata delegate serve a definire un tipo in grado di puntare a un metodo e gestire indirettamente la sua invocazione.  Possiamo vedere un delegate come un "puntatore a funzione“  Garantisce che il metodo abbia una specifica firma  Lista ordinata dei tipi dei parametri formali  Non include il tipo di ritorno (ma due funzioni non possono distinguersi per il solo tipo di ritorno)  Offrono la possibilità di chiamare un metodo (anche) in modo asincrono tramite BeginInvoke e EndInvoke  Un delegato ha dei metodi (è una classe)  <delegate>() è la sintassi contratta di <delegate>.Invoke()  I delegati sono multicast  È possibile assegnare ad un delegate più puntamenti a metodi diversi  Un invocazione sul delegato implica la chiamata a tutti i metodi referenziati  Vengono utilizzati principalmente per:  la gestione degli eventi  L’uso come callback (passare un metodo come “valore” ad un altro metodo)
  14. 14. Eventi Introduzione al .NET Framework – Marco Parenzan  Un evento caratterizza un componente  Qualcosa che succede all’interno del componente e che lo stesso notifica  Un oggetto esterno può sottoscrivere l’evento per essere notificato quando succede  Un evento è una specializzazione di un delegato  event è una parola chiave da associare ad una proprietà di un tipo delegato  event impedisce l’uso dell’assegnazione (“=“) ma solo la sottoscrizione (“+=“) o la cancellazione (“-=“)  Il mancato uso dell’assegnazione impedisce ad un consumatore generico di rimuovere la sottoscrizione a qualche altro componente  Qualsiasi delegato può essere usato per un evento  È convenzione usare un delegato del tipo delegate void <event handler>(object sender, <event args> e) dove <event args> è una classe che deriva da EventArgs  È possibile creare una variabile membro di tipo evento  È possibile creare una proprietà di tipo evento  Rispetto alle proprietà le funzioni accessorie sono add e remove
  15. 15. Eccezioni Introduzione al .NET Framework – Marco Parenzan  Un’eccezione è un evento sincrono  È prevedibile il punto in cui può avvenire, non il momento  Un’eccezione è un pattern utilizzato per notificare errori  Un’eccezione può essere gestita con un blocco try…catch…finally  Try: blocco che può generare eccezione  Catch: blocco eseguito subito dopo all’istruzione nel blocco try che ha generato l’eccezione  Finally: blocco eseguito comunque dopo il blocco try e l’eventuale blocco catch  Un’eccezione, per essere gestita dal blocco try prende forma di un oggetto che deriva dalla classe exception  La notifica di un’eccezione si basa sullo stack  Un blocco try…catch…finally viene registrato nello stack  Non è detto che un metodo che chiama un altro metodo che genera una eccezione debba “trappare” una eccezione  Viene fatto uno “stack walk” per trovare il primo blocco disponibile  Eventualmente quello di default fornito dal framework  È possibile definire una eccezione derivando una nuova classe dal tipo Exception  Si usa l’istruzione throw per sollevare una nuova eccezione  Ci sono delle eccezioni di uso comune
  16. 16. Eccezioni comuni Introduzione al .NET Framework – Marco Parenzan  System.ArgumentException  Thrown when a function is called with a bogus argument. This generally indicates a program bug.  System.ArgumentNullException  Thrown when a function argument is (unexpectedly) null. (It is a subclass of ArgumentException.  System.ArgumentOutOfRangeException  Thrown when a (usually numeric) argument is too big or too small. (It is also a subclass of ArgumentException.) For example, this is thrown when passing a negative number into a function that accepts only positive values.  System.InvalidOperationException  Thrown when the state of an object is unsuitable for a method to successfully execute, regardless of any particular argument values. Examples include reading an unopened file or getting the next element from an enumerator where the underlying list has been modified partway through the iteration.  System.NotSupportedException  Thrown to indicate that a particular functionality is not supported. A good example is calling the Add method on a collection for which IsReadOnly returns true.  System.NotImplementedException  Thrown to indicate that a function has not yet been implemented.  System.ObjectDisposedException  Thrown when the object upon which the function is called has been disposed.
  17. 17. Enumeratori Introduzione al .NET Framework – Marco Parenzan  Un enumeratore è un cursore read-only forward only  Permette di visitare una collezione di elementi  Si basa su due interfacce  IEnumerator: l’enumeratore vero e proprio  IEnumerable: permette di richiedere ad una collezione un enumeratore per visitare la stessa  Usato dal costrutto foreach
  18. 18. Attributi Introduzione al .NET Framework – Marco Parenzan  Permettono di associare metadati agli elementi di definizione di una classe (classe, metodo, variabile, proprietà, …)  Sono informazioni disponibili a runtime tramite reflection  <object>.GetType().GetMember()  Permettodo di implementare algoritmi basati sulla struttura stessa della classe, decidendo in base agli attributi  Un esempio su tutti: serializzazione  Atttributi Standard (dalla BCL)  Attributi Custom  Classi derivate da System.Attribute  Accessibili tramite Attribute.GetCustomAttribute(<memberinfo>)  Sintassi:  [<attribute>Attribute(positional parameters, named parameters….)]
  19. 19. C# LANGUAGE EVOLUTION What is new in C# 2.0
  20. 20. Novità in C# 2.0 Introduzione al .NET Framework – Marco Parenzan  Static Classes  Generics  Nullable Types  Partial Types  Anonymous Methods  Iterators
  21. 21. Static Classes Introduzione al .NET Framework – Marco Parenzan  Contengono solo metodi statici  Non membri di istanza  Serviranno per gli Extension Methods public static class Math { public static double Sin(double x) {…} public static double Cos(double x) {…} … }
  22. 22. Generics Introduzione al .NET Framework – Marco Parenzan  Cosa sono i generics?  Polimorfismo Parametrico  Funziona sia con reference and value types  Controllo dei tipi in fase di dichiarazione  No boxing (value types)  No downcasts (no object)  Supporto completo a runtime  Reduced code bloat  Non bisogna scrivere classi wrapper tipizzate
  23. 23. Come possono essere usati? Introduzione al .NET Framework – Marco Parenzan  Con varie definizione di tipo  Class, struct, interface and delegate  Per specificare variabili membro, parametri, valori di ritorno
  24. 24. Generic Collections and Interfaces Introduzione al .NET Framework – Marco Parenzan  System.Collections.Generic classes  List<ItemType>  Dictionary<K,V>  Stack<ItemType>  Queue<ItemType>  System.Collections.Generic interfaces  IList<ItemType>  IDictionary<K,V>  ICollection<ItemType>  IEnumerable<ItemType>  IEnumerator<ItemType>  IComparable<OperandType>  IComparer<OperandType>
  25. 25. Various other Generic Classes Introduzione al .NET Framework – Marco Parenzan  System.Collections.ObjectModel classes  Collection<T>  KeyedCollection<T>  ReadOnlyCollection<T>  Various Other Classes  Nullable<T>  EventHandler<T>  Comparer<T>
  26. 26. Nullable types Introduzione al .NET Framework – Marco Parenzan  Int è un value type e non può accettare il null (reference type)  Utile nel momento in cui mappiamo gli attributi di una tabella di database (tutti gli attributi di una tabella di DB possono essere nullabili)  Applicazione dei generics  Nullable<T>  T è un tipo primitivo (value type/struct)  Rende possibile la sintassi  int? x = null;  Int? è equivalente a Nullable<int>  Il cast può essere:  Implicito: int? x = 5;  Esplicito: int y = (int) x; // perché bisogna verificare se non sia null  int y = 0; if (x.HasValue) y = (int) x;
  27. 27. Tipi parziali (Partial Types) Introduzione al .NET Framework – Marco Parenzan  È possibile spezzare una dichiarazione in più files  Utile quando c’è un designer/generatore di codice  Ottimo anche per organizzare il codice  Una partial class per ogni interfaccia implementata  Tipi supportati  Classes (Partial Classes)  Struct  Interface  Divisi a design time, “fusi insieme” a compile time
  28. 28. Anonymous Methods Introduzione al .NET Framework – Marco Parenzan  Permettono di definire direttamente il codice dove è necessario un delegato  Il tipo dei delegati viene automaticamente inferenziato (non serve istanziare esplicitamente il delegato, ma scrivere solo il corpo) button.Click += delegate(object sender, EventArgs e) { MessageBox.Show(((Button)sender).Text); };
  29. 29. Anonymous Methods Introduzione al .NET Framework – Marco Parenzan  I blocchi di codice possono accedere alle variabili locali  Non possono però accedere a parametri (di un metodo in cui sono definiti) ref o out  Ovvio, in quanto la loro esecuzione non è legata all’invocazione del metodo di definizione  La vita delle variabili locali è “estesa” fino a che il delegato che le referenzia non è eligibile di garbage collection  Tutto è dovuto a generazione nascosta di classi int n = 0; Del d = delegate() { System.Console.WriteLine("Copy #:{0}", ++n); };
  30. 30. Iteratori Introduzione al .NET Framework – Marco Parenzan  È possibile usare la parola chiave yield  yield return e yield break  Bisogna restituire IEnumerator o IEnumerable public class List { public IEnumerator GetEnumerator() { for (int i = 0; i < count; i++) { yield return elements[i]; } } }
  31. 31. C# LANGUAGE EVOLUTION What is new in C# 3.0
  32. 32. What is new in C# 3.0 Introduzione al .NET Framework – Marco Parenzan  Auto-Implemented Properties  Object Initializers  Implicit Typed Variables  Anonymous Types  Extension Methods  Partial Methods  Lambdas  Expression Trees  The “real”Query Expressions
  33. 33. Autoimplemented Properties Introduzione al .NET Framework – Marco Parenzan  Permettono di specificare una proprietà senza doverne specificare il field privato  Velocizza il processo di creazione di proprietà all’interno delle classi  Il membro privato viene generato a compile-time  Per vedere il nome del field privato generato, è necessario utilizzare ildasm.exe o Reflector.exe  Non è possibile utilizzarle per specificare proprietà in read-only o write- only  E’ possibile limitare l’accesso al get o al set di una proprietà, specificandone la visibilità  Non è possibile specificare un valore di default a causa del membro privato che non è presente  Nel costruttore della classe si può intervenire impostando il valore di default
  34. 34. Object Initializers Introduzione al .NET Framework – Marco Parenzan  È possibile inizializzare variabili membro e proprietà, senza richiamare il costruttore in modo esplicito  new C(1, 2, name=“my class”);  Valgono le regole di visibilità  È possibile fare annidamento  Initializzare grafi  Collection initializers  List<int> digits = new List<int> { 0, 1};  Deve implementare System.Generic.ICollection<T>  Object initializers  var a = new Point { X = 0, Y = 1 };
  35. 35. Implicitly typed variables Introduzione al .NET Framework – Marco Parenzan  E’ possibile dichiarare le variabili in modo implicito, utilizzando la parola chiave “var”  var i = 5; var s = "Hello"; var d = 1.0; var orders = new Dictionary<int,Order>();  Il tipo delle variabili è indotto dalla espressione che lo inizializza  DEVE INCLUDERE L’INIZIALIZZAZIONE  “var” non è variant o object  È comunque statically typed  Non può essere null  Var può essere usata SOLO nei metodi  Non può essere usata a livello di classe  Attenzione all’abuso  Bisogna capire il contesto dell’esecuzione per capire cosa c’è dentro  E’ possibile utilizzare la keywork “var” anche all’interno di cicli for e foreach
  36. 36. Anonymous Types Introduzione al .NET Framework – Marco Parenzan  È una “tupla” le cui proprietà specifiche sono inferenziate tramite Object Initializer  Viene fatto a compile time, quindi è sempre comunque statically/strongly typed  Internamente viene creata una classe nascosta  var x = new {p1 = 10, p2 = “name”};  Il tipo di x è anonimo  Non è possibile referenziarlo “per nome” da codice  structural type equivalence  Due tipi anonimi possono essere compatibili  Viene ricostruita la “compatibilità” a compile time  Viene definito un solo nuovo tipo (anonimo)  La classe verrà generata automaticamente in fase di compilazione, e deriverà da System.Object  implicitly typed arrays  var a = new[] { 1, 10, 100, 1000 };  Devono avere tipi compatibili  O conversioni implicite
  37. 37. Extension methods Introduzione al .NET Framework – Marco Parenzan  È possibile aggiungere metodi a classi già definite  È possibile aggiungere metodi a classi già compilate, in assembly diversi  Non sono mixin (dai dynamic languages)  Sono “syntactic sugar”  Readability  Solo metodi  Non per properties, events, operators (almeno per adesso)  Metodi statici in classi statiche  La chiamata esplicita al metodo statico avviene sempre (e rimuove ambiguità)  Nel caso di sovrapposizione con metodi locali  I metodi locali hanno la precedenza  L’inserimento degli extension method avviene al momento dell’importazione del namespace
  38. 38. Extension methods Introduzione al .NET Framework – Marco Parenzan public static class Extensions { public static int ToInt32(this string s) { return Int32.Parse(s); } public static T[] Slice<T>(this T[] source, int index, int count) { if (index < 0 || count < 0 || source.Length – index < count) throw new ArgumentException(); T[] result = new T[count]; Array.Copy(source, index, result, 0, count); return result; } }
  39. 39. Partial Methods Introduzione al .NET Framework – Marco Parenzan  E’ stata aggiunta la possibilità di definire un metodo come “partial”  Permette di definire un metodo in una parte della classe, e poterlo implementare in un’altra parte della classe  Utile in caso di uso dei generatori di codice  Non necessità di ereditarietà di metodi virtuali  I metodi dichiarati come “partial” hanno delle limitazioni:  Devono essere definiti all’interno di una partial class  Devono sempre ritornare void  Possono avere argomenti, ma non con clausula “out”  Sono sempre implicitamente privati  Se un metodo partial non viene implementato, questo non compare nel codice compilato (nemmeno la chiamata del metodo)
  40. 40. Lambda expressions Introduzione al .NET Framework – Marco Parenzan  Permettono di definire delle funzioni “inline”, associando direttamente un blocco di codice  Permettono di creare un metodo “stand-alone” all’interno del codice (utilizzando gli anonymous methods)  Sono un’ulteriore semplificazione rispetto l’uso dei delegate  Dal calcolo lambda  x.x+1  In C# 3.0  x => x + 1  Dalla sintassi delle anonymous functions  delegate(int x) { return x + 1;}  Possono usare variabili implicitamente tipizzate  Possono avere più di una variabile  Il corpo può contenere espressioni o istruzioni
  41. 41. Esempi di Lambda Expressions Introduzione al .NET Framework – Marco Parenzan  x => x + 1 // Implicitly typed, expression body  x => { return x + 1; } // Implicitly typed, statement body  (int x) => x + 1 // Explicitly typed, expression body  (int x) => { return x + 1; } // Explicitly typed, statement body  (x, y) => x * y // Multiple parameters  () => Console.WriteLine() // No parameters
  42. 42. Lambda to Delegates Introduzione al .NET Framework – Marco Parenzan  Una lambda expression è un valore,che non ha tipo, ma può essere convertito in un particolare delegato  delegate R Func<A,R>(A arg);  Func<int,int> f1 = x => x + 1; // Ok  Func<int,double> f2 = x => x + 1; // Ok  Func<double,int> f3 = x => x + 1; // Error – double cannot be // implicitly converted to int  Nel framework sono predefiniti dei delegates “standard”  public delegate TResult Func<TResult>();  public delegate TResult Func<T, TResult>(T a);  public delegate TResult Func<T1, T2, TResult>(T1 a, T2 b);  public delegate TResult Func<T1, T2, T3, TResult>(T1 a, T2 b, T3 c);  public delegate TResult Func<T1, T2, T3, T4, TResult>(T1 a, T2 b, T3 c, T4 d);  public delegate void Action();  public delegate void Action<T>(T a);  public delegate void Action<T1, T2>(T1 a, T2 b);  public delegate void Action<T1, T2, T3>(T1 a, T2 b, T3 c);  public delegate void Action<T1, T2, T3, T4>(T1 a, T2 b, T3 c, T4 d);
  43. 43. Expression trees Introduzione al .NET Framework – Marco Parenzan  Forniscono una rappresentazione ad oggetti di una lambda expression.  Sono assimilabili agli AST generati da un compilatore per creare il codice “a compiler time”  L’expression tree è accessibile a runtime  Le lambda expression possono essere convertite in un expression tree  Expression<Func<T>> e = x => x + 1;  Sono compilati, strong-typed, provider independent e serializzabili.  Sono Immutabili, e quindi per modificarne una sua parte, si deve creare un nuovo Expression Tree
  44. 44. Visita e costruzione di un Expression Tree Introduzione al .NET Framework – Marco Parenzan // Create an expression tree. // Create the parameter "x" in x + 1 Expression<Func<int, bool>> exprTree = num => num < 5; ParameterExpression p0 = Expression.Parameter(typeof(int), "x"); // Decompose the expression tree. // Create the constant 1 in x + 1 ParameterExpression param = (ParameterExpression)exprTree.Parameters[0]; ConstantExpression c0 = Expression.Constant(1); BinaryExpression operation = (BinaryExpression)exprTree.Body; // Build the addition expression x + 1 using the above ParameterExpression left = (ParameterExpression)operation.Left; // Note it will really look like Add(x,1) ConstantExpression right = BinaryExpression expression = Expression.Add(p0, c0); (ConstantExpression)operation.Right; // Create the Lamda Expression x => Add(x,1) Console.WriteLine("Decomposed expression: {0} => {1} {2} var lambdaExpression = Expression.Lambda<Func<int,int>> {3}", (expression, new ParameterExpression[] { p0 }); param.Name, left.Name, operation.NodeType, right.Value); // Let's compile it so we can use it var theDelegate = lambdaExpression.Compile(); /* This code produces the following output: // Execute... 6 + 1 = 7 Decomposed expression: num => num LessThan 5 var seven = theDelegate.Invoke(6); */
  45. 45. C# LANGUAGE EVOLUTION The “real” LINQ: Query Expression
  46. 46. Query Expressions Introduzione al .NET Framework – Marco Parenzan  Fornisce delle API che permetteno di eseguire delle query expression (sia in lettura che scrittura) verso classi che implementano IEnumerable<T>, database relazionali, DataSets, o documenti XML. (etc etc ...)  Definiscono delle query verso una sorgente dati, utilizzando dei query operators (es: from, in, where, orderby, e select)  Le LINQ query expression sono strongly typed. Il compilatore verificherà la corretta sintassi delle query.  Il tipo di dati ritornato è del tipo IEnumerable<T>
  47. 47. Query Expressions Introduzione al .NET Framework – Marco Parenzan  Query expressions or LINQ (Language INtergrated Queries) are the key feature of .NET 3.5  Query expressions are translated to method calls works on classes like:  delegate R Func<A,R>(A arg);  class C<T>  {  public C<T> Where(Func<T,bool> predicate);  public C<S> Select<S>(Func<T,S> selector);  public C<S> SelectMany<S>(Func<T,C<S>> selector);  public O<T> OrderBy<K>(Func<T,K> keyExpr);  public O<T> OrderByDescending<K>(Func<T,K> keyExpr);  public C<G<K,T>> GroupBy<K>(Func<T,K> keyExpr);  public C<G<K,E>> GroupBy<K,E>(Func<T,K> keyExpr, Func<T,E> elemExpr);  }
  48. 48. Sintactic sugar Introduzione al .NET Framework – Marco Parenzan string[] londoners = from c in customers where c.City == “London” select c.Name; string[] londoners = customers. Where(expression). Select(expression);
  49. 49. Lambda Expressions Introduzione al .NET Framework – Marco Parenzan What is this? customers.Where(City == “London”) Expression? Data Structure? Code fragment? Local Query Anonymous method? vertices.Where(X > Y) vertices.Where(delegate(Point p) { return p.X > p.Y; })
  50. 50. Lambda Expressions Introduzione al .NET Framework – Marco Parenzan Remote Query == Remotable customers.Where(delegate(Customer c) { return c.City == “London”}) c.City “London” Inspectable customers.Where(Expr.Delegate( Expr.Param(“c”), AST Expr.EQ( IL doesn’t travel Good for API’s well Expr.Property( Expr.Param(“c”), “City”), Still no type Expr.Literal(“London”)) checking? But please don’t make me write this
  51. 51. Lambda Expressions Introduzione al .NET Framework – Marco Parenzan Better if something like this … customers.Where(City == “London”) or this Expr.Delegate( delegate(Customer c) { Expr.Param(“c”), return c.City == “London” Expr.EQ( } Expr.Property( Expr.Param(“c”), “City”), could become this Expr.Literal(“London”) ))
  52. 52. Lambda Expressions Introduzione al .NET Framework – Marco Parenzan Parameterized fragments of code public delegate Func<T,bool>(T t) Func<Customer,bool> f = c => c.City == “London”; Coercible to delegates Expression<Func<Customer,bool>> e = c=> c.City == “London”; or Expression types Syntax is the same
  53. 53. Definizione ed esecuzione Introduzione al .NET Framework – Marco Parenzan  La definizione di una query è differente dalla sua esecuzione  Questo è necessario perché il modello di interrogazione deve essere componibile  Componibile è necessario per rendere “accettabile” la definizione della query  Vale soprattutto se l’esecuzione deve essere eseguita remotamente (da una definizione locale)  Si parla di esecuzione “differita” (DEFERRED)
  54. 54. Query Execution Introduzione al .NET Framework – Marco Parenzan  Una query expression viene eseguita quando • Per avere una esecuzione viene valutata immediata della query, si possono int[] numbers = { 10, 20, 30, 40, 1, 2, 3, 8 }; utilizzare i metodi ToArray<T>(), var subset = from i in numbers where i < 10 select i; ToDictionary<TSource,TKey // LINQ statement evaluated here! int[] numbers = { 10, 20, 30, 40, 1, 2, 3, 8 }; foreach (var i in subset) Console.WriteLine("{0} < 10", i); // Get data RIGHT NOW as int[]. // Change some data in the array. int[] subsetAsIntArray = numbers[0] = 4; (from i in numbers // Evaluate again. where i < 10 select i).ToArray<int>(); foreach (var j in subset) Console.WriteLine("{0} < 10", j); // Get data RIGHT NOW as List<int>. List<int> subsetAsListOfInts = (from i in numbers where i < 10 select i).ToList<int>();

×