[RESOLVED] How to bind DGV to complex type properties

Hi Folks

I have a DataGridView with some DataGridViewTextBoxColumn columns in it.

The DGV itself is bound to a BindingList(Of Parameter)

The Parameter class has public property members (multiple) that are objects of class ParameterValue, which itself has two Decimal public property members.

I am trying to have the DGV bind to the two decimal members. I have tried custom PropertyDescriptor approach outlined here but it did not seem to do anything at all and is too complex for me to debug if there is a simpler method.

I found a second approach here that works via the DGV CellFormatting event. This approach displayed the values in the cell correctly (yay!) but did not update the related object members when the data was edited or added in the DGV.

I attempted to modify the event handler but must have mucked it up somehow as while it does change the data, it also changes it for every other similarly bound cell also!! :eek: :confused:

What have I done wrong, how can I adjust it do act as I require?
Or is there a better method? Or even a fix for the PropertyDescriptor approach?

The relevant classes:

vb Code:

Public Class ParameterValue
    Public Property Value As Decimal
End Class
 
Public Class Parameter
    '... Other intrinsic-type members - these bind OK
    Public Property UpperLimit As ParameterValue = New Parameter Value 'How to bind the members of these?
    Public Property DefaultValue As ParameterValue = New Parameter Value
    Public Property LowerLimit As ParameterValue = New Parameter Value
End class
 
Public Class Profile
    ' ... Other members
    Public Property Parameters As BindingList(Of Parameter) = New BindingList(Of Parameter)
End Class

In the form:

vb Code:

Public Class Form1
    
    'A dummy ParameterValue object
    Dim TestValue As parameterValue = New ParameterValue With { _
        .Value = 10, _
    }
 
   'Some dummy objects with populated ParameterValue objects on the BindingList
    Dim TestParameters As BindingList(Of Parameters) = New BindingList(Of Parameters) From { _
        New Parameter With {.UpperLimit = testValue, DefaultValue = TestValue, .LowerLimit = TestValue}, _
        New Parameter With {.UpperLimit = testValue, DefaultValue = TestValue, .LowerLimit = TestValue}, _
        New Parameter With {.UpperLimit = testValue, DefaultValue = TestValue, .LowerLimit = TestValue} _
    }
 
    'A dummy Profile object with a populated BindingList
    Dim TestProfile As Profile = New Profile With {.Parameters = TestParameters}
 
    Private Sub Form1_Load(sender As System.Object, e As System.EventArgs) Handles MyBase.Load
         'Set the basic data binding up
         DataGridView1.AutoGenerateColumns = False
         DataGridView1.Columns("UpperLimit").DataPropertyName = "UpperLimit.Value"
         DataGridView1.Columns("DefaultValue").DataPropertyName = "DefaultValue.Value"
         DataGridView1.Columns("LowerLimit").DataPropertyName = "LowerLimit.Value"
         DataGridView1.DataSource = TestProfile .Parameters
    End Sub 
 
    Private Sub DataGridView1_CellFormatting(sender As Object, e As DataGridViewCellFormattingEventArgs) Handles DataGridView1.CellFormatting
        '"Fixes" the DataPropertyNames that use the dot operator before updating the value in the object and the DGV cell.
        Dim Grid As DataGridView = DirectCast(sender, DataGridView)
        Dim Row As DataGridViewRow = Grid.Rows(e.RowIndex)
        Dim Col As DataGridViewColumn = Grid.Columns(e.ColumnIndex)
        If Row.DataBoundItem IsNot Nothing AndAlso Col.DataPropertyName.Contains(".") Then 'Check if the DataPropertyName member of the current cell contains dot operators (".")
            Dim PropertyStrings As String() = Col.DataPropertyName.Split("."c) 'Split the member string at the dot operators
            Dim PropInfo As Reflection.PropertyInfo = Row.DataBoundItem.[GetType]().GetProperty(PropertyStrings(0)) 'Get the property that matches the first of the split strings from the type of the object bound to the current cell
            Dim ParentVal As Object = Nothing
            Dim Val As Object = PropInfo.GetValue(Row.DataBoundItem, Nothing) 'Get the value from the property
            For i As Integer = 1 To PropertyStrings.Length - 1 'Get the property then the value of any subsequent split strings
                ParentVal = Val 'Save the preceding value as the new parent object
                PropInfo = Val.[GetType]().GetProperty(PropertyStrings(i)) 'Get the child as the new current property
                Val = PropInfo.GetValue(Val, Nothing) ' Get the value of the new current property
            Next
            If (e.Value IsNot Nothing) Then
                If ((e.Value <> "") And (Convert.ChangeType(e.Value, PropInfo.PropertyType) <> Val)) Then 'Update the value in the object
                    PropInfo.SetValue(ParentVal, Convert.ChangeType(e.Value, PropInfo.PropertyType), Nothing)
                    Val = PropInfo.GetValue(ParentVal, Nothing) 'Get the value back from the object (in case the getter or setter alters the value)
                End If
            End If
            e.Value = Val 'Save the final value as the value to use in the cell
        End If
    End Sub
End Class

OK, so I reverted to the PropertyDescriptor approach after reading this Which showed that the previous example had a bit missing.

