如何将 WPF DataGrid 绑定到可变数量的列？答案

【问题标题】：How do I bind a WPF DataGrid to a variable number of columns?如何将 WPF DataGrid 绑定到可变数量的列？
【发布时间】：2015-11-07 09:30:28
【问题描述】：

我的 WPF 应用程序生成的数据集每次可能具有不同的列数。输出中包含对将用于应用格式设置的每一列的描述。输出的简化版本可能类似于：

class Data
{
    IList<ColumnDescription> ColumnDescriptions { get; set; }
    string[][] Rows { get; set; }
}

此类被设置为 WPF DataGrid 上的 DataContext，但我实际上以编程方式创建列：

for (int i = 0; i < data.ColumnDescriptions.Count; i++)
{
    dataGrid.Columns.Add(new DataGridTextColumn
    {
        Header = data.ColumnDescriptions[i].Name,
        Binding = new Binding(string.Format("[{0}]", i))
    });
}

有没有办法用 XAML 文件中的数据绑定替换这段代码？

【问题讨论】：

标签： c# wpf xaml data-binding datagrid

【解决方案1】：

您也许可以使用 AutoGenerateColumns 和 DataTemplate 来做到这一点。我不肯定它是否可以在没有大量工作的情况下工作，您将不得不玩弄它。老实说，如果您已经有了可行的解决方案，除非有很大的原因，否则我不会立即进行更改。 DataGrid 控件变得非常好，但它仍然需要一些工作（我还有很多学习要做）才能轻松完成这样的动态任务。

【讨论】：

我的原因是来自 ASP.Net，我不熟悉可以通过体面的数据绑定完成的工作，但我不确定它的限制在哪里。我会玩一下 AutoGenerateColumns，谢谢。

【解决方案2】：

我继续我的研究，并没有找到任何合理的方法来做到这一点。 DataGrid 上的 Columns 属性不是我可以绑定的，实际上它是只读的。

Bryan 建议可以使用 AutoGenerateColumns 来做一些事情，所以我看了一下。它使用简单的 .Net 反射来查看 ItemsSource 中对象的属性，并为每个对象生成一列。也许我可以动态生成一个类型，每个列都有一个属性，但这已经偏离了轨道。

由于这个问题很容易在代码中解决，我将坚持使用一个简单的扩展方法，每当数据上下文更新为新列时我都会调用：

public static void GenerateColumns(this DataGrid dataGrid, IEnumerable<ColumnSchema> columns)
{
    dataGrid.Columns.Clear();

    int index = 0;
    foreach (var column in columns)
    {
        dataGrid.Columns.Add(new DataGridTextColumn
        {
            Header = column.Name,
            Binding = new Binding(string.Format("[{0}]", index++))
        });
    }
}

// E.g. myGrid.GenerateColumns(schema);

【讨论】：

最高投票和接受的解决方案不是最好的！两年后的答案是：msmvps.com/blogs/deborahk/archive/2011/01/23/…
不，不会。无论如何都不是提供的链接，因为该解决方案的结果完全不同！
似乎 Mealek 的解决方案更加通用，并且在直接使用 C# 代码有问题的情况下很有用，例如在 ControlTemplates 中。
这里是链接：blogs.msmvps.com/deborahk/…

【解决方案3】：

您可以使用网格定义创建用户控件，并使用 xaml 中的不同列定义定义“子”控件。父级需要列的依赖属性和加载列的方法：

家长：

public ObservableCollection<DataGridColumn> gridColumns
{
  get
  {
    return (ObservableCollection<DataGridColumn>)GetValue(ColumnsProperty);
  }
  set
  {
    SetValue(ColumnsProperty, value);
  }
}
public static readonly DependencyProperty ColumnsProperty =
  DependencyProperty.Register("gridColumns",
  typeof(ObservableCollection<DataGridColumn>),
  typeof(parentControl),
  new PropertyMetadata(new ObservableCollection<DataGridColumn>()));

public void LoadGrid()
{
  if (gridColumns.Count > 0)
    myGrid.Columns.Clear();

  foreach (DataGridColumn c in gridColumns)
  {
    myGrid.Columns.Add(c);
  }
}

子 Xaml：

