#Region "EventArgs classes"

Public Class RunWorkerCompletedEventArgs

    Inherits System.EventArgs

    ' This class should inherit from AsyncCompletedEventArgs but I don't see the point in the CF's case

    Private ReadOnly mResult As Object

    Private ReadOnly mCancelled As Boolean

    Private ReadOnly mError As System.Exception

    Public Sub New(ByVal aResult As Object, ByVal aError As System.Exception, ByVal aCancelled As Boolean)

        mResult = aResult

        mError = aError

        mCancelled = aCancelled

    End Sub

    Public ReadOnly Property Result() As Object

        Get

            Return mResult

        End Get

    End Property

    Public ReadOnly Property Cancelled() As Boolean

        Get

            Return mCancelled

        End Get

    End Property

    Public ReadOnly Property [Error]() As System.Exception

        Get

            Return mError

        End Get

    End Property

End Class

Public Class ProgressChangedEventArgs

    Inherits System.EventArgs

    Private ReadOnly mProgressPercent As Int32

    Private ReadOnly mUserState As Object

    Public Sub New(ByVal aProgressPercent As Int32, ByVal aUserState As Object)

        mProgressPercent = aProgressPercent

        mUserState = aUserState

    End Sub

    Public ReadOnly Property ProgressPercentage() As Int32

        Get

            Return mProgressPercent

        End Get

    End Property

    Public ReadOnly Property UserState() As Object

        Get

            Return mUserState

        End Get

    End Property

End Class

Public Class DoWorkEventArgs

    Inherits System.ComponentModel.CancelEventArgs

    Private ReadOnly mArgument As Object

    Private mResult As Object

    Public Sub New(ByVal aArgument As Object)

        mArgument = aArgument

    End Sub

    Public ReadOnly Property Argument() As Object

        Get

            Return mArgument

        End Get

    End Property

    Public Property Result() As Object

        Get

            Return mResult

        End Get

        Set(ByVal value As Object)

            mResult = value

        End Set

    End Property

End Class

#End Region

#Region "Delegates for 3 events of class"

Public Delegate Sub DoWorkEventHandler(ByVal sender As Object, ByVal e As DoWorkEventArgs)

Public Delegate Sub ProgressChangedEventHandler(ByVal sender As Object, ByVal e As ProgressChangedEventArgs)

Public Delegate Sub RunWorkerCompletedEventHandler(ByVal sender As Object, ByVal e As RunWorkerCompletedEventArgs)

#End Region

#Region "BackgroundWorker Class"

''' <summary>

''' Executes an operation on a separate thread.

