Tutorial :WPF GridView with a dynamic definition



Question:

I want to use the GridView mode of a ListView to display a set of data that my program will be receiving from an external source. The data will consist of two arrays, one of column names and one of strings values to populate the control.

I don't see how to create a suitable class that I can use as the Item in a ListView. The only way I know to populate the Items is to set it to a class with properties that represent the columns, but I have no knowledge of the columns before run-time.

I could create an ItemTemplate dynamically as described in: Create WPF ItemTemplate DYNAMICALLY at runtime but it still leaves me at a loss as to how to describe the actual data.

Any help gratefully received.


Solution:1

You can add GridViewColumns to the GridView dynamically given the first array using a method like this:

private void AddColumns(GridView gv, string[] columnNames)  {      for (int i = 0; i < columnNames.Length; i++)      {          gv.Columns.Add(new GridViewColumn          {              Header = columnNames[i],              DisplayMemberBinding = new Binding(String.Format("[{0}]", i))          });      }  }  

I assume the second array containing the values will be of ROWS * COLUMNS length. In that case, your items can be string arrays of length COLUMNS. You can use Array.Copy or LINQ to split up the array. The principle is demonstrated here:

<Grid>      <Grid.Resources>          <x:Array x:Key="data" Type="{x:Type sys:String[]}">              <x:Array Type="{x:Type sys:String}">                  <sys:String>a</sys:String>                  <sys:String>b</sys:String>                  <sys:String>c</sys:String>              </x:Array>              <x:Array Type="{x:Type sys:String}">                  <sys:String>do</sys:String>                  <sys:String>re</sys:String>                  <sys:String>mi</sys:String>              </x:Array>          </x:Array>      </Grid.Resources>      <ListView ItemsSource="{StaticResource data}">          <ListView.View>              <GridView>                  <GridViewColumn DisplayMemberBinding="{Binding Path=[0]}" Header="column1"/>                  <GridViewColumn DisplayMemberBinding="{Binding Path=[1]}" Header="column2"/>                  <GridViewColumn DisplayMemberBinding="{Binding Path=[2]}" Header="column3"/>              </GridView>          </ListView.View>      </ListView>  </Grid>  


Solution:2

Thanks, that is very helpful.

I used it to create a dynamic version as follows. I created the column headings as you suggested:

private void AddColumns(List<String> myColumns)  {      GridView viewLayout = new GridView();      for (int i = 0; i < myColumns.Count; i++)      {          viewLayout.Columns.Add(new GridViewColumn          {              Header = myColumns[i],              DisplayMemberBinding = new Binding(String.Format("[{0}]", i))          });      }      myListview.View = viewLayout;  }  

Set up the ListView very simply in XAML:

<ListView Name="myListview" DockPanel.Dock="Left"/>  

Created an wrapper class for ObservableCollection to hold my data:

public class MyCollection : ObservableCollection<List<String>>  {      public MyCollection()          : base()      {      }  }  

And bound my ListView to it:

results = new MyCollection();    Binding binding = new Binding();  binding.Source = results;  myListview.SetBinding(ListView.ItemsSourceProperty, binding);  

Then to populate it, it was just a case of clearing out any old data and adding the new:

results.Clear();  List<String> details = new List<string>();  for (int ii=0; ii < externalDataCollection.Length; ii++)  {      details.Add(externalDataCollection[ii]);  }  results.Add(details);  

There are probably neater ways of doing it, but this is very useful for my application. Thanks again.


Solution:3

This article on the CodeProject explains exactly how to create a Dynamic ListView - when data is known only at runtime. http://www.codeproject.com/KB/WPF/WPF_DynamicListView.aspx


Solution:4

