C# 任务。等待导致GUI线程长时间暂停

我有以下代码：

        public async Task<string> Solve(List<List<Node>> nodeList)
    {
        List<Task> taskList = new List<Task>();

        for (int i = 0; i < nodeList.Count(); i++)
        {
            int taskNo = i;
            Task<List<Node>> task = Task.Factory.StartNew((x) =>
            {
                List<Node> nodes = new List<Node>(nodeList[i]);
                Calculate(nodes);
                return nodes;
            }, taskNo);

            task.Wait();
            taskList.Add(task);

        }

        Task<string> r = BuildReport(taskList);

        return r;
    }

公共异步任务求解（列表节点列表）
{
List taskList=新列表（）；
对于（int i=0；i
{
列表节点=新列表（节点列表[i]）；
计算（节点）；
返回节点；
}，taskNo）；
task.Wait（）；
任务列表。添加（任务）；
}
任务r=构建报告（任务列表）；
返回r；
}

我的UI线程上的另一个方法正在调用此方法。 此方法导致我的UI线程暂停，并使窗口在20-50秒内无响应。我有一种感觉，这项任务是由等待引起的。我如何修改此方法以避免发生这种情况。如果我没有任务。请稍候，任务列表中没有正确的任务

---

谢谢。

不要等待您的任务。使用

wait Task.WhenAll（任务列表）您的代码与此类似：

public async Task<string> Solve(List<List<Node>> nodeList)
{
    List<Task> taskList = new List<Task>();

    for (int i = 0; i < nodeList.Count(); i++)
    {
        int taskNo = i;
        Task<List<Node>> task = Task.Factory.StartNew((x) =>
        {
            List<Node> nodes = new List<Node>(nodeList[taskNo]); //replace i with taskNo
            Calculate(nodes);
            return nodes;
        }, taskNo);

        // remove Wait
        taskList.Add(task);

    }

    await Task.WhenAll(taskList); //Add this line
    Task<string> r = BuildReport(taskList);

    return r;
}

公共异步任务求解（列表节点列表）
{
List taskList=新列表（）；
对于（int i=0；i
{
列表节点=新列表（nodeList[taskNo]）；//用taskNo替换i
计算（节点）；
返回节点；
}，taskNo）；
//移除等待
任务列表。添加（任务）；
}
wait Task.WhenAll（任务列表）；//添加此行
任务r=构建报告（任务列表）；
返回r；
}

在当前代码中，创建一个任务，然后等待它完成。这与按顺序运行代码没有多大区别。使用
Task.whalll
这里有两个优点。a） 您的任务将并行运行b）由于我们正在等待，您的UI将不会被阻止。
不要
等待
您的任务。使用
wait Task.WhenAll（任务列表）您的代码与此类似：

public async Task<string> Solve(List<List<Node>> nodeList)
{
    List<Task> taskList = new List<Task>();

    for (int i = 0; i < nodeList.Count(); i++)
    {
        int taskNo = i;
        Task<List<Node>> task = Task.Factory.StartNew((x) =>
        {
            List<Node> nodes = new List<Node>(nodeList[taskNo]); //replace i with taskNo
            Calculate(nodes);
            return nodes;
        }, taskNo);

        // remove Wait
        taskList.Add(task);

    }

    await Task.WhenAll(taskList); //Add this line
    Task<string> r = BuildReport(taskList);

    return r;
}

公共异步任务求解（列表节点列表）
{
List taskList=新列表（）；
对于（int i=0；i
{
列表节点=新列表（nodeList[taskNo]）；//用taskNo替换i
计算（节点）；
返回节点；
}，taskNo）；
//移除等待
任务列表。添加（任务）；
}
wait Task.WhenAll（任务列表）；//添加此行
任务r=构建报告（任务列表）；
返回r；
}

