|
Una delle novità più
interessanti introdotte con Visual Basic punto net e il supporto nativo
del Multithreating ossia multi processo.
Il nostro scopo è sviluppare
un’applicazione che esegue più processi contemporaneamente senza lo
stato di morte apparente che caratterizza normalmente le nostre
applicazioni in caso di operazioni lunghe o addirittura il blocco
in caso di cicli infiniti.
E’ proprio quest’ultimo caso
che ci interessa simulare!
Iniziamo con l’aprire il vostro
Visual Studio .Net ed aggiungere un progetto con nome: Multithreading.
Aggiungere un semplice Form
vuoto al progetto ed inserire sul form una ListBox e tre pulsanti
(Button1, Button2, Button3) ai quali impostare la proprietà .Text
(non esiste più .Caption in Vb.Net) rispettivamente “Esegui”,
“Ferma”, “Chiudi”
Nelle dichiarazioni generali
inserire:
Dim t As
Threading.Thread
Dove “t” sarà un’istanza della classe Tread che a sua volta è
contenuta nel namespace System.Threading del Framework.net.
A questo punto, inserire questa
Sub nel codice del Form che provocherà un ciclo infinito:
Private Sub
LupInfinito()
'questa è una subrutine che genererà
un ciclo infinito
Dim i As
Int32 = 1
Do While
True
ListBox1.Items.Add("Iterazione: " & i)
'nuovo metodo di
incremento veloce
i += 1
Loop
End
Sub
Questo ciclo infinito, ad ogni
incremento di “i”, inserirà il suo valore in una ListBox. Da
notare che è stato utilizzato il nuovo metodo di incremento veloce “i+=
1” al posto di “i = i+1”.
Adesso che abbiamo il
blocco di codice da eseguire, bisogna assegnarlo ad un nuovo Tread
e farlo eseguire.
Nel nostro caso, abbiamo
già inizializzato la variabile “t” come oggetto Tread.
Per cui, fare doppio
click sul tasto Button1 e nella sub Button1_Click inserire
il codice:
t = New Threading.Thread(AddressOf
Me.LupInfinito)
t.Start()
L’operatore AddressOf crea un oggetto delegate
al metodo LupInfinito. Un delegate, è un type-safe
di Vb.Net che punta ad una funzione.
Quindi, abbiamo creato
una nuova istanza dell’oggetto Tread al quale abbiamo passato
un riferimento al blocco di codice LupInfinito.
Il metodo Start , avvia il processo.
Una volta che il processo è in esecuzione, si ha la
possibilità di intervenire su di esso usando dei metodi dell’oggetto Thread.
Nel nostro esempio, utilizzeremo il metodo Sleep che ci consente
di creare delle pause. Quindi, aggiungendo “Threading.Thread.CurrentThread.Sleep(2000)” a “Lupinfinito”,
avremo un ritardo di due secondi (indicati dall’intero 2000) prima che
la ListBox1 visualizzerà il valore successivo.
Private Sub
LupInfinito()
'questa è una subrutine che genererà
un ciclo infinito
Dim i As
Int32 = 1
Do While
True
ListBox1.Items.Add("Iterazione: " & i)
'nuovo metodo di
incremento veloce
i += 1
'crea un ritardo nell'incremento
'in pratica creo una pausa del tread
'Threading.Thread.Sleep(2000)
Threading.Thread.CurrentThread.Sleep(2000)
Loop
End Sub
CurrentThread,
è un metodo pubblico, che ci permette di far riferimento al processo
che attualmente è in esecuzione.
Altri metodi simili a Sleep
sono: Suspend, Resume e Abort, dove Suspend
blocca il processo in esecuzione fino a quando non viene chiamato il Resume
e Abort conclude il processo in atto.
E’ proprio
quest’ultimo che utilizzeremo nella nostra applicazione per fermare il
ciclo infinito che abbiamo creato:
fare doppio click sul
tasto Button2 e nella sub Button2_Click inserire il
codice:
t.Abort()
fare doppio click sul
tasto Button3 e nella sub Button3_Click inserire il
codice:
end
Ora siamo pronti a
lanciare l’applicazione.
Ciccando su esegui,
vedremo la Listbox incrementarsi all’infinito, con un ritardo
di due secondi tra in iterazione e l’altra fino a quando non verrà
premuto il tasto Ferma.
Da notare che durante
l’esecuzione del ciclo infinito, si ha la possibilità di spostare,
ridimensionare il Form e quindi poter ciccare su tutti gli
oggetti in esso contenuti. Per cui, con questo metodo di programmazione,
si elimineranno quelle fastidiose fasi di morte apparente, (ad esempio
quando si carica un Recordset molto grande), avendo la possibilità di
intervenire sul processo in atto anche annullando l’operazione o
uscendo addirittura dall’applicazione.
Federico Barbati
|
