Programming with C# 3.0

1. Programming with C# 3.0 • Andrea Dottor – Microsoft MVP ASP/ASP.NET

2. Perchè questa sessione • Perchè una sessione su C# 3.0? www.xedotnet.org

3. Agenda • Agenda: • Auto-Implemented Properties • Partial Method Definitions • Extension Methods • Implicitly Typed Local Variables and Arrays • Object Initializers • Collection Initializers • Anonymous Method • Lambda Expressions • Anonymous Types • Linq • Query Expression • Expression tree www.xedotnet.org

4. Auto-Implemented Properties • Auto-Implemented Properties • Permettono di specificare una proprietà senza doverne specificare il field privato • Velocizza il processo di creazione di proprietà all’interno delle classi • E’ accessibile attraverso lo snippet ‘prop’ di Visual Studio 2008 class Car { // Automatic property syntax. public string PetName { get; set; } } www.xedotnet.org

5. Auto-Implemented Properties • Auto-Implemented Properties • Il membro privato viene generato a compile-time • Per vedere il nome del field privato generato, è necessario utilizzare ildasm.exe o Reflector.exe (tools che permettono di decompilare il codice MSIL) • Non è possibile utilizzarle per specificare proprietà in read-only o write-only // Read-only property? Error! public int MyReadOnlyProp { get; } // Write only property? Error! public int MyWriteOnlyProp { set; } www.xedotnet.org

6. Auto-Implemented Properties • Auto-Implemented Properties • 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 public string PetName { get; protected set; } www.xedotnet.org

7. Partial Method Definitions • Partial Method Definitions • E’ stata aggiunta la possibilità di definire un metodo come “partial” • Permette di definire un metodo in una classe, e poterlo implementare in un’altra classe partial class CarLocator { public bool CarAvailableInZipCode(string zipCode) { VerifyDuplicates(zipCode); return true; } partial void VerifyDuplicates(string make); } www.xedotnet.org

8. Partial Method Definitions • Partial Method Definitions • 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) www.xedotnet.org

9. DEMO DEMO • Auto-Implemented Properties • Partial Method Definitions www.xedotnet.org

10. Extension Methods • Extension Methods • Permettono di aggiungere metodi a tipi “compilati” (classi, strutture, implementazioni di interfacce) • Aggiungono funzionalità alle classi senza doverle modificare o ricompilare • Grosso vantaggio in quanto permettono di aggiungere metodi a classi di qui non si possiede il codice www.xedotnet.org

11. Extension Methods • Extension Methods • Vincoli: • Devono essere in una classe statica • Come primo argomento devono avere la clausola “this” • Devono essere chiamati da un specifico tipo di instanza (in memoria) oppure tramite la classe statica static class MyExtensions { public static void DisplayDefiningAssembly(this object obj) { Console.WriteLine("{0} lives here:{1}", obj.GetType().Name, Assembly.GetAssembly(obj.GetType())); } } www.xedotnet.org

12. DEMO DEMO • Extension Methods www.xedotnet.org

13. Implicitly Typed Local Variables and Arrays • Implicitly Typed Local Variables and Arrays • E’ possibiledichiarare le variabili in modoimplicito, utilizzando la parolachiave “var” • “var” non è “variant” • Saràilcompilatore a capireiltipocorretto da utilizzare • Visual Studio è in grado di indicarci l’esatto tipo della variabile var i = 5; var s = “ciao”; var numeri = new int[] {1, 2, 3}; var conn = new OleDbConnection(); www.xedotnet.org

14. Implicitly Typed Local Variables and Arrays • Implicitly Typed Local Variables and Arrays • E’ possibileutilizzare la keywork “var” ancheall’internodicicli for e foreach varevenNumbers = new int[] { 2, 4, 6, 8 }; // Use "var" in a standard foreach loop. foreach (var item in evenNumbers) { Console.WriteLine("Item value: {0}", item); } … // Use a strongly typed System.Int32 to iterate over contents. foreach (int item in evenNumbers) { Console.WriteLine("Item value: {0}", item); } www.xedotnet.org

15. Implicitly Typed Local Variables and Arrays • Implicitly Typed Local Variables and Arrays • Esistonoperòdellelimitazioni: • Puòessereutilizzatasolamente per variabililocali • Non puòessereutilizzata per definifirevaloridiritorno, parametri o proprietà • Nelladichiarazionedeveobbligatoriamenteesserefattoanchel’assegnamento • Nelladichiarazione non sipuòassegnarevalore “null” • Non puòesseredefinita come nullable www.xedotnet.org

16. Object Initializers • Object Initializers • Permettediimpostare le proprietà di un oggetto in fase di creazione di una classe, senza richiamare il costruttore in modo esplicito // Make a Point by setting each property manually... Point firstPoint = new Point(); firstPoint.X = 10; firstPoint.Y = 10; // ...or make a Point via a custom constructor... Point anotherPoint = new Point(20, 20); // ...or make some Point types using the new object init syntax. varyetAnotherPoint = new Point { X = 30, Y = 30 }; Point finalPoint = new Point { X = 30, Y = 30 }; www.xedotnet.org

