WPF DataGrid异步格式化单元格遇绑定失效问题求解决方案

针对你遇到的异步格式化结果无法更新到TextBlock的问题，核心原因是之前的Tag存储+Loaded事件的方式没有利用好WPF的绑定更新机制，且初始绑定的触发时机不对。下面提供两种更可靠的实现方案：

方案一：使用附加属性（推荐，无需自定义控件） #

通过自定义附加属性来管理异步格式化逻辑，利用WPF的DataContext变化和依赖属性绑定机制，确保格式化结果能正确更新到TextBlock。

1. 实现AsyncFormatter类（包含异步逻辑和通知） #

确保类实现INotifyPropertyChanged，并包装异步任务的结果：

using System.ComponentModel;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;

public class AsyncFormatter : INotifyPropertyChanged
{
    private INotifyTask<string> _formattedResult;
    public INotifyTask<string> FormattedResult
    {
        get => _formattedResult;
        private set
        {
            _formattedResult = value;
            OnPropertyChanged();
        }
    }

    private readonly Func<object, Task<string>> _formatLogic;

    public AsyncFormatter(Func<object, Task<string>> formatLogic)
    {
        _formatLogic = formatLogic;
    }

    public void FormatData(object data)
    {
        if (data == null) return;
        // 启动异步任务并包装为可通知的任务对象
        FormattedResult = NotifyTask.Create(_formatLogic(data));
    }

    public event PropertyChangedEventHandler PropertyChanged;
    protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

注：NotifyTask可使用Stephen Cleary的Nito.AsyncEx库实现，或自行封装一个监听Task完成并触发PropertyChanged的类

2. 定义附加属性类 #

创建附加属性来关联TextBlock和AsyncFormatter，并处理DataContext变化触发格式化：

using System.Windows;
using System.Windows.Controls;

public static class AsyncFormatterManager
{
    public static readonly DependencyProperty FormatterProperty =
        DependencyProperty.RegisterAttached(
            "Formatter",
            typeof(AsyncFormatter),
            typeof(AsyncFormatterManager),
            new PropertyMetadata(null, OnFormatterAssigned));

    public static void SetFormatter(DependencyObject element, AsyncFormatter value)
        => element.SetValue(FormatterProperty, value);

    public static AsyncFormatter GetFormatter(DependencyObject element)
        => (AsyncFormatter)element.GetValue(FormatterProperty);

    private static void OnFormatterAssigned(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        if (d is not TextBlock textBlock || e.NewValue is not AsyncFormatter formatter) return;

        // 绑定Text到异步任务的结果，确保单向更新
        var textBinding = new Binding($"{nameof(AsyncFormatter.FormattedResult)}.{nameof(INotifyTask<string>.Result)}")
        {
            Source = formatter,
            Mode = BindingMode.OneWay,
            FallbackValue = "加载中..."
        };
        textBlock.SetBinding(TextBlock.TextProperty, textBinding);

        // 当单元格DataContext变化时，触发格式化
        textBlock.DataContextChanged += (s, args) => formatter.FormatData(args.NewValue);
    }
}

3. 在AutoGeneratingColumn中配置列 #

根据不同列的数据类型，指定对应的异步格式化逻辑，并将附加属性应用到单元格样式：

private void DataGrid_AutoGeneratingColumn(object sender, DataGridAutoGeneratingColumnEventArgs e)
{
    if (e.Column is not DataGridTextColumn textColumn) return;

    // 根据列的绑定路径或数据类型，自定义格式化逻辑
    Func<object, Task<string>> formatFunc = async data =>
    {
        // 模拟耗时操作：比如解析复杂对象、远程获取附加信息等
        await Task.Delay(800);
        var rawValue = data?.ToString() ?? string.Empty;
        return $"[{DateTime.Now:HH:mm:ss}] {rawValue}";
    };

    // 创建单元格样式，设置附加属性
    var cellStyle = new Style(typeof(TextBlock));
    cellStyle.Setters.Add(new Setter(AsyncFormatterManager.FormatterProperty, new AsyncFormatter(formatFunc)));

    textColumn.ElementStyle = cellStyle;
}

方案二：自定义AsyncTextBlock控件 #

如果需要更高度封装的逻辑，可以自定义一个继承自TextBlock的控件，内部处理异步格式化：

public class AsyncTextBlock : TextBlock
{
    public static readonly DependencyProperty FormatFuncProperty =
        DependencyProperty.Register(nameof(FormatFunc), typeof(Func<object, Task<string>>), typeof(AsyncTextBlock));

    public Func<object, Task<string>> FormatFunc
    {
        get => (Func<object, Task<string>>)GetValue(FormatFuncProperty);
        set => SetValue(FormatFuncProperty, value);
    }

    protected override void OnDataContextChanged(DependencyPropertyChangedEventArgs e)
    {
        base.OnDataContextChanged(e);
        if (FormatFunc == null || e.NewValue == null) return;

        // 启动异步格式化并更新Text
        _ = ExecuteFormatAsync(e.NewValue);
    }

    private async Task ExecuteFormatAsync(object data)
    {
        Text = "加载中...";
        var result = await FormatFunc(data);
        Text = result;
    }
}

使用时在AutoGeneratingColumn中直接指定列的ElementStyle为AsyncTextBlock，并绑定FormatFunc：

private void DataGrid_AutoGeneratingColumn(object sender, DataGridAutoGeneratingColumnEventArgs e)
{
    if (e.Column is DataGridTextColumn textColumn)
    {
        Func<object, Task<string>> formatFunc = async data =>
        {
            await Task.Delay(500);
            return data?.ToString() + " [自定义控件格式化]";
        };

        var style = new Style(typeof(AsyncTextBlock));
        style.Setters.Add(new Setter(AsyncTextBlock.FormatFuncProperty, formatFunc));

        textColumn.ElementStyle = style;
        textColumn.CellTemplate = new DataTemplate(typeof(AsyncTextBlock));
    }
}

方案优势说明 #

• 附加属性方案完全贴合WPF的绑定机制，自动处理DataContext变化和属性更新，不会出现初始值覆盖问题
• 自定义控件方案封装性更强，适合复用场景
• 两种方案都避免了IConverter的同步限制，天然支持异步耗时操作

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