在当前代码中，创建一个任务，然后等待它完成。这与按顺序运行代码没有多大区别。使用
Task.whalll
这里有两个优点。a） 您的任务将并行运行b）由于我们正在等待，您的UI将不会被阻止。
不要
等待
您的任务。使用
wait Task.WhenAll（任务列表）您的代码与此类似：

public async Task<string> Solve(List<List<Node>> nodeList)
{
    List<Task> taskList = new List<Task>();

    for (int i = 0; i < nodeList.Count(); i++)
    {
        int taskNo = i;
        Task<List<Node>> task = Task.Factory.StartNew((x) =>
        {
            List<Node> nodes = new List<Node>(nodeList[taskNo]); //replace i with taskNo
            Calculate(nodes);
            return nodes;
        }, taskNo);

        // remove Wait
        taskList.Add(task);

    }

    await Task.WhenAll(taskList); //Add this line
    Task<string> r = BuildReport(taskList);

    return r;
}

公共异步任务求解（列表节点列表）
{
List taskList=新列表（）；
对于（int i=0；i
{
列表节点=新列表（nodeList[taskNo]）；//用taskNo替换i
计算（节点）；
返回节点；
}，taskNo）；
//移除等待
任务列表。添加（任务）；
}
wait Task.WhenAll（任务列表）；//添加此行
任务r=构建报告（任务列表）；
返回r；
}

在当前代码中，创建一个任务，然后等待它完成。这与按顺序运行代码没有多大区别。使用
Task.whalll
这里有两个优点。a） 您的任务将并行运行b）由于我们正在等待，您的UI将不会被阻止。
不要
等待
您的任务。使用
wait Task.WhenAll（任务列表）您的代码与此类似：

public async Task<string> Solve(List<List<Node>> nodeList)
{
    List<Task> taskList = new List<Task>();

    for (int i = 0; i < nodeList.Count(); i++)
    {
        int taskNo = i;
        Task<List<Node>> task = Task.Factory.StartNew((x) =>
        {
            List<Node> nodes = new List<Node>(nodeList[taskNo]); //replace i with taskNo
            Calculate(nodes);
            return nodes;
        }, taskNo);

        // remove Wait
        taskList.Add(task);

    }

    await Task.WhenAll(taskList); //Add this line
    Task<string> r = BuildReport(taskList);

    return r;
}

公共异步任务求解（列表节点列表）
{
List taskList=新列表（）；
对于（int i=0；i
{
列表节点=新列表（nodeList[taskNo]）；//用taskNo替换i
计算（节点）；
返回节点；
}，taskNo）；
//移除等待
任务列表。添加（任务）；
}
wait Task.WhenAll（任务列表）；//添加此行
任务r=构建报告（任务列表）；
返回r；
}

在当前代码中，创建一个任务，然后等待它完成。这与按顺序运行代码没有多大区别。使用
Task.whalll
这里有两个优点。a） 您的任务将并行运行b）因为我们正在等待它，您的UI不会被阻止。
可能会从UI线程以外的其他线程调用您的任务？您是否正在等待调用方发出此消息？请添加“解决”任务的调用代码可能会从UI线程以外的其他线程调用您的任务？您是否正在等待调用方发出此消息？请添加“解决”任务的调用代码task可能从UI线程以外的另一个线程调用您的任务？您是否
等待
调用方发出此消息？请为“解决”任务添加调用代码可能从UI线程以外的另一个线程调用您的任务？您是否
等待
从调用方发出此消息？请为“解决”任务添加调用代码啊，我太接近了。成功了。用户界面仍然有点粗糙…但我想我可以接受。谢谢你的帮助！另外，使用
async-.wait
使用
Task.Run
而不是
Task.Factory.StartNew
：啊，我差一点就到了。成功了。用户界面仍然有点粗糙…但我想我可以接受。谢谢你的帮助！另外，使用
async-.wait
使用
Task.Run
而不是
Task.Factory.StartNew
：啊，我差一点就到了。成功了。用户界面仍然有点粗糙…但我想我可以活下去