AOP Implementation of INotifyPropertyChanged

• Download source code - 1.22 KB
• Download Postsharp

Introduction

This article describes how to implement the INotifyPropertyChanged interface with AOP using Postsharp.

Background

On attempting to implement the INotifyPropertyChanged interface, you'll most likely become frustrated within a short time, just because you have to do the same steps for each class.

Possible solutions (from bad to good)

Copy & Paste

OK, copy & paste will work here, but this will produce very high redundancy.

Example

We will take a look at this example at every solution.

/// <summary>
/// A Person-Class
/// </summary>
public class Person : INotifyPropertyChanged
{
    private string firstName;
    private string lastName;

    /// <summary >
    /// Firstname of the Person
    /// </summary >
    public string FirstName
    {
        get { return firstName; }
        set
        {
            firstName = value;
            FirePropertyChanged("FirstName");
            FirePropertyChanged("Name");
        }
    }

    /// <summary >
    /// Lastname of the Person
    /// </summary >
    public string LastName
    {
        get { return lastName; }
        set
        {
            lastName = value; FirePropertyChanged("LastName");
            FirePropertyChanged("Name");
        }
    }

    /// <summary >
    /// Complete Name
    /// </summary >
    public string Name
    {
        get
        {
            return FirstName + " " + LastName;
        }
    }

    #region INotifyPropertyChanged Members

    public event PropertyChangedEventHandler PropertyChanged;

    public void FirePropertyChanged(string propName)
    {
        if (PropertyChanged != null)
        {
            PropertyChanged.Invoke(this, new PropertyChangedEventArgs(propName));
        }
    }

    #endregion
}

Here, you can see the standard way of implementing the INotifyPropertyChanged interface.

Remove redundancy

As you can see, the first solution causes a high redundancy. Now, we realize the similarity and implement an abstract class.

Example

Here, we implement the INotifyPropertyChanged members and our Help-function 'FirePropertyChanged' in an abstract class, and inherit our Person class from this base class 'NotifyingObject'.

public abstract class NotifyingObject : INotifyPropertyChanged
{
    #region INotifyPropertyChanged Members

    public event PropertyChangedEventHandler PropertyChanged;

    public void FirePropertyChanged(string propName)
    {
        if (PropertyChanged != null)
        {
            PropertyChanged.Invoke(this, 
              new PropertyChangedEventArgs(propName));
        }
    }

    #endregion
}

/// <summary >
/// A Person-Class
/// </summary >
public class Person : NotifyingObject
{ /*...*/ }

Now, you might say "That's it!". Yes, of course. It's a nice way to implement the interface. But in C#, there is no multiple inherency.

public class xyz{}
public class Person : NotifyingObject, xyz {}

The code above will not be compiled!

The AOP way

In this step, we transform our base class 'NotifyingObject' into an Aspect. After this step, your code will look like this:

Example

/// <summary >
/// A Person-Class
/// </summary >
[Notifying]
public class Person : INotifyPropertyChanged
{
    private string firstName;
    private string lastName;

    /// <summary >
    /// Firstname of the Person
    /// </summary >
    public string FirstName
    {
        get { return firstName; }
        [NotifyingDependency(DependencyProperty = "Name")]
        set { firstName = value; }
    }

    /// <summary >
    /// Lastname of the Person
    /// </summary >
    public string LastName
    {
        get { return lastName; }
        [NotifyingDependency(DependencyProperty = "Name")]
        set { lastName = value; }
    }

    /// <summary >
    /// Complete Name
    /// </summary >
    public string Name
    {
        get { return FirstName + " " + LastName; }
    }

    #region INotifyPropertyChanged Members

    public event PropertyChangedEventHandler PropertyChanged;

    #endregion
}

Now, let's take a closer look at a few lines:

[Notifying]
public class Person : INotifyPropertyChanged

This attaches the NotifyingAttribute to the set_ method from every property of the declaring class. The notification will be fired when this method is exited. The NotifyingAttribute can only be attached to classes which implement the INotifyPropertyChanged interface.

[Notifying]
public class Person

The code above will cause a Postsharp error which looks like this: PostSharp: WindowsFormsApplication_3._5.Person has to implement INotifyPropertyChanged.

[NotifyingDependency(DependencyProperty = "Name")]

The Name property depends on FirstName and LastName. The notification will be fired if one of these properties get changed. The property with the passed name has to exist, else you will see a Postshar error which looks like this: PostSharp: WindowsFormsApplication_3._5.Person has no Property 'ThirdName'.

Code listing

NotifyingAttribute

[Serializable]
[MulticastAttributeUsage(MulticastTargets.Method)]
public class NotifyingAttribute : OnMethodBoundaryAspect
{
    private string[] propertyNames;
    private FieldInfo typeFieldInfo;

