<Path x:Key="MinusPath"
          HorizontalAlignment="Stretch"
          VerticalAlignment="Stretch"
          Data="{StaticResource MinusData}"
          Stretch="Fill"
          Stroke="Red"
          StrokeThickness="3" />

and referenced the Path in each Button with

<Button Content="{StaticResource MinusPath}"/>

This works for exactly one Button but not for more. You will get a XamlParseException with an InvalidOperationException as its InnerException. The problem is that you need a new Instance of the Path for each Button.

It actually took me quite a bit until I googled a solution for the problem and the solution is shockingly simply. You just need to add x:Shared=”false” to the Path declaration

    <Path x:Key="MinusPath"
          HorizontalAlignment="Stretch"
          VerticalAlignment="Stretch"
          Data="{StaticResource MinusData}"
          Stretch="Fill"
          Stroke="Red"
          StrokeThickness="3"
          x:Shared="false" />

Up to now I just didn’t know about this x:-Attribute because it is missing in Intellisense.

In every applications life there comes a time when you need to show some kind of message to the user. Be it a question whether he really wants to delete something or a simple message that says that some operation was successfull. The most simple way to do that is the good ol’ MessageBox.Show() with its zillion overloads.

MessageBox.Show("Foo", "Bar", MessageBoxButton.OKCancel);

But in the shiny MVVM World , poluting your ViewModels with MessageBoxes is usually frowned upon since it breaks a lot of stuff, especially automated unit testing and theming.

You can find quite a lot solutions about how the ‘MVVMize’ MesasgeBoxes and dialog screens in general. Most of them involve wrapping the MessageBox.Show() in some kind of IService, setting up some kind of event infrastructure and other funky stuff. Surprisingly, all of those solutions completely ignore the first M in MVVM, namely the Model, and none really tackles the problem at its heart.

One Model to rule them all

Well, let’s forget about all the View and ViewModel stuff for now. We will start by specifying what we actually want to achieve with a dialog.

We want to display some message concerning some topic and a list of possible Responses from which the user can choose one.

So, let’s create a model with conforms to those specifications

public class Dialog<TResponse>
{
	public DialogType DialogType { get; set; }
	public string Subject { get; set; }
	public string Message { get; set; }

	public IEnumerable<TResponse> PossibleResponses { get; protected set; }
	public TResponse GivenResponse {get; set; }
	public bool IsResponseGiven { get; private set; }
}

public enum DialogType
{
	None,
	Question,
	Warning,
	Information,
	Error
}

The DialogType in conjunction with the subject defines the topic and the rest is pretty much straightforward. We also need a IsResponseGiven Property so that we can distinguish between default and unset values because TResponse may or may not be a value type (and hence not nullable).

One ViewModel to bind them

The ViewModel is responsible for bringing the Responses in a bindable format and setting the response on the dialog when the user selects one. The ViewModel also handles the case where the user closes the window without giving any response at all.

For supporting default (the user presses ‘Enter’) and cancel (the user presses ‘Escape’) responses,  I will use a convention based approach, namely defining the first response in the list as the default response and the last response as the cancel response.

public class BindableResponse<TResponse>
{
	public TResponse Response { get; set; }
	public bool IsDefault { get; set; }
	public bool IsCancel { get; set; }
}

public interface IDialogViewModel<TResponse>
{
	bool IsClosed { get; set; }
	Dialog<TResponse> Dialog { get; set; }
	IObservableCollection<BindableResponse<TResponse>> Responses { get; }
	void Respond(BindableResponse<TResponse> bindableResponse);
}

The implementation is pretty straightforward and omitted for brevity but can be found here.

One View to show them all

I will present the WPF version of the view here because the SL version requires a workaround for the nonexisting IsDefault/IsCancel Properties of the Button. For those interested in the SL version, the source is here. I will also omit all irrelevant (styling) properties.

<Window x:Class="Caliburn.Micro.Contrib.Interaction.DialogView"
        Title="{Binding Dialog.Subject}"
        Contrib:DialogCloser.DialogResult="{Binding CanClose}">
    <Window.Icon>
        <Binding Path="Dialog.DialogType">
            <Binding.Converter>
                <Converter:DialogTypeToSystemIconConverter />
            </Binding.Converter>
        </Binding>
    </Window.Icon>
    <DockPanel Focusable="False" LastChildFill="True">
        <ItemsControl x:Name="Responses">
            <ItemsControl.ItemTemplate>
                <DataTemplate>
                    <Button Content="{Binding Response}"
                            IsCancel="{Binding IsCancel}"
                            IsDefault="{Binding IsDefault}"
                            Micro:Message.Attach="Respond($dataContext)" />
                </DataTemplate>
            </ItemsControl.ItemTemplate>
        </ItemsControl>
        <TextBlock Text="{Binding Dialog.Message}" />
    </DockPanel>
