捕获在不同线程中抛出的异常

Question

我的一个方法 (Method1) 生成一个新线程。 该线程执行一个方法 (Method2)，并在执行期间引发异常。 我需要获取有关调用方法的异常信息 (Method1)

是否可以通过某种方式捕获 Method1 中在 Method2 中引发的异常？

Answer 1

在.NET 4及更高版本中，您可以使用Task类而不是创建新线程。然后，您可以使用任务对象上的 .Exceptions 属性来获取异常。
有两种方法可以做到这一点：

1. 在单独的方法中： // 在某些任务的线程中处理异常

   类程序
   {
       静态无效主（字符串[]参数）
       {
           任务任务=新任务（测试）；
           task.ContinueWith(ExceptionHandler, TaskContinuationOptions.OnlyOnFaulted);
           任务.Start();
           Console.ReadLine();
       }
   
       静态 int 测试()
       {
           抛出新的异常（）；
       }
   
       静态无效异常处理程序（任务任务）
       {
           var 异常 = 任务.Exception;
           Console.WriteLine(异常);
       }
   }
   

2. 在同一方法中： // 在调用者线程中处理异常强>线程

   类程序
   {
       静态无效主（字符串[]参数）
       {
           任务任务=新任务（测试）；
           任务.Start();
   
           尝试
           {
               任务.Wait();
           }
           catch（聚合异常前）
           {
               Console.WriteLine(ex);    
           }
   
           Console.ReadLine();
       }
   
       静态 int 测试()
       {
           抛出新的异常（）；
       }
   }
   

请注意，您得到的异常是 AggregateException。所有真正的异常都可以通过 ex.InnerExceptions 属性获得。

在.NET 3.5中，您可以使用以下代码：

1. //您在子线程中处理异常

   类程序
   {
       静态无效主（字符串[]参数）
       {
           异常异常=空；
           Thread 线程 = new Thread(() => SafeExecute(() => Test(0, 0), Handler));
           线程.Start();            
   
           Console.ReadLine();
       }
   
       private static void Handler(Exception异常)
       {        
           Console.WriteLine(异常);
       }
   
       private static void SafeExecute（操作测试，操作<异常>处理程序）
       {
           尝试
           {
               测试.Invoke();
           }
           catch（异常前）
           {
               处理程序（前）；
           }
       }
   
       静态无效测试（int a，int b）
       {
           抛出新的异常（）；
       }
   }
   

2. 或者 // 您在调用者线程中处理异常

   类程序
   {
       静态无效主（字符串[]参数）
       {
           异常异常=空；
           Thread thread = new Thread(() => SafeExecute(() => Test(0, 0), out 异常));
   
           线程.Start();            
   
           线程.Join();
   
           Console.WriteLine(异常);    
   
           Console.ReadLine();
       }
   
       private static void SafeExecute(Action 测试，out Exception 异常)
       {
           异常=空；
   
           尝试
           {
               测试.Invoke();
           }
           catch（异常前）
           {
               例外=前；
           }
       }
   
       静态无效测试（int a，int b）
       {
           抛出新的异常（）；
       }
   }
   

Answer 2

您无法捕获 Method1 中的异常。但是，您可以捕获 Method2 中的异常并将其记录到原始执行线程可以读取和使用的变量中。

Answer 3

我有一个特殊的问题，因为我想使用集成测试套件中包含控件的项目，因此必须创建一个 STA 线程。我最终得到的代码如下，放在这里以防其他人遇到同样的问题。

    public Boolean? Dance(String name) {

        // Already on an STA thread, so just go for it
        if (Thread.CurrentThread.GetApartmentState() == ApartmentState.STA) return DanceSTA(name);

        // Local variable to hold the caught exception until the caller can rethrow
        Exception lException = null;

        Boolean? lResult = null;

        // A gate to hold the calling thread until the called thread is done
        var lGate = new ManualResetEvent(false);

        var lThreadStart = new ThreadStart(() => {
            try {
                lResult = DanceSTA(name);
            } catch (Exception ex) {
                lException = ex;
            }
            lGate.Set();
        });

        var lThread = new Thread(lThreadStart);
        lThread.SetApartmentState(ApartmentState.STA);
        lThread.Start();

        lGate.WaitOne();

        if (lException != null) throw lException;

        return lResult;
    }

    public Boolean? DanceSTA(String name) { ... }

这是直接粘贴代码。对于其他用途，我建议提供一个操作或函数作为参数，并在线程上调用它，而不是对被调用的方法进行硬编码。

Answer 4

在不同线程之间共享数据的最简单方法是共享数据，如下所示（有些是伪代码）：

class MyThread
{
   public string SharedData;

   public void Worker()
   {
      ...lengthy action, infinite loop, etc...
      SharedData = "whatever";
      ...lengthy action...
      return;
   }
}

class Program
{
   static void Main()
   {
      MyThread m = new MyThread();
      Thread WorkerThread = new Thread(m.Worker);
      WorkerThread.Start();

      loop//or e.g. a Timer thread
      {
         f(m.SharedData);
      }
      return;
   }
}

您可以在 关于多线程的精彩介绍，但是，我更喜欢在 O'Reilly 的书《C# 3.0》中阅读有关此内容的内容简而言之，作者是 Albahari 兄弟（2007 年），它也可以在 Google 图书上免费访问，就像这本书的新版本一样，因为它还涵盖了线程池、前台线程与后台线程等内容，并且具有良好的和简单的示例代码。 （免责声明：我拥有这本书的一本破旧副本）

如果您正在制作 WinForms 应用程序，则使用共享数据特别方便，因为 WinForm 控件不是线程安全的。使用回调将数据从工作线程传递回 WinForm 控件，主 UI 线程需要带有 Invoke() 的丑陋代码才能使该控件线程安全。使用共享数据和单线程 System.Windows.Forms.Timer（例如 0.2 秒的短 Interval），您可以轻松地从工作线程发送信息到没有 Invoke 的控件。

Answer 5

这是我用来将异常抛出回主线程以进行捕获的代码。

class Program
{
    static void Main(string[] args)
    {
        CancellationTokenSource cancelToken = new CancellationTokenSource();
        Exception taskException = null;

        var timerTask = Task.Factory.StartNew(() =>
        {
            for (;;)
            {
                if (cancelToken.IsCancellationRequested)
                    break;

                ContinuousTask();

                Thread.Sleep(400);

            }
        }, cancelToken.Token).ContinueWith((t, o) => {
            taskException = t.Exception;
            ((Thread)o).Interrupt();
        }, Thread.CurrentThread, TaskContinuationOptions.OnlyOnFaulted);

        try
        {
            
            //do a bunch of tasks here

            //want to skip the do while and go to the catch if exception is thrown
            do
            {
                System.Threading.Thread.Sleep(200);
            } while (true);

        }
        catch
        {
            if (taskException != null)
                Console.WriteLine(taskException.Message);
        }
        
    }

    private static int _loopCounter = 0;
    public static void ContinuousTask()
    {
        int counter = 0;

        do
        {

            if (_loopCounter >= 3)
                throw new Exception("error");

            if (counter >= 5)
                break;

            counter += 1;
            System.Threading.Thread.Sleep(100);

        } while (true);

        _loopCounter += 1;
    }

}