How do I isolate event-generating code in a derived class?

[Elder Hyde]

Hey all,

A class of mine needs to tell the outside world when its buffer is not
empty. The problem is that C# seems to force you to put the
event-raising code in the base class. To illustrate, consider what I'll
do in Java:

public interface DataAvailabilit yListener extends java.util.Event Listener {
void dataArrived(Dat aAvailabilityEv ent event);
}

then, in my base class, I can do this:

public abstract class SmartQueue {
addDataAvailabi lityListener(Da taAvailabilityL istener listener);
}

then in my implementation class, say a memory-backed smart queue, I can
do this:

public class MemorySmartQueu e implements SmartQueue {
public void poolForData() {
// data available!
while(iter.hasN ext()) {
DataAvailabilit yListener lis =
(DataAvailabili tyListener)iter .next();
lis.dataArrived (someEvent);
}
}
}

Simple and straighforward. However, consider a C# implementation: in the
interface, I may have something like this:

public abstract class SmartQueue {
public event DataAvailabilit yEventHandler DataArrived;
}

Now, consider what I have to do in MemorySmartQueu e:

public class MemorySmartQueu e : SmartQueue {
public override void poolForData() {
// data available!
if(DataArrived == null) {
// BZZZZTTT!!! Can only do this in SmartQueue!
DataArrived(thi s, args);
}
}
}

I can't believe this. Either I'm missing a really obvious thing, or I
have to deal with this... this... awkward mechanism. Why the hell
doesn't it allow me to raise an event in the derived class? I don't want
to put any behaviour in my abstract class, I want to put just an interface!

Is there any way around this? (Plus I hope Whidbey will give us a Set
collection, dammit).

TIA!
Elder

[Elder Hyde]

Oops, please replace "implements " with "extends" :)

Elder Hyde wrote:

Hey all,

A class of mine needs to tell the outside world when its buffer is not
empty. The problem is that C# seems to force you to put the
event-raising code in the base class. To illustrate, consider what I'll
do in Java:

public interface DataAvailabilit yListener extends java.util.Event Listener {
void dataArrived(Dat aAvailabilityEv ent event);
}

then, in my base class, I can do this:

public abstract class SmartQueue {
addDataAvailabi lityListener(Da taAvailabilityL istener listener);
}

then in my implementation class, say a memory-backed smart queue, I can
do this:

public class MemorySmartQueu e implements SmartQueue {
public void poolForData() {
// data available!
while(iter.hasN ext()) {
DataAvailabilit yListener lis =
(DataAvailabili tyListener)iter .next();
lis.dataArrived (someEvent);
}
}
}

Simple and straighforward. However, consider a C# implementation: in the
interface, I may have something like this:

public abstract class SmartQueue {
public event DataAvailabilit yEventHandler DataArrived;
}

Now, consider what I have to do in MemorySmartQueu e:

public class MemorySmartQueu e : SmartQueue {
public override void poolForData() {
// data available!
if(DataArrived == null) {
// BZZZZTTT!!! Can only do this in SmartQueue!
DataArrived(thi s, args);
}
}
}

I can't believe this. Either I'm missing a really obvious thing, or I
have to deal with this... this... awkward mechanism. Why the hell
doesn't it allow me to raise an event in the derived class? I don't want
to put any behaviour in my abstract class, I want to put just an interface!

Is there any way around this? (Plus I hope Whidbey will give us a Set
collection, dammit).

TIA!
Elder

[Chris Taylor]

Hi,

It is standard to implement a method to fire the event, this method is the
event name prefixed with 'On'. So in your case the base class would have a
OnDataArrived, which can be called from anywhere. This has the advantage of
not having to cluter your code checking if the event has any delegates
before firing and also gives the derived implementation an alternative and
better performing method of handling the event by overriding the On...
method.

public abstract class SmartQueue
{
public event DataAvailabilit yEventHandler DataArrived;

// This is called to fire the event
public void OnDataArrived( YourEventArgs e )
{
if ( DataArrived != null )
DataArrived( this, e );
}
}

public class MemorySmartQueu e : SmartQueue
{
public override void poolForData()
{
// data available!
OnDataArrived( args ); // Fire the event
}
}
Hope this helps
--
Chris Taylor
http://dotnetjunkies.com/WebLog/chris.taylor/
"Elder Hyde" <no_way> wrote in message
news:%2******** ********@TK2MSF TNGP12.phx.gbl. ..

