WPF Bindings Not Updating When PropertyChanged Raised When Bound Against a Proxy Object

Last week I came across an issue with binding NHibernate proxy objects to a WPF UI.  My problem involved a read only property that was not updated in the UI even though the property changed event was being raised.  It worked fine when I first created the object, but after loading it at a later time the updates didn’t work anymore.  Upon closer inspection I discovered that the object we were binding to was an Nhibernate proxy object.  To understand what was going on better I have put together a simple example, consider the following class:

	public class ShoppingCart : INotifyPropertyChanged
	{
	public virtual Guid Id { get; private set; }
	public virtual IList<CartItem> _items = new ObservableCollection<CartItem>();
	public virtual IEnumerable<CartItem> { get { return _items; } }
	public virtual decimal Total { get { return _items.Sum(i => i.Price); } }
	public virtual void AddItem(CartItem item)
	{
	_items.Add(item);
	// We raise this event to notify subscribers that our Total has very likely changed its value.
	PropertyChanged(this, new PropertyChangedEventArgs("Total"));
	}
	public virtual event PropertyChangedEventHandler PropertyChanged = delegate {};
	}

view raw ExampleOfProblem.cs hosted with ❤ by GitHub

This is a very simple shopping cart, we might have a WPF TextBlock bound to the Total property so that we can show the shopping cart’s total value.  Everything would work find, but if we loaded this class lazily so for example through a Customer.CurrentShoppingCart property, then the total TextBlock wouldn’t be updated.  The reason for this is that in order to delay loading of the shopping cart NHibernate uses a proxy object instead of the actual value when it initializes the Customer’s CurrentShoppingCart property.  How the proxy works can be seen in the following diagram.

When our TextBlock binds to the Shopping Cart Proxy’s Total property it also subscribes to the PropertyChanged event.  The proxy passes this subscription onto the actual shopping cart which adds the event handler to its PropertyChanged delegate and you would think all is well.  You of course would be wrong, here is what happens when the Shopping Cart raises a property changed event.

Essentially for our event to work we need the sender to be the shopping cart proxy and not the actual shopping cart.  To do this we will need to extend one of NHibernate’s proxy implementations.  We were using the Castle proxy implementation so the following code will work with that.  It would be quite possible to implement something similar with the LinFu version, but I’ll leave that as an exercise for the reader.  Before we start I will mention you can get the full gist here: https://gist.github.com/906916

First up we need to create a new version of the LazyInitializer, which will intercept calls to add or remove subscriptions and keep track of them in the proxy.  We will also subscribe to the target objects PropertyChanged event when it is created so that we can forward on property changed calls, to our subscribers.  We will leave everything else as it was.

	public class FixDataBindingLazyInitializer : LazyInitializer
	{
	private PropertyChangedEventHandler _subscribers = delegate { };
	public object ProxyInstance { get; set; }
	public FixDataBindingInterceptor(String entityName, Type persistentClass, object id, MethodInfo getIdentifierMethod, MethodInfo setIdentifierMethod, IAbstractComponentType aType, ISessionImplementor session)
	: base(entityName, persistentClass, id, getIdentifierMethod, setIdentifierMethod, aType, session)
	{
	}
	public override void Intercept(Castle.DynamicProxy.IInvocation invocation)
	{
	// WPF will call a method named add_PropertyChanged to subscribe itself to the property changed events of
	// the given entity. The method to call is stored in invocation.Arguments[0]. We get this and add it to the
	// proxy subscriber list.
	if (invocation.Method.Name.EndsWith("PropertyChanged"))
	{
	PropertyChangedEventHandler propertyChangedEventHandler = (PropertyChangedEventHandler)invocation.Arguments[0];
	if (invocation.Method.Name.StartsWith("add_"))
	{
	_subscribers += propertyChangedEventHandler;
	}
	else
	{
	_subscribers -= propertyChangedEventHandler;
	}
	}
	else
	{
	base.Intercept(invocation);
	}
	}
	public override void Initialize()
	{
	base.Initialize();
	var notifyPropertyChanged = Target as INotifyPropertyChanged;
	if (notifyPropertyChanged != null)
	{
	// We subscribe to our Target's property changed event so we can pass it on
	// to any objects that subscribe to the proxies event.
	notifyPropertyChanged.PropertyChanged += TargetPropertyChanged;
	}
	}
	void TargetPropertyChanged(object sender, PropertyChangedEventArgs e)
	{
	_subscribers(ProxyInstance, e);
	}
	}

view raw FixDataBindingLazyInitializer.cs hosted with ❤ by GitHub

The next thing we need to do is extend ProxyFactory to create our version of the LazyInitializer.  This is pretty straight forward and looks like this:

	public class FixDataBindingProxyFactory : ProxyFactory
	{
	public override INHibernateProxy GetProxy(object id, ISessionImplementor session)
	{
	// If it is not a proxy for a class do what you usually did.
	if (!IsClassProxy) return base.GetProxy(id, session);
	try
	{
	var initializer = new FixDataBindingLazyInitializer(EntityName, PersistentClass, id,
	GetIdentifierMethod, SetIdentifierMethod, ComponentIdType, session);
	// Add to the list of the interfaces that the proxy class will support the INotifyPropertyChanged interface.
	// This is only needed in the case when we need to cast our proxy object as INotifyPropertyChanged interface.
	var extraInterfaces = new[] {typeof (INotifyPropertyChanged)};
	var interfaces = Interfaces.Concat(extraInterfaces).ToArray();
	object generatedProxy = DefaultProxyGenerator.CreateClassProxy(PersistentClass, interfaces, initializer);
	initializer._constructed = true;
	initializer.ProxyInstance = generatedProxy;
	return (INHibernateProxy)generatedProxy;
	}
	catch (Exception e)
	{
	log.Error("Creating a proxy instance failed", e);
	throw new HibernateException("Creating a proxy instance failed", e);
	}
	}
	}

view raw FixDataBindingProxyFactory.cs hosted with ❤ by GitHub

When then have to make our own implementation of IProxyFactoryFactory, our implementation is a straight copy of the one in the NHibernate.Castle.ByteCode assembly only we return our FixDataBindingProxyFactory instead of the Castle version.

	public class FixDataBindingProxyFactoryFactory : IProxyFactoryFactory
	{
	public IProxyFactory BuildProxyFactory()
	{
	return new FixDataBindingProxyFactory();
	}
	public bool IsInstrumented(Type entityClass)
	{
	return true;
	}
	public IProxyValidator ProxyValidator
	{
	get { return new DynProxyTypeValidator(); }
	}
	}

view raw FixDataBindingProxyFactoryFactory.cs hosted with ❤ by GitHub

And our last step is to update our config so that we use our new IProxyFactoryFactory.

	<hibernate-configuration xmlns="urn:nhibernate-configuration-2.2" >
	<session-factory name="YourAppName">
	<property name="connection.driver_class">NHibernate.Driver.SqlClientDriver</property>
	<property name="dialect">NHibernate.Dialect.MsSql2005Dialect</property>
	<property name="connection.connection_string">
	Server=(local);initial catalog=nhibernate;Integrated Security=SSPI
	</property>
	<property name="proxyfactory.factory_class"> YouProjectNameSpace.FixDataBindingProxyFactoryFactory, YourProjectAssembly</property>
	</session-factory>
	</hibernate-configuration>

view raw ExampleConfig.xml hosted with ❤ by GitHub

We have now solved the problem.  I would like to thank Ioannis for a blog post he wrote related to this problem which included a solution although it didn’t fix my problem did point me in the right direction.

Happy coding!

Caleb