4

我有一个工作线程，当它终止时，它会发出一个事件信号。然后将此事件编组到主线程以通知它工作线程的终止。当工作线程遇到未处理的异常时，我希望这个异常由主线程的错误处理系统来处理。因此，工作线程设置一个属性指示其意外终止，并将异常保存在另一个属性中，然后发出事件信号并退出。

将事件编组到主线程后，我想抛出一个新异常，并将原始异常设置为内部异常。我的问题是：这个新异常的类型应该是什么？对于这种情况是否有特定的 System.somethingException，我应该为这种特定情况设计自己的 Exception 类，还是认为抛出带有适当消息的标准 System.Exception 是合适的？

C#-伪代码：

class MyThread
{
    public TerminationState Termination { get; private set; }
    public Exception UncaughtException { get; private set; }

    public delegate void ThreadTerminatedDelegate(MyThread thread);
    public event ThreadTerminatedDelegate ThreadTerminated;

    private void run()
    {
        try
        {
            doSomeWork();
        }
        catch(Exception e)
        {
            UncaughtException = e;
            Termination = TerminationState.AbortOnException;
            ThreadTerminated(this);
            return;
        }
        Termination = TerminationState.NormalTermination;
        ThreadTerminated(this);
    }
}

class MainThread
{
    private MyThread myThread = new MyThread();

    private void run()
    {
        myThread.ThreadTerminated += handleTermination;
        myThread.Start();
    }

    private void handleTermination(MyThread thread)
    {
        if (InvokeRequired)
        {
            MyThread.ThreadTerminatedDelegate cb = new MyThread.ThreadTerminatedDelegate(handleTermination);
            BeginInvoke(cb, new object[] { thread });
        }
        else
        {
            if (thread.Termination == TerminationState.AbortOnException)
            {
                if (isFatal(thread.UncaughtException))
                    throw new Exception("", thread.UncaughtException); //what to do here?
                else
                    fixTheProblem();
            }
            else
            {
                //normal wrapping up
            }
        }
    }
}
4

1 回答 1

1

我相信您可以通过在 a 中执行后台工作，Task然后在明确安排在主线程上运行的任务的延续中处理任何异常，来对未处理的后台异常执行所有必要的异常处理。您可以为继续指定其他选项，但这应该涵盖您的方案。

Task.Factory.StartNew(
    () =>
    {
        // Do some work that may throw.
        // This code runs on the Threadpool.
        // Any exceptions will be propagated
        // to continuation tasks and awaiters
        // for observation.
        throw new StackOverflowException(); // :)
    }
).ContinueWith(
    (a) =>
    {
        // Handle your exception here.
        // This code runs on the thread
        // that started the worker task.
        if (a.Exception != null)
        {
            foreach (var ex in a.Exception.InnerExceptions)
            {
                // Try to handle or throw.
            }
        }
    },
    CancellationToken.None,
    TaskContinuationOptions.None,
    TaskScheduler.FromCurrentSynchronizationContext()
);

另一个有用的链接是MSDN 的异步编程模式。它确定了在应用程序中实现异步操作的 3 种主要方法。您当前的实现听起来与本文所说的 EAP（基于事件的异步模式）最相似。

我个人更喜欢依赖于 .NET 4.0 TPL（任务并行库）的 TAP（基于任务的异步模式）。由于其语法的简单性和广泛的功能，它非常值得掌握。

来自 MSDN：

  • 异步编程模型 (APM) 模式（也称为 IAsyncResult 模式），其中异步操作需要 Begin 和 End 方法（例如，用于异步写入操作的 BeginWrite 和 EndWrite）。不再建议将此模式用于新开发。有关详细信息，请参阅异步编程模型 (APM)。
  • 基于事件的异步模式 (EAP)，它需要具有 Async 后缀的方法，并且还需要一个或多个事件、事件处理程序委托类型和 EventArg 派生类型。EAP 是在 .NET Framework 2.0 中引入的。不再推荐用于新开发。有关详细信息，请参阅基于事件的异步模式 (EAP)。
  • 基于任务的异步模式 (TAP)，它使用单一方法来表示异步操作的启动和完成。TAP 是在 .NET Framework 4 中引入的，是 .NET Framework 中推荐的异步编程方法。有关详细信息，请参阅基于任务的异步模式 (TAP)。

另外，不要忘记可信赖的BackgroundWorker课程。很长一段时间以来，这门课一直是我的主食，虽然它已经被 TAP 弃用了，但它仍然可以完成工作，并且非常容易理解和使用。

// Create a new background worker.
var bgw = new BackgroundWorker();

// Assign a delegate to perform the background work.
bgw.DoWork += (s, e) =>
    {
        // Runs in background thread. Unhandled exceptions
        // will cause the thread to terminate immediately.
        throw new StackOverflowException();
    };

// Assign a delegate to perform any cleanup/error handling/UI updating.
bgw.RunWorkerCompleted += (s, e) =>
    {
        // Runs in UI thread. Any unhandled exception that
        // occur in the background thread will be accessible
        // in the event arguments Error property.
        if (e.Error != null)
        {
            // Handle or rethrow.
        }
    };

// Start the background worker asynchronously.
bgw.RunWorkerAsync();
于 2013-08-02T18:16:58.637 回答