<local:parentControl x:Name="deGrid">           
  <local:parentControl.gridColumns>
    <toolkit:DataGridTextColumn Width="Auto" Header="1" Binding="{Binding Path=.}" />
    <toolkit:DataGridTextColumn Width="Auto" Header="2" Binding="{Binding Path=.}" />
  </local:parentControl.gridColumns>  
</local:parentControl>

最后，棘手的部分是找到调用“LoadGrid”的位置。
我正在为此苦苦挣扎，但通过在我的窗口构造函数中调用 InitalizeComponent 后得到了工作（childGrid 是 window.xaml 中的 x:name）：

childGrid.deGrid.LoadGrid();

Related blog entry

【讨论】：

【解决方案4】：

这是在 DataGrid 中绑定列的解决方法。由于 Columns 属性是只读的，就像每个人都注意到的那样，我创建了一个名为 BindableColumns 的附加属性，每次通过 CollectionChanged 事件更改集合时，它都会更新 DataGrid 中的列。

如果我们有这个 DataGridColumn 的集合

public ObservableCollection<DataGridColumn> ColumnCollection
{
    get;
    private set;
}

然后我们可以像这样将 BindableColumns 绑定到 ColumnCollection

<DataGrid Name="dataGrid"
          local:DataGridColumnsBehavior.BindableColumns="{Binding ColumnCollection}"
          AutoGenerateColumns="False"
          ...>

附加属性 BindableColumns

public class DataGridColumnsBehavior
{
    public static readonly DependencyProperty BindableColumnsProperty =
        DependencyProperty.RegisterAttached("BindableColumns",
                                            typeof(ObservableCollection<DataGridColumn>),
                                            typeof(DataGridColumnsBehavior),
                                            new UIPropertyMetadata(null, BindableColumnsPropertyChanged));
    private static void BindableColumnsPropertyChanged(DependencyObject source, DependencyPropertyChangedEventArgs e)
    {
        DataGrid dataGrid = source as DataGrid;
        ObservableCollection<DataGridColumn> columns = e.NewValue as ObservableCollection<DataGridColumn>;
        dataGrid.Columns.Clear();
        if (columns == null)
        {
            return;
        }
        foreach (DataGridColumn column in columns)
        {
            dataGrid.Columns.Add(column);
        }
        columns.CollectionChanged += (sender, e2) =>
        {
            NotifyCollectionChangedEventArgs ne = e2 as NotifyCollectionChangedEventArgs;
            if (ne.Action == NotifyCollectionChangedAction.Reset)
            {
                dataGrid.Columns.Clear();
                foreach (DataGridColumn column in ne.NewItems)
                {
                    dataGrid.Columns.Add(column);
                }
            }
            else if (ne.Action == NotifyCollectionChangedAction.Add)
            {
                foreach (DataGridColumn column in ne.NewItems)
                {
                    dataGrid.Columns.Add(column);
                }
            }
            else if (ne.Action == NotifyCollectionChangedAction.Move)
            {
                dataGrid.Columns.Move(ne.OldStartingIndex, ne.NewStartingIndex);
            }
            else if (ne.Action == NotifyCollectionChangedAction.Remove)
            {
                foreach (DataGridColumn column in ne.OldItems)
                {
                    dataGrid.Columns.Remove(column);
                }
            }
            else if (ne.Action == NotifyCollectionChangedAction.Replace)
            {
                dataGrid.Columns[ne.NewStartingIndex] = ne.NewItems[0] as DataGridColumn;
            }
        };
    }
    public static void SetBindableColumns(DependencyObject element, ObservableCollection<DataGridColumn> value)
    {
        element.SetValue(BindableColumnsProperty, value);
    }
    public static ObservableCollection<DataGridColumn> GetBindableColumns(DependencyObject element)
    {
        return (ObservableCollection<DataGridColumn>)element.GetValue(BindableColumnsProperty);
    }
}

【讨论】：

