.NET & Funky Fresh



  • <script type="text/javascript" src="http://ws.amazon.com/widgets/q?ServiceVersion=20070822&amp;MarketPlace=US&amp;ID=V20070822/US/bluspiconinc-20/8001/8b68bf4b-6724-40e7-99a5-a6decf6d8648"> </script>
Caliburn.Micro Soup to Nuts Pt. 5 – IResult and Coroutines

Before our WP7 detour, we were deep in the thick of Actions. I mentioned that there was one more compelling feature of the Actions concept called Coroutines. If you haven’t heard that term before, here’s what wikipedia* has to say:

In computer science, coroutines are program components that generalize subroutines to allow multiple entry points for suspending and resuming execution at certain locations. Coroutines are well-suited for implementing more familiar program components such as cooperative tasks, iterators,infinite lists and pipes.

Here’s one way you can thing about it: Imagine being able to execute a method, then pause it’s execution on some statement, go do something else, then come back and resume execution where you left off. This technique is extremely powerful in task-based programming, especially when those tasks need to run asynchronously. For example, let’s say we have a ViewModel that needs to call a web service asynchronously, then it needs to take the results of that, do some work on it and call another web service asynchronously. Finally, it must then display the result in a modal dialog and respond to the user’s dialog selection with another asynchronous task. Accomplishing this with the standard event-driven async model is not a pleasant experience. However, this is a simple task to accomplish by using coroutines. The problem…C# doesn’t implement coroutines natively. Fortunately, we can (sort of) build them on top of iterators.

There are two things necessary to take advantage of this feature in Caliburn.Micro: First, implement the IResult interface on some class, representing the task you wish to execute; Second, yield instances of IResult from an Action.** Let’s make this more concrete. Say we had a Silverlight application where we wanted to dynamically download and show screens not part of the main package. First we would probably want to show a “Loading” indicator, then asynchronously download the external package, next hide the “Loading” indicator and finally navigate to a particular screen inside the dynamic module. Here’s what the code would look like if your first screen wanted to use coroutines to navigate to a dynamically loaded second screen:

using System.Collections.Generic;
using System.ComponentModel.Composition;

public class ScreenOneViewModel
    public IEnumerable<IResult> GoForward()
        yield return Loader.Show("Downloading...");
        yield return new LoadCatalog("Caliburn.Micro.Coroutines.External.xap");
        yield return Loader.Hide();
        yield return new ShowScreen("ExternalScreen");

First, notice that the Action “GoForward” has a return type of IEnumerable<IResult>. This is critical for using coroutines. The body of the method has four yield statements. Each of these yields is returning an instance of IResult. The first is a result to show the “Downloading” indicator, the second to download the xap asynchronously, the third to hide the “Downloading” message and the fourth to show a new screen from the downloaded xap.  After each yield statement, the compiler will “pause” the execution of this method until that particular task completes. The first, third and fourth tasks are synchronous, while the second is asynchronous.  But the yield syntax allows you to write all the code in a sequential fashion, preserving the original workflow as a much more readable and declarative structure. To understand a bit more how this works, have a look at the IResult interface:

public interface IResult
    void Execute(ActionExecutionContext context);
    event EventHandler<ResultCompletionEventArgs> Completed;

It’s a fairly simple interface to implement. Simply write your code in the “Execute” method and be sure to raise the “Completed” event when you are done, whether it be a synchronous or an asynchronous task. Because coroutines occur inside of an Action, we provide you with an ActionExecutionContext useful in building UI-related IResult implementations. This allows the ViewModel a way to declaratively state it intentions in controlling the view without having any reference to a View or the need for interaction-based unit testing. Here’s what the ActionResultContext looks like:

public class ActionExecutionContext
    public ActionMessage Message;
    public FrameworkElement Source;
    public object EventArgs;
    public object Target;
    public DependencyObject View;
    public MethodInfo Method;
    public Func<bool> CanExecute;
    public object this[string key];

And here’s an explanation of what all these properties mean:

  • Message – The original ActionMessage that caused the invocation of this IResult.
  • Source – The FrameworkElement that triggered the execution of the Action.
  • EventArgs – Any event arguments associated with the trigger of the Action.
  • Target – The class instance on which the actual Action method exists.
  • View – The view associated with the Target.
  • Method – The MethodInfo specifying which method to invoke on the Target instance.
  • CanExecute – A function that returns true if the Action can be invoked, false otherwise.
  • Key Index: A place to store/retrieve any additional metadata which may be used by extensions to the framework.