Hey all,

A class of mine needs to tell the outside world when its buffer is not
empty. The problem is that C# seems to force you to put the
event-raising code in the base class. To illustrate, consider what I'll
do in Java:

public interface DataAvailabilit yListener extends java.util.Event Listener { void dataArrived(Dat aAvailabilityEv ent event);
}

then, in my base class, I can do this:

public abstract class SmartQueue {
addDataAvailabi lityListener(Da taAvailabilityL istener listener);
}

then in my implementation class, say a memory-backed smart queue, I can
do this:

public class MemorySmartQueu e implements SmartQueue {
public void poolForData() {
// data available!
while(iter.hasN ext()) {
DataAvailabilit yListener lis =
(DataAvailabili tyListener)iter .next();
lis.dataArrived (someEvent);
}
}
}

Simple and straighforward. However, consider a C# implementation: in the
interface, I may have something like this:

public abstract class SmartQueue {
public event DataAvailabilit yEventHandler DataArrived;
}

Now, consider what I have to do in MemorySmartQueu e:

public class MemorySmartQueu e : SmartQueue {
public override void poolForData() {
// data available!
if(DataArrived == null) {
// BZZZZTTT!!! Can only do this in SmartQueue!
DataArrived(thi s, args);
}
}
}

I can't believe this. Either I'm missing a really obvious thing, or I
have to deal with this... this... awkward mechanism. Why the hell
doesn't it allow me to raise an event in the derived class? I don't want
to put any behaviour in my abstract class, I want to put just an interface!
Is there any way around this? (Plus I hope Whidbey will give us a Set
collection, dammit).

TIA!
Elder

How can we perform an Async event in C#?

Events are Synchronous usually. Do we just call BeginInvoke, if so, how
would we do this?

"Chris Taylor" <ch************ *@hotmail.com> wrote in message
news:#G******** ******@TK2MSFTN GP10.phx.gbl...

Hi,

It is standard to implement a method to fire the event, this method is the
event name prefixed with 'On'. So in your case the base class would have a
OnDataArrived, which can be called from anywhere. This has the advantage of not having to cluter your code checking if the event has any delegates
before firing and also gives the derived implementation an alternative and
better performing method of handling the event by overriding the On...
method.

public abstract class SmartQueue
{
public event DataAvailabilit yEventHandler DataArrived;

// This is called to fire the event
public void OnDataArrived( YourEventArgs e )
{
if ( DataArrived != null )
DataArrived( this, e );
}
}

public class MemorySmartQueu e : SmartQueue
{
public override void poolForData()
{
// data available!
OnDataArrived( args ); // Fire the event
}
}
Hope this helps
--
Chris Taylor
http://dotnetjunkies.com/WebLog/chris.taylor/
"Elder Hyde" <no_way> wrote in message
news:%2******** ********@TK2MSF TNGP12.phx.gbl. ..

Hey all,

A class of mine needs to tell the outside world when its buffer is not
empty. The problem is that C# seems to force you to put the
event-raising code in the base class. To illustrate, consider what I'll
do in Java:

public interface DataAvailabilit yListener extends

java.util.Event Listener {

void dataArrived(Dat aAvailabilityEv ent event);
}

then, in my base class, I can do this:

public abstract class SmartQueue {
addDataAvailabi lityListener(Da taAvailabilityL istener listener);
}

then in my implementation class, say a memory-backed smart queue, I can
do this:

public class MemorySmartQueu e implements SmartQueue {
public void poolForData() {
// data available!
while(iter.hasN ext()) {
DataAvailabilit yListener lis =
(DataAvailabili tyListener)iter .next();
lis.dataArrived (someEvent);
}
}
}

Simple and straighforward. However, consider a C# implementation: in the
interface, I may have something like this:

public abstract class SmartQueue {
public event DataAvailabilit yEventHandler DataArrived;
}

Now, consider what I have to do in MemorySmartQueu e:

public class MemorySmartQueu e : SmartQueue {
public override void poolForData() {
// data available!
if(DataArrived == null) {
// BZZZZTTT!!! Can only do this in SmartQueue!
DataArrived(thi s, args);
}
}
}

I can't believe this. Either I'm missing a really obvious thing, or I
have to deal with this... this... awkward mechanism. Why the hell
doesn't it allow me to raise an event in the derived class? I don't want
to put any behaviour in my abstract class, I want to put just an

interface!

