VB.Net 多个后台工作人员 - 只有最后一个任务完成

Question

我一直在努力解决这个问题。如果我在调试器中逐步执行代码，一切都会很好。

我的问题是，如果我只是运行它，只有最后一个任务会响应。我猜我正在覆盖背景工作或其他东西。我确定我做错了一些事情，但是我的代码现在很混乱，因为我在搜索时尝试了很多方法。我知道线程池和 .Net 4.0 任务，但很难完成我需要的工作。

基本上我正在编写一个程序（更可能尝试），然后获取计算机列表和 ping，然后检查它们的正常运行时间并返回报告。

这在 UI 线程中运行良好（显然这会锁定我的屏幕）。我可以让后台工作人员执行此操作，但随后它会逐台执行每台计算机，并且在屏幕响应时仍需要很长时间。

所以我的回答是为每个启动新后台工作线程的服务器设置一个 for 循环。我的解决方案不起作用。

我已经看到了其他可以做到的线程，但是我需要使用事件来调用代码以在每个线程完成后更新到 UI。

最简单的方法是什么？

这是我的代码。大多数只是复制粘贴+修改，直到我让它正常工作。

所以在主课中我有 testworker。

（我尝试使用 Testworker() 但它说我无法使用事件）

当我单击按钮时，列表会加载。

Private WithEvents TestWorker As System.ComponentModel.BackgroundWorker

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.Windows.RoutedEventArgs) Handles Button1.Click
    Button1.IsEnabled = False

    Dim indexMax As Integer
                    indexMax = DataGridStatus.Items.Count
    For index = 1 To (indexMax)
        Dim Temp As ServerInfo = DataGridStatus.Items(index - 1)
        Temp.Index = index - 1
        Call_Thread(Temp)
    Next
End Sub


Private Sub Call_Thread(ByVal server As ServerInfo)
    Dim localserver As ServerInfo = server

    TestWorker = New System.ComponentModel.BackgroundWorker
    TestWorker.WorkerReportsProgress = True
    TestWorker.WorkerSupportsCancellation = True
    TestWorker.RunWorkerAsync(localserver)

End Sub

Private Sub TestWorker_DoWork(ByVal sender As Object, ByVal e As System.ComponentModel.DoWorkEventArgs) Handles TestWorker.DoWork

    Dim iparray As IPHostEntry
    Dim ip() As IPAddress

    Dim Server As ServerInfo
    Server = e.Argument
    Try
        'Get IP Address first
        iparray = Dns.GetHostEntry(Server.ServerName)
        ip = iparray.AddressList
        Server.IPAddress = ip(0).ToString

        'Try Pinging
        Server.PingResult = PingHost(Server.ServerName)
        If Server.PingResult = "Success" Then

            'If ping success, get uptime
            Server.UpTime = GetUptime(Server.ServerName)
        Else
            Server.PingResult = "Failed"
        End If

    Catch ex As Exception
        Server.PingResult = "Error"
    End Try

    TestWorker.ReportProgress(0, Server)
    Thread.Sleep(1000)

End Sub


Private Sub TestWorker_ProgressChanged(ByVal sender As Object, ByVal e As System.ComponentModel.ProgressChangedEventArgs) Handles TestWorker.ProgressChanged

    Dim index As Integer
    Dim serverchange As ServerInfo = DirectCast(e.UserState, ServerInfo)

    index = DataGridStatus.Items.IndexOf(serverchange)
    ' index = serverchange.Index
    DataGridStatus.Items.Item(index) = serverchange

    ' ProgressBar1.Value = e.ProgressPercentage
    DataGridStatus.Items.Refresh()
End Sub

Answer 1

您只会得到最后一个结果，因为您每次调用 TestWorker = New System.ComponentModel.BackgroundWorker 时都会把您的 BackgroundWorker 吹走。由于处理是异步完成的，因此在之前的工作完成之前，会在您的 for 循环中多次调用此行。

以下内容可能会起作用。 （抱歉，我的 VB 生锈了；可能有更有效的表达方式。）

Delegate Function PingDelegate(ByVal server As String) As String

Private _completedCount As Int32
Private ReadOnly _lockObject As New System.Object
Dim _rnd As New Random
Private _servers As List(Of String)

Private Sub GoButton_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles GoButton.Click
    _servers = New List(Of System.String)(New String() {"adam", "betty", "clyde", "danny", "evan", "fred", "gertrude", "hank", "ice-t", "joshua"})
    _completedCount = 0
    ListBox1.Items.Clear()
    GoButton.Enabled = False
    BackgroundWorker1.RunWorkerAsync(_servers)
End Sub

Private Sub BackgroundWorker1_DoWork(ByVal sender As System.Object, ByVal e As System.ComponentModel.DoWorkEventArgs) Handles BackgroundWorker1.DoWork
    Dim servers As List(Of System.String) = DirectCast(e.Argument, List(Of System.String))
    Dim waitHandles As New List(Of WaitHandle)

    For Each server As System.String In servers
        ' Get a delegate for the ping operation. .Net will let you call it asynchronously
        Dim d As New PingDelegate(AddressOf Ping)

        ' Start the ping operation async. When the ping is complete, it will automatically call PingIsDone
        Dim ar As IAsyncResult = d.BeginInvoke(server, AddressOf PingIsDone, d)

        ' Add the IAsyncResult for this invocation to our collection.
        waitHandles.Add(ar.AsyncWaitHandle)
    Next

    ' Wait until everything is done. This will not block the UI thread because it is happening
    ' in the background. You could also use the overload that takes a timeout value and
    ' check to see if the user has requested cancellation, for example. Once all operations
    ' are complete, this method will exit scope and the BackgroundWorker1_RunWorkerCompleted 
    ' will be called.
    WaitHandle.WaitAll(waitHandles.ToArray())