Bearing that in mind, I wrote a naive Loader IResult that searches the VisualTree looking for the first instance of a BusyIndicator to use to display a loading message. Here’s the implementation:

using System;
using System.Windows;
using System.Windows.Controls;

public class Loader : IResult
    readonly string message;
    readonly bool hide;

    public Loader(string message)
        this.message = message;

    public Loader(bool hide)
        this.hide = hide;

    public void Execute(ActionExecutionContext context)
        var view = context.View as FrameworkElement;
        while(view != null)
            var busyIndicator = view as BusyIndicator;
            if(busyIndicator != null)
                    busyIndicator.BusyContent = message;
                busyIndicator.IsBusy = !hide;

            view = view.Parent as FrameworkElement;

        Completed(this, new ResultCompletionEventArgs());

    public event EventHandler<ResultCompletionEventArgs> Completed = delegate { };

    public static IResult Show(string message = null)
        return new Loader(message);

    public static IResult Hide()
        return new Loader(true);

See how I took advantage of context.View? This opens up a lot of possibilities while maintaining separation between the view and the view model. Just to list a few interesting things you could do with IResult implementations: show a message box, show a VM-based modal dialog, show a VM-based Popup at the user’s mouse position, play an animation, show File Save/Load dialogs, place focus on a particular UI element based on VM properties rather than controls, etc. Of coarse, one of the biggest opportunities is calling web services. Let’s look at how you might do that, but by using a slightly different scenario, dynamically downloading a xap:

using System;
using System.Collections.Generic;
using System.ComponentModel.Composition;
using System.ComponentModel.Composition.Hosting;
using System.ComponentModel.Composition.ReflectionModel;
using System.Linq;

