Visual Basic异步编程基础与Task并行库
2022-03-136.8k 阅读
Visual Basic异步编程基础
在现代软件开发中，异步编程已经成为一项至关重要的技术，特别是在处理可能会阻塞主线程的操作，如I/O 操作、网络请求或长时间运行的计算任务时。Visual Basic（VB）作为一种广泛使用的编程语言，提供了强大的异步编程支持，允许开发人员编写高效、响应式的应用程序。
为什么需要异步编程
在传统的同步编程模型中，代码按顺序执行，一个操作完成后才会执行下一个操作。如果某个操作（例如读取一个大文件或进行网络请求）需要较长时间才能完成，那么整个应用程序的主线程就会被阻塞，导致用户界面失去响应，应用程序看起来像是“冻结”了。
例如，考虑以下简单的同步代码，它从文件中读取数据：
Imports System.IO
Module Module1
Sub Main()
Dim filePath As String = "largeFile.txt"
Dim watch As New System.Diagnostics.Stopwatch()
watch.Start()
Dim content As String = File.ReadAllText(filePath)
Console.WriteLine("File content: " & content)
watch.Stop()
Console.WriteLine("Time taken: " & watch.ElapsedMilliseconds & " ms")
End Sub
End Module
在这个例子中，File.ReadAllText 方法会阻塞主线程，直到文件读取完成。如果文件很大，用户在等待文件读取时将无法与应用程序进行交互。
而异步编程允许主线程在等待操作完成时继续执行其他任务，从而保持应用程序的响应性。
Visual Basic中的异步编程模型
Visual Basic主要通过 Async 和 Await 关键字来支持异步编程。Async 关键字用于标记一个异步方法，表明该方法中可能包含需要异步执行的操作。Await 关键字用于暂停异步方法的执行，直到其等待的异步操作完成。
下面是一个简单的异步方法示例：
Imports System.IO
Imports System.Threading.Tasks
Module Module1
Async Function ReadFileAsync(filePath As String) As Task(Of String)
Dim content As String = Await File.ReadAllTextAsync(filePath)
Return content
End Function
Sub Main()
Dim watch As New System.Diagnostics.Stopwatch()
watch.Start()
Dim task As Task(Of String) = ReadFileAsync("largeFile.txt")
task.Wait()
Dim content As String = task.Result
Console.WriteLine("File content: " & content)
watch.Stop()
Console.WriteLine("Time taken: " & watch.ElapsedMilliseconds & " ms")
End Sub
End Module
在这个例子中，ReadFileAsync 方法被标记为 Async，表示它是一个异步方法。Await 关键字用于等待 File.ReadAllTextAsync 操作完成，这个操作是异步执行的，不会阻塞主线程。在 Main 方法中，我们启动了异步任务，并使用 task.Wait() 和 task.Result 来获取任务的结果。然而，在实际的应用程序开发中，尤其是在UI应用程序中，直接使用 Wait() 和 Result 可能会导致死锁，因此通常建议在UI线程之外的线程中调用异步方法，或者在UI线程中使用 Await。
异步方法的返回类型
异步方法可以有以下几种返回类型：
Task：当异步方法不返回值时，可以使用Task作为返回类型。例如，以下方法用于删除一个文件：
Imports System.IO
Imports System.Threading.Tasks
Module Module1
Async Function DeleteFileAsync(filePath As String) As Task
Await Task.Run(Sub() File.Delete(filePath))
End Function
End Module
Task(Of TResult)：当异步方法需要返回一个值时，使用Task(Of TResult)作为返回类型。前面读取文件的例子就是这种情况。Void：虽然可以将异步方法的返回类型设为Void，但这种情况主要用于事件处理程序。在大多数其他情况下，应避免使用Void返回类型，因为无法捕获Void异步方法中的异常。
Task并行库
Task并行库（TPL）是.NET Framework 4.0 引入的一个强大的并行编程模型，它为开发人员提供了一种简单而高效的方式来编写并行和异步代码。在Visual Basic中，TPL与异步编程紧密结合，使得处理多任务和并行计算变得更加容易。
Task类的基本使用
Task 类是TPL的核心，它表示一个异步操作。可以通过多种方式创建 Task 对象。
- 使用
Task.Run方法：Task.Run方法用于在后台线程池中启动一个新的任务。例如，下面的代码在后台线程中执行一个简单的计算任务：
Imports System.Threading.Tasks
Module Module1
Sub Main()
Dim task As Task = Task.Run(Sub()
Dim result As Integer = 0
For i As Integer = 1 To 1000000
result += i
Next
Console.WriteLine("Result: " & result)
End Sub)
task.Wait()
End Sub
End Module
- 创建
Task对象并手动启动：也可以手动创建Task对象，然后通过调用Start方法来启动它。
Imports System.Threading.Tasks
Module Module1
Sub Main()
Dim task As New Task(Sub()
Dim result As Integer = 0
For i As Integer = 1 To 1000000
result += i
Next
Console.WriteLine("Result: " & result)
End Sub)
task.Start()
task.Wait()
End Sub
End Module
虽然这两种方式都能实现异步执行任务，但 Task.Run 更加简洁，并且适用于大多数情况。
任务的延续（Task Continuation）
任务延续允许在一个任务完成后自动启动另一个任务。这在需要按顺序执行多个异步操作时非常有用。
- 使用
ContinueWith方法：ContinueWith方法用于在任务完成后启动一个延续任务。例如：
Imports System.Threading.Tasks
Module Module1
Sub Main()
Dim task1 As Task = Task.Run(Sub()
Dim result As Integer = 0
For i As Integer = 1 To 1000000
result += i
Next
Return result
End Sub)
Dim task2 As Task = task1.ContinueWith(Function(t)
Dim newResult As Integer = t.Result * 2
Console.WriteLine("New result: " & newResult)
Return newResult
End Function)
task2.Wait()
End Sub
End Module
在这个例子中，task2 是 task1 的延续任务。task1 完成后，task2 会自动启动，并使用 task1 的结果进行进一步的计算。
- 使用
Await实现延续：在异步方法中，使用Await可以更自然地实现任务延续。例如：
Imports System.Threading.Tasks
Module Module1
Async Function CalculateAsync() As Task(Of Integer)
Dim result1 As Integer = Await Task.Run(Function()
Dim temp As Integer = 0
For i As Integer = 1 To 1000000
temp += i
Next
Return temp
End Function)
Dim result2 As Integer = result1 * 2
Return result2
End Function
Sub Main()
Dim task As Task(Of Integer) = CalculateAsync()
task.Wait()
Dim finalResult As Integer = task.Result
Console.WriteLine("Final result: " & finalResult)
End Sub
End Module
这种方式通过 Await 暂停执行，直到前一个任务完成，然后继续执行后续的代码，使得代码逻辑更加清晰。
并行任务（Parallel Tasks）
TPL还支持并行执行多个任务，以充分利用多核处理器的性能。
- 使用
Task.WhenAll方法：Task.WhenAll方法用于等待一组任务全部完成。例如，假设我们有多个文件需要读取，并且希望并行读取这些文件：
Imports System.IO
Imports System.Threading.Tasks
Module Module1
Async Function ReadFilesAsync(filePaths As String()) As Task(Of String())
Dim tasks As Task(Of String)() = filePaths.Select(Function(p) File.ReadAllTextAsync(p)).ToArray()
Dim results As String() = Await Task.WhenAll(tasks)
Return results
End Function
Sub Main()
Dim filePaths As String() = {"file1.txt", "file2.txt", "file3.txt"}
Dim task As Task(Of String()) = ReadFilesAsync(filePaths)
task.Wait()
Dim contents As String() = task.Result
For Each content In contents
Console.WriteLine("File content: " & content)
Next
End Sub
End Module
在这个例子中，ReadFilesAsync 方法创建了一组并行读取文件的任务，并使用 Task.WhenAll 等待所有任务完成，然后返回所有文件的内容。
- 使用
Task.WhenAny方法：Task.WhenAny方法用于等待一组任务中的任何一个完成。例如，假设我们有多个任务，只要其中一个任务成功获取到数据，就停止其他任务：
Imports System.Threading.Tasks
Module Module1
Async Function FetchDataAsync() As Task(Of String)
Dim task1 As Task(Of String) = Task.Run(Function()
'模拟长时间运行的任务1
System.Threading.Thread.Sleep(5000)
Return "Data from task1"
End Function)
Dim task2 As Task(Of String) = Task.Run(Function()
'模拟长时间运行的任务2
System.Threading.Thread.Sleep(3000)
Return "Data from task2"
End Function)
Dim completedTask As Task(Of String) = Await Task.WhenAny(task1, task2)
Return completedTask.Result
End Function
Sub Main()
Dim task As Task(Of String) = FetchDataAsync()
task.Wait()
Dim data As String = task.Result
Console.WriteLine("Data: " & data)
End Sub
End Module
在这个例子中，Task.WhenAny 会等待 task1 或 task2 中任何一个任务完成，并返回完成的任务结果。
处理任务中的异常
在异步任务执行过程中，可能会发生异常。在TPL中，可以通过多种方式处理这些异常。
- 在延续任务中处理异常：可以在延续任务中通过检查
Task对象的Exception属性来处理异常。例如：
Imports System.Threading.Tasks
Module Module1
Sub Main()
Dim task1 As Task = Task.Run(Sub()
Throw New Exception("Simulated exception")
End Sub)
Dim task2 As Task = task1.ContinueWith(Sub(t)
If t.Exception IsNot Nothing Then
Console.WriteLine("Exception caught: " & t.Exception.Message)
End If
End Sub)
task2.Wait()
End Sub
End Module
- 在异步方法中使用 Try - Catch 块：在异步方法中，可以使用传统的
Try - Catch块来捕获异常。例如：
Imports System.Threading.Tasks
Module Module1
Async Function DivideNumbersAsync(a As Integer, b As Integer) As Task(Of Double)
Try
Return a / b
Catch ex As DivideByZeroException
Console.WriteLine("Exception caught: " & ex.Message)
Return Double.NaN
End Try
End Function
Sub Main()
Dim task As Task(Of Double) = DivideNumbersAsync(10, 0)
task.Wait()
Dim result As Double = task.Result
Console.WriteLine("Result: " & result)
End Sub
End Module
通过这些方式，可以有效地处理异步任务中发生的异常，保证应用程序的稳定性。
异步编程与Task并行库的高级应用
异步流（Async Streams）
在某些情况下，我们可能需要处理大量的数据，一次性加载所有数据可能会导致内存问题。异步流允许我们以流的方式异步处理数据，每次只处理一部分数据。
在Visual Basic中，可以使用 IAsyncEnumerable 接口来实现异步流。例如，假设我们有一个文件，其中包含大量的行数据，我们希望逐行异步读取：
Imports System.IO
Imports System.Threading.Tasks
Module Module1
Async Function ReadLinesAsync(filePath As String) As IAsyncEnumerable(Of String)
Using streamReader As New StreamReader(filePath)
While Not streamReader.EndOfStream
Yield Await streamReader.ReadLineAsync()
End While
End Using
End Function
Sub Main()
Dim filePath As String = "largeFile.txt"
Dim task As Task = Task.Run(Async Sub()
Dim asyncEnumerator As IAsyncEnumerator(Of String) = ReadLinesAsync(filePath).GetAsyncEnumerator()
Try
While Await asyncEnumerator.MoveNextAsync()
Dim line As String = asyncEnumerator.Current
Console.WriteLine("Line: " & line)
End While
Finally
Await asyncEnumerator.DisposeAsync()
End Try
End Sub)
task.Wait()
End Sub
End Module
在这个例子中，ReadLinesAsync 方法返回一个 IAsyncEnumerable(Of String)，通过 Yield Await 逐行返回数据。在 Main 方法中，我们使用 IAsyncEnumerator 来异步迭代数据。
取消任务
在实际应用中，有时需要能够取消正在执行的异步任务。TPL提供了 CancellationToken 来支持任务取消。
- 创建和传递
CancellationToken：首先，需要创建一个CancellationTokenSource，然后从中获取CancellationToken，并将其传递给异步任务。例如：
Imports System.Threading
Imports System.Threading.Tasks
Module Module1
Async Function LongRunningTaskAsync(cancellationToken As CancellationToken) As Task
For i As Integer = 1 To 1000000
If cancellationToken.IsCancellationRequested Then
Return
End If
'模拟一些工作
System.Threading.Thread.Sleep(10)
Next
End Function
Sub Main()
Dim cancellationTokenSource As New CancellationTokenSource()
Dim cancellationToken As CancellationToken = cancellationTokenSource.Token
Dim task As Task = LongRunningTaskAsync(cancellationToken)
'模拟在某个时刻取消任务
System.Threading.Thread.Sleep(100)
cancellationTokenSource.Cancel()
Try
task.Wait()
Catch ex As AggregateException
If ex.InnerExceptions.Any(Function(e) TypeOf e Is TaskCanceledException) Then
Console.WriteLine("Task was cancelled")
Else
Throw
End If
End Try
End Sub
End Module
在这个例子中，LongRunningTaskAsync 方法接收一个 CancellationToken，并在执行过程中检查是否请求取消。在 Main 方法中，我们创建了一个 CancellationTokenSource，并在一段时间后请求取消任务。
异步编程与UI应用程序
在Windows Forms或WPF等UI应用程序中，异步编程尤为重要，因为长时间运行的操作不能阻塞UI线程，否则会导致应用程序无响应。
- 在UI线程中使用异步方法：在UI应用程序中，可以直接在事件处理程序中使用异步方法。例如，在Windows Forms应用程序中，有一个按钮点击事件处理程序：
Imports System.IO
Imports System.Threading.Tasks
Imports System.Windows.Forms
Public Class Form1
Private Async Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
Button1.Enabled = False
Try
Dim content As String = Await File.ReadAllTextAsync("largeFile.txt")
TextBox1.Text = content
Catch ex As Exception
MessageBox.Show("Error: " & ex.Message)
Finally
Button1.Enabled = True
End Try
End Sub
End Class
在这个例子中，按钮点击事件处理程序是异步的。在读取文件时，UI线程不会被阻塞，用户仍然可以与应用程序进行交互。
- 更新UI控件：在异步任务中更新UI控件需要特别注意，因为UI控件只能在创建它们的线程（通常是UI线程）中更新。在Visual Basic中，可以使用
Control.Invoke或Dispatcher.Invoke（在WPF中）来在UI线程中执行代码。例如：
Imports System.IO
Imports System.Threading.Tasks
Imports System.Windows.Forms
Public Class Form1
Private Async Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
Button1.Enabled = False
Try
Dim task As Task(Of String) = Task.Run(Function() File.ReadAllText("largeFile.txt"))
Dim content As String = Await task
Me.Invoke(Sub() TextBox1.Text = content)
Catch ex As Exception
MessageBox.Show("Error: " & ex.Message)
Finally
Button1.Enabled = True
End Try
End Sub
End Class
在这个例子中，我们使用 Me.Invoke 来在UI线程中更新 TextBox1 的文本。
性能优化与注意事项
性能优化
- 避免不必要的异步操作：虽然异步编程可以提高应用程序的响应性，但在某些情况下，同步操作可能更高效。例如，如果一个操作非常快速，并且不会阻塞主线程很长时间，那么使用同步操作可能更好，因为异步操作会引入一定的开销，如线程切换和任务调度。
- 合理使用线程池：
Task.Run方法使用线程池来执行任务。在处理大量任务时，需要注意线程池的资源限制。如果创建过多的任务，可能会导致线程池过度使用，从而影响应用程序的性能。可以通过调整线程池的参数（如最大线程数）来优化性能。 - 减少锁的使用：在多线程和异步编程中，锁的使用可能会导致性能瓶颈。尽量使用无锁数据结构或并发集合来减少锁的竞争。例如，
ConcurrentDictionary可以在多线程环境下安全地使用，而不需要显式地加锁。
注意事项
- 死锁问题：在使用
Wait()或Result获取异步任务结果时，特别是在UI线程中，可能会导致死锁。这是因为主线程在等待异步任务完成，而异步任务可能又需要在主线程上执行某些操作（例如更新UI控件），从而形成死锁。应尽量避免在UI线程中直接使用Wait()和Result，而是使用Await。 - 异常处理：在异步编程中，异常处理需要特别小心。确保在适当的位置捕获和处理异常，避免异常在异步调用链中传播而未被处理，导致应用程序崩溃。同时，注意不同返回类型的异步方法（如
Task、Task(Of TResult)和Void）在异常处理上的差异。 - 资源管理：在异步操作中，要注意资源的正确管理，如文件句柄、数据库连接等。确保在异步操作完成后，及时释放资源，避免资源泄漏。可以使用
Using语句来自动管理资源的释放。
通过深入理解Visual Basic异步编程基础与Task并行库，并注意性能优化和相关注意事项，开发人员能够编写高效、稳定且响应式的应用程序，满足现代用户对应用程序性能和交互性的要求。无论是开发桌面应用程序、Web应用程序还是其他类型的软件，异步编程和TPL都是不可或缺的工具。