Is there any way around this? (Plus I hope Whidbey will give us a Set
collection, dammit).

TIA!
Elder

[Elder Hyde]

Hi Chris,

So there's really no way of escaping this? The thing is that I want my
abstract class to be really just an interface, with no implementation.
The way I'd like to organize it is something like:

public abstract class SmartQueue {
// all interface stuff only, plus
// static methods
}

public abstract class AbstractSmartQu eue : SmartQueue {
// put stuff that are common to base classes here.
}

public class MemorySmartQueu e : AbstractSmartQu eue {
// put memory-backed specific operations here
}

Now, I can't (or rather don't want to) make SmartQueue an interface,
because: I want to have static methods--it makes the most sense to put
them in SmartQueue. But anyway, OK, I know the way now. Thanks!

Regards,
Elder
Chris Taylor wrote:

Hi,

It is standard to implement a method to fire the event, this method is the
event name prefixed with 'On'. So in your case the base class would have a
OnDataArrived, which can be called from anywhere. This has the advantage of
not having to cluter your code checking if the event has any delegates
before firing and also gives the derived implementation an alternative and
better performing method of handling the event by overriding the On...
method.

public abstract class SmartQueue
{
public event DataAvailabilit yEventHandler DataArrived;

// This is called to fire the event
public void OnDataArrived( YourEventArgs e )
{
if ( DataArrived != null )
DataArrived( this, e );
}
}

public class MemorySmartQueu e : SmartQueue
{
public override void poolForData()
{
// data available!
OnDataArrived( args ); // Fire the event
}
}
Hope this helps

[Chris Taylor]

Hi,

Mistake in my code, in my haste, I forgot to make the On.... virtual SORRY.

public virtual void OnDataArrived( YourEventArgs e )

Regards

--
Chris Taylor
http://dotnetjunkies.com/WebLog/chris.taylor/
"Chris Taylor" <ch************ *@hotmail.com> wrote in message
news:%2******** ********@TK2MSF TNGP10.phx.gbl. ..

Hi,

It is standard to implement a method to fire the event, this method is the
event name prefixed with 'On'. So in your case the base class would have a
OnDataArrived, which can be called from anywhere. This has the advantage of not having to cluter your code checking if the event has any delegates
before firing and also gives the derived implementation an alternative and
better performing method of handling the event by overriding the On...
method.

public abstract class SmartQueue
{
public event DataAvailabilit yEventHandler DataArrived;

// This is called to fire the event
public void OnDataArrived( YourEventArgs e )
{
if ( DataArrived != null )
DataArrived( this, e );
}
}

public class MemorySmartQueu e : SmartQueue
{
public override void poolForData()
{
// data available!
OnDataArrived( args ); // Fire the event
}
}
Hope this helps
--
Chris Taylor
http://dotnetjunkies.com/WebLog/chris.taylor/
"Elder Hyde" <no_way> wrote in message
news:%2******** ********@TK2MSF TNGP12.phx.gbl. ..

Hey all,

A class of mine needs to tell the outside world when its buffer is not
empty. The problem is that C# seems to force you to put the
event-raising code in the base class. To illustrate, consider what I'll
do in Java:

public interface DataAvailabilit yListener extends

java.util.Event Listener {

void dataArrived(Dat aAvailabilityEv ent event);
}

then, in my base class, I can do this:

public abstract class SmartQueue {
addDataAvailabi lityListener(Da taAvailabilityL istener listener);
}

then in my implementation class, say a memory-backed smart queue, I can
do this:

public class MemorySmartQueu e implements SmartQueue {
public void poolForData() {
// data available!
while(iter.hasN ext()) {
DataAvailabilit yListener lis =
(DataAvailabili tyListener)iter .next();
lis.dataArrived (someEvent);
}
}
}

Simple and straighforward. However, consider a C# implementation: in the
interface, I may have something like this:

public abstract class SmartQueue {
public event DataAvailabilit yEventHandler DataArrived;
}

Now, consider what I have to do in MemorySmartQueu e:

public class MemorySmartQueu e : SmartQueue {
public override void poolForData() {
// data available!
if(DataArrived == null) {
// BZZZZTTT!!! Can only do this in SmartQueue!
DataArrived(thi s, args);
}
}
}

I can't believe this. Either I'm missing a really obvious thing, or I
have to deal with this... this... awkward mechanism. Why the hell
doesn't it allow me to raise an event in the derived class? I don't want
to put any behaviour in my abstract class, I want to put just an

