C# 如何并行管理异常。调用？_C#_Multithreading

C# 如何并行管理异常。调用？

c# multithreading

C# 如何并行管理异常。调用？,c#,multithreading,C#,Multithreading,我有以下情况： foreach(var item in collection) { DoWork().Wait; } 正如您所看到的，有一个foreach在集合上迭代，对于每个调用，我需要等待DoWork完成执行，然后foreach可以继续问题在于，在DoWork内部，我使用的是Parallel，我得到一个异常，即“冻结”程序，特别是没有显示任何异常，这是我的实现： public async Task DoWork() { Try { Parallel

我有以下情况：

foreach(var item in collection)
{
    DoWork().Wait;
}

正如您所看到的，有一个foreach在集合上迭代，对于每个调用，我需要等待

DoWork

完成执行，然后foreach可以继续

问题在于，在

DoWork

内部，我使用的是

Parallel

，我得到一个异常，即“冻结”程序，特别是没有显示任何异常，这是我的实现：

public async Task DoWork()
{
    Try
    {
        Parallel.Invoke(
               () => Foo(),
               () => Foo2(),
               () => Foo3());
    }
    catch(Exception e)
    {
       //No exception caught
    }
}

我在

Foo

方法中添加了

控制台。WriteLine

例如：

public void Foo()
{
    Console.WriteLine("foo 1");
}

在方法

Foo2

中生成了一个异常，但我看不出是哪个异常，因为我在

catch

上设置了一个断点，而这不会触发

我做错了什么

您的

DoWork（）

方法没有异步运行，因为它缺少任何调用等待

当我尝试您的代码的可编译版本时，我确实看到了异常

无论如何，如果要使

DoWork（）

正确异步，则需要使用

Task.Run（）

和

wait Task.WhenAll（）

，如下所示：

using System;
using System.Threading;
using System.Threading.Tasks;                                                    

namespace Demo
{
    class Program
    {
        public static async Task Main()
        {
            Console.WriteLine("Awaiting DoWork()");
            await DoWork();
            Console.WriteLine("Finished awaiting. Press <RETURN> to exit.");
            Console.ReadLine();
        }

        public static async Task DoWork()
        {
            try
            {
                await Task.WhenAll(
                    Task.Run(() => Foo()),
                    Task.Run(() => Foo2()),
                    Task.Run(() => Foo3())
                );
            }

            catch (Exception e)
            {
                Console.WriteLine("Caught exception: " + e.Message);
            }
        }

        public static void Foo()
        {
            Console.WriteLine("Starting Foo()");
            Thread.Sleep(1000);
            Console.WriteLine("Finishing Foo()");
        }

        public static void Foo2()
        {
            Console.WriteLine("Starting Foo2()");
            Thread.Sleep(500);
            Console.WriteLine("Foo2() is throwing an exception.");
            throw new InvalidOperationException("OOPS!");
        }

        public static void Foo3()
        {
            Console.WriteLine("Starting Foo3()");
            Thread.Sleep(250);
            Console.WriteLine("Finishing Foo3()");
        }
    }
}

使用系统；
使用系统线程；
使用System.Threading.Tasks；
名称空间演示
{
班级计划
{
公共静态异步任务Main（）
{
Console.WriteLine（“waiting DoWork（）”）；
等待嫁妆（）；
控制台。WriteLine（“完成等待。按退出”）；
Console.ReadLine（）；
}
公共静态异步任务DoWork（）
{
尝试
{
等待任务(
Task.Run（（）=>Foo（）），
Task.Run（（）=>Foo2（）），
Task.Run（（）=>Foo3（））
);
}
捕获（例外e）
{
Console.WriteLine（“捕获异常：+e.Message”）；
}
}
公共静态void Foo（）
{
WriteLine（“启动Foo（）”）；
睡眠（1000）；
Console.WriteLine（“Finishing Foo（）”）；
}
公共静态void Foo2（）
{
Console.WriteLine（“启动Foo2（）”）；
睡眠（500）；
WriteLine（“Foo2（）正在抛出异常。”）；
抛出新的InvalidOperationException（“OOPS！”）；
}
公共静态void Foo3（）
{
WriteLine（“启动Foo3（）”）；
睡眠（250）；
Console.WriteLine（“Finishing Foo3（）”）；
}
}
}

如果编译并运行该代码，您将看到以下消息：

waiting DoWork()
Starting Foo()
Starting Foo2()
Starting Foo3()
Finishing Foo3()
Foo2() is throwing an exception.
Finishing Foo()
Caught exception: OOPS!
Finished awaiting. Press <RETURN> to exit.

waiting DoWork（）
启动Foo（）
启动Foo2（）
启动Foo3（）
第3(3)
Foo2（）正在引发异常。
()
捕捉到异常：哎呀！
完成等待。按退出。

请记住，此答案仅适用于C#7.1或更新版本

您的

DoWork（）