''' </summary>

Public Class BackgroundWorker

    Inherits System.ComponentModel.Component

#Region "Public Interface"

    Public Event DoWork As DoWorkEventHandler

    Public Event ProgressChanged As ProgressChangedEventHandler

    Public Event RunWorkerCompleted As RunWorkerCompletedEventHandler

    Private _eventarg As System.Collections.Generic.Queue(Of ProgressChangedEventArgs)

    ''' <summary>

    ''' Initializes a new instance of the BackgroundWorker class.

    ''' </summary>

    Public Sub New()

        Me.New(New System.Windows.Forms.Control)

        _eventarg = New System.Collections.Generic.Queue(Of ProgressChangedEventArgs)

        ' ideally we want to call Control.CreateControl()

        ' without it, running on the desktop will crash (it is OK on the CF)

        ' [on the full fx simply calling a control's constructor does not create the Handle.]

        ' The CreateControl method is not supported on the CF so to keep this assembly retargettable

        ' I have offered the alternative ctor for desktop clients

        ' (where they can pass in already created controls)

    End Sub

    ''' <summary>

    ''' Initializes a new instance of the BackgroundWorker class.

    ''' Call from the desktop code as the other ctor is not good enough

    ''' Call it passing in a created control e.g. the Form

    ''' </summary>

    Public Sub New(ByVal aControl As System.Windows.Forms.Control)

        MyBase.New()

        mGuiMarshaller = aControl

    End Sub

    ''' <summary>

    ''' Gets a value indicating whether the application has requested cancellation of a background operation.

    ''' </summary>

    Public ReadOnly Property CancellationPending() As Boolean

        Get

            Return mCancelPending

        End Get

    End Property

    ''' <summary>

    ''' Raises the BackgroundWorker.ProgressChanged event.

    ''' </summary>

    ''' <param name="aProgressPercent">The percentage, from 0 to 100, of the background operation that is complete. </param>

    Public Sub ReportProgress(ByVal aProgressPercent As Int32)

        Me.ReportProgress(aProgressPercent, Nothing)

    End Sub

    ''' <summary>

    ''' Raises the BackgroundWorker.ProgressChanged event.

    ''' </summary>

    ''' <param name="aProgressPercent">The percentage, from 0 to 100, of the background operation that is complete. </param>

    ''' <param name="aUserState">The state object passed to BackgroundWorker.RunWorkerAsync(System.Object).</param>

    Public Sub ReportProgress(ByVal aProgressPercent As Int32, ByVal aUserState As Object)

        If Not mDoesProgress Then

            Throw New System.InvalidOperationException("Doesn't do progress events. You must WorkerReportsProgress=True")

        End If

        ' Send the event to the GUI

        _eventarg.Enqueue(New ProgressChangedEventArgs(aProgressPercent, aUserState))

        System.Threading.ThreadPool.QueueUserWorkItem( _

       New System.Threading.WaitCallback(AddressOf ProgressHelper))

    End Sub

    ''' <summary>

    ''' Starts execution of a background operation.

    ''' </summary>

    Public Sub RunWorkerAsync()

        Me.RunWorkerAsync(Nothing)

    End Sub

    Public ReadOnly Property IsBusy() As Boolean

        Get

            Return mInUse

        End Get

    End Property

    ''' <summary>

    ''' Starts execution of a background operation.

    ''' </summary>

    ''' <param name="aArgument"> A parameter for use by the background operation to be executed in the BackgroundWorker.DoWork event handler.</param>

    Public Sub RunWorkerAsync(ByVal aArgument As Object)

        If mInUse Then

            Throw New System.InvalidOperationException("Already in use.")

        End If

        If DoWorkEvent Is Nothing Then

            Throw New System.InvalidOperationException("You must subscribe to the DoWork event.")

        End If

        mInUse = True

        mCancelPending = False

        System.Threading.ThreadPool.QueueUserWorkItem( _

        New System.Threading.WaitCallback(AddressOf DoTheRealWork), aArgument)

    End Sub

    ''' <summary>

    ''' Requests cancellation of a pending background operation.

    ''' </summary>

    Public Sub CancelAsync()

        If Not mDoesCancel Then

            Throw New System.InvalidOperationException("Does not support cancel. You must WorkerSupportsCancellation=True")

        End If

        mCancelPending = True

    End Sub

    ''' <summary>

    ''' Gets or sets a value indicating whether the BackgroundWorker object can report progress updates.

    ''' </summary>

    Public Property WorkerReportsProgress() As Boolean

        Get

            Return mDoesProgress

        End Get

        Set(ByVal value As Boolean)

            mDoesProgress = value

        End Set

    End Property

    ''' <summary>

    ''' Gets or sets a value indicating whether the BackgroundWorker object supports asynchronous cancellation.

    ''' </summary>

    Public Property WorkerSupportsCancellation() As Boolean

        Get

            Return mDoesCancel

        End Get

        Set(ByVal Value As Boolean)

            mDoesCancel = Value

        End Set

    End Property

#End Region

#Region "Fields"

    'Ensures the component is used only once per session

    Private mInUse As Boolean

    'Stores the cancelation request that the worker thread (user's code) should check via CancellationPending

    Private mCancelPending As Boolean

    'Whether the object supports cancelling or not (and progress or not)

    Private mDoesCancel As Boolean

    Private mDoesProgress As Boolean

    'Helper objects since Control.Invoke takes no arguments

    Private mFinalResult As RunWorkerCompletedEventArgs

    Private mProgressArgs As ProgressChangedEventArgs

    'Private mProgressArgsList As New List(Of ProgressChangedEventArgs)

    ' Helper for marshalling execution to GUI thread

    Private mGuiMarshaller As System.Windows.Forms.Control

#End Region

#Region "Private Methods"

    ' Async(ThreadPool) called by ReportProgress for reporting progress

    Private Sub ProgressHelper()

        Dim t As System.Windows.Forms.Control = mGuiMarshaller

        t.Invoke(New System.EventHandler(AddressOf TellThemOnGuiProgress))

    End Sub

    ' ControlInvoked by ProgressHelper for raising progress

    Private Sub TellThemOnGuiProgress(ByVal sender As Object, ByVal e As System.EventArgs)

        Dim o As ProgressChangedEventArgs

        While _eventarg.Count >

            o = _eventarg.Dequeue()

            If o IsNot Nothing Then

                RaiseEvent ProgressChanged(sender, o)

            End If

        End While

    End Sub

    ' Async(ThreadPool) called by RunWorkerAsync [the little engine of this class]

    Private Sub DoTheRealWork(ByVal o As Object)

        ' declare the vars we will pass back to client on completion

        Dim er As System.Exception = Nothing

        Dim ca As Boolean

        Dim result As Object = Nothing

        ' Raise the event passing the original argument and catching any exceptions

        Try

            Dim inOut As New DoWorkEventArgs(o)

            RaiseEvent DoWork(Me, inOut)

            ca = inOut.Cancel

            result = inOut.Result

        Catch ex As System.Exception

            er = ex

        End Try

        ' store the completed final result in a temp var

        Dim tempResult As New RunWorkerCompletedEventArgs(result, er, ca)

        ' return execution to client by going async here

        System.Threading.ThreadPool.QueueUserWorkItem( _

         New System.Threading.WaitCallback(AddressOf RealWorkHelper), tempResult)

        ' prepare for next use

        mInUse = False

        mCancelPending = False

    End Sub

    ' Async(ThreadPool) called by DoTheRealWork [to avoid any rentrancy issues at the client end]

    Private Sub RealWorkHelper(ByVal o As Object)

        mFinalResult = DirectCast(o, RunWorkerCompletedEventArgs)

        mGuiMarshaller.Invoke(New System.EventHandler(AddressOf TellThemOnGuiCompleted))

    End Sub

    ' ControlInvoked by RealWorkHelper for raising final completed event

    Private Sub TellThemOnGuiCompleted(ByVal sender As Object, ByVal e As System.EventArgs)

        RaiseEvent RunWorkerCompleted(Me, mFinalResult)

    End Sub

#End Region

End Class

#End Region