L
Leslie Sanford
Say you have a class that raises an event:
public class SomeClass
{
public event EventHandler SomethingHappened;
// ...
}
And another class that uses SomeClass.
public class AnotherClass
{
private SomeClass sc = new SomeClass();
// ...
}
Say that AnotherClass raises an event just like SomeClass. In fact, it
raises this event in response to SomeClass raising its event:
public class AnotherClass
{
private SomeClass sc = new SomeClass();
public event EventHandler SomethingHappened;
public AnotherClass()
{
sc.SomethingHappened += delegate(object sender, EventArgs e)
{
OnSomethingHappened(e);
};
}
protected virtual void OnSomethingHappened(EventArgs e)
{
EventHandler handler = SomethingHappened;
if(handler != null)
{
handler(this, e);
}
}
}
Ok, it seems to me that if AnotherClass doesn't have to do anything
special in response to SomeClass raising its event, AnotherClass could
simply pass along delegates attaching to its SomethingHappened to
SomeClass's event:
public class AnotherClass
{
private SomeClass sc = new SomeClass();
public event EventHandler SomethingHappened
{
add
{
sc.SomethingHappened += value;
}
remove
{
sc.SomethingHappened -= value;
}
}
// ...
}
This seems to be a much cleaner solution. However, there is a potential
problem:
When SomeClass raises SomethingHappened, it passes itself as the sender
parameter. For clients that have attached to AnotherClass's
SomethingHappened event, they may not be expecting an object of
SomeClass's type. Worse, a private object of AnotherClass is being
exposed.
Thoughts?
public class SomeClass
{
public event EventHandler SomethingHappened;
// ...
}
And another class that uses SomeClass.
public class AnotherClass
{
private SomeClass sc = new SomeClass();
// ...
}
Say that AnotherClass raises an event just like SomeClass. In fact, it
raises this event in response to SomeClass raising its event:
public class AnotherClass
{
private SomeClass sc = new SomeClass();
public event EventHandler SomethingHappened;
public AnotherClass()
{
sc.SomethingHappened += delegate(object sender, EventArgs e)
{
OnSomethingHappened(e);
};
}
protected virtual void OnSomethingHappened(EventArgs e)
{
EventHandler handler = SomethingHappened;
if(handler != null)
{
handler(this, e);
}
}
}
Ok, it seems to me that if AnotherClass doesn't have to do anything
special in response to SomeClass raising its event, AnotherClass could
simply pass along delegates attaching to its SomethingHappened to
SomeClass's event:
public class AnotherClass
{
private SomeClass sc = new SomeClass();
public event EventHandler SomethingHappened
{
add
{
sc.SomethingHappened += value;
}
remove
{
sc.SomethingHappened -= value;
}
}
// ...
}
This seems to be a much cleaner solution. However, there is a potential
problem:
When SomeClass raises SomethingHappened, it passes itself as the sender
parameter. For clients that have attached to AnotherClass's
SomethingHappened event, they may not be expecting an object of
SomeClass's type. Worse, a private object of AnotherClass is being
exposed.
Thoughts?