Passa ai contenuti principali

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.

 

Commenti

Post popolari in questo blog

VB.NET: Convertire un file DOC in RTF e PDF con office interop

In questo post vorrei proporvi del codice per poter convertire un file .doc in un file .rtf oppure .pdf utilizzando le API di interoperabilità di Office.Creeremo una classe, DocConverter, che esporrà le due funzionalità sopra citate.Cominciamo con il prevedere un attributo privato della classe che rappresenterà l’applicazione Word che utilizzeremo per la conversione. Creeremo l’istanza dell’attributo privato all’interno del costruttore della classe:PublicSubNew()
IfNot CreateWordApp() Then
ThrowNew ApplicationException("Assembly di interoperabilità con Office non trovato!")
EndIf
EndSub
Private _wordApp As Word.ApplicationClass
ProtectedFunction CreateWordApp() AsBoolean
Dim retval = True
Try
_wordApp = New Word.ApplicationClass()
_wordApp.Visible = False
Catch ex As System.Exception
_wordApp = Nothing
retval = False
EndTry
Return retval
EndFunction

La conversione del file doc sarà effettuata aprendo il file stesso ed eseguendo un’operazione di SaveAs:

Pr…

Cambiare la lingua di Visual Studio 2008

Oggi ho avuto qualche problema installando Windows Mobile 6 Professional SDK Refresh e Windows Mobile 6 Standard SDK Refresh.Scaricati i file di installazione e installati, ho provato a creare un progetto di tipo Windows Mobile 6.0 e mi sono beccato questo errore:Dopo qualche smanettamento abbiamo scoperto (e ringrazio il mitico Matteo per l’aiuto) che il mio Visual Studio 2008, pur essendo in Inglese (prova ne era il fatto che gli hotfix e la SP installata erano nella lingua di Albione) aveva come lingua impostata quella del sistema operativo (italiano).Ovviamente, non avrebbe mai potuto trovare la cartella 1040 (italiano) visto che l’installazione dell’SDK aveva supposto che la lingua del Visual Studio fosse Inglese (1033).La soluzione del problema è duplice:1) Duplicate la cartella 1033 presente nel percorso evidenziato dall’errore e la rinominate 10402) cambiate la lingua di Visual Studio.Per questa ultima eventualità basta andare nel menù Strumenti/Opzioni:e cambiare il linguaggi…

Tascam DR-05 registratore digitale per tutti

Diverso tempo fa ho acquistato il registratore digitale Tascam DR-05 e, ora, dopo diversi mesi di utilizzo, posso dire la mia a proposito.

Si tratta di un ottimo registratore digitale con microfono stereo che permette di ottenere registrazioni di ottima qualitaà anche in ambienti non perfetti dal punto di vista acustico.

Interessante la possibilità di utilizzare un cavalletto di piccole dimensioni come HAMA Mini treppiede o Mini Cavalletto Universale per tenere il microfono sollevato dal tavolo in fase di registrazione grazie allàattacco universale per macchina fotografica che il microfono ha nella parte inferiore.

Da segnalare anche il menu’ ben fatto e la possibilita’ di utilizzare una scheda SD esterna per memorizzare i file audio. Anche a livello di consumo batterie non e’ niente male. Consiglio l’uso delle alcaline non ricaricabili.

Il mio utilizzo e’ stato prettamente di registrazione di podcast vocali (no musica) ma le recensioni confermano che se la cava egregiamente con la mu…