等待自定义函数

Question

我正在尝试了解 C# 中的新异步功能，到目前为止，我注意到的最奇怪的事情是，异步功能的每个示例都有一个等待 另一个异步的函数框架中定义的函数，但都没有自定义代码。

例如，我想要从文本文件中的每一行创建一个对象，但是是异步的，这样 UI 线程就不会冻结：

async Task Read()
{
    string[] subjectStrings = File.ReadAllLines(filePath);
    for (int i = 0; i < subjectStrings.Length; i++)
    {
        Task<Subject> function = new Task<Subject>(code => new Subject((string)code), subjectStrings[i]);
        try
        {
            Subject subject = await function;
            subjects.Add(subject);
        }
        catch (Exception ex)
        {
            debugWriter.Write("Error in subject " + subjectStrings[i]);
            continue;
        }
    }
}

如你所见，我定义了一个任务，它根据文本文件中的一行创建一个新的Subject 对象，然后等待这个任务。如果我这样做，调试器会到达await 行，然后停止。据我所知，没有更多代码运行。

如果我使用旧的异步功能，我只需使用 Task.ContinueWith() 并添加一个回调 lambda，将主题添加到列表中，然后就可以了。

所以我的问题是：

1. 为什么这段代码不起作用？您应该如何创建一个不使用任何异步方法本身的自定义异步方法？
2. 您应该如何使用异步方法？你不能使用await，除非你在一个异步函数中，而且你不应该在没有等待的情况下调用异步方法，那么你如何首先从同步方法中调用该方法？

Answer 1

你没有开始任务 - 所以它永远不会完成。

使用Task.Run 而不是new Task，它将为您创建并开始任务。

请注意，您仍在同步读取文件，这并不理想...如果您的 Subject 构造函数真的需要很长时间才能完成，我会质疑它是否应该做一个构造函数。

Answer 2

为什么这段代码不起作用？您应该如何制作一个不使用任何异步方法本身的自定义异步方法？

使用await Task.Run 或await Task.Factory.StartNew 创建并运行任务。调用new Task 将创建一个尚未开始的任务。在大多数情况下，这是不必要的，但您可以在以这种方式创建的任务上调用 Start。

你应该如何使用异步方法？除非在异步函数中，否则不能使用 await，并且不应该在没有 await 的情况下调用异步方法，那么如何首先从同步方法中调用该方法？

适当的“根”异步调用取决于应用程序的类型：

• 在控制台应用程序中：Wait 返回 Task。

• 在 GUI 应用程序中：使用 async void 事件处理程序。

• 在 ASP.NET MVC 中：控制器可以返回 Task。

Answer 3

您应该如何创建一个不使用任何异步方法本身的自定义异步方法？

你没有。如果该方法没有异步工作要做，它应该是同步的；它不应该是async。

在核心，所有async 方法都归结为两种方法之一。它们要么通过Task.Run 之类的方式将工作排队到线程池（不推荐用于库代码），要么通过TaskCompletionSource<T> 或Task.Factory.FromAsync 之类的快捷方式执行真正的异步工作。

你应该如何使用异步方法？除非您在异步函数中，否则您不能使用 await，并且您不应该在没有 await 的情况下调用异步方法，那么您如何首先从同步方法中调用该方法？

你没有。理想情况下，您应该一直是async。控制台应用程序是此规则的一个例外；他们必须拥有一个同步的Main。但是对于 WinForms、WPF、Silverlight、Windows Store、ASP.NET MVC、WebAPI、SignalR、iOS、Android 和 Windows Phone 应用程序以及单元测试，您应该一直使用异步。

您可以通过await 和Task.WhenAll 和Task.WhenAny 等组合符使用async 方法。这是使用async 方法的最常见方式，但不是唯一的；例如，您可以调用 async 方法并将其作为 IObservable<T> 使用。

Answer 4

您混淆了等待和工作。等待使用async/await，工作没有。这仍然意味着您可以await 一个 CPU 密集型任务，但您必须手动运行它，例如：

var result = await Task.Run(YourLongOperation);

帮助我从直觉上理解这一点的一个区别是，等待是合作的 - 我自愿放弃我的 CPU 时间份额，因为我实际上并不需要它。另一方面，工作必须并行运行。

在正常情况下，仅使用固有异步async/awaits，不必多于您开始使用的单个线程。将受 CPU 限制的操作与受 I/O 限制的操作结合通常是个坏主意（受 CPU 限制的操作会阻塞，除非您明确地并行运行任务）。

Answer 5

我不会对 Yet Another Technical Explanation™ 感到厌烦，而是让我根据您的代码示例向您展示一个实际示例。

从在调用线程上完成所有工作的同步版本开始。

class SubjectFactory
{
    public IEnumerable<Subject> Read(string filePath)
    {
        string[] subjectStrings = File.ReadAllLines(filePath);

        return Parse(subjectStrings);
    }

    private IEnumerable<Subject> Parse(IEnumerable<string> subjects)
    {
        string code = "XYZ";

        foreach ( var subject in subjects )
        {
            yield return new Subject(code, subject);
        }
    }
}

假设Subject中的构造函数是轻量级的，那么最大的瓶颈就是File.ReadAllLines。为什么？因为磁盘 I/O 本身就很慢。

那么你如何将它包装在一个任务中呢？

如果框架有 File.ReadAllLinesAsync() 方法，您可以等待它并完成它。

public async Task<IEnumerable<Subject>> ReadAsync(string filePath)
{ // Doesn't exist!
    string[] subjectStrings = await File.ReadAllLinesAsync(filePath);

    return this.Parse(subjectStrings);
}

不幸的是，生活是艰难的，并行编程也是如此。看起来你必须重新发明轮子。

private async Task<string[]> ReadAllLinesAsync(string filePath)
{
    ArrayList allLines = new ArrayList();

    using ( var streamReader = new StreamReader(File.OpenRead(filePath)) )
    {
        string line = await streamReader.ReadLineAsync();

        allLines.Add(line);
    }

    return (string[]) allLines.ToArray(typeof(string));
}

现在您可以像以前一样做同样的事情，但使用您的自定义方法ReadAllLinesAsync()。

public async Task<IEnumerable<Subject>> ReadAsync(string filePath)
{
    // call with 'this' instead of 'File'
    string[] subjectStrings = await this.ReadAllLinesAsync(filePath);

    return Parse(subjectStrings);
}

一切就绪后，在您的 WPF 应用程序中，您要做的就是：

var filePath             = @"X:\subjects\";
var subjectFactory       = new SubjectFactory();
var subjectsCollection   = await subjectFactory.ReadAsync(filePath);
var observableCollection = new ObservableCollection<Subject>(subjectsCollection);