interface!

Is there any way around this? (Plus I hope Whidbey will give us a Set
collection, dammit).

TIA!
Elder

[Elder Hyde]

Happened to me all the time.. I hadn't been typing "virtual" for about 7
years, since I left C++ behind ;)

Chris Taylor wrote:

Hi,

Mistake in my code, in my haste, I forgot to make the On.... virtual SORRY.

public virtual void OnDataArrived( YourEventArgs e )

Regards

[Chris Taylor]

Hi,

You could use BeginInvoke, and remember to always call EndInvoke. The events
will still be fired synchroneously, but in a separate thread. Something like
the following should do, this will be limited to only one handler however.

public virtual void OnDataArrived( EventArgs e )
{
if ( DataArrived != null )
DataArrived.Beg inInvoke( this, e, new AsyncCallback(
DataArrivedComp leted ), null );
}

private void DataArrivedComp leted( IAsyncResult ar )
{
if ( DataArrived != null )
DataArrived.End Invoke( ar );
}

You could also just use a separate thread to fire the event in, that way you
can have multiple handlers.

public virtual void OnDataArrived( EventArgs e )
{
if ( DataArrived != null )
System.Threadin g.ThreadPool.Qu eueUserWorkItem ( new
System.Threadin g.WaitCallback( FireDataArrived ), e );
}

private void FireDataArrived ( object e )
{
if ( DataArrived != null )
DataArrived( this, (EventArgs)e );
}

Then you can also fire each handler individually.

public virtual void OnDataArrived( EventArgs e )
{
if ( DataArrived != null )
foreach( DataAvailabilit yEventHandler d in
DataArrived.Get InvocationList( ) )
{
d.BeginInvoke( this, e, new AsyncCallback(D ataArrivedEvent Complete),
d );
}
}

private void DataArrivedEven tComplete( IAsyncResult ar )
{
DataAvailabilit yEventHandler e =
(DataAvailabili tyEventHandler) ar.AsyncState;
e.EndInvoke( ar );
}

Of course you would have to make sure the caller is aware of this
non-standard event calling and manage thread syncronization for shared data
etc. This code also lacks significant error handling, but should leave you
with a number of options.

Hope this helps

--
Chris Taylor
http://dotnetjunkies.com/WebLog/chris.taylor/
<di********@dis cussion.microso ft.com> wrote in message
news:Oj******** ******@TK2MSFTN GP11.phx.gbl...

How can we perform an Async event in C#?

Events are Synchronous usually. Do we just call BeginInvoke, if so, how
would we do this?

"Chris Taylor" <ch************ *@hotmail.com> wrote in message
news:#G******** ******@TK2MSFTN GP10.phx.gbl...

Hi,

It is standard to implement a method to fire the event, this method is the event name prefixed with 'On'. So in your case the base class would have a OnDataArrived, which can be called from anywhere. This has the advantage

of

not having to cluter your code checking if the event has any delegates
before firing and also gives the derived implementation an alternative and better performing method of handling the event by overriding the On...
method.

public abstract class SmartQueue
{
public event DataAvailabilit yEventHandler DataArrived;

// This is called to fire the event
public void OnDataArrived( YourEventArgs e )
{
if ( DataArrived != null )
DataArrived( this, e );
}
}

public class MemorySmartQueu e : SmartQueue
{
public override void poolForData()
{
// data available!
OnDataArrived( args ); // Fire the event
}
}
Hope this helps
--
Chris Taylor
http://dotnetjunkies.com/WebLog/chris.taylor/
"Elder Hyde" <no_way> wrote in message
news:%2******** ********@TK2MSF TNGP12.phx.gbl. ..

Hey all,

A class of mine needs to tell the outside world when its buffer is not
empty. The problem is that C# seems to force you to put the
event-raising code in the base class. To illustrate, consider what I'll do in Java:

public interface DataAvailabilit yListener extends

java.util.Event Listener

{

void dataArrived(Dat aAvailabilityEv ent event);
}

then, in my base class, I can do this:

public abstract class SmartQueue {
addDataAvailabi lityListener(Da taAvailabilityL istener listener);
}

then in my implementation class, say a memory-backed smart queue, I can do this:

public class MemorySmartQueu e implements SmartQueue {
public void poolForData() {
// data available!
while(iter.hasN ext()) {
DataAvailabilit yListener lis =
(DataAvailabili tyListener)iter .next();
lis.dataArrived (someEvent);
}
}
}