MVVM 模式的好解决方案
完美解决方案！可能您需要在 BindableColumnsPropertyChanged 中做一些其他的事情： 1. 在访问它之前检查 dataGrid 是否为空，并抛出一个异常，并很好地解释只绑定到 DataGrid。 2. 检查 e.OldValue 是否为 null 并取消订阅 CollectionChanged 事件以防止内存泄漏。只是为了说服您。
您使用列集合的CollectionChanged 事件注册了一个事件处理程序，但是您永远不会取消注册它。这样，只要视图模型存在，DataGrid 就会一直保持活动状态，即使同时替换了包含DataGrid 的控件模板。当不再需要 DataGrid 时，是否有任何保证方法可以再次取消注册该事件处理程序？
这不是最佳解决方案。主要原因是您在 ViewModel 中使用 UI 类。当您尝试创建一些页面切换时，它也不起作用。当切换回带有此类数据网格的页面时，您会在 dataGrid.Columns.Add(column) DataGridColumn 的行中得到预期，标题为“X”的 DataGrid 的 Columns 集合中已经存在。 DataGrid 不能共享列，也不能包含重复的列实例。
@RuslanF。要处理切换交换 foreach (DataGridColumn column in columns) { dataGrid.Columns.Add(column); } 部分与 foreach (var column in columns) { var dataGridOwnerProperty = column.GetType().GetProperty("DataGridOwner", BindingFlags.Instance | BindingFlags.NonPublic); if( dataGridOwnerProperty != null) dataGridOwnerProperty.SetValue(column, null); dataGrid.Columns.Add(column); } Sry 不能让换行符工作

【解决方案5】：

我发现了 Deborah Kurata 的一篇博客文章，其中有一个很好的技巧如何在 DataGrid 中显示可变数量的列：

Populating a DataGrid with Dynamic Columns in a Silverlight Application using MVVM

基本上，她创建了一个DataGridTemplateColumn 并将ItemsControl 放入其中以显示多列。

【讨论】：

和编程版的结果远远不一样！！
@321X：您能否详细说明观察到的差异是什么（并指定您所说的编程版本是什么意思，因为所有解决方案都是编程的），请?
它说“找不到页面”
这里是链接blogs.msmvps.com/deborahk/…
这简直太棒了！！

【解决方案6】：

我设法使动态添加列成为可能，只使用这样的一行代码：

MyItemsCollection.AddPropertyDescriptor(
    new DynamicPropertyDescriptor<User, int>("Age", x => x.Age));

关于这个问题，这不是一个基于 XAML 的解决方案（因为如上所述没有合理的方法来做到这一点），也不是一个可以直接使用 DataGrid.Columns 操作的解决方案。它实际上与 DataGrid 绑定的 ItemsSource 一起操作，它实现了 ITypedList 并因此为 PropertyDescriptor 检索提供了自定义方法。您可以在代码中的一处为您的网格定义“数据行”和“数据列”。

如果你有：

IList<string> ColumnNames { get; set; }
//dict.key is column name, dict.value is value
Dictionary<string, string> Rows { get; set; }

你可以使用例如：

var descriptors= new List<PropertyDescriptor>();
//retrieve column name from preprepared list or retrieve from one of the items in dictionary
foreach(var columnName in ColumnNames)
    descriptors.Add(new DynamicPropertyDescriptor<Dictionary, string>(ColumnName, x => x[columnName]))
MyItemsCollection = new DynamicDataGridSource(Rows, descriptors)

并且使用绑定到 MyItemsCollection 的网格将填充相应的列。这些列可以在运行时动态修改（新添加或现有删除），网格将自动刷新其列集合。

上面提到的DynamicPropertyDescriptor 只是对常规PropertyDescriptor 的升级，并提供了带有一些附加选项的强类型列定义。否则，DynamicDataGridSource 可以与基本 PropertyDescriptor 一起正常工作。

【讨论】：

【解决方案7】：

制作了处理取消订阅的已接受答案的版本。

public class DataGridColumnsBehavior
{
    public static readonly DependencyProperty BindableColumnsProperty =
        DependencyProperty.RegisterAttached("BindableColumns",
                                            typeof(ObservableCollection<DataGridColumn>),
                                            typeof(DataGridColumnsBehavior),
                                            new UIPropertyMetadata(null, BindableColumnsPropertyChanged));

    /// <summary>Collection to store collection change handlers - to be able to unsubscribe later.</summary>
    private static readonly Dictionary<DataGrid, NotifyCollectionChangedEventHandler> _handlers;

    static DataGridColumnsBehavior()
    {
        _handlers = new Dictionary<DataGrid, NotifyCollectionChangedEventHandler>();
    }

