Form Changed Control

• Download VB.NET FormChangeControl_src.zip - 79.0 KB
• Download C# FormChangeControlTest_CSharp_src.zip - 18.0 KB

Introduction

This control is a quick and dirty compontent (based on the System.ComponentModel.IExtenderProvider ) that allows you to list all the components that have been changed e.g. to allow you to decide whether a form needs to be saved.

Background

This is a quick and dirty solution to the "how do I know if any data on my form has changed" problem. It allows you to alter the user interface to show that it has changed and also to decide what needs to be saved.

Using the code

The component has one property: ControlsThatHaveChanged that is a generic list of all the controls whose data have changed since the last reset. If this list isn't empty then the form has changed and needs to be saved.

There is one method: ResetDirtyFlags which allows you to reset the list of controls that have changed - call this when the form is populated or the data are saved.

In addition, an event is raised whenever a control that is being monitored for changes is changed or changed back to its initial state.

 
    Private Sub FormChangedComponent1_FormControlChanged(ByVal sender As Object, _ 
             ByVal e As FormChangedEventArgs) _ 
             Handles FormChangedComponent1.FormControlChanged
        If TypeOf e.ControlChanged Is TextBox Then
            If e.Changed Then
                e.ControlChanged.BackColor = Color.Yellow
            Else
                e.ControlChanged.BackColor = Color.White
            End If
        End If
    End Sub  

C#

        void formChangedComponent1_MonitoredControlChanged(object sender, FormChangedEventArgs e)
        {
            if (e.ControlChanged is TextBox)
            {
                if (e.Changed)
                {
                    e.ControlChanged.BackColor = Color.Yellow; 
                }
                else 
                {
                    e.ControlChanged.BackColor = Color.White;
                }
            }
        }

How it works

The component implements the Implements System.ComponentModel.IExtenderProvider to extend the controls on a form and provides thre new properties to each of these controls:

MonitorForChanges - Set to True to monitor a control for changes

ChangeEventToMonitor - Set this to the name of the event to watch (e.g. "ValueChanged" or whichever for the control)

ValueNameToMonitor - Set this to the name of the property that represents the value of the control (e.g. "Text" for a textbox)

Note that these properties are case sensitive which can be a trap for the unwary

Where a component has this extended property set to True the component adds a handler to its "Changed" event specified and when that event fires, it updates an internal generic collection of the components that have changed

The component can be reset (i.e. all controls are marked as unchanged) after a save event or when a record has been refreshed

    
Public Sub SetMonitorForChanges(ByVal ctl As Control, ByVal value As Boolean)
        If value Then
            If Not _ControlChanged.ContainsKey(ctl) Then
                _ControlChanged.Add(ctl, False)
                Dim evi As System.Reflection.EventInfo
                evi = ctl.GetType.GetEvent(Me.GetChangeEventName(ctl))
                If Not (evi Is Nothing) Then
                    '\\ Get the method that adds a handler to the changed event
                    Dim mi As System.Reflection.MethodInfo
                    mi = evi.GetAddMethod(False)
                    '\\ add a handler to that changed event
                    mi.Invoke(ctl, New Object() {Me.ChangeEventhandler})
                End If
            End If
        Else
            If _ControlChanged.ContainsKey(ctl) Then
                _ControlChanged.Remove(ctl)
            End If
        End If
    End Sub

C#

            private void ResetMonitoringState()
            {
                System.Reflection.EventInfo evi;
                Type ctlType = _ctlToMonitor.GetType();
                evi = ctlType.GetEvent(_ChangeEventName);

                if (_MonitoringEvent )
                {
                    // Remove the event handler from the control
                    if ( evi != null)
                    {
                        System.Reflection.MethodInfo mi = evi.GetRemoveMethod(false);
                        mi.Invoke(_ctlToMonitor, new object[] { this.ChangeEventhandler() });
                    }
                }
                
                if (_Monitor )
                {
                    // Add the event handler to the control
                    if (evi != null)
                    {
                        System.Reflection.MethodInfo mi = evi.GetAddMethod(false);
                        mi.Invoke(_ctlToMonitor, new object[] { this.ChangeEventhandler() });
                        _MonitoringEvent = true;
                    }
                }
            }

History

2007-06-28 First release

2007-07-03 Added properties to specify what event and value are being monitored and changed the code to do a true changed check using the hash value of the property

2007-09-13 Added an event whenever a control being monitored changes or is changed back to its previous state

2008-05-26 Added C# code version