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 : Aggregare stringhe con LINQ

Tip facile facile, ma a qualcuno potrebbe servire. Supponiamo di avere una lista di stringhe (magari come risultato di una query LINQ) e di voler ottenere una stringa con la concatenazione delle stesse: Dim list = CreateList() Dim concatStr = (From s In list _ Select s).Aggregate( Function (currentString, nextString) currentString + nextString) MessageBox.Show(concatStr) Il metodo CreateList non ci interessa, in questo momento, ma crea una lista di oggetti String. Protected Function CreateList() As IEnumerable( Of String ) Dim list As String () = {" stringa1 ", " stringa2 ", " stringa3 ", " stringa4 ", " stringa5 "} Return list.AsEnumerable() End Function Questo metodo potrebbe restituire una qualsiasi lista di oggetti di cui, nella select successiva recuperiamo solo stringhe. La stessa tecnica è utilizzabile per concatenare stringhe inserendovi un carattere separatore Dim list = CreateList() Dim

VB.NET: SplashScreen con effetto fade-in

In questo post vorrei proporvi un modo per realizzare una splash screen per le nostre applicazioni Windows Form che appare progressivamente con un effetto fade. Supponiamo di avere il nostro progetto VB.NET in una soluzione Visual Studio 2008 in cui abbiamo il sorgente della nostra applicazione Windows Form. Inseriamo una splash screen utilizzando il menù Progetto->Aggiungi Nuovo Elemento e selezionando il tipo di elemento “Schermata Iniziale” A questo punto Visual Studio creerà, automaticamente, la schermata iniziale che possiamo personalizzare graficamente come vogliamo. Per poter fare in modo che questa finestra appaia nel momento in cui avviamo l’applicazione, è necessario aprire le proprietà del progetto e impostare la maschera di avvio: In questo modo, all’avvio dell’applicazione, la schermata appare immediatamente e scompare un attimo prima della visualizzazione della finestra dell’applicazione. Possiamo far apparire la schermata iniziale con un ef

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: Public Sub New () If Not CreateWordApp() Then Throw New ApplicationException(" Assembly di interoperabilità con Office non trovato! ") End If End Sub Private _wordApp As Word.ApplicationClass Protected Function CreateWordApp() As Boolean Dim retval = True Try _wordApp = New Word.ApplicationClass() _wordApp.Visible = False Catch ex As System.Exception _wordApp = Nothing retval = False End Try Return retval End Function La conve