PropertyChangedEventHandler and Delegates & Events in general

Guest User

Hi

I would just like clarification on Delegates and Events in particular the PropertyChangedEventHandler delegate. I think ive got a good grasp but I just wanted to be put right in certain places if necessary please.

// Declare PropertyChangedEventArgs which derives from the EventArgs base. This is used as it contains additional functionality instead of using the standard EventArgs.

public class PropertyChangedEventArgs : Eventargs

public PropertyChangedEventArgs(string propertyName);

public virtual string PropertyName { get; }

// Declare Delegate which takes PropertyChangedEventArgs as the 2nd parameter due to the added functionality it provides (as in the step above).

public delegate void PropertyChangedEventHandler(object sender, PropertyChangedEventArgs e)

// Declare the EventHandler with an identifer\variable named PropertyChanged.

public event PropertyChangedEventHandler PropertyChanged

// Declare a method that fires the Event which matches the signiture of the delegate and holds a reference to the EventHandler.

public void RaisePropertyChanged(string propertyName)

PropertychangedEventHandler propertyChanged = PropertyChanged;

if(propertyChanged != null)

// Not sure

propertyChanged(this, new PropertyChangedEventArgs(propertyName));

My question is how could this Event be assigned to a method I know it is subscribed by using the operator += and removed as a subscriber by -=

Thanks!

4 Replies

Know the answer? Post it — somebody with the same question will find it here.

Vulpes14y ago
Accepted answer
When the RaisePropertyChanged method is called and passed the name of the property that has been changed, the PropertyChanged event is fired.

As this event is a multi-cast delegate, it calls all the eventhandlers which have been been attached to the event in the same order that they were attached.

It passes all of them the same two arguments:

1. The sender (this) which is the current instance of the class containing the event.

2. A PropertyChangedEventArgs object which houses the name of the property that has been changed and which the handler can therefore recover and take the appropriate action.

Notice that a check is first made that the event is not null. If it were null, then this would mean that no handlers have been attached.

An event is really just a special kind of delegate which, outside the class it is declared in, can only be operated on using the += or -= operators which respectively attach handlers to, or detach handlers from, the event.
Guest User14y ago
Thanks so much Vulpes perfect explanation, cheers!
Vulpes14y ago
You don't actually need to create the PropertyChangedEventArgs class and the PropertyChangedEventHandler delegate as those are already defined in the .NET Framework.

To use them all you need to do is to add this using directive, if it's not already there:

using System.ComponentModel;

and to make sure (in References in Solution Explorer) that you have a reference to System.dll.

Your class then needs to implement INotifyPropertyChanged and will look like this:

public class CategoryEntity : INotifyPropertyChanged
{
private string _version;

public event PropertyChangedEventHandler PropertyChanged;

public string Version
{
get
{
return _version;
}

set
{
if (value != _version)
{
_version = value;
SendPropertyChanged("Version");
}
}
}

private void SendPropertyChanged(string propertyName)
{
if(PropertyChanged != null)
{
PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
}
}
}

and you can then subscribe to the PropertyChanged event from another class and provide a handler for it as follows:

// within some method of other class

CategoryEntity ce = new CategoryEntity();
ce.Version = "1.00";
ce.PropertyChanged += PropertyChangedHandler;
ce.Version = "2.00"; // cause event to be fired

public void PropertyChangedHandler(object sender, PropertyChangedEventArgs e)
{
Console.WriteLine(e.PropertyName + " has changed") ;
}

If it helps, here's a working console app which incorporates all these elements:

using System;
using System.ComponentModel;

public class CategoryEntity : INotifyPropertyChanged
{
private string _version;

public event PropertyChangedEventHandler PropertyChanged;

public string Version
{
get
{
return _version;
}

set
{
if (value != _version)
{
_version = value;
SendPropertyChanged("Version");
}
}
}

private void SendPropertyChanged(string propertyName)
{
if(PropertyChanged != null)
{
PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
}
}
}

class Test
{
static void Main()
{
Test t = new Test();
CategoryEntity ce = new CategoryEntity();
ce.Version = "1.00";
ce.PropertyChanged += t.PropertyChangedHandler;
ce.Version = "2.00"; // cause event to be fired
Console.ReadKey(); // pause to read out if necessary
}

public void PropertyChangedHandler(object sender, PropertyChangedEventArgs e)
{
Console.WriteLine(e.PropertyName + " has changed");
}
}
Guest User14y ago
Thanks Vulpes

Ive just tried to write the above but ive ran into issues, ive listed the code below. Could you check it and correct where necessary please?

// Create custom PropertyChangingEventArgs class deriving from EventArgs with an addition member.

public class PropertyChangingEventArgs : EventArgs

public string PropertyName { get; set; }

public PropertyChangingEventArgs(string propertyName)
{
        PropertyName = propertyName;
}

// Declare delegate method signiture

public delegate void PropertyChangedEventHandler(object sender, PropertyChangingEventArgs e)

// Define a class which contains event declaration

public class CategoryEntity

public event PropertyChangedEventHandler PropertyChanged;

// Implement Event handler

public void SendPropertyChangedHandler(object sender, PropertyChangingEventArgs e)

Console.Writeline("the output is: " + e.propertyName.ToString();

// Not sure

public void SendPropertyChanged(string propertyName)
{
if(PropertyChanged != null)
        {
              this.PropertyChanged(this, new                 PropertyChangedEventArgs(propertyName);
        }
}

// Attach event to handler

CategoryEntity ce = new CategoryEntity()
ce.PropertyChanged += new ?????

// Invoke Event method

SendPropertyChanging("Version");

Thanks