Il nuovo riferimento per gli sviluppatori: sviluppareperwindows.it

Microsoft Italia ha lanciato il nuovo portale per gli sviluppatori "Sviluppare per Windows" (http://msdn.microsoft.com/it-it/gg649876).

Vi potete trovare tutte le risorse utili per sviluppare su qualsiasi piattaforma: Windows Desktop, Windows Azure, Windows Phone, Silverlight e molto altro.

Vi consiglio quindi di aggiungere il link sopra indicato tra i vostri preferiti e di consultare periodicamente i contenuti del portale, perché prossimamente saranno aggiunti molti materiali utili per lo sviluppo di qualsiasi tipo di applicazione abbiate in mente!

Espressioni Lambda multi-linea e Statement Lambda

Le espressioni lambda erano state introdotte già nella versione 2008 di Visual Basic, per cui non sono una novità assoluta. Tuttavia, nella versione 2010 sono state ulteriormente potenziate.

Infatti, in precedenza, nelle espressioni lambda poteva essere indicato il codice da eseguire come funzione (Function), quindi con il ritorno di un valore. Ora non è più così: nelle espressioni lambda possiamo inserire anche delle routine (Sub), senza quindi dover necessariamente richiedere un valore di ritorno.

Completa il quadro l’abolizione del carattere di continuazione di linea, come abbiamo già visto in questo articolo, permettendo così di sviluppare l’istruzione su più righe, ma mantenendo una buona leggibilità del codice. Vediamo alcuni esempi.

Innanzi tutto vediamo la sintassi che era ammessa da Visual Basic 2008 (tuttora utilizzabile):

Visual Basic

1.     ' sintassi con VB 2008
2.     Dim processi = _
3.         Process.GetProcesses.Where( _
4.         Function(proc) proc.ProcessName.StartsWith("F"))

 

Questo codice legge il nome di tutti i processi in esecuzione sul computer che iniziano con la lettera "F" e li inserisce nella variabile processi.

In Visual Basic 2010 possiamo scrivere un’istruzione molto più articolata:

Visual Basic

1.     ' sintassi con VB 2010
2.     Dim processi = Process.GetProcesses.Where(
3.     Function(p)
4.       Try
5.         Return p.ProcessName.
6.                 StartsWith("F")
7.       Catch ex As Win32Exception
8.         ' qui si inserisce la gestione
9.         ' dell'eccezione
10.         Return False
11.       End Try
12.     End Function)

 

Come potete vedere, non solo l’istruzione si sviluppa in più righe senza l’uso del carattere di continuazione, ma addirittura è possibile inserire al suo interno un blocco Try … Catch … End Try come in un qualsiasi metodo classico.

L’ultima cosa che dobbiamo ancora vedere è come leggere le stringhe inserite nella variabile processi. Possiamo farlo in due modi, con il metodo classico o con una Statement Lambda:

Visual Basic

1.     ' scorrimento classico dell'elenco
2.     processi.ToList.ForEach(Sub(proc) MessageBox.Show(proc.ProcessName))

 

Con questa istruzione, ad ogni ciclo viene visualizzato un messaggio sullo schermo con il nome del processo.

Nella nuova sintassi, anche questa volta possiamo sviluppare l’istruzione su più righe, con un blocco di istruzioni e con una leggibilità che finora non era mai stata possibile (ElencoProcessi è un controllo di tipo TextBox):

Visual Basic

1.     ' statement lambda per lo scorrimento
2.     ' degli elementi
3.     processi.ToList.ForEach(
4.     Sub(proc)
5.       Form1.ElencoProcessi.Text &= "Nome: "
6.       Form1.ElencoProcessi.Text &= proc.ProcessName
7.       Form1.ElencoProcessi.Text &= System.Environment.NewLine
8.     End Sub)

System.Tuple

Un oggetto di tipo System.Tuple è un oggetto che permette di raggruppare in un’unica struttura più elementi, ciascuno con il proprio tipo di dato.

Ecco un paio di esempi d’uso di questo oggetto:

 

Code Snippet

1.    Dim t1 As System.Tuple(Of String, Integer) =
2.      Tuple.Create("Mario", 46)
3.     MessageBox.Show(t1.Item1 & " " & t1.Item2)
4.  
5.     Dim t2 As Tuple(Of String, String, Date) =
6.       tuple.Create("io", "Programmo", #5/15/2010#)
7.     MessageBox.Show(t2.Item1 & t2.Item2 & " " & t2.Item3)

Il risultato ottenuto nei due casi sarà il seguente:

    Mario 46

    ioProgrammo 15/05/2010

 

E’ possibile anche sostituire un parametro con un altro oggetto Tuple, utilizzando anche il metodo statico Create per non dover utilizzare il costruttore:

 

Code Snippet

1. Dim t3 = Tuple.Create(
2.       "io", "Programmo", Tuple.Create("Maggio", 2010))
3.     MessageBox.Show(t3.Item1 & t3.Item2 & " " &
4.       t3.Item3.Item1 & " " & t3.Item3.Item2)

 

Il risultato di quest’ultimo esempio è il seguente:

    ioProgrammo Maggio 2010

Questo è anche un ottimo stratagemma per poter superare il limite di 8 parametri ammessi dal costruttore.

VB 2010 – Covarianza e Controvarianza

Spiegare i concetti relativi alla varianza generica non è semplicissimo, soprattutto con l’uso di termini come Covarianza e di Controvarianza, e presuppone una conoscenza abbastanza approfondita della programmazione orientata agli oggetti, ma ci proveremo con qualche esempio.

Covarianza e Controvarianza sono, appunto, due aspetti distinti e complementari della Varianza generica, nell’ambito dell’ereditarietà in una gerarchia di classi.

Iniziamo con la Covarianza: supponiamo di avere un oggetto di tipo Insalata e un oggetto di tipo Carota e di voler assegnare questi oggetti a un oggetto di tipo Verdura. Per la programmazione orientata agli oggetti questo dovrebbe essere possibile, visto che Insalata e Carota sono classi che derivano dalla classe Verdura. Tuttavia, fino alla versione 2008 di Visual Basic, questo non era possibile perché era necessario effettuare una conversione esplicita.

In Visual Basic 2010, otteniamo il risultato desiderato dalle classi derivate Insalata e Carota, ma nell’ambito di una collezione di oggetti di tipo astratto Verdura. Questo risultato lo possiamo ottenere solamente utilizzando un’interfaccia IEnumerable(Of Object), dove Object in questo caso viene sostituito dal tipo Verdura.

Vediamo un esempio più semplice con una lista di stringhe:

 

Code Snippet

1.     ' definisce una lista di stringhe
2.     Dim listaStringhe As New List(Of String) From
3.            {
4.              "Visual Studio ",
5.              "2010 ",
6.              "su ",
7.              "io ",
8.              "Programmo"
9.            }
10.     ' definisce un insieme generico di elementi
11.     Dim lstCovarianza As IEnumerable(Of Object) =
12.           listaStringhe
13.     ' inizializza un oggetto di tipo StringBuilder
14.     ' per il concatenamento dinamico delle stringhe
15.     Dim sb As New StringBuilder
16.     ' ciclo per leggere tutte le stringhe
17.     ' dall'insieme generico
18.     For Each lst In lstCovarianza
19.       ' accoda la prossima stringa letta
20.       sb.Append(lst)
21.     Next
22.     ' visualizza il risultato
23.     MessageBox.Show(sb.ToString)

 

Nella Controvarianza, il concetto è diametralmente opposto: da una classe derivata Insalata o Carota, ricaviamo il risultato desiderato sfruttando la classe astratta Verdura.

Come nella Covarianza dobbiamo necessariamente utilizzare un’interfaccia IEnumerable, nella Controvarianza utilizziamo i delegati.

Come esempio classico di Controvarianza possiamo citare un metodo per gestire due eventi distinti di un controllo visuale: per esempio gli eventi MouseClick, cioè il normale click con il tasto sinistro del mouse, e KeyUp che avviene al momento del rilascio di un tasto.

Normalmente, questi due eventi ricevono due oggetti diversi: il primo riceve un oggetto di tipo MouseEventArgs, mentre il secondo riceve un oggetto di tipo KeyEventArgs. Si porrebbe, quindi, il problema di gestire questi due diversi tipi di oggetto. Per fortuna, entrambi sono derivati da System.EventArgs ed ereditano quindi tutte le caratteristiche principali da quest’ultimo.

In Visual Basic 2008 possiamo scrivere qualcosa di simile a questo codice:

 

Code Snippet

1.   ' definisco un metodo comune
2.   ' per i due diversi eventi
3.   Private Sub GestoreComune(
4.             ByVal sender As Object,
5.             ByVal e As EventArgs)
6.     ' visualizza un messaggio
7.     MessageBox.Show("Click o tasto!")
8.   End Sub
9.  
10.   ' questo ? il normale metodo gestore
11.   ' dell'evento Load di un form
12.   Private Sub frmMain_Load(
13.         ByVal sender As System.Object,
14.         ByVal e As System.EventArgs) _
15.         Handles MyBase.Load
16.     AddHandler btnTest.MouseClick,
17.       AddressOf GestoreComune
18.     AddHandler btnTest.KeyUp,
19.       AddressOf GestoreComune
20.   End Sub

 

 

In Visual Basic 2010 possiamo anche scrivere nella seguente forma alternativa:

 

Code Snippet

1.   ' funziona solo in VB 2010:
2.     AddHandler btnMessaggi.KeyUp,
3.       Sub() MessageBox.Show("Evento KeyUp")
4.  
5.     AddHandler btnMessaggi.Click,
6.       Sub()
7.         Dim msg As String
8.         msg = "Evento Click"
9.         MessageBox.Show(msg)
10.       End Sub

 

In questo esempio ridefiniamo gli eventi KeyUp e Click, in modo tale che se si verifica il primo evento viene visualizzato "Evento KeyUp", mentre se si verifica il secondo viene visualizzato "Evento Click".

Provate l’esempio e vedrete che le situazioni che potrete incontrare sono diverse. Per esempio, se portate il focus sul pulsante btnMessaggi e premete la barra degli spazi, vedrete apparire in sequenza entrambi i messaggi: questo avviene perché la pressione della barra degli spazi equivale a un click del mouse e quindi scatena l’evento Click, ma scatena anche l’evento KeyUp al momento del sollevamento del tasto. Se fate click con il mouse, vedrete il messaggio "Evento Click", mentre se premete qualsiasi altro tasto diverso dalla barra, vedrete il messaggio "Evento KeyUp".