the columns now have data in them again!

But changing the data in one cell still results in it being changed seemingly random other cells that are of the same type... :confused:

So atm I have done away with the event handler from above and added the below classes, and applied and attribute of <TypeDescriptionProvider(GetType(ParameterDescriptionProvider))> to the Parameter class

vb Code:

Public Class ParameterPropertyDescriptor
    Inherits PropertyDescriptor
 
    Private _SubPD As PropertyDescriptor
    Private _ParentPD As PropertyDescriptor
 
    Public Sub New(parentPD As PropertyDescriptor, subPD As PropertyDescriptor, pdName As String)
        MyBase.New(pdName, Nothing)
        _SubPD = subPD
        _ParentPD = parentPD
    End Sub
 
    Public Overrides Function CanResetValue(component As Object) As Boolean
        Return False
    End Function
 
    Public Overrides ReadOnly Property ComponentType As System.Type
        Get
            Return _ParentPD.ComponentType
        End Get
    End Property
 
    Public Overrides Function GetValue(component As Object) As Object
        Return _SubPD.GetValue(_ParentPD.GetValue(component))
    End Function
 
    Public Overrides ReadOnly Property IsReadOnly As Boolean
        Get
            Return False
        End Get
    End Property
 
    Public Overrides ReadOnly Property PropertyType As System.Type
        Get
            Return _SubPD.PropertyType
        End Get
    End Property
 
    Public Overrides Sub ResetValue(component As Object)
        ' TODO: Code for this sub?
    End Sub
 
    Public Overrides Sub SetValue(component As Object, value As Object)
        _SubPD.SetValue(_ParentPD.GetValue(component), value)
        OnValueChanged(component, EventArgs.Empty)
    End Sub
 
    Public Overrides Function ShouldSerializeValue(component As Object) As Boolean
        Return True
    End Function
End Class
 
Public Class ParameterTypeDescriptor
    Inherits CustomTypeDescriptor
 
    Public Sub New(parent As ICustomTypeDescriptor)
        MyBase.New(parent)
    End Sub
 
    Public Overrides Function GetProperties() As System.ComponentModel.PropertyDescriptorCollection
        Dim Cols As PropertyDescriptorCollection = MyBase.GetProperties()
 
        Dim UpperLimitPD As PropertyDescriptor = Cols("UpperLimit")
        Dim UpperLimitChild As PropertyDescriptorCollection = UpperLimitPD.GetChildProperties()
        Dim DefaultValuePD As PropertyDescriptor = Cols("DefaultValue")
        Dim DefaultValueChild As PropertyDescriptorCollection = DefaultValuePD.GetChildProperties()
        Dim LowerLimitPD As PropertyDescriptor = Cols("LowerLimit")
        Dim LowerLimitChild As PropertyDescriptorCollection = LowerLimitPD.GetChildProperties()
 
        Dim array(Cols.Count + 2) As PropertyDescriptor
        Cols.CopyTo(array, 0)
        array(Cols.Count) = New ParameterPropertyDescriptor(UpperLimitPD, UpperLimitChild("Value"), "UpperLimit.Value")
        array(Cols.Count + 1) = New ParameterPropertyDescriptor(DefaultValuePD, DefaultValueChild("Value"), "DefaultValue.Value")
        array(Cols.Count + 2) = New ParameterPropertyDescriptor(LowerLimitPD, LowerLimitChild("Value"), "LowerLimit.Value")
 
        Dim NewCols As PropertyDescriptorCollection = New PropertyDescriptorCollection(array)
        Return NewCols
    End Function
 
    Public Overrides Function GetProperties(attributes() As Attribute) As System.ComponentModel.PropertyDescriptorCollection
        Return Me.GetProperties()
    End Function
End Class
 
Public Class ParameterDescriptionProvider
    Inherits TypeDescriptionProvider
 
    Private td As ICustomTypeDescriptor
 
    Public Sub New()
        Me.New(TypeDescriptor.GetProvider(GetType(Parameter)))
    End Sub
 
    Public Sub New(parent As TypeDescriptionProvider)
        MyBase.New(parent)
    End Sub
 
    Public Overrides Function GetTypeDescriptor(objectType As Type, instance As Object) As ICustomTypeDescriptor
        If td Is Nothing Then
            td = MyBase.GetTypeDescriptor(objectType, instance)
            td = New ParameterTypeDescriptor(td)
        End If
        Return td
    End Function
End Class

Got it.

When I set up my objects that I was testing with I created a single TestValue object of type ParameterValue.
then I set all of the ParameterValue type members in each Parameter equal to this object.

Thinking of course that I was being clever and saving typing. But of course I actually set the ParameterValue members to a Reference to the TestValue object!

This meant that when the binding updated a members of TestValue it was only one member shared between all the ParameterValue references and so updated everywhere else that it had been used as well... D'oh!!! Such a waste of most of the day :\

EDIT: Note that the descriptor approach is better than handling the CellFormatting event because the former automatically handles types, whereas the latter runs into type conflicts if the DGV column's bound data are not all of the same type and you wish to have data changes in the grid reflected by changes in the bound data

W99