Evo ti jedan primer kako se implementira neki property sa eventom koji se aktivira kada se taj property promeni:
Code:
public class MyClass
{
private int m_MyValue = 0;
public virtual int MyValue
{
get { return m_MyValue; }
set
{
if(m_MyValue != value) {
m_MyValue = value;
OnMyValueChanged(EventArgs.Empty);
}
}
}
public event EventHandler MyValueChanged = null;
protected virtual void OnMyValueChanged(EventArgs e)
{
if(this.MyValueChanged != null) {
this.MyValueChanged(this, e);
}
}
}
OnMyValueChanged je metoda koja ce aktivirati event
MyValueChanged.
U toj metodi imas proveru "this.MyValueChanged != null" kojom se proverava da li ima registrovanih (nakacenih) handlera za taj event, a jednim pozivom ovog eventa se pozivaju svi handleri koji su registrovani i to onim redom kojim su se registrovali.
Kada koristis neku instancu doticne klase tebi je dostupan samo taj handler kojim mozes pratiti da li se vrednost property-a promenila.
Code:
public class Test
{
public Test()
{
MyClass myClass = new MyClass();
myClass.MyValueChanged += new EventHandler(myClass_MyValueChanged);
}
void myClass_MyValueChanged(object sender, EventArgs e)
{
MessageBox.Show("MyValue changed");
}
}
Ako nasledis klasu taj event i dalje mozes da nadgledas tako sto ces registrovati event (nakaciti se na event):
Code:
public class MyClassEx: MyClass
{
public MyClassEx()
{
this.MyValueChanged += new EventHandler(MyClassEx_MyValueChanged);
}
public void MyClassEx_MyValueChanged(object sender, EventArgs e)
{
MessageBox.Show("MyValue changed");
}
}
Medjutim ti mozes pratiti event i tako sto ces
override-ovati metodu
OnMyValueChanged:
Code:
public class MyClassEx2: MyClass
{
protected override void OnMyValueChanged(EventArgs e)
{
MessageBox.Show("MyValue changed");
base.OnMyValueChanged(e);
}
}
Ako odradis override
OnMyValueChanged i u tom override-u ne pozoves metodu
OnMyValueChanged iz bazne klase sprecices podizanje doticnog eventa.
Mozes odraditi i override property-a
MyValue i izmeniti ga tako da se ovaj event nikada ni ne poziva.