1. …musing…
A Language Renaissance
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
2. Language: our tool
• Il linguaggio di programmazione è il nostro strumento (“la
nostra cassetta degli attrezzi”)
– Ma la metafora (meccanica) si ferma qui
– Una chiave inglese è immutabile
– I nostri linguaggi no
– Non siamo più nel XX secolo in cui VB6, C, C++, Pascal, Perl,
Java, Javascript erano a lungo stabili…
• Stiamo vivendo un momento particolarmente fertile…
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
3. A Language Renaissance
• Diversi paradigmi di programmazione
– Imperativo
– Object Oriented
– Funzionale
– Dichiarativo
• Visual Studio 2010 esce con un nuovo linguaggio
ufficiale (F#)
• Tipizzazione
– Statica (compile type)
– Dinamica (runtime)
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
4. C# e Visual Basic
• Due team distinti fino a .NET 3.5 sp1
– .NET è un VB evoluto
– VB.Net è un C# con sintassi VB
• Dalla versione 4.0 (.NET 4.0 – Visual Studio 2010)
– Nucleo comune tra i due team
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
5. C# and VB.NET
Language Evolution
26 febbraio 2010
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
6. Agenda
• What is new in C# and VB.NET 1.x (.NET 1.0 –
VS2002/3)
• What is new in C# and VB.NET 2.0 (.NET 2.0 – VS2005)
• What is new in C# and VB.NET 3.0 (.NET 3.5 – VS2008)
• What is new in C# and VB.NET 4.0 (.NET 4.0 – VS2010)
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
7. The Evolution
of C# and VB.NET
4.0 Dynamic
Programming
3.0 Language Integrated
Query
2.0 Generics
1.0
Managed Code
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
8. .NET 4.0 e Visual Studio 2010
• Siamo in RC1
• RTM per l’22 marzo 20108 aprile 2010
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
9. C# and VB.NET
Language Evolution
What is new in C# and VB.NET 1.x
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
10. What is new in C# and VB.NET 1.0
• Reference Types • Enum
• Value Types • Delegates
• Tipi primitivi • Eventi
4.0 Dynamic
• Struct • Eccezioni Programming
• Class e • Enumeratori
3.0 Language Integrated
Ereditarietà • Attributi Query
• Proprietà 2.0 Generics
• Namespace
1.0
Managed Code
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
11. Reference Types
• 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
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
12. Value Types
• 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
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
13. Tipi primitivi
• I tipi primitivi sono strutture definite nel namespace
Boolean bool Boolean
System
character char Char
– È possibile usare il loro nome o il loro sbyte SByte
alias C# byte Byte
short Int16
ushort UInt16
structure name Int32 i = 4; integer
int Int32
C# alias int j;
uint UInt32
same type so long Int64
j = i;
can interoperate
ulong UInt64
float Single
floating point double Double
decimal Decimal
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
14. struct
• 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
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
15. class(i) e ereditarietà
• 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>
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
16. Proprietà
• 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
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
17. Namespace
• 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
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
18. Enum
• 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
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
19. Delegate
• 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)
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
20. Eventi
• 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
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
21. Eccezioni
• 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
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
22. Eccezioni comuni
• 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.
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
23. Enumeratori
• 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
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
24. Attributi
• 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….)]
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
25. C# and VB.NET
Language Evolution
What is new in C# and VB.NET 2.0
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
26. What is new in C# and VB.NET 2.0
• Static Classes
• Generics
• Nullable Types
4.0 Dynamic
• Partial Types Programming
• Anonymous
3.0 Language Integrated
Methods Query
• Iterators 2.0 Generics
1.0
Managed Code
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
27. Static Classes
• 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) {…}
…
}
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
28. Generics
• 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
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
29. Come possono essere usati?
• Con varie definizione di tipo
– Class, struct, interface and delegate
• Per specificare variabili membro, parametri, valori di
ritorno
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
31. Various other Generic Classes
• System.Collections.ObjectModel classes
– Collection<T>
– KeyedCollection<T>
– ReadOnlyCollection<T>
• Various Other Classes
– Nullable<T>
– EventHandler<T>
– Comparer<T>
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
32. Nullable types
• 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;
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
33. Tipi parziali (Partial Types)
• È 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
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
34. Anonymous Methods
• 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);
};
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
35. Anonymous Methods
• 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);
};
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
36. Iteratori
• È 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];
}
}
}
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
37. C# and VB.NET
Language Evolution
What is new in C# and VB.NET 3.0
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
38. What is new in C# and VB.NET 3.0
• Auto- • Extension
Implemented Methods
Properties • Partial Methods
• Object Initializers • Lambdas 4.0 Dynamic
Programming
• Implicit Typed • Expression Trees
Variables 3.0 Language Integrated
Query
• Anonymous
2.0 Generics
Types
– Xml Literals
1.0
Managed Code
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
39. Autoimplemented Properties
• 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
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
40. Object Initializers
• È 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 };
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
41. Implicitly typed variables
• 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
• In VBOption Infer On
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
42. Anonymous Types
• È 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
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
43. Xml Literals
• VB only!
– Uno dei tanti divertissements….
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
44. Extension methods
• È 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
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
45. Partial Methods
• 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)
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
46. Lambda expressions
• 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
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
47. Esempi di Lambda Expressions
– 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
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
48. Lambda to Delegates
• 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);
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
49. Expression trees
• 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
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
50. Visita e costruzione
di un Expression Tree
• // 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.
• ParameterExpression param = • // Create the constant 1 in x + 1
(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 = • // Note it will really look like Add(x,1)
(ParameterExpression)operation.Left; • BinaryExpression expression = Expression.Add(p0, c0);
• ConstantExpression right =
(ConstantExpression)operation.Right;
• // Create the Lamda Expression x => Add(x,1)
• var lambdaExpression =
• Console.WriteLine("Decomposed expression: {0} => {1} {2} Expression.Lambda<Func<int,int>> (expression, new
{3}", 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);
• */
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
51. C# and VB.NET
Language Evolution
The “real” LINQ:
Query Expression
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
52. Query Expressions
• 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>
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
53. Query Expressions
• 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);
– }
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
54. Sintactic sugar
• string[] londoners =
• from c in customers
• where c.City == “London”
• select c.Name;
• string[] londoners =
• customers.
• Where(expression).
• Select(expression);
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
55. Lambda Expressions
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; })
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
56. Lambda Expressions
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
Relatore: Marco Parenzan make me write this
www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
57. Lambda Expressions
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”)
))
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
58. Lambda Expressions
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
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
59. Definizione ed esecuzione
• 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)
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
60. Query Execution
• Una query expression viene eseguita • Per avere una esecuzione
quando viene valutata immediata della query, si possono
• int[] numbers = { 10, 20, 30, 40, 1, 2, utilizzare i metodi ToArray<T>(),
3, 8 }; ToDictionary<TSource,TKey
• var subset = from i in numbers where i int[] numbers = { 10, 20, 30, 40, 1, 2, 3,
< 10 select i; 8 };
• // LINQ statement evaluated here!
// Get data RIGHT NOW as int[].
• foreach (var i in subset)
int[] subsetAsIntArray =
• Console.WriteLine("{0} < 10", i); (from i in numbers
• // Change some data in the array. where i < 10 select i).ToArray<int>();
• numbers[0] = 4;
// Get data RIGHT NOW as List<int>.
• // Evaluate again.
List<int> subsetAsListOfInts = (from
• foreach (var j in subset) i in numbers where i < 10 select
• Console.WriteLine("{0} < 10", j); i).ToList<int>();
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
61. C# and VB.NET
Language Evolution
What is new in C# and VB.NET 4.0
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
62. What is new in C# and VB.NET 4.0
• Dynamic Support • Type Embedding
• Optional and and Type
Named Equivalence
Parameters • Office 4.0 Dynamic
Programming
• Covariance and Programmability
Contravariance 3.0 Language Integrated
Query
2.0 Generics
1.0
Managed Code
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
63. Dynamic Support
• È l’implementazione in C# del “Late Binding”, ora chiamato
“dynamic binding”
– VB ce l’ha sempre avuto!
• Differenza MetodologicaMolti VB-ers dimenticano di impostare in
un nuovo progetto (o modulo) prima di tutto “Option Strict On”
• …e il progetto è INTERAMENTE Option Strict On, mentre dynamic solo
quella variabile
• Differenza Tecnologica
– È una generalizzazione del meccanismo del VB
• Vale solo per se stesso
– È una evoluzione della Reflection
– È una evoluzione di altre API (ICustomTypeDescriptor)
– DLR
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
64. Dynamic Language Runtime
IronPython IronRuby C# VB.NET Others…
Dynamic Language Runtime
Expression Trees Dynamic Dispatch Call Site Caching
Object JavaScript Python Ruby COM
binder binder binder binder binder
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
65. CLR Evolution
Script Compiler as
DLR2 hosting a Service
Dynamic Expression Call site
DLR dispatch trees v2 caching
Language Expression
LINQ features trees
Silverlight
.NET 4.0
Fast Dynamic
.NET 3.5
Generics
delegates methods
.NET 2.0
.NET 1.0
JIT GC Reflection
Verifier Code
BCL
sandbox generation
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
66. dynamic @ work
Calculator calc = GetCalculator();
int sum = calc.Add(10, 20);
object calc = GetCalculator();
Type calcType = calc.GetType();
object res = calcType.InvokeMember("Add",
BindingFlags.InvokeMethod, null,
new object[] { 10, 20 });
int sum = Convert.ToInt32(res);
Statically typed to dynamic calc = GetCalculator();
be dynamic int sum = calc.Add(10, 20);
Dynamic Dynamic method
conversion invocation
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
67. Optional and
Named parameters
• Optional parameters
– Poter definire alcuni parametri opzionali senza dover creare tanti
metodi sovraccarichi per distinguere la firma
– Anche questo il VB ce l’aveva già!!!!!!!!!
• Named parameters
– Conseguenza degli optional parameters
– Poter valorizzare alcuni parametri e non altri, in una sequenza
arbitraria
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
68. Co- and Contra-variance
.NET arrays are
string[] strings = GetStringArray(); co-variant
Process(strings);
void Process(object[] objects) { … } …but not safely
objects[0] = "Hello"; // Ok co-variant
objects[1] = new Button(); // Exception!
}
Until now, C#
generics have
List<string> strings = GetStringList();
Process(strings); been invariant
void Process(IEnumerable<object> objects) { … }
// IEnumerable<T> is read-only and C# 4.0 supports
// therefore safely co-variant safe co- and
} contra-variance
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
69. Safe Co- and Contra-variance
public interface IEnumerable<T> T>
IEnumerable<out out = Co-variant
{ Output positions only
IEnumerator<T> GetEnumerator();
}
Can be treated as
public interface IEnumerator<T> T>
IEnumerator<out less derived
{
T Current { get; } IEnumerable<string> strings = GetStrings();
bool MoveNext(); IEnumerable<object> objects = strings;
}
in = Contra-variant
Input positions only
public interface IComparer<T> T>
IComparer<in
{ Can be treated as
int Compare(T x, T y); more derived
}
IComparer<object> objComp = GetComparer();
Relatore: Marco Parenzan
IComparer<string> strComp = objComp; www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
70. Type Embedding
• Type Embedding
– Visual Studio option enabling Type Embedding of assembly references
• Interfaces with the same GUID are treated by CLR as equivalent types
• Only metadata is locally embedded
– interfaces (must have ComImport, Guid attributes)
– delegates
– simple structs
– enums
– But not classes or static methods
• Typical applications use helper libraries
– Helper libraries also need to embed types
• Number of separate copies of the same interop type are created
– Yes, these all are different types!
– Can we still use a method returning a different copy of a type ?
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
71. Type Equivalence
• Interfaces with the same GUID are treated by CLR as
equivalent types
• Casts to an equivalent interface
– CLR looks for TypeIdentifier attribute to be present on one of the
interfaces
• Calls through an equivalent interface
– COM objects: CLR intercepts the calls and routes them through
COM interop (this is the old behavior)
– Managed objects: CLR finds an equivalent interface in the
inheritance chain, looks up a method with the same vtable offset,
and verifies the signatures match
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
72. Type Embedding
and Type Equivalence
• Future versioni del CLR, C# e VB.NET sfrutteranno
meglio queste capacità
– http://channel9.msdn.com/shows/Going+Deep/Raja-
Krishnaswamy-and-Vance-Morrison-CLR-4-Inside-Type-
Equivalence/
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
73. C# and VB.NET Language
Evolution
Conclusioni
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
74. Conclusioni
• Con un nuovo framework .NET spesso coincide il rilascio
di un aggiornamento dei linguaggi (al momento solo la
3.0 non ha portato evoluzioni ai linguaggi)
– Nuove librerie
– Nuove sintassi
• Migliorare la manutenibilità delle applicazione
• “Be a polyglot programmer”
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
75. Dynamic Languages
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
76. Mono Experimental
C# Extensions
• Sono funzioni che si possono (dis)abilitare in mcs (il compilatore C# di
Mono
– Non è detto (spero sia probabile) che Microsoft le inserisca ufficialmente in future
versioni del linguaggio
• String interpolation
– String.Format
– A livello di linguaggio (come Python e Ruby)
– Named (non positional) arguments
– Es. var x = “Hello World, {name}”;
– http://tirania.org/blog/archive/2009/Dec-20.html
• Tuple
– Tuple<string, string, string, int, string> ParseUri (string url);
(user, password, host, port, path) = ParseUri (url);
– http://tirania.org/blog/archive/2009/Dec-23.html
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
77. Compiler as a Service
Class
Meta-programming Read-Eval-Print Loop
public Foo
Language Field
DSL Embedding
Object Model private X
string
Source .NET
File Assembly
Source code
Source code Compiler Source code
Source code
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net
78. Prossimi Eventi 2010
Venerdì 26 Febbraio Caratteristiche del framework Microsoft .Net 4.0 Stefano Casagrande
L’evoluzioni dei linguaggi C# e VB.Net, dalla 1.0 alla 4.0 Marco Parenzan
Venerdì 2 Aprile Microsoft Entity Framework 4.0 Manuel Scapolan
ASP.NET MVC 2.0 Marco Parenzan
Styling in 2010: CSS, jQuery and Smashing Magazine! Sandro Marcon e Pietro Vian
Silverlight 4.0 Marco Parenzan
Venerdì 14 Maggio Windows Presentation Foundation Marco Parenzan
• Abbiamo altri eventi per voi
• Proponete idee e argomenti
– soci@1nn0va.net
Relatore: Marco Parenzan www.1nn0va.net
Mail: marco.parenzan@libero.it – Blog: http://blog.codeisvalue.com/ info@1nn0va.net