Simple and straighforward. However, consider a C# implementation: in the interface, I may have something like this:

public abstract class SmartQueue {
public event DataAvailabilit yEventHandler DataArrived;
}

Now, consider what I have to do in MemorySmartQueu e:

public class MemorySmartQueu e : SmartQueue {
public override void poolForData() {
// data available!
if(DataArrived == null) {
// BZZZZTTT!!! Can only do this in SmartQueue!
DataArrived(thi s, args);
}
}
}

I can't believe this. Either I'm missing a really obvious thing, or I
have to deal with this... this... awkward mechanism. Why the hell
doesn't it allow me to raise an event in the derived class? I don't want to put any behaviour in my abstract class, I want to put just an

interface!

Is there any way around this? (Plus I hope Whidbey will give us a Set
collection, dammit).

TIA!
Elder

I would assume this is a rare case that we would need async events then if
its so much hassle.
I am basically trying to draw a similarity between Win32 PostMessage and
SendMessage. Usually I used PostMessage as a way to fire events rather than
SendMessage wheras on C# I am using the equivilent to SendMessage now.

"Chris Taylor" <ch************ *@hotmail.com> wrote in message
news:Oh******** ******@tk2msftn gp13.phx.gbl...

Hi,

You could use BeginInvoke, and remember to always call EndInvoke. The events will still be fired synchroneously, but in a separate thread. Something like the following should do, this will be limited to only one handler however.

public virtual void OnDataArrived( EventArgs e )
{
if ( DataArrived != null )
DataArrived.Beg inInvoke( this, e, new AsyncCallback(
DataArrivedComp leted ), null );
}

private void DataArrivedComp leted( IAsyncResult ar )
{
if ( DataArrived != null )
DataArrived.End Invoke( ar );
}

You could also just use a separate thread to fire the event in, that way you can have multiple handlers.

public virtual void OnDataArrived( EventArgs e )
{
if ( DataArrived != null )
System.Threadin g.ThreadPool.Qu eueUserWorkItem ( new
System.Threadin g.WaitCallback( FireDataArrived ), e );
}

private void FireDataArrived ( object e )
{
if ( DataArrived != null )
DataArrived( this, (EventArgs)e );
}

Then you can also fire each handler individually.

public virtual void OnDataArrived( EventArgs e )
{
if ( DataArrived != null )
foreach( DataAvailabilit yEventHandler d in
DataArrived.Get InvocationList( ) )
{
d.BeginInvoke( this, e, new AsyncCallback(D ataArrivedEvent Complete), d );
}
}

private void DataArrivedEven tComplete( IAsyncResult ar )
{
DataAvailabilit yEventHandler e =
(DataAvailabili tyEventHandler) ar.AsyncState;
e.EndInvoke( ar );
}

Of course you would have to make sure the caller is aware of this
non-standard event calling and manage thread syncronization for shared data etc. This code also lacks significant error handling, but should leave you
with a number of options.

Hope this helps

--
Chris Taylor
http://dotnetjunkies.com/WebLog/chris.taylor/
<di********@dis cussion.microso ft.com> wrote in message
news:Oj******** ******@TK2MSFTN GP11.phx.gbl...

How can we perform an Async event in C#?

Events are Synchronous usually. Do we just call BeginInvoke, if so, how
would we do this?

"Chris Taylor" <ch************ *@hotmail.com> wrote in message
news:#G******** ******@TK2MSFTN GP10.phx.gbl...

Hi,

It is standard to implement a method to fire the event, this method is the event name prefixed with 'On'. So in your case the base class would have

a

OnDataArrived, which can be called from anywhere. This has the

advantage

of

not having to cluter your code checking if the event has any delegates
before firing and also gives the derived implementation an alternative

and better performing method of handling the event by overriding the On...
method.

public abstract class SmartQueue
{
public event DataAvailabilit yEventHandler DataArrived;

// This is called to fire the event
public void OnDataArrived( YourEventArgs e )
{
if ( DataArrived != null )
DataArrived( this, e );
}
}

public class MemorySmartQueu e : SmartQueue
{
public override void poolForData()
{
// data available!
OnDataArrived( args ); // Fire the event
}
}
Hope this helps
--
Chris Taylor
http://dotnetjunkies.com/WebLog/chris.taylor/
"Elder Hyde" <no_way> wrote in message
news:%2******** ********@TK2MSF TNGP12.phx.gbl. ..
> Hey all,
>
> A class of mine needs to tell the outside world when its buffer is

