need help with EventHandler

[Sascha Dietl]

hi,
i wrote my own generic class based on IList that fires events, so it's just
a better List<class.
When my "EventedLis t" fires an event I don't want to take "this" as sender
instead i would like to use the instance of the class that's holding my EventedList
object that currently fires.
Any ideas how to get this to work?

thanks
Sascha

[Marc Gravell]

Well, either A: the list would need to know what sender to use, e.g. ctors:

private readonly object _sender;
public EventedList() : this(this) {}
public EventedList(obj ect sender) {
_sender = sender;
}

(and then use _sender as the sender), or B: you would need to catch the
event at the holder and forward with the revised sender, i.e.

_eventedList = new EventedList();
_eventedList.So meEvent += OnSomeEvent;
....
public event EventHandler SomeEvent;
protected void OnSomeEvent(obj ect sender, EventArgs args) {
EventHandler handler = SomeEvent;
if(handler!=nul l) handler(this, args); // ignore sender
}

===

A involves less hops, but limits you to one master holder per list - which
may not be unreasonable. As an aside, with A you could expose the event
(without incurring a hop) on the holder via (using similar to the above
example):

_eventedList = new EventedList();
public event EventHandler SomeEvent {
add {_eventedList.S omeEvent += value;}
remove {eventedList.So meEvent -= value;}
}

Marc

[Sascha Dietl]

thanks for you suggestions marc, but I'm wondering if there's no way through
reflection or any mechanism like this?

Sascha

Well, either A: the list would need to know what sender to use, e.g.
ctors:

private readonly object _sender;
public EventedList() : this(this) {}
public EventedList(obj ect sender) {
_sender = sender;
}
(and then use _sender as the sender), or B: you would need to catch
the event at the holder and forward with the revised sender, i.e.

_eventedList = new EventedList();
_eventedList.So meEvent += OnSomeEvent;
...
public event EventHandler SomeEvent;
protected void OnSomeEvent(obj ect sender, EventArgs args) {
EventHandler handler = SomeEvent;
if(handler!=nul l) handler(this, args); // ignore sender
}
===

A involves less hops, but limits you to one master holder per list -
which may not be unreasonable. As an aside, with A you could expose
the event (without incurring a hop) on the holder via (using similar
to the above example):

_eventedList = new EventedList();
public event EventHandler SomeEvent {
add {_eventedList.S omeEvent += value;}
remove {eventedList.So meEvent -= value;}
}
Marc

[Marc Gravell]

if there's no way through reflection or any mechanism like this?
What? for the list to know who it's "owner" is? No, firstly because
reflection doesn't offer (AFAIK) backtrace capability (i.e. "who can see
me?"), but mainly because "owner" here is an invention; in the pure sense,
any number of objects could hold a reference to the list; which is the
owner? none specifically. It is only because you are holding this e.g. as a
private member on a class that this concept holds water, hence you would
need to tell it e.g. in the ctor (or event forwarding / spoofing).

Have I answered the correct question? I wasn't quite sure...

Marc

[Sascha Dietl]

hi Marc,

thanks that's exactly what i wanted to know

Sascha

>if there's no way through reflection or any mechanism like this?

What? for the list to know who it's "owner" is? No, firstly because
reflection doesn't offer (AFAIK) backtrace capability (i.e. "who can
see me?"), but mainly because "owner" here is an invention; in the
pure sense, any number of objects could hold a reference to the list;
which is the owner? none specifically. It is only because you are
holding this e.g. as a private member on a class that this concept
holds water, hence you would need to tell it e.g. in the ctor (or
event forwarding / spoofing).

Have I answered the correct question? I wasn't quite sure...

Marc