    private static void BindableColumnsPropertyChanged(DependencyObject source, DependencyPropertyChangedEventArgs e)
    {
        DataGrid dataGrid = source as DataGrid;

        ObservableCollection<DataGridColumn> oldColumns = e.OldValue as ObservableCollection<DataGridColumn>;
        if (oldColumns != null)
        {
            // Remove all columns.
            dataGrid.Columns.Clear();

            // Unsubscribe from old collection.
            NotifyCollectionChangedEventHandler h;
            if (_handlers.TryGetValue(dataGrid, out h))
            {
                oldColumns.CollectionChanged -= h;
                _handlers.Remove(dataGrid);
            }
        }

        ObservableCollection<DataGridColumn> newColumns = e.NewValue as ObservableCollection<DataGridColumn>;
        dataGrid.Columns.Clear();
        if (newColumns != null)
        {
            // Add columns from this source.
            foreach (DataGridColumn column in newColumns)
                dataGrid.Columns.Add(column);

            // Subscribe to future changes.
            NotifyCollectionChangedEventHandler h = (_, ne) => OnCollectionChanged(ne, dataGrid);
            _handlers[dataGrid] = h;
            newColumns.CollectionChanged += h;
        }
    }

    static void OnCollectionChanged(NotifyCollectionChangedEventArgs ne, DataGrid dataGrid)
    {
        switch (ne.Action)
        {
            case NotifyCollectionChangedAction.Reset:
                dataGrid.Columns.Clear();
                foreach (DataGridColumn column in ne.NewItems)
                    dataGrid.Columns.Add(column);
                break;
            case NotifyCollectionChangedAction.Add:
                foreach (DataGridColumn column in ne.NewItems)
                    dataGrid.Columns.Add(column);
                break;
            case NotifyCollectionChangedAction.Move:
                dataGrid.Columns.Move(ne.OldStartingIndex, ne.NewStartingIndex);
                break;
            case NotifyCollectionChangedAction.Remove:
                foreach (DataGridColumn column in ne.OldItems)
                    dataGrid.Columns.Remove(column);
                break;
            case NotifyCollectionChangedAction.Replace:
                dataGrid.Columns[ne.NewStartingIndex] = ne.NewItems[0] as DataGridColumn;
                break;
        }
    }

    public static void SetBindableColumns(DependencyObject element, ObservableCollection<DataGridColumn> value)
    {
        element.SetValue(BindableColumnsProperty, value);
    }

    public static ObservableCollection<DataGridColumn> GetBindableColumns(DependencyObject element)
    {
        return (ObservableCollection<DataGridColumn>)element.GetValue(BindableColumnsProperty);
    }
}

【讨论】：

【解决方案8】：

有一个我以编程方式执行的示例：

public partial class UserControlWithComboBoxColumnDataGrid : UserControl
{
    private Dictionary<int, string> _Dictionary;
    private ObservableCollection<MyItem> _MyItems;
    public UserControlWithComboBoxColumnDataGrid() {
      _Dictionary = new Dictionary<int, string>();
      _Dictionary.Add(1,"A");
      _Dictionary.Add(2,"B");
      _MyItems = new ObservableCollection<MyItem>();
      dataGridMyItems.AutoGeneratingColumn += DataGridMyItems_AutoGeneratingColumn;
      dataGridMyItems.ItemsSource = _MyItems;

    }
private void DataGridMyItems_AutoGeneratingColumn(object sender, DataGridAutoGeneratingColumnEventArgs e)
        {
            var desc = e.PropertyDescriptor as PropertyDescriptor;
            var att = desc.Attributes[typeof(ColumnNameAttribute)] as ColumnNameAttribute;
            if (att != null)
            {
                if (att.Name == "My Combobox Item") {
                    var comboBoxColumn =  new DataGridComboBoxColumn {
                        DisplayMemberPath = "Value",
                        SelectedValuePath = "Key",
                        ItemsSource = _ApprovalTypes,
                        SelectedValueBinding =  new Binding( "Bazinga"),   
                    };
                    e.Column = comboBoxColumn;
                }

            }
        }

}
public class MyItem {
    public string Name{get;set;}
    [ColumnName("My Combobox Item")]
    public int Bazinga {get;set;}
}

  public class ColumnNameAttribute : Attribute
    {
        public string Name { get; set; }
        public ColumnNameAttribute(string name) { Name = name; }
}

【讨论】：