</Window>

The most important part is where we bind the Responses to an ItemsControl (by using Caliburn.Micros Convention Binding Feature) and create a Button for each Response which will call the Respond() Method on the ViewModel with the bound Response as a parameter. The Subject of the Dialog is bound to the Title of the Window and the DialogType is converted to an Icon.

And in the IResult wrap them

No Caliburn.Micro Extension with the corresponding IResult to use them !

To actually show the dialog to the user, we would have to

1. Create the dialog
2. Import the IWindowManager in the ViewModel
3. Create the ViewModel and pass it the dialog
4. Invoke ShowDialog() on the IWindowManager with the ViewModel as a parameter

Well, the first step cannot be encapsulated in an IResult, but 2-4 rest can easily be encapsulated.

public class DialogResult<TResponse> : IResult
{
	private Func<IDialogViewModel<TResponse>> _locateVM = () => new DialogViewModel<TResponse>();

	public DialogResult(Dialog<TResponse> dialog)
	{
		Dialog = dialog;
	}

	public Dialog<TResponse> Dialog { get; private set; }

	public void Execute(ActionExecutionContext context)
	{
		IDialogViewModel<TResponse> vm = _locateVM();
		vm.Dialog = Dialog;
		Micro.Execute.OnUIThread(() => IoC.Get<IWindowManager>().ShowDialog(vm));
	}

	public DialogResult<TResponse> In(IDialogViewModel<TResponse> dialogViewModel)
	{
		_locateVM = () => dialogViewModel;
		return this;
	}

	public DialogResult<TResponse> In<TDialogViewModel>()
		where TDialogViewModel : IDialogViewModel<TResponse>
	{
		_locateVM = () => IoC.Get<TDialogViewModel>();
		return this;
	}
}

We do not only get reusable code, but also a nice way to change the implementation of IDialogViewModel<> for specific dialogs if we want to.

Last but not least we can write a small Extension Method to get even more readable code !

public static DialogResult<TResponse> AsResult<TResponse>(this Dialog<TResponse> dialog)
        {
            return new DialogResult<TResponse>(dialog);
        }

And use it in the coroutine

public IEnumerable<IResult> Foo()
{
	var question = new Dialog<Answer>(DialogType.Question,
									  "Isn't this a nice way to create a Dialog Window?",
									  Answer.Yes,
									  Answer.No);

	yield return question.AsResult();

	if (question.GivenResponse == Answer.Yes)
		Console.WriteLine(" :] ");
	else
		Console.WriteLine(" :[ ");
}

In my last post I gave two possible approaches and a preview of my final solution for handling errors in IResults. The syntax for my final solution was

yield return new ProcessDataResult()
		.Rescue().With(coroutine: IORescue)
		.Rescue().With(coroutine: GeneralRescue);

This means that

• whenever the result completes with an error of type IOException, the IORescue coroutine is executed
• whenever the result completes with any other error, the GeneralRescue coroutine is executed

So the behaviour of the Rescue is similar to a try/catch block

