Async : come trasformare un metodo non async in async

Windows 8, WinRT e le applicazioni Metro UI hanno portato una ventata di aria nuova nella progettazione delle interfacce, soprattutto per il fatto che tutte le operazioni la cui durata supera i 50 ms debbono essere asincrone (in realtà sarebbe stata buona norma anche prima, ma la legge è legge).

Il paradigma Async prevede due nuove parole chiave del linguaggio, Async e Await, il cui utilizzo congiunto permette di ottenere applicazioni completamente asincrone mantenendo un codice pulito e chiaro.

Vedremo in altri post (e, in ogni caso, internet è piena di fonti in da cui capire l’esatto funzionamento del meccanismo Async) come è implementato l’Async nel framework 4.5, ma in questo post ci chiediamo: “e se abbiamo già delle nostre classi con della logica (metodi) che potenzialmente possono durare più di 50ms?”………”Dobbiamo riscrivere tutto?”

Cerchiamo di vedere come si possono facilmente far diventare Async metodi che, in realtà, non lo sono.

Supponiamo di avere la nostra classe LegacyClass (frutto di duro ed estenuante lavoro ) con dei metodi di lunga durata:

1. Public Class LegacyClass
2.  
3.     Public Function Method1(i As Integer) As Integer
4.         Dim str As String = ""
5.         For index = 1 To 100000
6.             str += index.ToString()
7.         Next
8.         Return i
9.     End Function
10.  
11.     Public Function Method2(s As String, i As Integer) As String
12.         Dim str As String = ""
13.         For index = 1 To 100000
14.             str += index.ToString()
15.         Next
16.         Return s
17.     End Function
18.  
19.     Public Sub Method3(s As String)
20.         Dim str As String = ""
21.         For index = 1 To 100000
22.             str += index.ToString()
23.         Next
24.     End Sub
25.  
26. End Class

I tre metodi hanno una lunga durata e, quindi, nell’ottica Async, così come sono, non vanno bene.

Se abbiamo il classico pulsante nella nostra UI che deve richiamare i tre metodi in sequenza:

1. Private Sub Button_Click_1(sender As Object, e As RoutedEventArgs)
2.     Dim lc = New LegacyClass
3.     txt.Text = "Metodo1"
4.     Dim i = lc.Method1(5)
5.     txt.Text = "Metodo2"
6.     Dim s = lc.Method2(i.ToString(), i)
7.     txt.Text = "Metodo3"
8.     lc.Method3(s)
9.     txt.Text = "fine"
10. End Sub

questi bloccheranno la UI rendendo la nostra applicazione non adatta ad un’applicazione “moderna”

Il trucco per farli diventare Async sta nel fatto di fare in modo che, tali metodi, restituiscano un Task(Of T) anziché il semplice T.

Ad esempio, dobbiamo fare in modo che il Method1 restituisca Task(Of Integer) anziché Integer.

In questo modo possiamo richiamare i metodi anteponendo la parola Await, il compilatore si occuperà della creazione della macchina a stati che sta dietro il meccanismo dell’Async e il metodo (richiamato con  Await davanti) ritorna di nuovo Integer (ma lo fa in maniera non bloccante).

Per ogni metodo della nostra LegacyClass possiamo creare la versione async nel seguente modo:

1. Public Function Method1Async(i As Integer) As Task(Of Integer)
2.     Dim tf = New TaskFactory(Of Integer)
3.     Dim task = tf.StartNew(Function() Method1(i))
4.     Return task
5. End Function
6.  
7. Public Function Method2Async(s As String, i As Integer) As Task(Of String)
8.     Dim tf = New TaskFactory(Of String)
9.     Dim task = tf.StartNew(Function() Method2(s, i))
10.     Return task
11. End Function
12.  
13. Public Function Metodo3Async(s As String) As Task
14.     Dim tf = New TaskFactory
15.     Dim task = tf.StartNew(Sub() Method3(s))
16.     Return task
17. End Function

Method3Async restituisce un Task essendo una Sub e non ritornando alcun valore.

A questo punto il nostro gestore di evento del pulsante di cui sopra diventa:

1. Private Async Sub Button_Click_1(sender As Object, e As RoutedEventArgs)
2.     Dim lc = New LegacyClass
3.     txt.Text = "Metodo1"
4.     Dim i = Await lc.Method1Async(5)
5.     txt.Text = "Metodo2"
6.     Dim s = Await lc.Method2Async(i.ToString(), i)
7.     txt.Text = "Metodo3"
8.     Await lc.Metodo3Async(s)
9.     txt.Text = "fine"
10. End Sub

In questo modo la UI non si blocca e i metodi sfruttano a pieno il meccanismo dell’Async.

Possiamo osservare che, di fatto, il codice presente all’interno delle versioni Async dei metodi, è sempre molto simile.

Razionalizzando il tutto, possiamo scrivere la seguente classe:

1. Public NotInheritable Class AsyncHelper
2.     Private Sub New()
3.  
4.     End Sub
5.  
6.     Public Shared Function CreateAsync(Of TRet)(func As Func(Of TRet)) As Task(Of TRet)
7.         Dim tf = New TaskFactory(Of TRet)
8.         Dim task = tf.StartNew(Function() func.Invoke())
9.         Return task
10.     End Function
11.  
12.     Public Shared Function CreateAsync(action As action) As Task
13.         Dim tf = New TaskFactory
14.         Dim task = tf.StartNew(Sub() action.Invoke())
15.         Return task
16.     End Function
17. End Class

La classe ci permette di scrivere i metodi della nostra classe nel seguente modo:

1. Public Function Method1Async(i As Integer) As Task(Of Integer)
2.     Return AsyncHelper.CreateAsync(Of Integer)(Function() Method1(i))
3. End Function
4.  
5. Public Function Method2Async(s As String, i As Integer) As Task(Of String)
6.     Return AsyncHelper.CreateAsync(Of String)(Function() Method2(s, i))
7. End Function
8.  
9. Public Function Metodo3Async(s As String) As Task
10.     Return AsyncHelper.CreateAsync(Sub() Method3(s))
11. End Function

L’utilizzo della AsyncHelper va adottato quando abbiamo del codice che non può essere convertito in asincrono utilizzando opportuni metodi (ad esempio il metodo GetResponseAsync della classe HttpWebRequest) come, ad esempio, quando si utilizzano librerie di terze parti che non hanno ancora metodi “awaitabili”.

In allegato trovate la soluzione con la classe mostrata in questo post.

 

Tag di Technorati: winrt,async,await,multithread,win8,wndows8