The next most common request seems to be passing a value between two siblings. That is, two child classes sharing the same parent class. This also demonstrates passing between the child and the parent.
First, it is important to note that in most cases the two child classes should probably know nothing about each other. If the two child classes start to communicate directly with each other the coupling in the application increases and this will make maintenance of the application more difficult. Therefore the first thing to do is to allow the child classes to raise events when they change.
In order to raise events, create a delegate to define the signature of the method that will be called when the event is raised. It is a good practice to conform to the same style as the delegates used in the .NET Framework itself. For example, if an event handler for the
Click event of a Button is created then it is possible to see that the signature of the method created by the IDE has two parameters,
sender is an object and is a reference to the object that generated the event.
e is the
EventArgs (or a something derived from
With that in mind, the delegate created here will have
e parameters as well. But for the
e parameter a new class will be created to store the specific details of the event.
Public Class ValueUpdatedEventArgs
' Stores the new value
Dim _newValue As String
' Create a new instance of the
' ValueUpdatedEventArgs class.
' newValue represents the change to the value.
Public Sub New(ByVal newValue As String)
Me._newValue = newValue
' Gets the updated value
ReadOnly Property NewValue() As String
Next the delegate needs to be defined.
Public Delegate Sub ValueUpdated(ByVal sender As Object,
ByVal e As ValueUpdatedEventArgs)
Now that the foundation of the mechanism for informing other objects of changes is written, the child classes can implement the raising of events so that observers (i.e. interested parties) can be notified when the value changes.
Next, when the child class is updated it needs to inform its observers (the interested parties, in this case it will be the parent and sibling forms). The following code shows what happens when the text is changed on the form.
Private Sub uxMyValue_TextChanged(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles uxMyValue.TextChanged
Dim newValue As String
newValue = Me.uxMyValue.Text
Dim valueArgs As ValueUpdatedEventArgs
valueArgs = New ValueUpdatedEventArgs(newValue)
RaiseEvent ValueUpdated(Me, valueArgs)
Now that the child form can inform others of the changes and what the changes are, the parent needs to open the child form and register as an observer so that it can be informed when changes are made. The parent will also ensure that other siblings that are interested get added as observers too.
Private Sub uxOpenChildA_Click(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles uxOpenChildA.Click
' Create the child form
Me.childA = New ChildAForm
' Add a handler to this class for when child A is updated
AddHandler childA.ValueUpdated, AddressOf ChildAValueUpdated
If Not Me.childB Is Nothing Then
' Make sure that the siblings are informed of each other.
AddHandler childA.ValueUpdated, _
AddHandler childB.ValueUpdated, _
' Show the form
All that remains is to implement the event handlers.
Private Sub ChildAValueUpdated(ByVal sender As Object,
ByVal e As ValueUpdatedEventArgs) Handles childA.ValueUpdated
' Update the value on this form (the parent) with the
' value from the child.
Me.uxChildAValue.Text = e.NewValue
And similarly in the child class.
Public Sub ChildBValueUpdated(ByVal sender As Object, _
ByVal e As ValueUpdatedEventArgs)
Me.uxOtherValue.Text = e.NewValue
The code for this example is in the accompanying zip file. The project is called SiblingToSiblingCS (for the C# version) and SiblingToSiblinVB (for the VB.NET version)