try {}
catch (IOException e) { //IORescue }
catch (Exception e) { //GeneralRescue }

Decorators to the Rescue !

Now, before we have a look at the implementation, you should make yourself familiar with the Decorator Pattern since we will use a Decorator to ‘extend’ the behaviour of the Execute-Method of our Inner Result.

Well, let’s start with a base class for our decorators.

internal class ResultDecoratorBase : IResult
{
	private readonly IResult _inner;

	protected ResultDecoratorBase(IResult inner)
	{
		if (inner == null) throw new ArgumentNullException("inner");

		_inner = inner;
	}

	public IResult Inner
	{
		get { return _inner; }
	}

	#region IResult Members

	public virtual void Execute(ActionExecutionContext context)
	{
		var wrapper = new SequentialResult(new SingleResultEnumerator(_inner));
		wrapper.Completed += InnerCompleted;

		wrapper.Execute(context);
	}

	public virtual event EventHandler Completed;

	#endregion

	protected virtual void OnCompleted(ResultCompletionEventArgs args)
	{
		if (Completed != null)
			Completed(this, args);
	}

	protected virtual void InnerCompleted(object sender, ResultCompletionEventArgs args)
	{
		(sender as IResult).Completed -= InnerCompleted;
	}
}

The base Decorator takes an arbitrary IResult and, when executed, wraps it in a SequentialResult (to get some benefits like build up by the IoC ) and executes it. The InnerCompleted()-Method is the hook for the inheriting Decorators to perform their logic.

The Rescue Decorator

The Rescue Decorator will be generic (for the type that we want to catch) and takes a Function in its constructor which taked an exception as an argument and returns the Rescue Coroutine. We can also specify if we always want to cancel the Result after the rescue was executed.

/// <summary>
///   A result decorator which executes a coroutine when the inner result completes with an error
/// </summary>
/// <typeparam name = "TException">The type of the exception we want to perform the rescue on</typeparam>
internal class RescueCoroutineDecorator<TException> : ResultDecoratorBase
	where TException : Exception
{
	private readonly bool _cancelResult;
	private readonly Func<TException, IEnumerable<IResult>> _rescue;

	public RescueCoroutineDecorator(IResult inner, Func<TException, IEnumerable<IResult>> rescue, bool cancelResult)
		: base(inner)
	{
		if (rescue == null) throw new ArgumentNullException("rescue");

		_rescue = rescue;
		_cancelResult = cancelResult;
	}
}

In the InnerCompleted()-Method we check if the Inner Result completed with an error of type TException and if so, execute the Rescue Coroutine. If not, we ignore the error and raise the Completed-Event with the same args.

protected override void InnerCompleted(object sender, ResultCompletionEventArgs args)
{
	base.InnerCompleted(sender, args);

	if (args.Error is TException)
	{
		var error = (TException)args.Error;

		LogRescuedError(error);

		try
		{
			Rescue(error);
		}
		catch (Exception e)
		{
			Log.Error(e);
			OnCompleted(new ResultCompletionEventArgs { Error = e });
		}
	}
	else
	{
		OnCompleted(args);
	}
}

private void Rescue(TException exception)
{
	var rescueResult = new SequentialResult(_rescue(exception).GetEnumerator());
	rescueResult.Completed += RescueCompleted;

	rescueResult.Execute(_context);
}

Then, when the Rescue Coroutine completed, the Decorator will also complete. Since we execute the Rescue inside the execution of the Decorator we can also check if the Rescue completes successfully and react accordingly (like setting the error on the EventArgs or cancel it)

private void RescueCompleted(object sender, ResultCompletionEventArgs args)
{
	(sender as IResult).Completed -= RescueCompleted;

	OnCompleted(new ResultCompletionEventArgs { Error = args.Error, WasCancelled = args.WasCancelled || CancelResult });
}

The full code for the Rescue Decorator can be found here.

Recap

Well, with the Decorator Pattern it was possible to implement all the desired features in a nice and testable way. Furthermore, we can use same principle for executing a coroutine when the result is cancelled or when an exception is thrown inside the result.

One of Caliburn.Micro’s nicest feature is, hands down, the concept of Actions. In that concept the IResult plays an important role, especially when using Coroutines. If you don’t know about them, you should definately read up on them here first.

So, let’s assume we are executing a Coroutine which first shows a loading screen to the user, then starts processing a lot of data and finally hides the loading screen once the processing is finished. Since the processing is also likely to fail for whatever reason we want to handle the error by executing a Rescue Coroutine.

public IEnumerable ProcessData()
{
	yield return new BusyResult("Processing...");

	yield return new ProcessDataResult();

	yield return new NotBusyResult();
}

The implementation of those results is irrelevant since we want to have a look at how we can handle the error during the processing in a nice (reusable) way.

The First Attempt

Well, let’s see how we can handle it at all. The first approach is to ignore the built-in mechanism and expose an error property on the result which will then be checked during the execution of the Coroutine.

public IEnumerable ProcessData()
{
	yield return new BusyResult("Processing...");

	var processDataResult = new ProcessDataResult();
	yield return processDataResult;

	if (processDataResult.Error != null)
	{
		// We could use Coroutine.BeginExecute(Rescue().GetEnumerator()); but than the context would be null
		foreach (var rescueResult in Rescue())
		{
			yield return rescueResult;
		}
		yield break;
	}
	else
	{
		yield return new NotBusyResult();
	}
}

public IEnumerable<IResult> Rescue()
{
	yield return new NotBusyResult();

	// more rescue stuff
}

public class ProcessDataResult : IResult
{
	public Exception Error { get; private set; }

	public void Execute(ActionExecutionContext context)
	{
		try
		{
			//process the data
		}
		catch (Exception e)
		{
			Error = e;
		}

		Completed(this, new ResultCompletionEventArgs());
	}

	public event EventHandler<ResultCompletionEventArgs> Completed;
}

Although this works, there are some problems with this approach.

• We need to add an error property to each result where an error is likely (which may not be always possible)
• The syntax for executing the Rescue Coroutine is quite ugly and not easy to comprehend
• The method itself gets exponentially more complex for every result which can fail
• Calling different rescues for different error is tideous

The Better Attempt

The second approach uses the built-in mechanism by raising the Completed Event with the Error roperty of the ResultCompletitionEventArgs set to the actual error.

public IEnumerable<IResult> ProcessData()
{
	yield return new BusyResult("Processing...");

	var processDataResult = new ProcessDataResult();
	processDataResult.Completed += (sender, args) =>
									   {
										   if (args.Error != null)
											   Coroutine.BeginExecute(Rescue().GetEnumerator());
									   };

	yield return processDataResult;

	yield return new NotBusyResult();
}

public IEnumerable<IResult> Rescue()
{
	yield return new NotBusyResult();

	// more rescue stuff
}

public class ProcessDataResult : IResult
{
	public void Execute(ActionExecutionContext context)
	{
		try
		{
			//process the data
		}
		catch (Exception e)
		{
			Completed(this, new ResultCompletionEventArgs { Error = e });
		}

		Completed(this, new ResultCompletionEventArgs());
	}

	public event EventHandler<ResultCompletionEventArgs> Completed;
}

With this approach we don’t need to add an extra property to our Result which is a huge gain but there are still some disadvantages.

• We ‘lose’ the context in the Rescue Coroutine
• Syntax still not optimal
• Calling different rescues is still tedious

The Final Solution

So, what we want is basically

• a nice syntax,
• something that works for every implementation of IResult,
• execute the Rescue Coroutine with the same context as the failing Coroutine,
• and a way to handle different types of errors

Whew, that’s quite a bit to ask for. Let’s have a look at the first two points. Since we want it to work on every implementation of IResult, we cannot use inheritance but how about an Extension Method for IResults together with some fluent syntax?

public IEnumerable<IResult> ProcessData()
{
	yield return new BusyResult("Processing...");

	yield return new ProcessDataResult()
		.Rescue<IOException>().With(coroutine: IORescue)
		.Rescue().With(coroutine: GeneralRescue);

	yield return new NotBusyResult();
}

public IEnumerable<IResult> IORescue(IOException exception)
{
	yield return new NotBusyResult();

	// more rescue stuff
}

public IEnumerable<IResult> GeneralRescue(Exception exception)
{
	yield return new NotBusyResult();

	// more rescue stuff
}

That doesn’t look too bad, does it?

But since this post got really long, I will show the implementation of the solution in the next part. So you either wait for the next post or you can have a look at the code yourself

So, we will start with an interface which defines some methods for saving/restoring the state of a class on startup/shutdown.

public interface ICanResurrect
{
	bool CanResurrect { get; }

	void CreateTombstone();
	void Resurrect();
}

A tombstone is basically the file (or the row in a sql table, etc) in which you store all the information you need to ‘resurrect’ the class on startup. For the implementation of this interface in the different classes (view, conductor, conducted items) i wrote an ITombstoneService which helps with the with storing the information on disk. I won’t go into implementation details of this interface because it is outside of the scope of this post but it is included in the demo project. Here’s the signature of the interface

public interface ITombstoneService<TTombstone>
{
	string TombstoneDirectory { get; }

	void Create(string tombstoneName, TTombstone tombstone);
	TTombstone Load(string tombstoneName);
	bool Exists(string tombstoneName);
}

So, we will start with the view implementation this time. First, we will extend the IAvalonDockView interface.

public interface IResurrectableAvalonDockView<T> : IAvalonDockView<T>, ICanResurrect
	where T : IHaveGuid
{
}

public interface IHaveGuid
{
	Guid Guid { get; set; }
}

You can change the restriction of T in your implementation to whatever you want, we just need a way the uniquely identify each view model and a guid is the easiest way to do this. We will implement the interface again in a seperate class and use that class in the view.

public class ResurrectableAvalonDockViewImpl<T> : AvalonDockViewImpl<T>, IResurrectableAvalonDockView<T>
        where T : IHaveGuid
{
	private readonly ILog _log = LogManager.GetLog(typeof (ResurrectableAvalonDockViewImpl<T>));

	private readonly string _tombstoneName;
	private readonly ITombstoneService<string> _tombstoneService = new DemoTombstoneService();

	public ResurrectableAvalonDockViewImpl(DockingManager dockingManager, string tombstoneName)
		: base(dockingManager)
	{
		_tombstoneName = tombstoneName;
		dockingManager.Loaded += (s, e) => Resurrect();
	}

	#region IResurrectableAvalonDockView<T> Members

	public bool CanResurrect
	{
		get { return _tombstoneService.Exists(_tombstoneName); }
	}

	public void CreateTombstone()
	{
		using (var sw = new StringWriter())
		{
			_log.Info("Creating Tombstone {0}", _tombstoneName);

			DockingManager.SaveLayout(sw);

			string tombstoneContent = sw.GetStringBuilder().ToString();

			_tombstoneService.Create(_tombstoneName, tombstoneContent);
		}
	}

	public void Resurrect()
	{
		if (CanResurrect)
		{
			_log.Info("Resurrect from Tombstone {0}", _tombstoneName);

			string tombstoneContent = _tombstoneService.Load(_tombstoneName);
			using (var sr = new StringReader(tombstoneContent))
			{
				DockingManager.RestoreLayout(sr);
			}
		}
	}

	#endregion
}

Well, not so much to do here because we just need to create/load our tombstone and use it for the save/restore feature of the DockingManager after it has loaded.

Since the implementation of the conductor is a bit more complicated, i will split the code in three parts and discuss it one by one. We will start with the creation of the tombstone.

public abstract class ResurrectableAvalonConductor<T> : AvalonConductor<T>, ICanResurrect
        where T : IHaveGuid
{
	public void CreateTombstone()
	{
		_log.Info("Creating Tombstone.");

		string[] itemDescriptions = GetTombstoneItems()
			.Select(x => string.Format("{0}{1}{2}", x.GetType().AssemblyQualifiedName, Seperator, x.Guid))
			.ToArray();

		string content = String.Join(Environment.NewLine, itemDescriptions);

		_tombstoneService.Create(TombstoneName, content);

		foreach (T item in Items)
		{
			if (item is ICanResurrect)
				(item as ICanResurrect).CreateTombstone();
		}
	}

	protected virtual IEnumerable<T> GetTombstoneItems()
	{
		// here you can filter out the items which should not be resurrected
		return Items;
	}
}

First, we select all the conducted items we want to store in the tombstone and save all the information we need for resurrection (type and guid) in a string. Then, we also call CreateTombstone() for each item which implements the ICanResurrect interface.

public virtual void Resurrect()
{
	if (CanResurrect)
	{
		_log.Info("Resurrecting from Tombstone {0}", TombstoneName);
		string content = _tombstoneService.Load(TombstoneName);
		string[] lines = content
			.Split(new[] {Environment.NewLine}, StringSplitOptions.RemoveEmptyEntries);

		var itemDescriptions = lines
			.Select(x => x.Split(new[] {Seperator}, StringSplitOptions.None))
			.Select(x => new {AssemblyQualifiedName = x[0], Guid = new Guid(x[1])});

		foreach (var itemDescription in itemDescriptions)
		{
			Type itemType = Type.GetType(itemDescription.AssemblyQualifiedName);
			T item;
			if (TryResurrectItem(itemType, itemDescription.Guid, out item))
			{
				if (item is ICanResurrect)
				{
					(item as ICanResurrect).Resurrect();
				}
				_log.Info("Activating type from tombstone: {0} {1}",
						  itemDescription.AssemblyQualifiedName,
						  itemDescription.Guid);
				ActivateItem(item);
			}
		}
	}
}

protected virtual object ResurrectItem(Type type, Guid guid)
{
	object instance = Activator.CreateInstance(type);
	if (instance is IHaveGuid) (instance as IHaveGuid).Guid = guid;

	return instance;
}

private bool TryResurrectItem(Type type, Guid guid, out T item)
{
	object instance = ResurrectItem(type, guid);
	if (instance is T)
	{
		item = (T) instance;
		return true;
	}

	item = default(T);
	_log.Info("Wrong type in tombstone: {0}", type.AssemblyQualifiedName);
	return false;
}

In the Resurrect() method, we load the tombstone and parse its content . Each line contains the type and the guid of the item, so we store that data in an anonymous class for better readability. Then, we iterate over all items and try to resurrect them. If you want to use an IoC container for object creation, you should override the ResurrectItem() method. Also, we check for each item if it implements the ICanResurrect interface and if so, call its Resurrect() method. Finally, we activate the item.
Last but not least, we need to know when to call the CreateTombstone() and Resurrect() method. The CreateTombstone() method must be called before we deactivate the items but after we checked if we can actually close the conductor. So we need to override the CanClose() method. Another way might be to implement a custom ICloseStrategy<T>.

public override void CanClose(Action<bool> callback)
{
	CloseStrategy.Execute(Items,
						  (canClose, closable) =>
						  {
							  if (canClose)
							  {
								  CreateTombstone();
								  if (View is ICanResurrect) (View as ICanResurrect).CreateTombstone();
							  }
							  closable.Apply(x => DeactivateItem(x, true));
							  callback(canClose);
						  });
}

The Resurrect() method will be called after the view has been created because ActivateItem() needs it.

protected override void OnViewLoaded(object view)
{
	base.OnViewLoaded(view);
	Resurrect();
}

That’s it for the second (and last) part. I’ve again created a small demo project where you can see how you can use all those classes we just implemented. Download is here

So, how can we implement that. Well, my idea was to make the conductor aware of the view and implement an interface in the view which allows me to change/close the active item in the AvalonDock control and to register to the events when the user activates/closes a tab in the control. The interface i came up with is this:

public interface IAvalonDockView<T>
{
	DockingManager DockingManager { get; }

	void Show(T item);
	void Close(T item);

	event EventHandler<ContentActivatedEventArgs<T>> ContentActivated;
	event EventHandler<ContentClosingEventArgs<T>> ContentClosing;
}

public class ContentActivatedEventArgs<T> : EventArgs
{
	public T Item;
}

public class ContentClosingEventArgs<T> : EventArgs
{
	public T Item;
	public bool Cancel;
}

I think it is pretty straightforward. One thing to note though is the cancel flag in the ContentClosingEventArgs which allows the conductor to cancel the closing of a tab item (f.e. when the viewmodels TryClose() method returns false). I choosed to not implement the interface directly in my view but in a seperate implementor class and the view basically acts as an adapter for the implementor.

public class AvalonDockViewImpl<T> : IAvalonDockView<T>
{
	private readonly ILog _log = LogManager.GetLog(typeof (AvalonDockViewImpl<T>));

	/// <summary>
	/// Returns the name for the dockable content of the item. This name must be unique for each item if you want to use the save/restore layout feature!
	/// </summary>
	/// <param name="item"></param>
	/// <returns></returns>
	public Func<T, string> ResolveDockableContentName { get; set; }

	/// <summary>
	/// Returns the title for the dockable content of the item. This name must not be unique !
	/// </summary>
	/// <param name="item"></param>
	/// <returns></returns>
	public Func<T, string> ResolveDockableContentTitle { get; set; }

	public AvalonDockViewImpl(DockingManager dockingManager)
	{
		DockingManager = dockingManager;

		dockingManager.ActiveDocumentChanged += (s, e) =>
													{
														var dc = dockingManager.ActiveDocument as DockableContent;
														OnDcActivated(dc);
													};

		ResolveDockableContentName = item => string.Format("Item{0}", item.GetHashCode().ToString());

		ResolveDockableContentTitle = item => item is IHaveDisplayName
												  ? (item as IHaveDisplayName).DisplayName
												  : typeof (T).Name;
	}

	#region IAvalonDockView<T> Members

	public DockingManager DockingManager { get; private set; }

	public void Show(T item)
	{
		_log.Info("Showing {0}", ResolveDockableContentName(item));
		object view = LocateViewFor(item);

		DockableContent dc = GetDockableContentFromView(view);

		if (dc == null)
		{
			_log.Info("No dockable content found for {0}. Creating a new one", ResolveDockableContentName(item));
			dc = CreateDockableContent(item);
			_log.Info("Created dockable content: {0}", dc.Name);
			dc.ShowAsDocument(DockingManager);
		}
		else
		{
			_log.Info("Dockable content {0} found for {1}", dc.Name, ResolveDockableContentName(item));
			dc.Activate();
			if (dc.State == DockableContentState.Hidden)
			{
				dc.Show();
			}
			if (dc.State == DockableContentState.DockableWindow)
			{
				((FloatingDockablePane) (dc.Parent)).FloatingWindow.Focus();
				((FloatingDockablePane) (dc.Parent)).FloatingWindow.Topmost = true;
			}
		}
	}

	public void Close(T item)
	{
		_log.Info("Showing {0}", item is IHaveDisplayName ? (item as IHaveDisplayName).DisplayName : typeof (T).Name);
		object view = LocateViewFor(item);

		DockableContent dc = GetDockableContentFromView(view);
		if (dc != null)
		{
			dc.Close(true);
		}
	}

	public event EventHandler<ContentActivatedEventArgs<T>> ContentActivated;
	public event EventHandler<ContentClosingEventArgs<T>> ContentClosing;

	#endregion

	private DockableContent GetDockableContentFromView(object view)
	{
		return DockingManager.DockableContents
			.SingleOrDefault(x => x.Content == view);
	}

	private DockableContent CreateDockableContent(T item)
	{
		object view = LocateViewFor(item);

		var dockableContent = new DockableContent
								  {
									  Content = view,
									  Name = ResolveDockableContentName(item),
									  Title = ResolveDockableContentTitle(item),
									  HideOnClose = false
								  };

		dockableContent.Closing += (s, e) =>
									   {
										   var dc = (s as DockableContent);
										   _log.Info("Attempting to close dc {0}", dc.Name);

										   T vm = LocateViewModelFor(dc.Content);

										   bool cancel = false;
										   if (ContentClosing != null)
										   {
											   var closingEventArgs = new ContentClosingEventArgs<T>
																		  {
																			  Item = vm
																		  };
											   ContentClosing(this, closingEventArgs);
											   cancel = closingEventArgs.Cancel;
										   }

										   if (cancel)
										   {
											   _log.Info("Closing of dc {0} canceled", dc.Name);
										   }

										   e.Cancel |= cancel;
									   };

		dockableContent.Closed += (s, e) =>
									  {
										  var dc = (s as DockableContent);
										  dc.Content = null;
									  };

		dockableContent.IsActiveContentChanged += (s, e) =>
													  {
														  var dc = (s as DockableContent);
														  OnDcActivated(dc);
													  };

		return dockableContent;
	}

	private void OnDcActivated(DockableContent dc)
	{
		T vm = LocateViewModelFor(dc.Content);
		if (dc.IsActiveContent)
		{
			_log.Info("Changed active dc to {0}", dc.Name);
			if (ContentActivated != null)
			{
				ContentActivated(this, new ContentActivatedEventArgs<T> {Item = vm});
			}
		}
	}

	public static object LocateViewFor(T item)
	{
		UIElement view = ViewLocator.LocateForModel(item, null, null);

		ViewModelBinder.Bind(item, view, null);

		return view;
	}

	public static T LocateViewModelFor(object view)
	{
		object viewModel = ViewModelLocator.LocateForView(view);

		return (T) viewModel;
	}
}

The Show() method checks if there already exists a dockable content for the view and if so makes it the active tabitem or window. If there doesn’t exist a dockable content, one is created and activated. We also register to various events of the dockable content, notably to the closing event to cancel the closing of the dockable content if the view model permits it. The two Func<T,string> which resolve the title (what is shown in the tab header) and name (used for saving/restoring layouts) for the dockable content can be changed easily in the view. Note that the name of the dockable content must be unique if you want to use the save/restore layout feature and that you can bind to the title property if you need to. We will take a look at the layout feature in the second part. The Close() method looks for the dockable content which host the view and closes it. Easy stuff.

For the conductor, i decided to subclass the existsing Conductor<T>.Collection.OneActive since that is exactly the behavior i wanted. So i only had to override some methods, namely:

public class AvalonConductor<T> : Conductor<T>.Collection.OneActive
{
	private IAvalonDockView<T> View { get; set; }

	protected override void ChangeActiveItem(T newItem, bool closePrevious)
	{
		T previous = ActiveItem;
		base.ChangeActiveItem(newItem, closePrevious);
		if (closePrevious && !Equals(previous, ActiveItem))
		{
			View.Close(previous);
		}
	}

	public override void ActivateItem(T item)
	{
		bool updateView = !Equals(item, ActiveItem);
		base.ActivateItem(item);
		if (updateView) View.Show(ActiveItem);
	}

	protected override T DetermineNextItemToActivate(int lastIndex)
	{
		// this will be handled by the view
		return default(T);
	}

	protected override void OnViewLoaded(object view)
	{
		base.OnViewLoaded(view);
		var avalonDockView = view as IAvalonDockView<T>;
		if (avalonDockView != null)
		{
			View = avalonDockView;
			View.ContentActivated += (s, e) => ActivateItem(e.Item);

			View.ContentClosing += (s, e) =>
							{
								DeactivateItem(e.Item, true);
								e.Cancel = Items.Contains(e.Item);
							};
		}
	}
}

When the view is loaded we register to its events and call the appropiate methods when the event is fired. And when the conductor activates/closes an item, we call the the corresponding method on the view. One thing to note is that the view actually determines the next active item if the current is closed so we just return null.

That’s it for the first part.  I also created a small demo project which can be downloaded here

The requirements are:

• Fine-grained control about what we want to audit for each entity type
• Automatic (fluent) mapping of the audit properties
• Setting the audit data automatically on each insert/update
• Easily change how the username and date is retrieved

We will start with two interfaces, IAuditCreation and IAuditLastModification. The interfaces add the respective audit properties to our entities

    public interface IAuditCreation
    {
        string CreatedBy { get; }
        DateTime? CreatedOn { get; }
    }

    public interface IAuditLastModification
    {
        string LastModifiedBy { get; }
        DateTime? LastModifiedOn { get; }
    }

The next step is to create an abstract base class for our fluent mappings. We get all interfaces from the type we want to map and if the type implements one of our audit interfaces, we simply map the fields provided by that interface.

public class AuditMap<TEntity> : ClassMap<TEntity>
    {
        public AuditMap()
        {
            var interfaces = typeof(TEntity).GetInterfaces();
            if (interfaces.Contains(typeof(IAuditCreation)))
            {
                Map(x => (x as IAuditCreation).CreatedBy)
                    .Access.Property();
                Map(x => (x as IAuditCreation).CreatedOn)
                    .Access.Property();
            }
            if (interfaces.Contains(typeof(IAuditLastModification)))
            {
                Map(x => (x as IAuditLastModification).LastModifiedBy)
                    .Access.Property();
                Map(x => (x as IAuditLastModification).LastModifiedOn)
                    .Access.Property();
            }
        }
    }

With the mapping in place, we need a way to automatically set the property on our entity before each save or update. We will use the event / listener system introduced in NHibernate 2.0 for this task. First, we will create an IAuditor interface which provides functions for retrieving the username/date and for updating the properties on our entity. In case you ask yourself why we use the events as a parameter instead of the entity itself, then you should note that we must update the entity as well as the entity state of the event. For more informations on the events, read this

    public interface IAuditor
    {
        string Username { get; }
        DateTime Date { get; }

        void HandleInsert(PreInsertEvent @event);
        void HandleUpdate(PreUpdateEvent @event);
    }

My implementation of the interface looks like this. Note that the Date property should be evaluated each time it is called. If you just set it to DateTime.Now it will be the same for each subsequent call.

    public class DefaultAuditor : AuditorBase
    {
        protected Func<string> RetrieveUsername { get; set; }
        protected Func<DateTime> RetrieveDate { get; set; }

        public override string Username { get { return RetrieveUsername(); } }
        public override DateTime Date { get { return RetrieveDate(); } }

        public DefaultAuditor()
            : this(() => Environment.UserName, () => DateTime.Now)
        {

        }

        public DefaultAuditor(Func<string> retrieveUsername, Func<DateTime> retrieveDate)
        {
            RetrieveUsername = retrieveUsername;
            RetrieveDate = retrieveDate;
        }
    }

    public abstract class AuditorBase : IAuditor
    {
        public abstract string Username { get; }
        public abstract DateTime Date { get; }

        protected AuditorBase()
        {
        }

        public virtual void HandleInsert(PreInsertEvent @event)
        {
            var logCreation = @event.Entity as IAuditCreation;
            if (logCreation != null)
            {
                Set(@event,
                    "CreatedBy",
                    Username);
                Set(@event,
                    "CreatedOn",
                    Date);
            }

            HandleUpdate(new PreUpdateEvent(@event.Entity, @event.Id, @event.State, null, @event.Persister, null));
        }

        public virtual void HandleUpdate(PreUpdateEvent @event)
        {
            var lastModification = @event.Entity as IAuditLastModification;
            if (lastModification != null)
            {
                Set(@event,
                    "LastModifiedBy",
                    Username);
                Set(@event,
                    "LastModifiedOn",
                    Date);
            }
        }

        private void Set(PreUpdateEvent @event, string propertyName, object value)
        {
            SetEntity(@event.Entity, propertyName, value);
            SetState(@event.Persister.PropertyNames, @event.State, propertyName, value);
        }

        private void Set(PreInsertEvent @event, string propertyName, object value)
        {
            SetEntity(@event.Entity, propertyName, value);
            SetState(@event.Persister.PropertyNames, @event.State, propertyName, value);
        }

        private void SetState(string[] propertyNames, object[] state, string propertyName, object value)
        {
            int index = Array.IndexOf(propertyNames, propertyName);
            if (index != -1)
            {
                state[index] = value;
            }
        }

        private void SetEntity(object entity, string propertyName, object value)
        {
            var propertyInfo = entity.GetType().GetProperty(propertyName, BindingFlags.Public | BindingFlags.Instance);
            if (propertyInfo != null && propertyInfo.CanWrite)
            {
                propertyInfo.SetValue(entity, value, null);
            }
        }
    }

Last but not least we need to provide an event listener which uses the IAuditor

    public class AuditorEventListener :
        IPreInsertEventListener,
        IPreUpdateEventListener
    {
        public IAuditor Auditor { get; private set; }

        public AuditorEventListener(IAuditor auditor)
        {
            Auditor = auditor;
        }

        public bool OnPreInsert(PreInsertEvent @event)
        {
            Auditor.HandleInsert(@event);

            return false;
        }

        public bool OnPreUpdate(PreUpdateEvent @event)
        {
            Auditor.HandleUpdate(@event);

            return false;
        }
    }

To register the listener with NHibernate, you must add this to your fluent configuration. You can, of course, replace the creation of the auditor with your IoC framework of choice, but for the sake of simplicity i created the auditor directly in the configuration. Also note, that you should not overwrite the event listeners with a new array because that would remove already registered listeners.

Fluently.Configure()
                .Database(SQLiteConfiguration.Standard.InMemory()
                    .ShowSql())
                .Mappings(x => x.FluentMappings.Add<CustomerMap>())
                .ExposeConfiguration(c =>
                {
                    var auditor = new DefaultAuditor();
                    var listener = new AuditorEventListener(auditor);

                    c.EventListeners.PreInsertEventListeners =
                        c.EventListeners.PreInsertEventListeners
                        .Concat(new[] { listener })
                        .ToArray();
                    c.EventListeners.PreUpdateEventListeners =
                        c.EventListeners.PreUpdateEventListeners
                        .Concat(new[] { listener })
                        .ToArray();
                });

That’s it. The whole solution, including unit test and a short console demo can be downloaded from my SkyDrive here.