WPF DataGrid를 가변 개수의 열에 바인드하려면 어떻게 해야 합니까?

WPF DataGrid를 가변 개수의 열에 바인드하려면 어떻게 해야 합니까?

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 파일의 데이터 바인딩으로 대체할 수 있는 방법이 있습니까?

다음은 DataGrid의 바인딩 열에 대한 해결 방법입니다.Columns 속성은 모두 알고 있듯이 읽기 전용이므로 CollectionChanged 이벤트를 통해 컬렉션이 변경될 때마다 DataGrid의 Columns를 업데이트하는 BindableColumns라는 Attached 속성을 만들었습니다.

이 DataGridColumn 컬렉션이 있는 경우

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

그런 다음 다음과 같이 Bindable Columns를 Column Collection에 바인딩할 수 있습니다.

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

연결된 속성 바인딩 가능 열

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

저는 연구를 계속하고 있지만, 이 일을 할 수 있는 합리적인 방법을 찾지 못했습니다.DataGrid의 Columns 속성은 읽기 전용으로 바인딩할 수 없습니다.

브라이언이 AutoGenerateColumns에 대해 뭔가 할 수 있다고 해서 찾아봤어요.심플을 사용합니다.순반사 - 항목 내 객체의 속성을 확인합니다.소스 및 각 열에 대한 열을 생성합니다.각 컬럼의 속성을 가진 타입을 즉석에서 생성할 수 있을 것 같습니다만, 이것은 궤도에서 벗어나 있습니다.

이 문제는 코드에서 쉽게 해결되기 때문에 데이터 컨텍스트가 새 열로 업데이트될 때마다 호출하는 간단한 확장 메서드를 계속 사용합니다.

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

DataGrid에서 가변적인 수의 열을 표시하는 방법에 관한 Deborah Kurata의 블로그 기사를 찾았습니다.

MVVM을 사용한Silverlight 어플리케이션에서의 DataGrid 동적 컬럼 입력

기본적으로, 그녀가 만든 것은DataGridTemplateColumn및 puts.ItemsControl여러 열을 표시하는 inside.

다음과 같은 코드 한 줄만 사용하여 열을 동적으로 추가할 수 있었습니다.

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

이 질문에 대해서는 XAML 기반 솔루션이 아닙니다(상기한 바와 같이 합리적인 방법이 없기 때문에). DataGrid와 직접 연동되는 솔루션도 아닙니다.컬럼실제로 DataGrid 바인딩 항목과 함께 작동합니다.Source: 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) 

My Items Collection에 바인딩을 사용하는 그리드는 대응하는 컬럼으로 채워집니다.이러한 열은 런타임에 동적으로 수정(새로 추가 또는 기존 제거)할 수 있으며 그리드는 자동으로 열 컬렉션을 새로 고칩니다.

위에서 설명한 DynamicPropertyDescriptor는 일반 PropertyDescriptor로의 업그레이드일 뿐이며, 일부 추가 옵션과 함께 강력한 유형의 열 정의를 제공합니다.그렇지 않으면 Dynamic Data Grid Source는 기본 Property Descriptor에서 제대로 작동합니다.

구독 해제를 처리하는 승인된 답변 버전을 만들었습니다.

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

그리드 정의를 사용하여 사용자 컨트롤을 생성하고 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, LoadGrid, LoadGrid는 LoadGrid 。
때문에 , .InitalizeComponent'childGrid'(childGrid) window.xaml x:name:

childGrid.deGrid.LoadGrid();

관련 블로그 엔트리

AutoGenerateColumns 및 DataTemplate를 사용하여 이 작업을 수행할 수 있습니다.손이 많이 가지 않아도 잘 될 것 같진 않지만, 가지고 놀아야 할 것 같아요.솔직히, 당신이 이미 유효한 해결책을 가지고 있다면, 나는 큰 이유가 없는 한 아직 변경하지 않을 것이다.DataGrid 제어는 매우 좋아지고 있지만 이와 같은 동적 작업을 쉽게 수행할 수 있으려면 아직 작업이 필요합니다.

다음은 프로그래밍 방식으로 수행하는 방법의 예입니다.

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

언급URL : https://stackoverflow.com/questions/320089/how-do-i-bind-a-wpf-datagrid-to-a-variable-number-of-columns