WPF: Why BackgroundWorker.RunWorkerCompleted Event() throw an exception and main thread does not receive it?

Question

WPF: Why BackgroundWorker.RunWorkerCompleted Event() throw an exception and main thread does not receive it?

Jane Jie Chen 466

Our WPF application targets .NET 4.8.

The AbortableBackgroundWorkder class inherences from the BackgroundWorker class and used as following.

there are two background workers:

_protocolProcessorBackgroundWorker..DoWork() will call {

_protocolProcessorMacro.Execute(_protocolProcessorBackgroundWorker.Token);

}

_protocolProcessorBackgroundWorker.RunWorkerAsync();

_protocolProcessorMacro.Execute() will call {

pcrBackgroundWorker.DoWork += (, __) => { _pcrMacro.Execute(_pcrBackgroundWorker.Token); };

}

_pcrBackgroundWorker.RunWorkerAsync();

when _pcrMacro.Execute() has occurred an exception, it went through "_pcrBackgroundWorker.RunWorkerCompleted()" event with following black code.

// Exception occurred

                    if ( e.Error != null )

                    {

                        WriteToRunLog( "!! PCR Exception " + e.Error.Message );

                        throw e.Error;

                    }

However, "throw e.Error;" seems hidden and did not receive by ProtocolProcessorMacro catch block.

so ProtocolProcessorMacro continues to next macro "transferPcrMacro.Execute();"

what cause that "throw e.Error" hidden?

How to fix it so that ProtocolProcessorMacro catch block will catch the exception. Thx!

public class ProtocolProcessor
{
	public void Execute()       
	{
		try
        {
            //  Raise (and log) the Macro Started event
            MarkMacroStarted();
			
			// a lot instrument control sequence actions
			if ( _protocolProcessorParams.PerformPcrMacro )
                {
                    EvaluateMacroStopPoint( "PCR" );
                    WriteToRunLog( "!! Start Macro - PCR" );
                    _pcrBackgroundWorker = new AbortableBackgroundWorker();
                    _pcrBackgroundWorker.WorkerSupportsCancellation = true;
                    _pcrBackgroundWorker.DoWork += (_, __) => { _pcrMacro.Execute(_pcrBackgroundWorker.Token); };
                    _pcrBackgroundWorker.RunWorkerCompleted += ( sender, e ) =>
                    {
                        //  clear the background worker to indicate it done
                        _pcrBackgroundWorker = null;
                        if ( e.Cancelled )
                        {
                            WriteToRunLog( "!! PCR Aborted " );
                        }
                        else
                        //  Exception occurred
                        if ( e.Error != null )
                        {
                            WriteToRunLog( "!! PCR Exception " + e.Error.Message );
                            throw e.Error;
                        }
                        else
                        {
                            WriteToRunLog( "!! Finish Macro - PCR" );
                        }
                    };
                    _pcrBackgroundWorker.RunWorkerAsync();
                }

			if ( _protocolProcessorParams.PerformTransferPcrMacro )
                {
					 _transferPcrMacro.Execute(token);
				}
			.......

			EvaluateMacroStopPoint( "Macro Finished" );
		}
		catch( Exception ex )
        {
            WriteToRunLog( "!!! Exception Occurred in Macro !!! - " + ex.Message );
            stoppedByError = true;
            throw;
        }
        finally
        {
			// Thread.Sleep(200);  //is it safe to sleep in finally block?
            //  handle case where the macro was stopped by the user (not aborted)
            //  exception occurred, was logged and thrown again
			TurnOffAllHeatersAndStopLogging();  //include write sth into run log
            
		}
	}
}

private AbortableBackgroundWorker           _protocolProcessorBackgroundWorker  = null;
private ProtocolProcessor                   _protocolProcessorMacro             = null;

Public void BeginXXXRun()
{
	InstrumentControl.Instance.ExceptionThrown += OnInstrumentControlExceptionThrownDuringProtocol;

	_protocolProcessorBackgroundWorker = new AbortableBackgroundWorker();
    _protocolProcessorBackgroundWorker.WorkerSupportsCancellation = true;
    _protocolProcessorBackgroundWorker.DoWork += (_, __) =>
    {
		try
		{
		_protocolProcessorMacro = new ProtocolProcessor( );
        _protocolProcessorMacro.ProtocolProcessorRunEvent += OnProtocolProcessorRunEvent;
		
		_protocolProcessorMacro.PreExecute();
        _protocolProcessorMacro.Execute();
        _protocolProcessorMacro.PostExecute();
		}
		catch ( ThreadAbortException /* taEx */ )
        {
        }
        catch ( Exception ex )
        {
             GenerateInstrumentExceptionWarningOrFault( ex );
             throw;
        }
        finally
        {
        
               _protocolProcessorMacro.StopLoggingToFile();
        }
	};
	_protocolProcessorBackgroundWorker.RunWorkerCompleted += OnProtocolProcessorRunComplete;
    _protocolProcessorBackgroundWorker.RunWorkerAsync();
  }
}

}