17. Object Initializers • Object Initializers • E’ possibile chiamare esplicitamente il costruttore di default • Oppure esplicitamente • Oppure chiamare un costruttore custom prima di inizializzare l’oggetto // Here, the default constructor is called implicitly. Point finalPoint = new Point { X = 30, Y = 30 }; // Here, the default constructor is called explicitly. Point finalPoint = new Point() { X = 30, Y = 30 }; // Calling a custom constructor. Point pt = new Point(10, 16) { X = 100, Y = 100 }; www.xedotnet.org

18. Collection Initializers • Collection Initializers • Utilizzando la stessasintassiutilizzata per inizializzaregli array, è possibileinizializzareanchecollezioni e liste // Init a standard array. int[] myArrayOfInts = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; // Init a generic List<> of ints. List<int> myGenericList = new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; // Init an ArrayList with numerical data. ArrayListmyList = new ArrayList { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; www.xedotnet.org

19. Collection Initializers • Collection Initializers • E’ possibilecombinare le Collection Initializers con Object Initializers per inizializzareoggetticomplessi List<Rectangle> myListOfRects = new List<Rectangle> { new Rectangle { TopLeft = new Point { X = 10, Y = 10 }, BottomRight = new Point { X = 200, Y = 200}}, new Rectangle { TopLeft = new Point { X = 2, Y = 2 }, BottomRight = new Point { X = 100, Y = 100}}, new Rectangle { TopLeft = new Point { X = 5, Y = 5 }, BottomRight = new Point { X = 90, Y = 75}} }; www.xedotnet.org

20. DEMO DEMO • Implicitly Typed Local Variables and Arrays • Object Initializers • Collection Initializers www.xedotnet.org

21. PAUSA www.xedotnet.org

22. delegate • ...torniamo indietro e vediamo cosa sono I 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“ • Offrono la possibilità di chiamare un metodo (anche) in modo asincrono tramite BeginInvoke e EndInvoke • Vengono utilizzati principalmente per la gestione degli eventi www.xedotnet.org

23. delegate • ...torniamo indietro e vediamo cosa sono I DELEGATE         public delegate object MioDelegate(int numero);        public class ClasseEsempio        {            public object metodoEsempio(int numero)            {...}        }        public static void Main()        {            ClasseEsempio classe = new ClasseEsempio();MioDelegate dele = new MioDelegate(classe.metodoEsempio);            object risultato = dele(110);        } www.xedotnet.org

24. Anonymous Types • Anonymous Method • Offrono la possibilità di specificare un blocco di codice ad un metodo (“inline”) tramite delegate static void Main(string[] args) { SomeType t = new SomeType(); t.SomeEvent += delegate (optionallySpecifiedDelegateArgs) { /* statements */ }; } button1.Click += delegate(object sender, EventArgs e) { Console.WriteLine("Message : {0}", textBox1.Text); }; www.xedotnet.org

25. Lambda Expressions • Lambda Expressions • Permettono di gestire gli eventi “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 • Il compilatore converte una lambda expression in un standard anonymous method che fa uso di Predicate<T> www.xedotnet.org

26. Lambda Expressions • Lambda Expressions • Una lambda expression è compostadaunaseriediparametriseguitidaicaratteri=>, seguiti a suavoltadalcodicecheprocesseràgliargomenti. ArgumentsToProcess => StatementsToProcessThem // Lambda expression... List<int> evenNumbers = list.FindAll(i => (i % 2) == 0); // Il compilatore la traduce in questo anonymous method. List<int> evenNumbers = list.FindAll(delegate (int i) { return (i % 2) == 0; }); www.xedotnet.org

27. Lambda Expressions • Lambda Expressions • I parametripossonoesseredichiaratiesplicitamente. • Le lambda expression possonocontenerepiùlineedicodice List<int> evenNumbers = list.FindAll((int i) => (i % 2) == 0); List<int> evenNumbers = list.FindAll((i) => { Console.WriteLine("value of i is currently: {0}", i); boolisEven = ((i % 2) == 0); return isEven; }); www.xedotnet.org

28. Lambda Expressions • Lambda Expressions • Possonoaverepiùargomenti • …ma anchenessuno m.SetMathHandler((msg, result) => {Console.WriteLine("Message: {0}, Result: {1}", msg, result);}); VerySimpleDelegate d = new VerySimpleDelegate( () => {return "Enjoy your string!";} ); Console.WriteLine(d.Invoke()); www.xedotnet.org

29. DEMO DEMO • Delegate • Anonymous Method • Lambda Expressions www.xedotnet.org

30. Anonymous Types • Anonymous Types • Permettonodicreareedinizializzare un nuovaclasse. • E’ possibileutilizzarla grazie alla keyword var(Implicitly Typed) • La classe verrà generata automaticamente in fase di compilazione, e deriverà da System.Object • La classe può essere utilizzata solo all’interno dell’applicazione (viene generato come internal sealed) varmyCar = new { Color = "Bright Pink", Make = "Opel", CurrentSpeed = 55 }; www.xedotnet.org

