Async/Await使用困惑：文件处理UI冻结及跨线程更新问题

问题背景 #

我了解过一些async/await相关内容，但始终搞不懂它的工作原理。我的需求很简单：点击按钮打开文件选择器，选中文件后逐行读取并做数据处理。文件加载很快，但处理耗时久，我想加个进度条，同时保证UI不冻结。

我试着到处加async或await，但都没用，想知道正确的实现方式。

初始代码 #

private async void BtnLoadFile_Clicked(object sender, EventArgs e)
{
    var result = await FilePicker.Default.PickAsync();
    if (result != null)
    {
        // 读取流 - 这一步很快
        Stream s = await result.OpenReadAsync();

        // 处理文件 - 需要在另一个线程执行
        DoLenghtyStuff(s);
    }
}

private void DoLenghtyStuff(Stream s)
{
    // 这里做耗时操作，同时更新进度条UI
}

第一次修改后的尝试 #

我查了相关资料后修改了代码：

private async void BtnLoadFile_Clicked(object sender, EventArgs e)
{
    var result = await FilePicker.Default.PickAsync();
    if (result != null)
    {
        // 读取流 - 这一步很快
        Stream s = await result.OpenReadAsync();

        // 处理文件 - 需要在另一个线程执行
        await DoLenghtyStuff(s);
    }
}

private async Task<int> DoLenghtyStuff(Stream s)
{
    // 这里做耗时操作
    await Task.Delay(1); // 1秒延迟

    return 1;
}

但问题依旧：UI还是会冻结，而且用await Task.Delay(1)显然不是正确的做法。

更新后的问题 #

我用Task.Run()后出现错误："Only the original thread that created a view hierarchy can touch its views"，发现更新Label.Text时程序崩溃，但更新ProgressBar却正常。最新代码如下：

private async void BtnLoadFile_Clicked(object sender, EventArgs e)
{
    var result = await FilePicker.Default.PickAsync();
    if (result != null)
    {
        invalidLines = new List<string>();
        chatList = new List<ChatLine>();

        // 处理文件相关操作
        Stream s = await result.OpenReadAsync();

        // 处理文件
        await Task.Run(() => { FileHandler(s); });
    }
    else
    {
        // 显示日志
        frmLogs.IsVisible = true;
        frmLogs.BackgroundColor = Color.FromArgb("b47d7d");
        lblLogs.Text = $"用户已取消操作";
    }
}

private void FileHandler(Stream s)
{
    int realLines = 0;
    int keptLines = 0;
    int totalLines = 0;


    //using (StreamReader sr = new StreamReader(s, Encoding.GetEncoding("iso-8859-1")))
    using StreamReader sr = new(s, Encoding.GetEncoding("UTF-8"));

    // 统计总行数
    while ((sr.ReadLine()) != null)
        totalLines++;

    // 重置流位置
    s.Position = 0;
    sr.DiscardBufferedData();        // 现在阅读器从位置0开始读取

    string currentLine;

    // 跳过第一行
    currentLine = sr.ReadLine();
    realLines++;

    while ((currentLine = sr.ReadLine()) != null)
    {
        realLines++;

        // 更新进度条
        prgBarLines.Progress = ((double)realLines / totalLines);
        lblProgress.Text = $"{Math.Round((double)realLines / totalLines * 100)}%"; // <= 这里会崩溃

        // 耗时的数据处理：正则校验等...
    }
}

核心问题分析 #

1. UI线程限制：所有UI控件的更新必须在创建它们的**主线程（UI线程）**上执行，Task.Run()会把代码放到后台线程，直接在后台线程更新Label.Text就会触发跨线程操作错误。部分控件（比如某些平台的ProgressBar）可能有特殊处理允许后台更新，但这不是通用行为，不能依赖。
2. async/await的正确用法：单纯给方法加async和await但没有真正把耗时操作放到后台线程，UI还是会被阻塞。Task.Delay(1)只是挂起当前线程，并没有把实际耗时任务移到后台。

正确实现步骤 #

1. 使用IProgress<T>传递进度更新 #

通过IProgress<T>接口可以安全地将后台线程的进度数据传递到UI线程，它会自动在UI线程触发更新回调。

2. 把耗时操作完全放在后台线程 #

用Task.Run()包裹所有CPU密集型或耗时的文件处理逻辑，避免阻塞UI线程。

3. 仅在UI线程更新控件 #

通过IProgress<T>的回调方法来更新所有UI控件，确保操作在主线程执行。

修改后的完整代码 #

// 定义进度数据类，用来传递进度信息
public class ProgressInfo
{
    public double ProgressValue { get; set; }
    public string ProgressText { get; set; }
}

private async void BtnLoadFile_Clicked(object sender, EventArgs e)
{
    var result = await FilePicker.Default.PickAsync();
    if (result != null)
    {
        invalidLines = new List<string>();
        chatList = new List<ChatLine>();

        Stream s = await result.OpenReadAsync();

        // 创建Progress实例，指定UI线程的更新回调
        var progress = new Progress<ProgressInfo>(UpdateProgressUI);

        // 在后台线程执行耗时操作，并传入进度对象
        await Task.Run(() => FileHandler(s, progress));
    }
    else
    {
        frmLogs.IsVisible = true;
        frmLogs.BackgroundColor = Color.FromArgb("b47d7d");
        lblLogs.Text = $"用户已取消操作";
    }
}

private void FileHandler(Stream s, IProgress<ProgressInfo> progress)
{
    int realLines = 0;
    int totalLines = 0;

    using StreamReader sr = new(s, Encoding.GetEncoding("UTF-8"));

    // 统计总行数
    while (sr.ReadLine() != null)
        totalLines++;

    // 重置流位置
    s.Position = 0;
    sr.DiscardBufferedData();

    // 跳过第一行
    sr.ReadLine();
    realLines++;

    string currentLine;
    while ((currentLine = sr.ReadLine()) != null)
    {
        realLines++;

        // 计算进度值
        double progressValue = (double)realLines / totalLines;
        string progressText = $"{Math.Round(progressValue * 100)}%";

        // 通过Progress对象发送进度更新，自动在UI线程执行回调
        progress.Report(new ProgressInfo
        {
            ProgressValue = progressValue,
            ProgressText = progressText
        });

        // 耗时的数据处理：正则校验等...
    }
}

// 专门的UI更新方法，运行在主线程
private void UpdateProgressUI(ProgressInfo info)
{
    prgBarLines.Progress = info.ProgressValue;
    lblProgress.Text = info.ProgressText;
}

关键说明 #

• IProgress<T>的作用：它封装了SynchronizationContext，会自动捕获当前UI线程的上下文，确保Report方法触发的回调在UI线程执行，避免跨线程错误。
• Task.Run()的正确使用：把所有耗时的文件读取、数据处理逻辑都放到Task.Run()中，保证UI线程不被阻塞。
• 分离UI逻辑和业务逻辑：把文件处理的业务逻辑和UI更新逻辑分开，代码更清晰，也符合模块化设计思想。

内容的提问来源于stack exchange，提问作者Beb