{"id":57,"date":"2011-07-22T12:18:23","date_gmt":"2011-07-22T17:18:23","guid":{"rendered":"http:\/\/kratzindustries.com\/CodeRedBlog\/?p=57"},"modified":"2014-03-27T04:36:51","modified_gmt":"2014-03-27T04:36:51","slug":"formclass-mapping-with-custom-provider-control","status":"publish","type":"post","link":"https:\/\/burnt-traces.com\/?p=57","title":{"rendered":"Form\/Class Mapping With Custom Provider Control"},"content":{"rendered":"

In my last article<\/a>, I talked a little bit about taking time to program for yourself. The example used was a drop-down list control that automatically filled itself from an enumeration. Today, we will be looking at the process of filling a form from, and copying data back to, a class. A typical situation for software that deals with user input. Whether its data collection, sales order entry, or whatever, the standard CRUD <\/a>(create,read,update,delete) theme is repeated over and over again. With anything that is repeated over and over, it can, and probably should be automated. The following is a simplified example of how to replace the process of manually ‘gluing’ your forms controls to the underlying class object.<\/p>\n

I’ve explored the process of doing this before in other projects. The original scheme was to create a base class that all other controls\/forms would inherit from that contained all the generic code for filling the controls and updating the class. Although this worked quite well, you can always learn something from exploring a new approach. So, instead of using a universal base control\/form, we will instead be using a Custom Provider Control<\/a>. To explain, this is similar to how the ToolTip component works. It provides a service to the form\/control its placed on, and adds a property to each control in the property designer. So our control will provide the service of filling the form with class data, and updating the class data when the user changes what’s on the form.<\/p>\n

First things first, we need to create or provider control. If you read the linked article above, you see that we just have to create a new class that inherits from System.ComponentModel.Component<\/a><\/code>, and implements the System.ComponentModel.IExtenderProvider<\/a><\/code> interface. It also needs to have a System.ComponentModel.ProvideProperty<\/a><\/code> attribute, which give the property to be added to controls in the property wizard and also give a control type filter.<\/p>\n

\r\n<System.ComponentModel.ProvideProperty("PropertyName", GetType(Control))>\r\nPublic Class ControlMapper\r\n    Inherits System.ComponentModel.Component\r\n    Implements System.ComponentModel.IExtenderProvider\r\n<\/pre>\n
The property name we give to the ProvideProperty<\/code> attribute is “PropertyName”, since what we are mapping our controls to are public properties of a class. The type filter we give it is just Control<\/code>, since we could bind a property to almost any type of control we can code for. That leads us to the implementation of the IExtenderProvider<\/code> interface, which contains only one method, CanExtend<\/a><\/code>. CanExtend<\/code> is called for any control in the form and we return True<\/code> if our class will extend it, or False<\/code> if it will not.<\/p>\n
\r\n    Public Function CanExtend(ByVal extendee As Object) As Boolean Implements System.ComponentModel.IExtenderProvider.CanExtend\r\n        If extendee.GetType Is GetType(TextBox) Then\r\n            Return True\r\n        Else\r\n            Return False\r\n        End If\r\n    End Function\r\n<\/pre>\n
For simplicity of the example, we will only deal with text boxes. I’ll leave it as an exercise for you to extend the class to handle other controls like combo boxes, picture boxes, calendars, etc. Now, the next thing that needs to be created is a Get and Set function for the property name we gave to the ProvideProperty<\/code> attribute, in the format of Get<\/b>PropertyName<\/i> and Set<\/b>PropertyName<\/i>. These functions will use a private member Mapped<\/code> which is an instance of Dictionary(of Control, String)<\/code>. This local will track the controls that are being associated to the provider and the property name that was set in the designer. We also set up and event handler when the property is set, so that we can update the forms class when the text is changed by the user.<\/p>\n
\r\n\r\n    Public Function GetPropertyName(ByVal myControl As Control) As String\r\n        'Get property name based on control, return empty string if not found\r\n        If Mapped.ContainsKey(myControl) Then\r\n            Return Mapped.Item(myControl)\r\n        Else\r\n            Return ""\r\n        End If\r\n    End Function\r\n\r\n    Public Sub SetPropertyName(ByVal myControl As Control, ByVal value As String)\r\n        'Add property\/control pair to dictionary\r\n        If Mapped.ContainsKey(myControl) Then\r\n            Mapped.Item(myControl) = value\r\n        Else\r\n            Mapped.Add(myControl, value)\r\n        End If\r\n        'Add event handler for control type\r\n        If myControl.GetType() Is GetType(TextBox) Then\r\n            Dim tb As TextBox = myControl\r\n            AddHandler tb.TextChanged, AddressOf Me.TextChanged\r\n        End If\r\n    End Sub\r\n<\/pre>\n
Now, we need to add a public property to the provider itself, so the form using it can give it a pointer to the class object that the form is editing. <\/p>\n
\r\nPublic Property FormObject As Object\r\n<\/pre>\n
And we will add a private field, to mark when we are filling the form. This will server to let us ignore events while we populate controls with class object data. <\/p>\n
\r\nDim Filling As Boolean = False\r\n<\/pre>\n
Now, the first thing we have to do before we edit data, is that we must load it to be edited. So a method is needed to fill all the associated controls with the value of the property they were mapped to. We first loop through the KeyValuePair(of Control, String)<\/code> that are stored in our Mapped<\/code> dictionary, this gives us the control object and the name of the property it is bound to. <\/p>\n
\r\nDim Cntl As Control = item.Key\r\nDim PropertyName As String = item.Value\r\n<\/pre>\n
Then, using reflection, we can retrieve the PropertyInfo<\/code> for the property name and use it to get the value from the class object.<\/p>\n
\r\nDim Prop = FormObject.GetType().GetProperty(PropertyName)\r\nValue = Prop.GetValue(FormObject, Nothing)\r\n<\/pre>\n
Here’s the complete fill method, complete with null checks, etc.<\/p>\n
\r\n    Public Sub FillFromClass()\r\n        'Check for null\r\n        If FormObject IsNot Nothing Then\r\n            Try\r\n                'Set filing flag, use try...finally structure to \r\n                'ensure the flag is always turned off\r\n                Filling = True\r\n                'Loop through all handled controls\r\n                For Each item In Mapped\r\n                    'Get control on property name from dictionary item\r\n                    Dim Cntl As Control = item.Key\r\n                    Dim PropertyName As String = item.Value\r\n                    'Get value from class \r\n                    Dim Value As Object\r\n                    'Get reflection property\r\n                    Dim Prop = FormObject.GetType().GetProperty(PropertyName)\r\n                    'Check null \r\n                    If Prop IsNot Nothing Then\r\n                        'get property value\r\n                        Value = Prop.GetValue(FormObject, Nothing)\r\n                        'Set value according to control type \r\n                        If Cntl.GetType() Is GetType(TextBox) Then\r\n                            'Set text property for text boxes\r\n                            Dim TB As TextBox = Cntl\r\n                            TB.Text = Value\r\n                            'Done!\r\n                        End If\r\n                    End If\r\n                Next\r\n            Finally\r\n                Filling = False\r\n            End Try\r\n        End If\r\n    End Sub\r\n<\/pre>\n
As you may have seen in the SetPropertyName<\/code> method, we are adding an event handler to the TextChanged<\/code> event of the text box. This event will handle updating the FormObject<\/code> with the value from the modified control. We can use the GetPropertyName<\/code> function to get the name of the property the control is bound to so that we can update FormObject<\/code> using reflection. <\/p>\n
\r\n    Private Sub TextChanged(ByVal sender As Control, ByVal e As EventArgs)\r\n        'Check for DesingMode\r\n        If Not DesignMode Then\r\n            'Check if the control is being filled\r\n            If Not Filling Then\r\n                'Check for null\r\n                If FormObject IsNot Nothing Then\r\n                    'Get the name of the property bound to control\r\n                    Dim PropetyName = GetPropertyName(sender)\r\n                    'Check if found\r\n                    If PropetyName <> "" Then\r\n                        'Get property using reflection\r\n                        Dim Prop = FormObject.GetType().GetProperty(PropetyName)\r\n                        'Check null\r\n                        If Prop IsNot Nothing Then\r\n                            'Get value based on control type \r\n                            Dim Value As Object\r\n                            If sender.GetType() Is GetType(TextBox) Then\r\n                                'Get text property\r\n                                Value = CType(sender, TextBox).Text\r\n                            Else\r\n                                'Unsupported control type\r\n                                Return\r\n                            End If\r\n                            'Set the value of the class to the new value\r\n                            Prop.SetValue(FormObject, Value, Nothing)\r\n                            'All done!\r\n                        End If\r\n                    End If\r\n                End If\r\n            End If\r\n        End If\r\n    End Sub\r\n<\/pre>\n
That completes our provider. Here’s the complete code.<\/p>\n
\r\n\r\n<System.ComponentModel.ProvideProperty("PropertyName", GetType(Control))>\r\nPublic Class ControlMapper\r\n    Inherits System.ComponentModel.Component\r\n    Implements System.ComponentModel.IExtenderProvider\r\n\r\n    ''' <summary>\r\n    ''' Dictionary to hold control\/property mapping\r\n    ''' <\/summary>\r\n    ''' <remarks><\/remarks>\r\n    Dim Mapped As Dictionary(Of Control, String)\r\n\r\n    Public Sub New()\r\n        'Instantiate the dictionary\r\n        Mapped = New Dictionary(Of Control, String)\r\n    End Sub\r\n\r\n    ''' <summary>\r\n    ''' Get function used by the ProvideProperty attribute\r\n    ''' <\/summary>\r\n    ''' <param name="myControl"><\/param>\r\n    ''' <returns><\/returns>\r\n    ''' <remarks><\/remarks>\r\n    Public Function GetPropertyName(ByVal myControl As Control) As String\r\n        'Get property name based on control, return empty string if not found\r\n        If Mapped.ContainsKey(myControl) Then\r\n            Return Mapped.Item(myControl)\r\n        Else\r\n            Return ""\r\n        End If\r\n    End Function\r\n\r\n    ''' <summary>\r\n    ''' Set function used by the ProvideProperty attribute\r\n    ''' <\/summary>\r\n    ''' <param name="myControl"><\/param>\r\n    ''' <param name="value"><\/param>\r\n    ''' <remarks><\/remarks>\r\n    Public Sub SetPropertyName(ByVal myControl As Control, ByVal value As String)\r\n        'Add property\/control pair to dictionary\r\n        If Mapped.ContainsKey(myControl) Then\r\n            Mapped.Item(myControl) = value\r\n        Else\r\n            Mapped.Add(myControl, value)\r\n        End If\r\n        'Add event handler for control type\r\n        If myControl.GetType() Is GetType(TextBox) Then\r\n            Dim tb As TextBox = myControl\r\n            AddHandler tb.TextChanged, AddressOf Me.TextChanged\r\n        End If\r\n    End Sub\r\n\r\n    ''' <summary>\r\n    ''' The IExtenderProvider interface, returns true if the passed control type can be extended.\r\n    ''' <\/summary>\r\n    ''' <param name="extendee"><\/param>\r\n    ''' <returns><\/returns>\r\n    ''' <remarks><\/remarks>\r\n    Public Function CanExtend(ByVal extendee As Object) As Boolean Implements System.ComponentModel.IExtenderProvider.CanExtend\r\n        If extendee.GetType Is GetType(TextBox) Then\r\n            Return True\r\n        Else\r\n            Return False\r\n        End If\r\n    End Function\r\n\r\n    ''' <summary>\r\n    ''' Used to set the class the form will be updating\r\n    ''' <\/summary>\r\n    ''' <value><\/value>\r\n    ''' <returns><\/returns>\r\n    ''' <remarks><\/remarks>\r\n    Public Property FormObject As Object\r\n\r\n    ''' <summary>\r\n    ''' Internal flag the the form is being filled\r\n    ''' value changes should be ignored when true\r\n    ''' <\/summary>\r\n    ''' <remarks><\/remarks>\r\n    Dim Filling As Boolean = False\r\n\r\n    ''' <summary>\r\n    ''' Called to initiallize all controls from the values stored in the class\r\n    ''' <\/summary>\r\n    ''' <remarks><\/remarks>\r\n    Public Sub FillFromClass()\r\n        'Check for null\r\n        If FormObject IsNot Nothing Then\r\n            Try\r\n                'Set filing flag, use try...finally structure to \r\n                'ensure the flag is always turned off\r\n                Filling = True\r\n                'Loop through all handled controls\r\n                For Each item In Mapped\r\n                    'Get control on property name from dictionary item\r\n                    Dim Cntl As Control = item.Key\r\n                    Dim PropertyName As String = item.Value\r\n                    'Get value from class \r\n                    Dim Value As Object\r\n                    'Get reflection property\r\n                    Dim Prop = FormObject.GetType().GetProperty(PropertyName)\r\n                    'Check null \r\n                    If Prop IsNot Nothing Then\r\n                        'get property value\r\n                        Value = Prop.GetValue(FormObject, Nothing)\r\n                        'Set value according to control type \r\n                        If Cntl.GetType() Is GetType(TextBox) Then\r\n                            'Set text property for text boxes\r\n                            Dim TB As TextBox = Cntl\r\n                            TB.Text = Value\r\n                            'Done!\r\n                        End If\r\n                    End If\r\n                Next\r\n            Finally\r\n                Filling = False\r\n            End Try\r\n        End If\r\n    End Sub\r\n\r\n    Private Sub TextChanged(ByVal sender As Control, ByVal e As EventArgs)\r\n        'Check for DesingMode\r\n        If Not DesignMode Then\r\n            'Check if the control is being filled\r\n            If Not Filling Then\r\n                'Check for null\r\n                If FormObject IsNot Nothing Then\r\n                    'Get the name of the property bound to control\r\n                    Dim PropetyName = GetPropertyName(sender)\r\n                    'Check if found\r\n                    If PropetyName <> "" Then\r\n                        'Get property using reflection\r\n                        Dim Prop = FormObject.GetType().GetProperty(PropetyName)\r\n                        'Check null\r\n                        If Prop IsNot Nothing Then\r\n                            'Get value based on control type \r\n                            Dim Value As Object\r\n                            If sender.GetType() Is GetType(TextBox) Then\r\n                                'Get text property\r\n                                Value = CType(sender, TextBox).Text\r\n                            Else\r\n                                'Unsupported control type\r\n                                Return\r\n                            End If\r\n                            'Set the value of the class to the new value\r\n                            Prop.SetValue(FormObject, Value, Nothing)\r\n                            'All done!\r\n                        End If\r\n                    End If\r\n                End If\r\n            End If\r\n        End If\r\n    End Sub\r\n\r\nEnd Class\r\n<\/pre>\n
Now, if you build you project, you should be able to drag and drop the provider control right onto your form. <\/p>\n
\"\"<\/a><\/p>\n
Let’s create a simple class to test our new control.<\/p>\n
\r\nPublic Class ExampleClass\r\n\r\n    Public Property Name As String\r\n\r\n    Public Property City As String\r\n\r\n    Public Property State As String\r\n\r\n    Public Sub New()\r\n        Name = "Testing Testerton"\r\n        City = "Anytown"\r\n        State = "WI"\r\n    End Sub\r\n\r\nEnd Class\r\n<\/pre>\n
Simple enough. We also need a form with some text boxes, like this.<\/p>\n
\"\"<\/a><\/p>\n
After you drag a ControlMapper onto your form, you will notice that it appear in the designer in the component tray. You will also see that each text box will gain a new property.<\/p>\n
\"\"<\/a><\/p>\n
\"\"<\/a><\/p>\n
Now for each of the text boxes, you just have to fill in the new PropertyName property with the name of the property in ExampleClass<\/code> you want it to be mapped to. In the example form, we will create a new instance of ExampleClass<\/code> and assign the ControlMapper1.FormObject<\/code> that instance.<\/p>\n
\r\n        FormObject = New ExampleClass\r\n        ControlMapper1.FormObject = FormObject\r\n<\/pre>\n
Then to demonstrate that the form filling works, we will call ControlMapper1.FillFromClass()<\/code> in the Load<\/code> event of the form.<\/p>\n
\r\n    Private Sub Form1_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load\r\n        'Fill the form with the class values\r\n        ControlMapper1.FillFromClass()\r\n    End Sub\r\n<\/pre>\n
Lastly, we can demonstrate that the updating works by displaying a message box with the updated values when we click on the button.<\/p>\n
\r\n    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click\r\n        Dim Msg As String = String.Format("Name: {0}, City: {1}, State: {2}", FormObject.Name, FormObject.City, FormObject.State)\r\n        MsgBox(Msg)\r\n    End Sub\r\n<\/pre>\n
Here’s the complete example form code.<\/p>\n
\r\nPublic Class Form1\r\n\r\n    Dim FormObject As ExampleClass\r\n\r\n    Public Sub New()\r\n        ' This call is required by the designer.\r\n        InitializeComponent()\r\n        ' Add any initialization after the InitializeComponent() call.\r\n\r\n        'Setup form object, and add to control mapper\r\n        FormObject = New ExampleClass\r\n        ControlMapper1.FormObject = FormObject\r\n    End Sub\r\n\r\n    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click\r\n        Dim Msg As String = String.Format("Name: {0}, City: {1}, State: {2}", FormObject.Name, FormObject.City, FormObject.State)\r\n        MsgBox(Msg)\r\n    End Sub\r\n\r\n    Private Sub Form1_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load\r\n        'Fill the form with the class values\r\n        ControlMapper1.FillFromClass()\r\n    End Sub\r\nEnd Class\r\n<\/pre>\n
Lets see this in action. First the form fill.
\n\"\"<\/a><\/p>\n
The let’s edit the values.<\/p>\n
\"\"<\/a><\/p>\n
Let’s click the button to see if the class was updated.<\/p>\n
\"\"<\/a><\/p>\n
It may seem a bit much for a filling a couple text boxes, but when multiple control types are supported, the forms get big, and there are lots of forms, such an automation of the fill-form\/update-object cycle can be a big time saver when building your forms. It reduces coding needed to make the form and update the form, and by implementing a reusable component, reduces the risk of introducing errors when you update.<\/p>\n
Download the Sample Project.<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
In my last article, I talked a little bit about taking time to program for yourself. The example used was a drop-down list control that automatically filled itself from an enumeration. Today, we will be looking at the process of filling a form from, and copying data back to, a class. A typical situation for… Read More »Form\/Class Mapping With Custom Provider Control<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"neve_meta_sidebar":"","neve_meta_container":"","neve_meta_enable_content_width":"","neve_meta_content_width":0,"neve_meta_title_alignment":"","neve_meta_author_avatar":"","neve_post_elements_order":"","neve_meta_disable_header":"","neve_meta_disable_footer":"","neve_meta_disable_title":"","footnotes":""},"categories":[5],"tags":[12,13,88,27],"class_list":["post-57","post","type-post","status-publish","format-standard","hentry","category-vb-net","tag-controls","tag-crud","tag-vb-net","tag-winforms"],"_links":{"self":[{"href":"https:\/\/burnt-traces.com\/index.php?rest_route=\/wp\/v2\/posts\/57","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/burnt-traces.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/burnt-traces.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/burnt-traces.com\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/burnt-traces.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=57"}],"version-history":[{"count":1,"href":"https:\/\/burnt-traces.com\/index.php?rest_route=\/wp\/v2\/posts\/57\/revisions"}],"predecessor-version":[{"id":330,"href":"https:\/\/burnt-traces.com\/index.php?rest_route=\/wp\/v2\/posts\/57\/revisions\/330"}],"wp:attachment":[{"href":"https:\/\/burnt-traces.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=57"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/burnt-traces.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=57"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/burnt-traces.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=57"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}