Save and Load a DataGrid's Columns Graphical Properties in WPF


We'll see in this article how a user can customize a DataGrid, ordering columns or modifying their width, saving those changes for later use (in other words, when the program will show again a specific grid). In the following I'll present a class that does that, with a simple use scenario. The code was commented to be as clear as possible. The function is declared Shared to facilitate the static use of the class. We'll use mainly DataSet and DataTable classes, to benefit from the handy XML access methods, through which we'll realize the storage of column parameters.

Sample Class

  1. Imports System.Data  
  2. Public Class emDataGridOptions  
  3.     ' We declare a certain path in which we'll store the grid's options file  
  4.     Const _DATAGRID_OPTIONS_DIR As String = "C:\tmp\"  
  5.     ' As file extension, we'll use ".di"  
  6.     Const _DATAGRID_OPTIONS_EXT As String = ".di"  
  8.     ' ===============================================================================  
  9.     ' Private function to return the full path of options file  
  10.     ' ===============================================================================  
  11.     Private Shared Function ComposeGridOptionsFile(gridName) As String  
  12.         ' Simple concatenation of directory, grid's name, and default extension  
  13.         Return _DATAGRID_OPTIONS_DIR & gridName & _DATAGRID_OPTIONS_EXT  
  14.     End Function  
  16.     ' ===============================================================================  
  17.     ' Public shared sub to save DataGrid's option  
  18.     ' ===============================================================================  
  19.     Public Shared Sub SaveGridOptions(dg As DataGrid)  
  20.         ' We'll create a DataSet with the same name of the Grid, generating inside it a DataTable named "columns"  
  21.          Dim columns As New DataSet(dg.Name)  
  22.         Dim coltable As New DataTable("columns")  
  24.         ' Here we'll save only some parameters, such as the visibility, the sort direction, etc.  
  25.         ' we must create in the DataTable a number of columns equals to the number of property we intend to save.  
  26.         With coltable  
  27.             .Columns.Add("DisplayIndex", Type.GetType("System.Int32"))  
  28.             .Columns.Add("Width", Type.GetType("System.Double"))  
  29.             .Columns.Add("Visibility", Type.GetType("System.Int32"))  
  30.             .Columns.Add("SortDirection", Type.GetType("System.Int32"))  
  31.         End With  
  33.         columns.Tables.Add(coltable)  
  35.         ' We execute a loop on the DataGrid's columns, adding to the DataTable a number of rows equals to the  
  36.         ' count of DataGrid's columns, each one of them exposing the value of the property itself          
  37.         For Each c As DataGridColumn In dg.Columns  
  38.             coltable.Rows.Add(New Object() {c.DisplayIndex,  
  39.                                             c.Width.DisplayValue,  
  40.                                             c.Visibility,  
  41.                                             c.SortDirection})  
  42.         Next  
  44.         ' Then, using the WriteXml() method, we save an XML file which contains the columns extracted values  
  45.         columns.WriteXml(ComposeGridOptionsFile(dg.Name))  
  46.     End Sub  
  48.     ' ===============================================================================  
  49.     ' Public shared sub to load DataGrid's option  
  50.     ' ===============================================================================  
  51.     Public Shared Sub LoadGridOptions(dg As DataGrid)  
  52.         ' We check if the options file exists...  
  53.          If Not (IO.File.Exists(ComposeGridOptionsFile(dg.Name))) Then Exit Sub  
  55.         ' A new DataSet will be generated, and then populated using the readXml() method  
  56.         Dim columns As New DataSet(dg.Name)  
  57.         columns.ReadXml(ComposeGridOptionsFile(dg.Name))  
  59.         ' We execute a loop on grid's columns: for each of them, we read and apply the corresponding property's value from the table in DataSet  
  60.         Dim ii As Integer = 0  
  61.         For Each c As DataGridColumn In dg.Columns  
  63.             c.DisplayIndex = columns.Tables(0).Rows(ii).Item("DisplayIndex")  
  64.             c.Width = Double.Parse(columns.Tables(0).Rows(ii).Item("Width"))  
  65.             c.Visibility = columns.Tables(0).Rows(ii).Item("Visibility")  
  67.             ' The SortDirection case is a particular one: if no sort was set on a column, there will be no corresponding entity  
  68.             ' in the XML file. So, we must manage possible Nothing values  
  69.             Dim sortDirection As Nullable(Of Integer) = Nothing  
  70.             If Not (columns.Tables(0).Rows(ii).Item("SortDirection").Equals(DBNull.Value)) Then sortDirection = Integer.Parse(columns.Tables(0).Rows(ii).Item("SortDirection"))  
  72.             ' If SortDirection is specified, we need to execute the actual sort. We compile the list of sort's descriptions through the read value, plus the  
  73.             ' column's SortMemberPath, refreshing the grid's Items.  
  74.             If Not (sortDirection Is NothingThen  
  75.                 c.SortDirection = sortDirection  
  76.                 dg.Items.SortDescriptions.Add(New ComponentModel.SortDescription(c.SortMemberPath, c.SortDirection))  
  77.                 dg.Items.Refresh()  
  78.             End If  
  79.             ii += 1  
  80.         Next  
  81.     End Sub  
  82. End Class  

Use scenario

The typical scenario is represented by entering a window (in case of parameters loading) and from closing it at the end of the program's lifecycle (for saving). Assuming we have a Window named MainWindow, on top of which we create a DataGrid named DataGrid1, we could use Loaded() and Closing() events (if in an event-driven model), respectively for the option's loading and saving. In those event's context, it will be possible to call on the static functions, feeding them the grid's name as a parameter.
  1. Private Sub MainWindow_Loaded(sender As Object, e As RoutedEventArgs) Handles Me.Loaded  
  2.    'Eseguire qui le operazioni preliminari, tra cui il binding dei dati sulla griglia  
  3.     emDataGridOptions.LoadGridOptions(DataGrid1)  
  4. End Sub  
  6. Private Sub MainWindow_Closing(sender As Object, e As ComponentModel.CancelEventArgs) Handles Me.Closing  
  7.     emDataGridOptions.SaveGridOptions(DataGrid1)  
  8. End Sub