Not sure if it's still relevant but I found a way to style the individual cells with a celltemplate selector. It's a bit hacky because you have to munch around with the Content of the ContentPresenter to get the proper DataContext for the cell (so you can bind to the actual cell item in the cell template):

    public class DataMatrixCellTemplateSelectorWrapper : DataTemplateSelector      {          private readonly DataTemplateSelector _ActualSelector;          private readonly string _ColumnName;          private Dictionary<string, object> _OriginalRow;            public DataMatrixCellTemplateSelectorWrapper(DataTemplateSelector actualSelector, string columnName)          {              _ActualSelector = actualSelector;              _ColumnName = columnName;          }            public override DataTemplate SelectTemplate(object item, DependencyObject container)          {              // The item is basically the Content of the ContentPresenter.              // In the DataMatrix binding case that is the dictionary containing the cell objects.              // In order to be able to select a template based on the actual cell object and also              // be able to bind to that object within the template we need to set the DataContext              // of the template to the actual cell object. However after the template is selected              // the ContentPresenter will set the DataContext of the template to the presenters              // content.               // So in order to achieve what we want, we remember the original DataContext and then              // change the ContentPresenter content to the actual cell object.              // Therefor we need to remember the orginal DataContext otherwise in subsequent calls              // we would get the first cell object.                // remember old data context              if (item is Dictionary<string, object>)              {                  _OriginalRow = item as Dictionary<string, object>;              }                if (_OriginalRow == null)                  return null;                // get the actual cell object              var obj = _OriginalRow[_ColumnName];                // select the template based on the cell object              var template = _ActualSelector.SelectTemplate(obj, container);                // find the presenter and change the content to the cell object so that it will become              // the data context of the template              var presenter = WpfUtils.GetFirstParentForChild<ContentPresenter>(container);              if (presenter != null)              {                  presenter.Content = obj;              }                return template;          }      }  

Note: I changed the DataMatrix frome the CodeProject article so that rows are Dictionaries (ColumnName -> Cell Object).

I can't guarantee that this solution will not break something or will not break in future .Net release. It relies on the fact that the ContentPresenter sets the DataContext after it selected the template to it's own Content. (Reflector helps a lot in these cases :))

When creating the GridColumns, I do something like that:

           var column = new GridViewColumn                            {                                Header = col.Name,                                HeaderTemplate = gridView.ColumnHeaderTemplate                            };              if (listView.CellTemplateSelector != null)              {                  column.CellTemplateSelector = new DataMatrixCellTemplateSelectorWrapper(listView.CellTemplateSelector, col.Name);              }              else              {                  column.DisplayMemberBinding = new Binding(string.Format("[{0}]", col.Name));              }              gridView.Columns.Add(column);  

Note: I have extended ListView so that it has a CellTemplateSelector property you can bind to in xaml

@Edit 15/03/2011: I wrote a little article which has a little demo project attached: http://codesilence.wordpress.com/2011/03/15/listview-with-dynamic-columns/


Solution:5

Totally progmatic version:

        var view = grid.View as GridView;          view.Columns.Clear();          int count=0;          foreach (var column in ViewModel.GridData.Columns)          {              //Create Column              var nc = new GridViewColumn();              nc.Header = column.Field;              nc.Width = column.Width;              //Create template              nc.CellTemplate = new DataTemplate();              var factory = new FrameworkElementFactory(typeof(System.Windows.Controls.Border));              var tbf = new FrameworkElementFactory(typeof(System.Windows.Controls.TextBlock));                factory.AppendChild(tbf);              factory.SetValue(System.Windows.Controls.Border.BorderThicknessProperty, new Thickness(0,0,1,1));              factory.SetValue(System.Windows.Controls.Border.MarginProperty, new Thickness(-7,0,-7,0));              factory.SetValue(System.Windows.Controls.Border.BorderBrushProperty, Brushes.LightGray);              tbf.SetValue(System.Windows.Controls.TextBlock.MarginProperty, new Thickness(6,2,6,2));              tbf.SetValue(System.Windows.Controls.TextBlock.HorizontalAlignmentProperty, column.Alignment);                //Bind field              tbf.SetBinding(System.Windows.Controls.TextBlock.TextProperty, new Binding(){Converter = new GridCellConverter(), ConverterParameter=column.BindingField});              nc.CellTemplate.VisualTree = factory;                view.Columns.Add(nc);              count++;          }  


Solution:6

I would go about doing this by adding an AttachedProperty to the GridView where my MVVM application can specify the columns (and perhaps some additional metadata.) The Behavior code can then dynamically work directly with the GridView object to create the columns. In this way you adhere to MVVM and the ViewModel can specify the columns on the fly.


Note:If u also have question or solution just comment us below or mail us on toontricks1994@gmail.com
Previous
Next Post »