public class LoadCatalog : IResult
    static readonly Dictionary<string, DeploymentCatalog> Catalogs = new Dictionary<string, DeploymentCatalog>();
    readonly string uri;

    public AggregateCatalog Catalog { get; set; }

    public LoadCatalog(string relativeUri)
        uri = relativeUri;

    public void Execute(ActionExecutionContext context)
        DeploymentCatalog catalog;

        if(Catalogs.TryGetValue(uri, out catalog))
            Completed(this, new ResultCompletionEventArgs());
            catalog = new DeploymentCatalog(uri);
            catalog.DownloadCompleted += (s, e) =>{
                if(e.Error == null)
                    Catalogs[uri] = catalog;
                        .Select(part => ReflectionModelServices.GetPartType(part).Value.Assembly)
                        .Where(assembly => !AssemblySource.Instance.Contains(assembly))
                        .Apply(x => AssemblySource.Instance.Add(x));
                else Loader.Hide().Execute(context);

                Completed(this, new ResultCompletionEventArgs {
                    Error = e.Error,
                    WasCancelled = false


    public event EventHandler<ResultCompletionEventArgs> Completed = delegate { };

In case it wasn’t clear, this sample is using MEF. Furthermore, we are taking advantage of the DeploymentCatalog created for Silverlight 4.  You don’t really need to know a lot about MEF or DeploymentCatalog to get the takeaway. Just take note of the fact that we wire for the DownloadCompleted event and make sure to fire the IResult.Completed event in its handler. This is what enables the async pattern to work. We also make sure to check the error and pass that along in the ResultCompletionEventArgs. Speaking of that, here’s what that class looks like:

public class ResultCompletionEventArgs : EventArgs
    public Exception Error;
    public bool WasCancelled;

Caliburn.Micro’s enumerator checks these properties after it get’s called back from each IResult. If there is either an error or WasCancelled is set to true, we stop execution. You can use this to your advantage. Let’s say you create an IResult for the OpenFileDialog. You could check the result of that dialog, and if the user canceled it, set WasCancelled on the event args. By doing this, you can write an action that assumes that if the code following the Dialog.Show executes, the user must have selected a file. This sort of technique can simplify the logic in such situations. Obviously, you could use the same technique for the SaveFileDialog or any confirmation style message box if you so desired. My favorite part of the LoadCatalog implementation shown above, is that the original implementation was written by a CM user! Thanks janoveh for this awesome submission! As a side note, one of the things we added to the CM project site is a “Recipes” section. We are going to be adding more common solutions such as this to that area in the coming months. So, it will be a great place to check for cool plugins and customizations to the framework.***

Another thing you can do is create a series of IResult implementations built around your application’s shell. That is what the ShowScreen result used above does. Here is its implementation:

using System;
using System.ComponentModel.Composition;

public class ShowScreen : IResult
    readonly Type screenType;
    readonly string name;

    public IShell Shell { get; set; }

    public ShowScreen(string name)
        this.name = name;

    public ShowScreen(Type screenType)
        this.screenType = screenType;

    public void Execute(ActionExecutionContext context)
        var screen = !string.IsNullOrEmpty(name)
            ? IoC.Get<object>(name)
            : IoC.GetInstance(screenType, null);

        Completed(this, new ResultCompletionEventArgs());

    public event EventHandler<ResultCompletionEventArgs> Completed = delegate { };

    public static ShowScreen Of<T>()
        return new ShowScreen(typeof(T));

This bring up another important feature of IResult. Before CM executes a result, it passes it through the IoC.BuildUp method allowing your container the opportunity to push dependencies in through the properties. This allows you to create them normally within your view models, while still allowing them to take dependencies on application services. In this case, we depend on IShell. You could also have your container injected, but in this case I chose to use the IoC static class internally. As a general rule, you should avoid pulling things from the container directly. However, I think it is acceptable when done inside of infrastructure code such as a ShowScreen IResult.

I hope this gives some explanation and creative ideas for what can be accomplished with IResult. Be sure to check out the sample application attached. There’s a few other interesting things in there as well.

* When I went to look up the “official” definition on wikipedia I was interested to see what it had to say about implementations in various languages. Scrolling down to the section on C#…Caliburn was listed! Fun stuff.

** You can also return a single instance of IResult without using IEnuermable<IResult> if you just want a simple way to execute a single task.

*** If you want a sample of a truly awesome plugin we will be adding to the recipes section soon, check this out!

Posted 08-21-2010 2:31 PM by Rob Eisenberg



Mike Strobel wrote re: Caliburn.Micro Soup to Nuts Pt. 5 – IResult and Coroutines
on 08-21-2010 3:35 PM

Nice.  I have a similar API that I'm working on, which also allows you to override which scheduler is used to execute individual results (by default they execute with the thread pool, but you could force use the dispatcher scheduler if a result interacts with the UI).

One observation: instead of having discrete Load/Hide IResults for your Loader, you could implement your load indicator using IDisposable such that calling Dispose() hides the indicator.  Then you could yield your other results from within a "using (Loader.Load()) { ... }" block.  One of the nice things about the async enumerator pattern is that 'using' blocks work like they would in synchronous code.

Rob Eisenberg wrote re: Caliburn.Micro Soup to Nuts Pt. 5 – IResult and Coroutines
on 08-21-2010 4:00 PM

Great idea with "using" I don't think it would work in this instance due to the implementation's dependency on being executed with the Action's context. This example was certainly a bit contrived in order to show a few different types of things that could be done with IResult. So, I would definitely consider that type of solution as an alternative.

Travis wrote re: Caliburn.Micro Soup to Nuts Pt. 5 – IResult and Coroutines
on 09-28-2010 7:58 PM

Do we need to worry about dispatching or threading with this? I assume that the action and IResults execute on the UI thread unless instructed otherwise. It follows that you download the Xap catalog asynchronously, but I don't see it dispatched back to the UI thread when complete. Does whatever-executes-IResult.Completed handle that for us?

Frank Quednau wrote re: Caliburn.Micro Soup to Nuts Pt. 5 – IResult and Coroutines
on 09-29-2010 4:40 PM


that's all pretty amazing stuff, to be honest. I am just trying to get a grip on this framework and I see in the codeplex documentation section that you have planned to talk about Screens and Conductors and the Window Manager. I get the feeling I need that information to get really productive with CM. Now it's been more than a month :'( Are you around? Will you manage?

I'm sorry that I'm nagging...

Mikael Koskinen wrote Caliburn.Micro
on 07-23-2011 12:14 PM


About The CodeBetter.Com Blog Network
CodeBetter.Com FAQ

Our Mission

Advertisers should contact Brendan

Google Reader or Homepage

del.icio.us CodeBetter.com Latest Items
Add to My Yahoo!
Subscribe with Bloglines
Subscribe in NewsGator Online
Subscribe with myFeedster
Add to My AOL
Furl CodeBetter.com Latest Items
Subscribe in Rojo

Member Projects
DimeCasts.Net - Derik Whittaker

Friends of Devlicio.us
Red-Gate Tools For SQL and .NET


SmartInspect .NET Logging
NGEDIT: ViEmu and Codekana
NHibernate Profiler
Balsamiq Mockups
JetBrains - ReSharper
Web Sequence Diagrams
Ducksboard<-- NEW Friend!


Site Copyright © 2007 CodeBetter.Com
Content Copyright Individual Bloggers


Community Server (Commercial Edition)