Viorel 120.4K Reputation points

2025-03-07T23:12:19.45+00:00

Maybe the catch block was already passed (and the Execute finished). Check if the e.Error can be detected in OnProtocolProcessorRunComplete.
Hongrui Yu-MSFT 4,930 Reputation points Microsoft External Staff

2025-03-10T09:52:00.3366667+00:00

Hi, @Jane Jie Chen. Welcome to Microsoft Q&A.

Is there any update to the question? Did Bruce (SqlWork.com)’s answer solve your problem? If so, you could accept it as the answer. It's helpful for community members with related questions.

As Bruce (SqlWork.com) said, a thread cannot catch another linear exception. When you execute the RunWorkerCompleted asynchronous method, RunWorkerCompleted is at the top of the call stack. You execute throw e.Error; and there is no higher level to accept and handle this exception, so the system will report an error.

1 answer

Your answer

Viorel 120.4K Reputation points

2025-03-07T23:12:19.45+00:00

Maybe the catch block was already passed (and the Execute finished). Check if the e.Error can be detected in OnProtocolProcessorRunComplete.
Hongrui Yu-MSFT 4,930 Reputation points Microsoft External Staff

2025-03-10T09:52:00.3366667+00:00

Hi, @Jane Jie Chen. Welcome to Microsoft Q&A.

Is there any update to the question? Did Bruce (SqlWork.com)’s answer solve your problem? If so, you could accept it as the answer. It's helpful for community members with related questions.

As Bruce (SqlWork.com) said, a thread cannot catch another linear exception. When you execute the RunWorkerCompleted asynchronous method, RunWorkerCompleted is at the top of the call stack. You execute throw e.Error; and there is no higher level to accept and handle this exception, so the system will report an error.

Answer 1

Bruce (SqlWork.com) 72,276

There is no code to catch the error. The Execute() method exits long before the error is thrown. Even if it had a sleep, it would not catch the error. You need to use a task wait or async/await to catch the error. note: one thread can not catch another’s error. You need check the status of the task after completion, to detect and re-throw the error. This is what wait() and await do.

Jane Jie Chen 466 Reputation points

2025-03-10T13:26:45.7066667+00:00

Brace & Viorel,

thanks for replying to our question!

The reason we use "throw e.Error;" is because we want popup exception error message to calling thread.

Brace mentioned that "note: one thread can not catch another’s error."

if we want to one thread to catch another thread error, what should we do?

Is there a code example to show us how to "use a task wait or async/await to catch the error."? Thx!
Bruce (SqlWork.com) 72,276 Reputation points

2025-03-10T21:19:26.01+00:00

the classic background worker does not lend itself to the new awaitable tasks.

you need to catch the error in on complete event, as you are, but throwing has no impact as the worker class eats it. you need to pass the error to your main thread. as your code does a fire and forget, it not clear how you want to handle the error notification. you could add an on error delegate to the worker, and trigger from the oncomplete callback. You could add a RecordError() method called when there is an error.
Jane Jie Chen 466 Reputation points

2025-03-11T02:53:51.0533333+00:00

Bruce,

thanks for your reply!

we need to pass the error to your main thread.

Is there a code example to show us how to archive that? thx!

Hongrui Yu-MSFT 4,930 Microsoft External Staff

Hi, @Jane Jie Chen.

Accessing resources across threads, you may consider storing the exception in a shared variable first, and access the exception from somewhere else after RunWorkerCompleted is executed. Refer to the following method:

Add a tool class to store and throw exceptions.

    public class MyTool
    {
        public static Exception exception;

        public static void HandleException()
        {
            if(exception!=null)
            {
                throw exception;
            } 
        }

        public static void ClearException()
        {
            exception = null;
        }
    }

Storing exception in _pcrBackgroundWorker.RunWorkerCompleted.

if ( e.Error != null )
{
      WriteToRunLog( "!! PCR Exception " + e.Error.Message );
      MyTool.exception = e.Error;
}

Access exception after execution.

_protocolProcessorBackgroundWorker.RunWorkerCompleted += (sender, e) =>
{
      try
      {
            MyTool.HandleException();
      }
      catch (Exception ex)
      {
            MessageBox.Show(ex.Message);
            MyTool.ClearException();
       }
};

Share via

WPF: Why BackgroundWorker.RunWorkerCompleted Event() throw an exception and main thread does not receive it?

1 answer

Your answer