Introducing DependencyPropertyWeaver

As part of my demonstration for the NYC .NET Meetup in the next couple of days, I prepared some material to show how to use Mono.Cecil to manually weave IL as a post-build step.  It solves the problem of what I call “WPF Verbosity Hell”: the thing that makes your eyes bleed and makes God kill a kitten every time you declare a new property.

Since notifypropertyweaver already exists, I figured I’d release the other side of the coin, dependencypropertyweaver.  I just pushed my changes onto GitHub.

There are a couple of reasons to use dependency properties rather than regular properties with INotifyPropertyChanged.  If you’re using WPF they make more sense because they perform faster and they give you a lot of extra bells and whistles for free.  However, the INPC route tends to be more popular because it doesn’t bring in the dependency of WPF.

IL post-build weaving solves the dependency problem because you can selectively choose to weave only the assemblies that get deployed with WPF, and you could even weave INPC into your service layer, and DPs into your client layer.  That’s the power of post-build processes.

While this little project initially started out as a simple demonstration of using Mono.Cecil to perform low-level aspect oriented principles, it didn’t take much more work to tidy things up and make it ‘releasable’ into the wild, so I did just that, and open sourced it.

The concept is simple.  You take something like this:

    public class Student
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }

And DependencyPropertyWeaver will turn it into this:

         public class Student : DependencyObject
	{
		public static readonly DependencyProperty NameDependencyProperty = DependencyProperty.Register("Name", typeof(string), typeof(Student));
		public static readonly DependencyProperty AgeDependencyProperty = DependencyProperty.Register("Age", typeof(int), typeof(Student));
		public string Name
		{
			[CompilerGenerated]
			get
			{
				return (string)base.GetValue(Student.NameDependencyProperty);
			}
			[CompilerGenerated]
			set
			{
				base.SetValue(Student.NameDependencyProperty, value);
			}
		}
		public int Age
		{
			[CompilerGenerated]
			get
			{
				return (int)base.GetValue(Student.AgeDependencyProperty);
			}
			[CompilerGenerated]
			set
			{
				base.SetValue(Student.AgeDependencyProperty, value);
			}
		}
	}

Even though the class initially didn’t inherit from DependencyObject, the weaved version does.  It will also continually go up the inheritance chain until it finds the abstract base class, and makes that inherit from DependencyObject.

Next on the list is obviously documentation (what open source project doesn’t need more documentation?!), however, I think I can slack off on this one since the core library is only 200-300 lines of code :-)