C# ”；用户代码未处理的异常“；使用Parallel.Invoke时

我这里有个例外：

用户代码未处理MyException

事实上我已经试过了，但是

问题是什么？如何解决？我想要实现的是让异常被并行的try-catch所捕获。现在，它不知道try-catch，并提示我用户代码未处理异常。注意，我需要使用

TestParallel1

方法来抛出异常，因为这是我的程序的简化格式。如果出现异常，我希望立即停止所有其他线程。此外，我希望异常在并行之外传播

namespace WindowsFormsApplication1
{
    static class Program
    {

        public static void Main()
        {
            try
            {
                List<Action> act = new List<Action>
                      {
                         ()=>TestParallel1(),
                         () => TestParallel1()
                      };

                Parallel.Invoke(act.ToArray());
            }
            catch (AggregateException ae)
            {
                foreach (var e in ae.InnerExceptions)  // note the 's' in InnerExceptions
                {
                    //do something with 'e'
                }
                //do something
            }
        }

        public class MyException : Exception
        {
        }

        public static void TestParallel1()
        {
            throw new MyException();
        }
    }
}

命名空间窗口窗体应用程序1
{
静态类程序
{
公共静态void Main（）
{
尝试
{
List act=新列表
{
（）=>TestParallel1（），
（）=>TestParallel1（）
};
Parallel.Invoke（act.ToArray（））；
}
捕获（聚合异常ae）
{
foreach（ae.InnerExceptions中的var e）//注意InnerExceptions中的's'
{
//用“e”做点什么
}
//做点什么
}
}
公共类MyException:异常
{
}
公共静态void TestParallel1（）
{
抛出新的MyException（）；
}
}
}

并行成员将始终引发聚合异常。你抓错类型了

您需要的更改：

//catch(MyException e)
catch (AggregateException ae)
{       

   foreach (var e in ae.InnerExceptions)  // note the 's' in InnerExceptions
   {
        //do something with 'e'
   }
}

---

要捕获此异常并仍然使用Parallel，可以执行以下操作：

        List<Action> act = new List<Action> { () => TestParallel1(), 
                                              () => TestParallel1() };

        Parallel.ForEach(act, a =>{
            try
            {
                a.Invoke();
            }
            catch (MyException ae)
            {
                //do something
            }
        });

首先列出（来自斯科特·张伯伦）

List act=newlist{（）=>TestParallel1（），
（）=>TestParallel1（）}；
平行。ForEach（行为，（a，状态）=>
{
尝试
{
a、 调用（）；
}
捕获（MyException ae）
{
state.Stop（）；
}
});
您在调试器中获得“未处理的用户代码”，因为您已启用“仅我的代码””设置（从技术上讲，原始异常不是由您的代码处理的，而是由框架的代码处理的）

关闭“仅我的代码”，您将获得不同的体验

注意，这只是调试经验——对常规程序流没有任何影响

请参阅：
谢谢，但这没有帮助，编辑我的问题，相同的异常未处理问题仍然存在。像这样堆叠处理程序将不起作用，但您不应该以这种方式获得“未处理的”。@HenkHolterman我用您的注释再次编辑了代码，它仍然无法工作仔细测试并详细描述发生的情况。这不应产生未处理的异常错误。在不调试的情况下运行以避免混淆。在不使用调试器的情况下运行它（Ctrl+F5），或单击“继续”（F5）几次。您将进入foreach循环。问题正在转移。当您需要停止所有其他线程时，那么
Parallel.Invoke（）
就不是合适的工具。而且立即不在菜单上。谢谢，事实上我已经尝试过了，但是我想要实现的是一个异常，它会立即停止所有其他线程，使用此方法只会停止一个线程。此外，我希望异常在并行之外传播。哦，好的，我会看看在这种情况下我能做些什么：）@william007查看我的编辑也许这就是你要找的
public partial class MainWindow : Window
{
    List<MyThread> threads = new List<MyThread>();

    public MainWindow()
    {
        var thread1 = new MyThread();
        thread1.A = () => TestParallel1();
        thread1.RaisError += RaisError;

        var thread2 = new MyThread();
        thread2.A = () => TestParallel1();


        threads.Add(thread1);
        threads.Add(thread2);

        Parallel.ForEach(threads, t => { t.Start(); });
    }

    public void RaisError()
    {
        Parallel.ForEach(threads, t => { t.Stop(); });
    }

    public static void TestParallel1()
    {
        throw new MyException();
    }
}

public class MyException:Exception{}


public class MyThread
{
    public Action A { get; set; }
    public delegate void Raiser();
    public event Raiser RaisError;

    public void Start()
    {
        try
        {
            A.Invoke();
        }
        catch (MyException me)
        {
            RaisError();
        }
    }

    public void Stop()
    {
        // do some stop
    }
}

        List<Action> act = new List<Action> { () => TestParallel1(), 
                                          () => TestParallel1() };

        Parallel.ForEach(act, (a, state) =>
        {
            try
            {
                a.Invoke();
            }
            catch (MyException ae)
            {
                state.Stop();
            }
        });