Como vincular um WPF DataGrid a um número variável de colunas?

124

Meu aplicativo WPF gera conjuntos de dados que podem ter um número diferente de colunas a cada vez. Está incluída na saída uma descrição de cada coluna que será usada para aplicar a formatação. Uma versão simplificada da saída pode ser algo como:

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

Essa classe é definida como DataContext em um WPF DataGrid, mas na verdade eu crio as colunas programaticamente:

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

Existe alguma maneira de substituir esse código por ligações de dados no arquivo XAML?

Erro genérico
fonte

Respostas:

127

Aqui está uma solução alternativa para vincular colunas no DataGrid. Como a propriedade Columns é ReadOnly, como todo mundo notou, criei uma propriedade Attached chamada BindableColumns que atualiza as colunas no DataGrid sempre que a coleção é alterada pelo evento CollectionChanged.

Se tivermos essa coleção de DataGridColumn's

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

Em seguida, podemos vincular BindableColumns ao ColumnCollection assim

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

A propriedade anexada 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);
    }
}
Fredrik Hedblad
fonte
1
boa solução para o padrão MVVM
WPFKK
2
Uma solução perfeita! Provavelmente, você precisa fazer algumas outras coisas em BindableColumnsPropertyChanged: 1. Verifique se o dataGrid é nulo antes de acessá-lo e emita uma exceção com uma boa explicação sobre a associação apenas ao DataGrid. 2. Verifique e.OldValue para obter null e cancelar a inscrição no evento CollectionChanged para evitar vazamentos de memória. Só para convencer.
Mike Eshva
3
Você registra um manipulador de eventos no CollectionChangedevento da coleção de colunas, mas nunca o cancela o registro. Dessa forma, DataGridele será mantido vivo enquanto o modelo de exibição existir, mesmo que o modelo de controle que continha DataGrido primeiro tenha sido substituído enquanto isso. Existe alguma maneira garantida de cancelar o registro desse manipulador de eventos novamente quando DataGridnão for mais necessário?
OR Mapper
1
@OR Mapper: Teoricamente existe, mas não funciona: WeakEventManager <ObservableCollection <DataGridColumn>, NotifyCollectionChangedEventArgs> .AddHandler (colunas, "CollectionChanged", (s, ne) => {switch ....});
também
6
Não é uma solução. O principal motivo é que você está usando classes de interface do usuário no ViewModel. Também não funcionará quando você tentar criar alguma troca de página. Ao voltar para a página com esse datagrid, você terá uma expectativa na linha dataGrid.Columns.Add(column)DataGridColumn com o cabeçalho 'X' já existente na coleção Columns de um DataGrid. O DataGrids não pode compartilhar colunas e não pode conter instâncias de coluna duplicadas.
Ruslan F.
19

Continuei minha pesquisa e não encontrei nenhuma maneira razoável de fazer isso. A propriedade Columns no DataGrid não é algo contra o qual possa me vincular; na verdade, é somente leitura.

Bryan sugeriu que algo poderia ser feito com o AutoGenerateColumns, então eu dei uma olhada. Ele usa reflexão .Net simples para examinar as propriedades dos objetos no ItemsSource e gera uma coluna para cada um. Talvez eu possa gerar um tipo em tempo real com uma propriedade para cada coluna, mas isso está saindo do caminho.

Como esse problema é tão facilmente resolvido no código, continuarei com um método de extensão simples que chamo sempre que o contexto dos dados for atualizado com novas colunas:

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);
Erro genérico
fonte
1
A solução mais votada e aceita não é a melhor! Dois anos depois, a resposta seria: msmvps.com/blogs/deborahk/archive/2011/01/23/…
Mikhail
4
Não, não seria. Não é o link fornecido de qualquer maneira, porque o resultado dessa solução é completamente diferente!
321X 10/08/11
2
Parece que a solução de Mealek é muito mais universal e é útil em situações em que o uso direto do código C # é problemático, por exemplo, nos ControlTemplates.
EFraim 07/12/11
@Mikhail link quebrado
LuckyLikey 14/09
3
Aqui está o link: blogs.msmvps.com/deborahk/…
Mikhail
9

