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

问题描述 投票：0回答：9

我的 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
9个回答
130
投票

这是在 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);
    }
}
19
投票

我继续进行研究，但没有找到任何合理的方法来做到这一点。 我无法绑定 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);
9
投票

我找到了 Deborah Kurata 的一篇博客文章，其中介绍了如何在 DataGrid 中显示可变数量的列：

使用 MVVM 在 Silverlight 应用程序中使用动态列填充 DataGrid

基本上，她创建了一个 

DataGridTemplateColumn
并将 
ItemsControl
放入其中显示多列。

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 一起正常工作。

3
投票

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

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);
    }
}
2
投票

您可以使用网格定义创建用户控件，并在 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();

相关博客条目

1
投票

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

0
投票

有一个我以编程方式进行操作的示例：

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; }
}
0
投票

@rune-anderson 在评论中发布了答案。因为它隐藏在评论中，所以我再次发布它作为回复，以供其他人使用。

当您第二次将同一列添加到数据网格时，问题不在于数据网格，而在于列。问题是该列已经有一个 

DataGridOwner
。通过清除 DataGridColumn 的 
DataGridOwner
属性可以轻松解决此问题。就像鲁恩·安德森（Rune Anderson）所展示的那样：

    // – Rune Andersen Commented Oct 31, 2017 at 9:11 
    Table.Columns.Clear();
    foreach (var column in columns)
    {
        var dataGridOwnerProperty = column.GetType().GetProperty("DataGridOwner", BindingFlags.Instance | BindingFlags.NonPublic); 
        dataGridOwnerProperty?.SetValue(column, null); 
        Table.Columns.Add(column);
    }
最新问题
© www.soinside.com 2019 - 2024. All rights reserved.