(Vedi Re[studing] C# 5 - (WinRT))

• Delegates

  • I delegati sono oggetti immutabili, quindi, ad esempio ogni chiamata di sottoscrizione o cancellazione +=/-= determina sempre la creazione di una nuova istanza.
  • Tutti i delegati sono implicitamente di tipo System.MultiCastDelegate che a sua volta estende System.Delegate
  • Quando viene assegnato un metodo di classe, l'istanza della classe viene referenziata dal delegato. Conoscere questo è molto importante perché possibile causa di memory leak non previsti: In caso di eventi statici sottoscritti da un metodo di classe, allora l'istanza di quest'ultima non viene rilasciata se non viene effettuata la rimozione della sottoscrizione (Vedi ad es. Windows.Forms, ToolStrip and Memory Leak
  • I delegati supportano la varianza e la covarianza secondo logiche simili a quelle delle interfacce (vedi Re[studing] C# 5 - (... covariance and controvariance))
  • Questo spiega l'utilizzo dello standard degli eventi basato sulla classe System.EventArgs che essendo un parametro di input supporta la controvarianza
    • Seguendo la stessa regola delle interfacce generic, per sfruttare la varianza e controvarianza con i generic delegates dobbiamo esplicitare la direzione dei parametri. (I vari generic delegates Action e Function sono definiti seguendo questa logica
      • delegate TResult Func<out TResult>(); - Varianza
      • delegate void Action<in T>(T arg); - Controvarianza
  
  

• Events

  • Il brodcaster è la classe che invoca l'evento, il subscriber il metodo che sottoscrive l'evento.
  • Aggiungendo la keyword event nell'esposizione del metodo:
    • Il compilatore incapsula il delegato, in particolare espone solo Add (+=) e Remove (-=)
    • Il compilatore implementa un meccanismo di sincronizzazione (lock-free compare-and-swap alghoritm)
  • Per evitare side-effects in ambito multi-thread copiare all'interno del metodo di invocazione il delegato prima di effetuare l'invoke
  • I delegati EventHandler ed EventHandler<T> implementano il pattern .NET standard degli eventi
  
  
  Code Snippet

  1.         class Broadcaster
  2.         {
  3.             public event EventHandler<EventArgs> EventOccured;
  4.  
  5.             public void InvokeOnEventOccurred()
  6.             {
  7.                 OnEventOccured();
  8.             }
  9.  
  10.             public Task InvokeOnEventOccurredAsync()
  11.             {
  12.                 return Task.Factory.StartNew(OnEventOccured);
  13.             }
  14.  
  15.             protected virtual void OnEventOccured()
  16.             {
  17.                 var eventOccured = EventOccured;
  18.                 if (eventOccured != null)
  19.                     EventOccured(this, EventArgs.Empty);
  20.             }
  21.         }
  
  

• Lambda expressions

  • Una lambda expression è una funzione o un metodo anonimo, nella forma (parameters) => expression-or-statment-block, quest'ultima può definire:
    • Un istanza di un delegato: System.Delegate
    • Un albero di espressione: System.Linq.Expressions.Expression<TDelegate>
  • Nel caso più comune, il delegato, il compilatore genera un metodo privato nel quale sposta l'implementazione
  • I parametri di una Lambda Expressions possono essere "puri" oppure specificati es: (int x) => x * x
  • Quando una variabile esterna è utilizzata all'interno di una lambda expression, quest'ultima viene chiamata captured variable, mentre l'espressione viene chiamata closure, le importanti conseguenze sono:
    • Il ciclo di vita delle variabili catturato è esteso a quello del delegato
    • Le variabili sono valutate quando il delegato è invocato e non quando la variabile è catturata. (NOTA: Questo vale anche per gli Anonymous Methods in gran parte assorbiti dalle Lambda Expressions)


Code Snippet
1.         [Test]
2.         public void TestOnCapturedVariable()
3.         {
4.             var exprs = new Func<int>[3];
5.             
6.             for (int i = 0; i < 3; i++)
7.                 exprs[i] = () => i;
8.  
9.             Assert.AreEqual(3, exprs[0]());
10.             Assert.AreEqual(3, exprs[1]());
11.             Assert.AreEqual(3, exprs[2]());
12.         }



• Exceptions

  • Le eccezioni sono molto pesanti da gestire occupando centinaia di cicli di clock.
  • Le eccezioni .NET devono essere sottoclassi di System.Exception (Questo non è vero in C++ dove è possibile "lanciare" qualsiasi oggetto come eccezione, in questo ultimo caso il CLR incapsula l'oggetto in una System.Runtime.CompilerServices.RuntimeWrappedException)
  • Importante: Quando si gestisce cattura un eccezione con lo statment catch è possibile "rilanciarla" con lo statment throw, con la sottile differenza che throw; (senza parametri) rilancia l'eccezione originale senza modificarne gli attributi mentre throw ex; (dove ex è il nome della variabile assegnato all'eccezione nello statment catch) modifica l'eccezione propagata cambiando lo StackTrace che non riflette più quello dell'eccezione originale.
  
  
Code Snippet
1.         [Test]
2.         public void TestDifferentStackTraceOnExceptionThrown()
3.         {
4.             try
5.             {
6.                 CaptureExceptionAndRethrowWithoutParameter();
7.             }
8.             catch (Exception ex)
9.             {
10.                 Console.WriteLine("-----CaptureExceptionAndRethrowWithoutParameter-----");
11.                 Console.WriteLine(ex.StackTrace);
12.                 Console.WriteLine("----------------------------------------------------");
13.                 Console.WriteLine();
14.             }
15.  
16.             try
17.             {
18.                 CaptureExceptionAndRethrowWithParameter();
19.             }
20.             catch (Exception ex)
21.             {
22.                 Console.WriteLine("-----CaptureExceptionAndRethrowWithParameter-----");
23.                 Console.WriteLine(ex.StackTrace);
24.                 Console.WriteLine("-------------------------------------------------");
25.                 Console.WriteLine();
26.             }
27.         }
28.  
29.         void CaptureExceptionAndRethrowWithoutParameter()
30.         {
31.             try
32.             {
33.                 NotImplementedMethod();
34.             }
35.             catch (Exception ex)
36.             {
37.                 throw;
38.             }
39.         }
40.  
41.         void CaptureExceptionAndRethrowWithParameter()
42.         {
43.             try
44.             {
45.                 NotImplementedMethod();
46.             }
47.             catch (Exception ex)
48.             {
49.                 throw ex;
50.             }
51.         }
52.  
53.         void NotImplementedMethod()
54.         {
55.             throw new NotImplementedException();
56.         }

Di seguito lo Stack Trace notate le differenze, nel secondo cas perdiamo l'origine dell'eccezione

-----CaptureExceptionAndRethrowWithoutParameter-----
in snftest.CSharp5.AdvancedCSharp.NotImplementedMethod() in c:\Sviluppo\privatedev.sinformatic\Libreria\snftest\CSharp5\AdvancedCSharp.cs:riga 100
in snftest.CSharp5.AdvancedCSharp.CaptureExceptionAndRethrowWithoutParameter() in c:\Sviluppo\privatedev.sinformatic\Libreria\snftest\CSharp5\AdvancedCSharp.cs:riga 84
in snftest.CSharp5.AdvancedCSharp.TestDifferentStackTraceOnExceptionThrown() in c:\Sviluppo\privatedev.sinformatic\Libreria\snftest\CSharp5\AdvancedCSharp.cs:riga 51
----------------------------------------------------

-----CaptureExceptionAndRethrowWithParameter-----
in snftest.CSharp5.AdvancedCSharp.CaptureExceptionAndRethrowWithParameter() in c:\Sviluppo\privatedev.sinformatic\Libreria\snftest\CSharp5\AdvancedCSharp.cs:riga 96
in snftest.CSharp5.AdvancedCSharp.TestDifferentStackTraceOnExceptionThrown() in c:\Sviluppo\privatedev.sinformatic\Libreria\snftest\CSharp5\AdvancedCSharp.cs:riga 63
-------------------------------------------------


• Enumerator (IEnumerator) e Enumerable (IEnumerable)

  • Un enumeratore si può definire come un cursore in sola lettura, che può iterare solo in avanti, su di una sequenza di elementi.
    • NOTA: Qualsiasi oggetto implementi MoveNext() and Current è enumerabile.
    • Quando un oggetto enumeratore implementa IDisposable, lo statment foreach() chiama Dispose() al termine dell'enumerazione.
• Un oggetto enumerabile espone una sequenza logica di elementi, la differenza sostanziale è che l'oggetto enumerabile NON è un cursore ma PRODUCE un cursore.
  • Lo statment foreach implementa l'iterazione su un oggetto enumerabile chiedendo all'oggetto di produrre l'enumeratore con GetEnumerator() per iterarlo.
• yield keyword
  • C'è una sostanziale differenza tra un restituire l'istanza di un oggetto enumeratore o enumerabile oppure usare la parola chiave yield.
  • Quando si usa uno statment yield return x (dove x è il tipo da enumerare) si esprime il concetto di ritornare il "prossimo elemento richiesto dell'enumerazione", questo richiede che lo stato del chiamante sia conservato fino alla prossima iternazione (MoveNext()).
    • Dal punto di vista del programma questo approccio modifica profondamente il flusso di esecuzione: La funzione viene eseguita solo quando è enumerata e non quando viene chiamata, infatti il compilatore incapsula il nostro metodo in un oggetto enumeratore, in grado di conservare lo stato del metodo.
    • Lo statment yield break interrompe l'enumerazione, non è obbligatorio a meno che non sia necessario interrompere prematuramente l'iterazione.
    • Per ragioni di complessità l'istruzione yield non può essere presente in un blocco try/catch/[finally] mentre può comparire nella clausola try di un blocco try/finally
  
  
Code Snippet
1.         static int GeneratedNumbers = 0;
2.  
3.         [Test]
4.         public void EnumerateFirstHundredIntegerNumbers()
5.         {
6.             GeneratedNumbers = 0;
7.             foreach (var number in IntNumbers)
8.                 if (number == 99)
9.                     break;
10.             Assert.AreEqual(100,GeneratedNumbers);
11.         }
12.  
13.         IEnumerable<int> IntNumbers
14.         {
15.             get
16.             {
17.                 for (int i = 0; i < int.MaxValue;                  i++)
18.                 {
19.                     GeneratedNumbers++;
20.                     yield return i;
21.                 }
22.             }
23.         }



• Nullable<T>

  • Quando dichiaramo un T? dove T è un value-type (tipo nativo o struct) la nostra dichiarazione viene tradotta dal compilatore come Nullable<T>.
  • Il compilatore ridefinisce automaticamente gli operatori, come > < o ==, per renderli "semanticamente uguali" agli operatori dei corrispondenti not nullable value-type.
    • Ad esempio: a < b viene ridefinito come (a.HasValue && b.HasValue) ? (a.Value < b.Value) : false
  • Nel caso di confronto con gli operatori logici & oppure | il null viene considerato come valore sconosciuto
    • Ad esempio: a | b dove a è true è b nullo il risultato è true, mentre se a fosse false allora il risultato sarebbe null