    /// <summary>
    /// Do as much work as possible at the Compiletime
    /// see: http://doc.postsharp.org/1.5/ClassRef/html/
    //             fbc0e32a-2617-c9ef-cb9e-45cdc171dde0.htm
    /// </summary>
    public override void CompileTimeInitialize(System.Reflection.MethodBase method)
    {
        // get the DependencyAttributes of the method
        Attribute[] atts = Attribute.GetCustomAttributes(method, 
                             typeof(NotifyingDependencyAttribute));

        int attCount = atts.Count();

        this.propertyNames = new string[attCount + 1];

        // first Fired = Property
        this.propertyNames[0] = GetPropertyNameFromMethodName(method.Name);

        // Add the dependency properties
        for (int i = 0; i < attCount; i++)
        {
            string depProp = (atts[i] as NotifyingDependencyAttribute).DependencyProperty;

            this.propertyNames[i + 1] = (atts[i] as 
                 NotifyingDependencyAttribute).DependencyProperty;
        }
    }

    /// <summary>
    /// Validating the Usage of NotifyingAttribute
    /// see: http://doc.postsharp.org/1.5/ClassRef/html/
    ///            aa77e517-2c98-ebec-c0e1-6bb20d013c33.htm
    /// </summary>
    public override bool CompileTimeValidate(System.Reflection.MethodBase method)
    {
        // check on implemented INotifyPropertyChanged
        if (method.DeclaringType.GetInterface(typeof(INotifyPropertyChanged).Name) != null)
        {
            // set_* are of interest
            // IsSpecialName checked to avoid attaching to something
            // like this: public void set_FooBar()
            // Note:
            // If somebody knows a Method, which set IsSpecialName
            // to true (without property setters)
            // -> leve a comment. thanks!
            if (method.Name.StartsWith("set_") && method.IsSpecialName)
            {
                // check if NotifyingIgnoreAttribute is set
                Attribute[] atts = Attribute.GetCustomAttributes(method, 
                                          typeof(NotifyingIgnoreAttribute));
                return atts.Count() == 0;
            }
        }
        else
        {
            // Create Postsharp Error
            PostSharp.Extensibility.Message error = 
              new PostSharp.Extensibility.Message(SeverityType.Error, 
              "AOP0001", method.DeclaringType.ToString() + 
              " has to implement INotifyPropertyChanged", "#");

            MessageSource.MessageSink.Write(error);
        }
        return false;
    }

    /// <summary>
    /// Callback which is called after executing setter-code
    /// see: http://doc.postsharp.org/1.5/ClassRef/html/
    ///            4d72f4ea-11c5-cbce-b56b-b671c98cffaf.htm
    /// </summary>
    public override void OnExit(MethodExecutionEventArgs eventArgs)
    {
        // get Fieldinfo of event PropertyChangedEventHandler PropertyChanged 
        this.typeFieldInfo = eventArgs.Instance.GetType()
                                .GetFields(BindingFlags.Instance | 
                                           BindingFlags.NonPublic | 
                                           BindingFlags.Public)
                                .Where(f => f.FieldType == 
                                            typeof(PropertyChangedEventHandler))
                                .FirstOrDefault();

        // fire the Notify on the invoking Instance
        FireNotify(eventArgs.Instance);
    }

    /// <summary>
    /// Fire the Notifies on the invoking Instance
    /// </summary>
    /// <param name="Target">invoking Instance</param>
    private void FireNotify(object Target)
    {
        // Fieldinfo of PropertyChanged found
        if (this.typeFieldInfo != null)
        {
            // get the value of PropertyChanged
            PropertyChangedEventHandler evHandler = 
               typeFieldInfo.GetValue(Target) as PropertyChangedEventHandler;

            if (evHandler != null)
            {
                foreach (string prop in propertyNames)
                {
                    // invoke the event
                    evHandler.Invoke(Target, new PropertyChangedEventArgs(prop));
                }
            }
        }
    }

    /// <summary>
    /// Gets the Property Name from a setter method name
    /// </summary>
    /// <param name="methodName">setter method name</param>
    /// <returns>Property Name</returns>
    private string GetPropertyNameFromMethodName(string methodName)
    {
        return methodName.Substring(4);
    }
}

NotifyingDependencyAttribute

/// <summary>
/// Aspect for defining notify dependencies
/// </summary>
[Serializable]
public class NotifyingDependencyAttribute : OnMethodBoundaryAspect
{
    public string DependencyProperty { get; set; }

    /// <summary>
    /// Validating the Usage of NotifyingDependencyAttribute
    /// see: http://doc.postsharp.org/1.5/ClassRef/html/
    ///           aa77e517-2c98-ebec-c0e1-6bb20d013c33.htm
    /// </summary>
    public override bool CompileTimeValidate(MethodBase method)
    {
        // Dependency Property must exists
        if (!PropertyHelper.PropertyExists(method.DeclaringType, DependencyProperty))
        {
            // Create Postsharp Error
            PostSharp.Extensibility.Message error = 
              new PostSharp.Extensibility.Message(SeverityType.Error, 
              "AOP0002", method.DeclaringType.ToString() + 
              " has no Property '" + DependencyProperty + 
              "'", "#");

            MessageSource.MessageSink.Write(error);
            return false;
        }
        return true;
    }
}

NotifyingDependencyAttribute

This class can be used to accept properties from the notifying object.

/// <summary>
/// Aspect to except Setters of Properties of Classes marked with [Notifying]
/// </summary>
[Serializable]
public class NotifyingIgnoreAttribute : Attribute { }

HelpClass

public class PropertyHelper
{
    public static bool PropertyExists(Type t, string propertyName)
    {
        return t.GetProperty(propertyName) != null;
    }
}