not > empty. The problem is that C# seems to force you to put the
> event-raising code in the base class. To illustrate, consider what

I'll > do in Java:
>
> public interface DataAvailabilit yListener extends

java.util.Event Listener

{
> void dataArrived(Dat aAvailabilityEv ent event);
> }
>
> then, in my base class, I can do this:
>
> public abstract class SmartQueue {
> addDataAvailabi lityListener(Da taAvailabilityL istener listener);
> }
>
> then in my implementation class, say a memory-backed smart queue, I can > do this:
>
> public class MemorySmartQueu e implements SmartQueue {
> public void poolForData() {
> // data available!
> while(iter.hasN ext()) {
> DataAvailabilit yListener lis =
> (DataAvailabili tyListener)iter .next();
> lis.dataArrived (someEvent);
> }
> }
> }
>
> Simple and straighforward. However, consider a C# implementation: in the > interface, I may have something like this:
>
> public abstract class SmartQueue {
> public event DataAvailabilit yEventHandler DataArrived;
> }
>
> Now, consider what I have to do in MemorySmartQueu e:
>
> public class MemorySmartQueu e : SmartQueue {
> public override void poolForData() {
> // data available!
> if(DataArrived == null) {
> // BZZZZTTT!!! Can only do this in SmartQueue!
> DataArrived(thi s, args);
> }
> }
> }
>
> I can't believe this. Either I'm missing a really obvious thing, or I > have to deal with this... this... awkward mechanism. Why the hell
> doesn't it allow me to raise an event in the derived class? I don't want > to put any behaviour in my abstract class, I want to put just an
interface!
>
> Is there any way around this? (Plus I hope Whidbey will give us a Set > collection, dammit).
>
> TIA!
> Elder

[Daniel O'Connell]

"Elder Hyde" <no_way> wrote in message
news:%2******** ********@TK2MSF TNGP12.phx.gbl. ..

Hey all,

A class of mine needs to tell the outside world when its buffer is not
empty. The problem is that C# seems to force you to put the
event-raising code in the base class. To illustrate, consider what I'll
do in Java:

public interface DataAvailabilit yListener extends java.util.Event Listener { void dataArrived(Dat aAvailabilityEv ent event);
}

then, in my base class, I can do this:

public abstract class SmartQueue {
addDataAvailabi lityListener(Da taAvailabilityL istener listener);
}

then in my implementation class, say a memory-backed smart queue, I can
do this:

public class MemorySmartQueu e implements SmartQueue {
public void poolForData() {
// data available!
while(iter.hasN ext()) {
DataAvailabilit yListener lis =
(DataAvailabili tyListener)iter .next();
lis.dataArrived (someEvent);
}
}
}

Simple and straighforward. However, consider a C# implementation: in the
interface, I may have something like this:

public abstract class SmartQueue {
public event DataAvailabilit yEventHandler DataArrived;
}

Now, consider what I have to do in MemorySmartQueu e:

public class MemorySmartQueu e : SmartQueue {
public override void poolForData() {
// data available!
if(DataArrived == null) {
// BZZZZTTT!!! Can only do this in SmartQueue!
DataArrived(thi s, args);
}
}
}

I can't believe this. Either I'm missing a really obvious thing, or I
have to deal with this... this... awkward mechanism. Why the hell
doesn't it allow me to raise an event in the derived class? I don't want
to put any behaviour in my abstract class, I want to put just an interface!

It is an annoying thing. The CLR does allow for a protected raise_
method(atleast, by a vauge reading), however C# doesn't appear to support
this currently(MC++ is the only one I know that does.
Anyway, if you don't want any serious implementation in your base class, you
can do

public abstract class BaseClass
{
public event MyEventHandler MyEvent
{
add
{
Delegate.Combin e(myEventDelega te,value);
}
remove
{
Delegate.Remove (myEventDelegat e,value);
}
}
//this will contain the invocation list, might wanna convert this
//to a protected property so that you don't *have* to back off
myEventDelegate .
protected MyEventHandler myEventDelegate ;
}
(note the syntax may be a touch off, I'm working from memory).
I would not be adverse to allowing a
raise
{

}
style method to events, however convincing the C# team of such may be
substatial work.
Is there any way around this? (Plus I hope Whidbey will give us a Set
collection, dammit).

TIA!
Elder