can't wrap my mind around events

[John Salerno]

My general problem with events seems to be that there are so many parts
to them, and I'm not sure where they all go or when you use which parts.
For example, there's the delegate, the event name, the event handler,
then the coding that wires it together. For the most part, I do
understand these things, but I get confused when it comes to putting it
all together.

More specifically, here's some code from a book:

this.txtMonthly Investment.Text Changed += new
System.EventHan dler(this.txtMo nthlyInvestment _TextChanged);

First off, do you need the 'this' keyword? Second, where does this code
go? In the Load event of the form that contains the text box?

Another example:

ProductList products = new ProductList(); //an array list object

products.Change d += new EventHandler(Ch angedHandler);

Why isn't 'this' used in the second example? Is the book being
inconsistent, or is it a different situation? (In the book, it says it's
calling it from a different class, but I don't know what that means
exactly: "To handle an event from another class, you create an instance
of the class that raises the event and assign it to a class variable.")

Where does that first line go? (The declaration of products). The above
two lines are the entire example (except for the event handler itself),
so I think some stuff has been left out. It doesn't show which class
it's included in.
Basically I'm just very lost when it comes to events, and I always have.
I don't understand where all the code goes for each 'part', and that's
probably what it all comes down to, I guess.

Any help would be appreciated, or any suggestions for sites that clearly
explain events.

Thanks,
John

[John Salerno]

Hmm, it's starting to make a little more sense. I appreciate all this help.

I think one thing that had me confused at first (and that I see a little
more clearly now because I've seen an entire program presented in the
book I'm reading) is that I didn't realize that 'products' in one class
was different than 'products' in another class. I never realized this
because the code was presented in pieces, until I got to the end of the
chapter. Now I realize that each 'products' is a private member of its
own class, and is independent of the other.

Wavemaker wrote:

"John Salerno" wrote:

Let's say you have class A, which is a button. The event for this
class is Click. You want class B to respond to this click. Now, is
class B responding to a particular button's Click event, or just any
button that is instantiated from class A?

Depends on whether or not the event was declared as static. But we won't
go there because I think that would just make things more confusing,

So assuming the event exists at the instance level, in other words that
every instance of A has its own Click event, an instance of class B will
be responding to events from an instance of class A.

For example: I have an OK button that was created from class A, and
it's on my main form. In class B, when I'm writing the code to wire
the event to the event handler, do I need to refer to this button
specificall y, or do I simply create a new instance of A that isn't
even used in the program or anywhere on the form?

You need the instance of class A, the OK button, in order to wire it to
the instance of class B.

public class A
{
public event EventHandler Click;

// Normally, the method for raising an event is protected virtual,
// but this is just for demonstration purposes.
public void OnClick()
{
EventHandler handler = Click;

if(handler != null)
{
handler(this, EventArgs.Empty );
}
}
}

public class B
{
public B(A aInstance)
{
// Here we are connecting the event in an instance of
// class A to an instance of class B.
aInstance.Click += new EventHandler(Ha ndleClick);
}

private void HandleClick(obj ect sender, EventArgs e)
{
Console.WriteLi ne("Handled Click event.");
}
}

// Somewhere else in your application...

A a1 = new A();
B b1 = new B(a1);

A a2 = new A();
B b2 = new B(a2);

Now, an instance of class A called 'a1' is connected via the Click event
to an instance of class B called 'b1'. And an instance of class A called
a2 is connected via the Click event to an instance of class B called
'b2'.

When a1 raises its event through a call to the OnClick method, only b1
will respond to the event. Likewise, when a2 raises the Click event,
only b2 will respond.

[rhaley]

k. first off, this was GREAT exercise for me so thanks for the
googlespace.

This compiles in Mono (Fedora 4, Mono, MonoDevelop is my new toy :) -
can't get dovecot to work!!!) but I haven't figured out abstraction in
Mono so I had to implement everything three times... but this should be
a good example of delegates. Every call made to the BroadcastSometh ing
method in the 'RadioStation' class is handled by three entirely
independant 'Radio' objects. Two of them are BackwardsStatio n, one of
them is ForwardStation.
CODE:

//************Rad ioStationTestin g.cs ---
// created on 9/6/2005 at 6:02 PM
namespace Broadcaster
{
using System.Diagnost ics;
public delegate void SendAMessage(st ring strMessage);

public class RadioStation
{
public event SendAMessage BroadcastEvent;

public RadioStation() {}

public void BroadcastSometh ing(string strMyMessage)
{
if(BroadcastEve nt != null) //This is important. Always test
//before firing
{
BroadcastEvent( strMyMessage);
}
}
} //End Class

public abstract class Radio
{
public string _strRadioName;
public Radio(RadioStat ion rsNewStation, string strRadioName)
{
_strRadioName = strRadioName;
rsNewStation.Br oadcastEvent += new
SendAMessage(Di splayBroadcast) ;
}
public abstract void DisplayBroadcas t(string strStuff);
} //End class

public class BackwardsStatio n:RadioStation
{
public string _strRadioName;
public BackwardsStatio n(RadioStation rsNewStation, string
strRadioName)
{
_strRadioName = strRadioName;
rsNewStation.Br oadcastEvent += new
SendAMessage(Di splayBroadcast) ;
}

public void DisplayBroadcas t(string strStuff)
{
string strTemp = "";
for(int i = strStuff.Length - 1; i > 0 ; i--)
{
strTemp += strStuff.Substr ing(i,1);
}
System.Console. WriteLine("Reci eved from radio " +
_strRadioName + ": " + strTemp);
}
}

public class ForwardStation: RadioStation
{
public string _strRadioName;
public ForwardStation( RadioStation rsNewStation, string
strRadioName)
{
_strRadioName = strRadioName;
rsNewStation.Br oadcastEvent += new
SendAMessage(Di splayBroadcast) ;
}

public void DisplayBroadcas t(string strStuff)
{
System.Console. WriteLine("Reci eved from radio " +
_strRadioName + ": " + strStuff);
}
}
}
/*************** *************/
namespace Testing
{
using Broadcaster;
using System.Collecti ons;
public class MyTest
{
public RadioStation _rsHeavyMetalHe aven = new RadioStation();
public ArrayList _alRadio = new ArrayList();
private RadioStation RadioStation1;
private RadioStation RadioStation2;
private RadioStation RadioStation3;

public MyTest()
{
RadioStation1 = new BackwardsStatio n(_rsHeavyMetal Heaven,
"Radio #1");
RadioStation2 = new ForwardStation( _rsHeavyMetalHe aven,
"Radio #2");
RadioStation3 = new BackwardsStatio n(_rsHeavyMetal Heaven, "Radio
#3");
}
}
}
///-----------End File
//File: Main.cs
// project created on 9/6/2005 at 6:01 PM
using System;
using Testing;

class MainClass
{
public static void Main(string[] args)
{
MyTest mt= new MyTest();
mt._rsHeavyMeta lHeaven.Broadca stSomething("Gr owl,growl...
DIE DIE DIE!");
mt._rsHeavyMeta lHeaven.Broadca stSomething("Th at was
VegetarianDogs with 'die'. " +
"And now a word from our sponsor...");
}
}

OUTPUT:
--Sorry, I can't seem to capture my console window output in Fedora...
(I suck :{ )
Back to Windows Land:
If, in VS.Net (2003) you simply moved the Testing namespace to one
project, and the Broadcast namespace to a different one and included a
reference to Broadcast in Testing, you may start to see the value in
this. I have one class (a wrapper around a serial port driver) that
fires an event that is consumed by a windows form, a class on an
independant thread and Log4Net all at the same time, in multiple
projects and namespaces...

I have a different project where a Windows User control takes an object
from an independant thread as a parameter in the constructor (much like
Radio class). Basically it allows me to talk back to any independant
control from an entirely independant thread .

NOTE:
I have found that in any class I fire an event from, I MUST wrap the
call in a "!= null" check. Otherwise if no handler for the event is
ever created, it throws an exception. (Any opinions on this?)

k. Gonna give it a rest now. Hope nobody else ever has to go through my
pain to figure out delegates again. :)

Russ