Как связать WPF DataGrid с переменным числом столбцов?

Question

Приложение WPF генерирует множество данных, которые могут иметь разное количество столбцов каждый раз. В число выходных данных входит описание каждого столбца, который будет использоваться для форматирования. Упрощенная версия вывода может быть что-то вроде:

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

Этот класс устанавливается как DataContext на WPF DataGrid, но я на самом деле создать столбцы программно:

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-файле?

Answer 1

Вот обходной путь для связывания столбцов в DataGrid. Поскольку свойство Columns ReadOnly, как и все заметили, я создал свойство Attached, называемое BindableColumns, которое обновляет столбцы в DataGrid каждый раз, когда коллекция изменяется через событие CollectionChanged.

Если у нас есть эта коллекция

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

Тогда мы можем связывать BindableColumns DataGridColumn к в ColumnCollection как этот

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

Прилагаемый Недвижимость BindableColumns

Answer 2

Возможно, вы сможете сделать это с помощью AutoGenerateColumns и DataTemplate. Я не уверен, что если он будет работать без большой работы, вам придется поиграть с ним. Честно говоря, если у вас уже есть рабочее решение, я бы не внес изменения, пока не будет большой причины. Элемент управления DataGrid становится очень хорош, но ему по-прежнему требуется некоторая работа (и у меня много времени на изучение), чтобы легко выполнять динамические задачи.

Answer 3

Я продолжил свое исследование и не нашел разумного способа сделать это. Свойство Columns в DataGrid не является чем-то, с чем я могу связать, на самом деле это только чтение.

Bryan предположил, что что-то может быть сделано с помощью AutoGenerateColumns, поэтому я посмотрел. Он использует простое .Net-отражение, чтобы посмотреть на свойства объектов в ItemsSource и генерирует столбец для каждого из них. Возможно, я мог бы генерировать тип «на лету» с свойством для каждого столбца, но это ускользает.

Поскольку эта проблема так легко sovled в коде я буду придерживаться простого метода расширения я зову, когда контекст данных обновляется с новыми столбцами:

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); 

Answer 4

Вы можете создать UserControl с определением сетки и определить «дочерние» элементы управления с различными определениями столбцов в 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):

childGrid.deGrid.LoadGrid(); 

Related blog entry

Answer 5

Я нашел статья блога Дебора Курата с хорошим трюком, как показать varia BLE количество колонок в DataGrid:

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

В принципе, она создает DataGridTemplateColumn и помещает ItemsControl внутри, который отображает несколько столбцов.

Answer 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.

Answer 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); 
    } 
} 

Answer 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; } 
}