Eu encontrei um artigo de blog de Deborah Kurata com um bom truque como mostrar o número variável de colunas em um DataGrid:

Preenchendo um DataGrid com Colunas Dinâmicas em um Aplicativo Silverlight usando MVVM

Basicamente, ela cria um DataGridTemplateColumne coloca ItemsControldentro que exibe várias colunas.

Lukas Cenovsky
fonte
1
Não é de longe o mesmo resultado que a versão programada !!
321X 10/08/11
1
@ 321X: Você poderia, por favor, explicar quais são as diferenças observadas (e também especificar o que você quer dizer com versão programada , pois todas as soluções para isso são programadas), por favor?
OR Mapper
Ele diz "Página não encontrada"
Jeson Martajaya 17/04/2015
2
aqui está o link blogs.msmvps.com/deborahk/…
Mikhail
Isso é nada menos que incrível !!
Ravid Goldenberg 29/06
6

Consegui tornar possível adicionar dinamicamente uma coluna usando apenas uma linha de código como esta:

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

Em relação à pergunta, essa não é uma solução baseada em XAML (já que, como mencionado, não há uma maneira razoável de fazê-lo), nem é uma solução que funcionaria diretamente com o DataGrid.Columns. Na verdade, ele opera com o ItemsSource ligado ao DataGrid, que implementa ITypedList e, como tal, fornece métodos personalizados para a recuperação do PropertyDescriptor. Em um lugar no código, você pode definir "linhas de dados" e "colunas de dados" para sua grade.

Se você tivesse:

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

você poderia usar por exemplo:

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) 

e sua grade usando a ligação a MyItemsCollection seria preenchida com as colunas correspondentes. Essas colunas podem ser modificadas (novas adicionadas ou removidas) em tempo de execução dinamicamente e a grade atualizará automaticamente sua coleção de colunas.

O DynamicPropertyDescriptor mencionado acima é apenas uma atualização para o PropertyDescriptor regular e fornece uma definição de colunas fortemente tipada com algumas opções adicionais. Caso contrário, o DynamicDataGridSource funcionaria bem com o PropertyDescriptor básico.

doblak
fonte
3

Criou uma versão da resposta aceita que lida com a desinscrição.

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);
    }
}
Mikhail Orlov
fonte
2

Você pode criar um controle de usuário com a definição de grade e definir controles 'filho' com definições de coluna variadas no xaml. O pai precisa de uma propriedade de dependência para colunas e um método para carregar as colunas:

Pai:


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 filho:


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

E, finalmente, a parte complicada é encontrar onde chamar 'LoadGrid'.
Estou lutando com isso, mas consegui que as coisas funcionassem chamando depois InitalizeComponentno meu construtor de janelas (childGrid é x: name em window.xaml):

childGrid.deGrid.LoadGrid();

Entrada de blog relacionada

Andy
fonte
1

Você pode fazer isso com AutoGenerateColumns e um DataTemplate. Não tenho certeza se funcionaria sem muito trabalho, você teria que brincar com isso. Honestamente, se você já tem uma solução funcional, eu não faria a alteração ainda, a menos que haja um grande motivo. O controle DataGrid está ficando muito bom, mas ainda precisa de algum trabalho (e ainda tenho muito aprendizado a fazer) para poder executar tarefas dinâmicas como essa facilmente.

Bryan Anderson
fonte
Minha razão é que, vindo do ASP.Net, sou novo no que pode ser feito com a vinculação de dados decente e não tenho certeza de onde estão os limites. Vou brincar com o AutoGenerateColumns, obrigado.
Erro genérico
0

Há uma amostra da maneira que eu faço programaticamente:

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; }
}
David Soler
fonte