AttachedPropertyEvent Pattern

Introduction

In our project we use the Composite WPF model, and we needed a way to publish events from our views (XAML code) without creating any code-behind, and without having any dependencies. To publish and subscribe to events, we already used IEventAggregator, but still we had to write some code-behind in order to publish the events.

So we came up with what we call "AttachedPropertyEvent".

About the Example

In this example, I'm going to implement SelectedItemsChanged on a datagrid. The datagrid resides in a view, and I wish to subscribe to this event in some viewmodel.

Implementation

First we create an AttachedProperty with get and set methods, and a callback to perform some logic. This class resides in our Infrastructure project, and namespace Events.

public static class SelectedItemsChangedApe
{
    public static readonly DependencyProperty SelectedItemsProperty =
        DependencyProperty.RegisterAttached("SelectedItems",
                                    typeof (object), 
                                    typeof (SelectedItemsChangedApe), 
                                    new PropertyMetadata(RaiseEventCallback));

    public static object GetSelectedItems(DependencyObject obj)
    {
        return obj.GetValue(SelectedItemsProperty);
    }

    public static void SetSelectedItems(DependencyObject obj, object value)
    {
        obj.SetValue(SelectedItemsProperty, value);
    }

    private static void RaiseEventCallback
	(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        // Implement logic here
    }
}   

Next we need to implement the attached property in our View (XAML). We're using Xceed DataGridControl as our datagrid.

<xceed:DataGridControl
    x:Name="gridControl"
    ItemsSource="Some item source"
    Events:SelectedItemsChangedApe.SelectedItems=
	"{Binding RelativeSource={RelativeSource Self}, Path=SelectedItem}" /> 

By now we have an attached property, which really doesn't do much. What we want to do now is to publish an event every time the selected items change. To achieve this, we use IEventAggregator. So back to our Infrastructure project, we start by creating our own event, deriving from CompositePresentationEvent (Microsoft.Practices.Composite.Presentation.Events).

public class SelectedItemsChangedEvent : CompositePresentationEvent<IList<object>> { } 

So, with our composite presentation event, we can go back to our attached property and implement our logic in the callback method. What we want to do is publish the SelectedItemsChangedEvent. First we get our IEventAggregator by using the ServiceLocator, and publish the event to the event aggregator.

private static void RaiseEventCallback
	(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
    IEventAggregator eventAggregator = 
	ServiceLocator.Current.GetInstance<IEventAggregator>();
    eventAggregator.GetEvent<SelectedItemsChangedEvent>().Publish
					(e.NewValue as IList<object>);
}

Now our event is published, and we just need to subscribe to it. In this example, I have some viewmodel, where I subscribe to the event within the constructor.

public SomeViewModel()
{
    IEventAggregator eventAggregator = 
	ServiceLocator.Current.GetInstance<IEventAggregator>();
    eventAggregator.GetEvent<SelectedItemsChangedEvent>().Subscribe
					(OnSelectedItemsChanged);
}

private void OnSelectedItemsChanged(IList<object> obj)
{
    // Implement logic here
}

That's it.

Points of Interest

This is our first implementation using this pattern. For now, you need to create one attached property and event for each event you want to publish. We're working on making this generic at the moment.

History

• 2 July 2009 - Article uploaded

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)