End Sub

Private Sub BackgroundWorker1_ProgressChanged(ByVal sender As System.Object, ByVal e As System.ComponentModel.ProgressChangedEventArgs) Handles BackgroundWorker1.ProgressChanged
    ListBox1.Items.Add(String.Format("{0} ({1}% done)", e.UserState, e.ProgressPercentage))
End Sub

Private Sub BackgroundWorker1_RunWorkerCompleted(ByVal sender As System.Object, ByVal e As System.ComponentModel.RunWorkerCompletedEventArgs) Handles BackgroundWorker1.RunWorkerCompleted
    GoButton.Enabled = True
End Sub

Private Function Ping(ByVal server As System.String) As System.String
    ' Simulate a ping with random result and duration
    Threading.Thread.Sleep(_rnd.Next(1000, 4000))
    Dim result As Int32 = _rnd.Next(0, 2)
    If result = 0 Then
        Return server & " is ok"
    Else
        Return server & " is down"
    End If
End Function

Private Sub PingIsDone(ByVal ar As IAsyncResult)
    ' This method is called everytime a ping operation completes. Note that the order in which
    ' this method fires is completely independant of the order of the servers. The first server
    ' to respond calls this method first, etc. This keeps optimal performance.
    Dim d As PingDelegate = DirectCast(ar.AsyncState, PingDelegate)

    ' Complete the operation and get the result.
    Dim pingResult As String = d.EndInvoke(ar)

    ' To be safe, we put a lock around this so that _completedCount gets incremented atomically
    ' with the progress report. This may or may not be necessary in your application.
    SyncLock (_lockObject)
        _completedCount = _completedCount + 1
        Dim percent As Int32 = _completedCount * 100 / _servers.Count
        BackgroundWorker1.ReportProgress(percent, pingResult)
    End SyncLock
End Sub

Answer 2

更新：我发布了这个答案，重点关注您从技术角度（使用许多后台工作人员）尝试做的事情，而没有真正考虑这是否是一个好方法完成你的真正的目标。事实上，我认为你可以通过一个BackgroundWorker 和Parallel.ForEach 事件处理程序中的Parallel.ForEach 循环来更轻松地实现你想要的东西（这会处理很多细节工作例如，Dave's 解决方案）。

---

当你在 VB 中声明 WithEvents TestWorker As BackgroundWorker 时，它会将它包装成这样（不完全是——这只是为了说明这个想法）：

Private _TestWorker As BackgroundWorker
Private Property TestWorker As BackgroundWorker
    Get
        Return _TestWorker
    End Get
    Set(ByVal value As BackgroundWorker)
        ' This is all probably handled in a more thread-safe way, mind you. '

        Dim prevWorker As BackgroundWorker = _TestWorker
        If prevWorker IsNot Nothing Then
            RemoveHandler prevWorker.DoWork, AddressOf TestWorker_DoWork
            ' etc. '
        End If

        If value IsNot Nothing Then
            AddHandler value.DoWork, AddressOf TestWorker_DoWork
            ' etc. '
        End If
        _TestWorker = value
    End Set
End Property

当您意识到这一点时，很明显，通过在每次调用 Call_Thread 时将TestWorker 设置 新 BackgroundWorker，您正在删除任何附加的来自该字段先前引用的对象的处理程序。

最明显的解决方法是在每次调用Call_Thread 时创建一个新的本地 BackgroundWorker 对象，将处理程序附加到那里（使用AddHandler 和RemoveHandler），然后然后让它做它的事情：

Private Sub Call_Thread(ByVal server As ServerInfo)
    Dim localserver As ServerInfo = server

    ' Use a local variable for the new worker. '
    ' This takes the place of the Private WithEvents field. '
    Dim worker As New System.ComponentModel.BackgroundWorker

    ' Set it up. '
    With worker
        .WorkerReportsProgress = True
        .WorkerSupportsCancellation = True
    End With

    ' Attach the handlers. '
    AddHandler worker.DoWork, AddressOf TestWorker_DoWork
    AddHandler worker.ProgressChanged, AdressOf TestWorker_ProgressChanged

    ' Do the work. '
    worker.RunWorkerAsync(localserver)
End Sub

只要您从 UI 线程中直接在该方法中创建工作线程应该没问题，因为 BackgroundWorker 在其构造函数中自动附加到当前的 SynchronizationContext（如果我没记错的话）。

Answer 3

理想情况下，您应该只使用 1 个后台工作人员并像这样使用它：

• 组装所有需要完成的工作：在您的情况下是 ServerInfo 列表
• 在后台执行工作：ping 所有服务器并保留结果
• 报告进度：例如在每个服务器 ping 之后
• 将结果放回 DoWorkEventArgs.Result
• 在您的 UI 中显示结果。

Answer 4

您需要将TestWorker_DoWork 和TestWorker_ProgressChanged 附加到Call_Thread 中的DoWork 和ProgressChanged 事件。我还没有检查其余的代码，但这就是它现在没有做任何事情的原因。

TestWorker = New System.ComponentModel.BackgroundWorker
TestWorker.WorkerReportsProgress = True
TestWorker.WorkerSupportsCancellation = True
AddHandler TestWorker.DoWork, AddressOf TestWorker_DoWork
AddHandler TestWorker.ProgressChanged, AddressOf TestWorker_ProgressChanged
TestWorker.RunWorkerAsync(localserver)