31. Linq • Linq • LINQ è il termine utilizzato per definire questo un tipo di approccio per l’accesso ai dati. • Forniscedelle API chepermettenodieseguiredellequery expression (sia in letturachescrittura) verso classicheimplementanoIEnumerable<T>, database relazionali, DataSets, o documenti XML. (etc etc ...) www.xedotnet.org

32. Linq • Linq • LINQ è una tecnologia estensibile, in quanto può essere implementata per accedere a diverse sorgenti dati • Esistono diversi tipi di implementazioni: • LINQ to Objects è LINQ verso classicheimplementanoIEnumerable<T> • LINQ to SQL è LINQ verso database relazionali (SQL Server) • LINQ to DataSet è un subset di LINQ to SQL • LINQ to XML è LINQ verso documenti XML www.xedotnet.org

33. Linq • Qualsiasiimplementazionedi LINQ sivogliautilizzare, sidovràimportareil namespace System.Linq (contenuto in System.Core.dll) www.xedotnet.org

34. Query Expression • Query Expression • 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> string[] currentVideoGames = {"Morrowind", "BioShock", "Half Life 2: Episode 1", "The Darkness", "Daxter", "System Shock 2"}; IEnumerable<string> subset = from g in currentVideoGames where g.Length > 6 orderby g select g; www.xedotnet.org

35. Query Expression • Query Expression • Una query expression viene useguita quando viene valutata int[] numbers = { 10, 20, 30, 40, 1, 2, 3, 8 }; var subset = from i in numbers where i < 10 select i; // LINQ statement evaluated here! foreach (var i in subset) Console.WriteLine("{0} < 10", i); // Change some data in the array. numbers[0] = 4; // Evaluate again. foreach (var j in subset) Console.WriteLine("{0} < 10", j); www.xedotnet.org

36. Query Expression • Query Expression • Per avereunaesecuzioneimmediatadella query, sipossonoutilizzareimetodiToArray<T>(), ToDictionary<TSource,TKey>(), e ToList<T>() int[] numbers = { 10, 20, 30, 40, 1, 2, 3, 8 }; // Get data RIGHT NOW as int[]. int[] subsetAsIntArray = (from i in numbers where i < 10 select i).ToArray<int>(); // Get data RIGHT NOW as List<int>. List<int> subsetAsListOfInts = (from i in numbers where i < 10 select i).ToList<int>(); www.xedotnet.org

37. Expression tree • Expression tree • Forniscono una rappresentazione ad oggetti di una lambda expression. • Sono compilati, strong-typed, provider independent e serializzabili. • Sono Immutabili, e quindi per modificarne una sua parte, si deve creare un nuovo Expression Tree www.xedotnet.org

38. Expression tree • Expression tree www.xedotnet.org

39. Expression tree • Expression tree • Visionediuna lambda expression come Expression Tree // Create an expression tree. Expression<Func<int, bool>> exprTree = num => num < 5; // Decompose the expression tree. ParameterExpressionparam = (ParameterExpression)exprTree.Parameters[0]; BinaryExpression operation = (BinaryExpression)exprTree.Body; ParameterExpression left = (ParameterExpression)operation.Left; ConstantExpression right = (ConstantExpression)operation.Right; Console.WriteLine("Decomposed expression: {0} => {1} {2} {3}", param.Name, left.Name, operation.NodeType, right.Value); /* This code produces the following output: Decomposed expression: num => num LessThan 5 */ www.xedotnet.org

40. Expression tree • Expression tree • Creazionedi un Expression Tree // Create the parameter "x" in x + 1 ParameterExpression p0 = Expression.Parameter(typeof(int), "x"); // Create the constant 1 in x + 1 ConstantExpression c0 = Expression.Constant(1); // Build the addition expression x + 1 using the above // Note it will really look like Add(x,1) BinaryExpression expression = Expression.Add(p0, c0); // Create the Lamda Expression x => Add(x,1) varlambdaExpression = Expression.Lambda<Func<int,int>> (expression, new ParameterExpression[] { p0 }); // Let's compile it so we can use it vartheDelegate = lambdaExpression.Compile(); // Execute... 6 + 1 = 7 var seven = theDelegate.Invoke(6); www.xedotnet.org

41. DEMO DEMO • Anonymous Types • Linq • Query Expression • Expression tree www.xedotnet.org

42. Extension Methods • Cosa ci sarà di nuovo su C# 4.0? • Dynamic Typed Objects • Dichiarazionedioggettiditipodinamico, chepossonocambiareillorotipo in fasedi runtime.dynamic myVar = "Andrea"; myVar = 14; • Optional and Named Parameters • Parametriopzionalineimetodi.MyMethod(Name: "Andrea"); MyMethod(Name: "Andrea", Id: 1); • Improved COM Interoperability • Covariance – Contravariance • Permette di trattare gli oggetti come il tipo da cui derivapublic class Second : First List<Second> xsecond = new List<Second>(); List<First> xfirst = xsecond; www.xedotnet.org

43. Sponsor In collaborazione con

44. Links Andrea Dottor www.xedotnet.org