<Buttonx:Name="Save">

<Buttoncal:Message.Attach="Save">

<Buttoncal:Message.Attach="[Event MouseEnter] = [Action Save]">

<Buttoncal:Message.Attach="[Event MouseEnter] = [Action Save($this)]">

<UserControlx:Class="Caliburn.Micro.CheatSheet.ShellView"xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"xmlns:i="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity"xmlns:cal="http://www.caliburnproject.org"><StackPanel><TextBoxx:Name="Name"/><ButtonContent="Save"><i:Interaction.Triggers><i:EventTriggerEventName="Click"><cal:ActionMessageMethodName="Save"><cal:ParameterValue="{Binding ElementName=Name, Path=Text}"/></cal:ActionMessage></i:EventTrigger></i:Interaction.Triggers></Button></StackPanel></UserControl>

<TextBoxx:Name="FirstName"/>

<TextBoxText="{Binding Path=FirstName, Mode=TwoWay}"/>

publicinterface IEventAggregator {  
    void Subscribe(object instance);  
    void Unsubscribe(object instance);  
    void Publish(object message, Action<System.Action> marshal);  
}

publicclass MyEvent {
    public MyEvent(string myData) {
        this.MyData = myData;
    }

    publicstring MyData { get; privateset; }
}

namespace Caliburn.Micro.Hello {
    using System.Windows;

    publicpartialclass App : Application {
        public App() {
            InitializeComponent();
        }
    }
}

namespace Caliburn.Micro.Hello {
    using System.Windows;

    publicclass ShellViewModel : PropertyChangedBase {
        string name;

        publicstring Name {
            get { return name; }
            set {
                name = value;
                NotifyOfPropertyChange(() => Name);
                NotifyOfPropertyChange(() => CanSayHello);
            }
        }

        publicbool CanSayHello {
            get { return !string.IsNullOrWhiteSpace(Name); }
        }

        publicvoid SayHello() {
            MessageBox.Show(string.Format("Hello {0}!", Name)); //Don't do this in real life :)
        }
    }
}

namespace Caliburn.Micro.Hello {
    publicclass HelloBootstrapper : BootstrapperBase {
        public HelloBootstrapper() {
            Start();
        }

        protectedoverridevoid OnStartup(object sender, StartupEventArgs e) {
            DisplayRootViewFor<ShellViewModel>();
        }
    }
}

<Applicationxmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"xmlns:local="clr-namespace:Caliburn.Micro.Hello"x:Class="Caliburn.Micro.Hello.App"><Application.Resources><local:HelloBootstrapperx:Key="bootstrapper"/></Application.Resources></Application>

<Applicationxmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"xmlns:local="clr-namespace:Caliburn.Micro.Hello"x:Class="Caliburn.Micro.Hello.App"><Application.Resources><ResourceDictionary><ResourceDictionary.MergedDictionaries><ResourceDictionary><local:HelloBootstrapperx:Key="bootstrapper"/></ResourceDictionary></ResourceDictionary.MergedDictionaries></ResourceDictionary></Application.Resources></Application>

<UserControlx:Class="Caliburn.Micro.Hello.ShellView"xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"><StackPanel><TextBoxx:Name="Name"/><Buttonx:Name="SayHello"Content="Click Me"/></StackPanel></UserControl>

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

publicclass MefBootstrapper : BootstrapperBase
{
    private CompositionContainer container;

    public MefBootstrapper()
    {
        Start();
    }

    protectedoverridevoid Configure()
    {
        container = CompositionHost.Initialize(
            new AggregateCatalog(
                AssemblySource.Instance.Select(x => new AssemblyCatalog(x)).OfType<ComposablePartCatalog>()
                )
            );

        var batch = new CompositionBatch();

        batch.AddExportedValue<IWindowManager>(new WindowManager());
        batch.AddExportedValue<IEventAggregator>(new EventAggregator());
        batch.AddExportedValue(container);

        container.Compose(batch);
    }

    protectedoverrideobject GetInstance(Type serviceType, string key)
    {
        string contract = string.IsNullOrEmpty(key) ? AttributedModelServices.GetContractName(serviceType) : key;
        var exports = container.GetExportedValues<object>(contract);

        if (exports.Any())
            return exports.First();

        thrownew Exception(string.Format("Could not locate any instances of contract {0}.", contract));
    }

    protectedoverride IEnumerable<object> GetAllInstances(Type serviceType)
    {
        return container.GetExportedValues<object>(AttributedModelServices.GetContractName(serviceType));
    }

    protectedoverridevoid BuildUp(object instance)
    {
        container.SatisfyImportsOnce(instance);
    }

    protectedoverridevoid OnStartup(object sender, StartupEventArgs e)
    {
        DisplayRootViewFor<IShell>();
    }
}

protectedoverride IEnumerable<Assembly> SelectAssemblies()
{
    returnnew[] {
        Assembly.GetExecutingAssembly()
    };
}

protectedoverridevoid DisplayRootView() 
{
    var viewModel = IoC.Get<TRootModel>();
#if SILVERLIGHT
    var view = ViewLocator.LocateForModel(viewModel, null, null);
    ViewModelBinder.Bind(viewModel, view, null);

    var activator = viewModel as IActivate;
    if (activator != null)
        activator.Activate();

    Application.RootVisual = view;
#else
    IWindowManager windowManager;

    try
    {
        windowManager = IoC.Get<IWindowManager>();
    }
    catch
    {
        windowManager = new WindowManager();
    }

    windowManager.Show(viewModel);
#endif
}

publicinterface IShell
{
}

[Export(typeof(IShell))]
publicclass ShellViewModel : PropertyChangedBase, IShell
{
   ...implementation is same as before...
}

<UserControlx:Class="Caliburn.Micro.Hello.ShellView"xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"xmlns:i="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity"xmlns:cal="http://www.caliburnproject.org"><StackPanel><TextBoxx:Name="Name"/><ButtonContent="Click Me"><i:Interaction.Triggers><i:EventTriggerEventName="Click"><cal:ActionMessageMethodName="SayHello"/></i:EventTrigger></i:Interaction.Triggers></Button></StackPanel></UserControl>

publicclass MefBootstrapper : BootstrapperBase
{
    //same as beforeprotectedoverridevoid OnStartup(object sender, StartupEventArgs e)
    {
        Application.RootVisual = new ShellView();
    }

    //same as before
} 

[Export("Shell", typeof(IShell))]
publicclass ShellViewModel : PropertyChangedBase, IShell
{
    //same as before
} 

<UserControlx:Class="Caliburn.Micro.ViewFirst.ShellView"xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"xmlns:cal="http://www.caliburnproject.org"cal:Bind.Model="Shell"><StackPanel><TextBoxx:Name="Name"/><Buttonx:Name="SayHello"Content="Click Me"/></StackPanel></UserControl>

using System.ComponentModel.Composition;
using System.Windows;

[Export(typeof(IShell))]
publicclass ShellViewModel : IShell
{
    publicbool CanSayHello(string name)
    {
        return !string.IsNullOrWhiteSpace(name);
    }

    publicvoid SayHello(string name)
    {
        MessageBox.Show(string.Format("Hello {0}!", name));
    }
} 

<UserControlx:Class="Caliburn.Micro.HelloParameters.ShellView"xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"xmlns:i="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity"xmlns:cal="http://www.caliburnproject.org"><StackPanel><TextBoxx:Name="Name"/><ButtonContent="Click Me"><i:Interaction.Triggers><i:EventTriggerEventName="Click"><cal:ActionMessageMethodName="SayHello"><cal:ParameterValue="{Binding ElementName=Name, Path=Text}"/></cal:ActionMessage></i:EventTrigger></i:Interaction.Triggers></Button></StackPanel></UserControl>

<UserControlx:Class="Caliburn.Micro.HelloParameters.ShellView"xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"><StackPanel><TextBoxx:Name="Name"/><Buttonx:Name="SayHello"Content="Click Me"/></StackPanel></UserControl>

using System;

publicclass Model
{
    public Guid Id { get; set; }
}

using System;
using System.ComponentModel.Composition;

[Export(typeof(IShell))]
publicclass ShellViewModel : IShell
{
    public BindableCollection<Model> Items { get; privateset; }

    public ShellViewModel()
    {
        Items = new BindableCollection<Model>{
            new Model { Id = Guid.NewGuid() },
            new Model { Id = Guid.NewGuid() },
            new Model { Id = Guid.NewGuid() },
            new Model { Id = Guid.NewGuid() }
        };
    }

    publicvoid Add()
    {
        Items.Add(new Model { Id = Guid.NewGuid() });
    }

    publicvoid Remove(Model child)
    {
        Items.Remove(child);
    }
}

<UserControlx:Class="Caliburn.Micro.BubblingAction.ShellView"xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"xmlns:cal="http://www.caliburnproject.org"><StackPanel><ItemsControlx:Name="Items"><ItemsControl.ItemTemplate><DataTemplate><StackPanelOrientation="Horizontal"><ButtonContent="Remove"cal:Message.Attach="Remove($dataContext)"/><TextBlockText="{Binding Id}"/></StackPanel></DataTemplate></ItemsControl.ItemTemplate></ItemsControl><ButtonContent="Add"cal:Message.Attach="Add"/></StackPanel></UserControl>

<ButtonContent="Remove"cal:Message.Attach="[Event Click] = [Action Remove($dataContext)]"/>

<ButtonContent="Click Me"cal:Message.Attach="[Event Click] = [Action SayHello(Name.Text)]"/>

<ButtonContent="Click Me"cal:Message.Attach="SayHello(Name)"/>

<ButtonContent="Let's Talk"cal:Message.Attach="[Event MouseEnter] = [Action Talk('Hello', Name.Text)]; [Event MouseLeave] = [Action Talk('Goodbye', Name.Text)]"/>

publicclass HelloWP7Bootstrapper : PhoneBootstrapperBase {  
    PhoneContainer container;  
  
    public HelloWP7Bootstrapper() {
        Start();
    }

    protectedoverridevoid Configure() {  
        container = new PhoneContainer(RootFrame);

        if (!Execute.InDesignMode)
            container.RegisterPhoneServices();

        container.PerRequest<MainPageViewModel>();  
        container.PerRequest<PivotPageViewModel>();  
        container.PerRequest<TabViewModel>();  
  
        AddCustomConventions();  
    }  
  
    staticvoid AddCustomConventions() {  
        //ellided  
    }  
  
    protectedoverrideobject GetInstance(Type service, string key) {  
        return container.GetInstance(service, key);  
    }  
  
    protectedoverride IEnumerable<object> GetAllInstances(Type service) {  
        return container.GetAllInstances(service);  
    }  
  
    protectedoverridevoid BuildUp(object instance) {  
        container.BuildUp(instance);  
    }  
}  

<Applicationx:Class="Caliburn.Micro.HelloWP7.App"xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"xmlns:local="clr-namespace:Caliburn.Micro.HelloWP7"><Application.Resources><local:HelloWP7Bootstrapperx:Key="bootstrapper"/></Application.Resources></Application>

publicclass MainPageViewModel {  
    readonly INavigationService navigationService;  
  
    public MainPageViewModel(INavigationService navigationService) {  
        this.navigationService = navigationService;  
    }  
  
    publicvoid GotoPageTwo() {  
        navigationService.UriFor<PivotPageViewModel>()  
            .WithParam(x => x.NumberOfTabs, 5)  
            .Navigate();  
    }  
}  

<phone:PhoneApplicationPagex:Class="Caliburn.Micro.HelloWP7.MainPage"xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"xmlns:phone="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone"xmlns:shell="clr-namespace:Microsoft.Phone.Shell;assembly=Microsoft.Phone"xmlns:cal="clr-namespace:Caliburn.Micro;assembly=Caliburn.Micro"SupportedOrientations="Portrait"Orientation="Portrait"shell:SystemTray.IsVisible="True"><GridBackground="Transparent"><Grid.RowDefinitions><RowDefinitionHeight="Auto"/><RowDefinitionHeight="*"/></Grid.RowDefinitions><StackPanelGrid.Row="0"Margin="24,24,0,12"><TextBlockText="WP7 Caliburn.Micro"Style='{StaticResource PhoneTextNormalStyle}'/><TextBlockText='Main Page'Margin='-3,-8,0,0'Style='{StaticResource PhoneTextTitle1Style}'/></StackPanel><GridGrid.Row='1'><Buttonx:Name='GotoPageTwo'Content='Goto Page Two'/></Grid></Grid><phone:PhoneApplicationPage.ApplicationBar><shell:ApplicationBarIsVisible='True'><shell:ApplicationBar.Buttons><cal:AppBarButtonIconUri='ApplicationIcon.png'Text='Page Two'Message='GotoPageTwo'/></shell:ApplicationBar.Buttons></shell:ApplicationBar></phone:PhoneApplicationPage.ApplicationBar></phone:PhoneApplicationPage>

publicclass PivotPageViewModel : Conductor<IScreen>.Collection.OneActive {  
    readonly Func<TabViewModel> createTab;  
  
    public PivotPageViewModel(Func<TabViewModel> createTab) {  
        this.createTab = createTab;  
    }  
  
    publicint NumberOfTabs { get; set; }  
  
    protectedoverridevoid OnInitialize() {  
        Enumerable.Range(1, NumberOfTabs).Apply(x => {  
            var tab = createTab();  
            tab.DisplayName = "Item " + x;  
            Items.Add(tab);  
        });  
  
        ActivateItem(Items[0]);  
    }  
}  

publicclass PivotPageModelStorage : StorageHandler<PivotPageViewModel> {  
    publicoverridevoid Configure() {  
        this.ActiveItemIndex()  
            .InPhoneState()  
            .RestoreAfterViewLoad();  
    }  
}  

publicclass TabViewModelStorage : StorageHandler<TabViewModel> {  
    publicoverridevoid Configure() {  
        Id(x => x.DisplayName);  
  
        Property(x => x.Text)  
            .InPhoneState()  
            .RestoreAfterActivation();  
    }  
}  

publicclass PivotPageModelStorage : StorageHandler<PivotPageViewModel> {  
    publicoverridevoid Configure() {  
        this.ActiveItemIndex()  
            .InAppSettings()  
            .RestoreAfterViewLoad();  
    }  
}  

publicclass TabViewModel : Screen, IHandle<TaskCompleted<PhoneNumberResult>> {  
    string text;  
    readonly IEventAggregator events;  
  
    public TabViewModel(IEventAggregator events) {  
        this.events = events;  
    }  
  
    publicstring Text {  
        get { return text; }  
        set {  
            text = value;  
            NotifyOfPropertyChange(() => Text);  
        }  
    }  
  
    publicvoid Choose() {  
        events.RequestTask<PhoneNumberChooserTask>();  
    }  
  
    publicvoid Handle(TaskCompleted<PhoneNumberResult> message) {  
        MessageBox.Show("The result was " + message.Result.TaskResult, DisplayName, MessageBoxButton.OK);  
    }  
  
    protectedoverridevoid OnActivate() {  
        events.Subscribe(this);  
        base.OnActivate();  
    }  
  
    protectedoverridevoid OnDeactivate(bool close) {  
        events.Unsubscribe(this);  
        base.OnDeactivate(close);  
    }  
}  

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

[Export(typeof(ScreenOneViewModel))]
publicclass ScreenOneViewModel
{
    public IEnumerable<IResult> GoForward()
    {
        yieldreturn Loader.Show("Downloading...");
        yieldreturnnew LoadCatalog("Caliburn.Micro.Coroutines.External.xap");
        yieldreturn Loader.Hide();
        yieldreturnnew ShowScreen("ExternalScreen");
    }
}

publicinterface IResult
{
    void Execute(CoroutineExecutionContext context);
    event EventHandler<ResultCompletionEventArgs> Completed;
}

publicclass ActionExecutionContext
{
    public ActionMessage Message;
    public FrameworkElement Source;
    publicobject EventArgs;
    publicobject Target;
    public DependencyObject View;
    public MethodInfo Method;
    public Func<bool> CanExecute;
    publicobjectthis[string key];
}

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

publicclass Loader : IResult
{
    readonlystring message;
    readonlybool hide;

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

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

    publicvoid Execute(CoroutineExecutionContext context)
    {
        var view = context.View as FrameworkElement;
        while(view != null)
        {
            var busyIndicator = view as BusyIndicator;
            if(busyIndicator != null)
            {
                if(!string.IsNullOrEmpty(message))
                    busyIndicator.BusyContent = message;
                busyIndicator.IsBusy = !hide;
                break;
            }

            view = view.Parent as FrameworkElement;
        }

        Completed(this, new ResultCompletionEventArgs());
    }

    publicevent EventHandler<ResultCompletionEventArgs> Completed = delegate { };

    publicstatic IResult Show(string message = null)
    {
        returnnew Loader(message);
    }

    publicstatic IResult Hide()
    {
        returnnew Loader(true);
    }
}

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

publicclass LoadCatalog : IResult
{
    staticreadonly Dictionary<string, DeploymentCatalog> Catalogs = new Dictionary<string, DeploymentCatalog>();
    readonlystring uri;

    [Import]
    public AggregateCatalog Catalog { get; set; }

    public LoadCatalog(string relativeUri)
    {
        uri = relativeUri;
    }

    publicvoid Execute(CoroutineExecutionContext context)
    {
        DeploymentCatalog catalog;

        if(Catalogs.TryGetValue(uri, out catalog))
            Completed(this, new ResultCompletionEventArgs());
        else
        {
            catalog = new DeploymentCatalog(uri);
            catalog.DownloadCompleted += (s, e) =>{
                if(e.Error == null)
                {
                    Catalogs[uri] = catalog;
                    Catalog.Catalogs.Add(catalog);
                    catalog.Parts
                        .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
                });
            };

            catalog.DownloadAsync();
        }
    }

    publicevent EventHandler<ResultCompletionEventArgs> Completed = delegate { };
}

publicclass ResultCompletionEventArgs : EventArgs
{
    public Exception Error;
    publicbool WasCancelled;
}

using System;
using System.ComponentModel.Composition;

publicclass ShowScreen : IResult
{
    readonly Type screenType;
    readonlystring name;

    [Import]
    public IShell Shell { get; set; }

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

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

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

        Shell.ActivateItem(screen);
        Completed(this, new ResultCompletionEventArgs());
    }

    publicevent EventHandler<ResultCompletionEventArgs> Completed = delegate { };

    publicstatic ShowScreen Of<T>()
    {
        returnnew ShowScreen(typeof(T));
    }
}

publicinterface IEventAggregator {
    	bool HandlerExistsFor(Type messageType);
    	void Subscribe(object subscriber);
    	void Unsubscribe(object subscriber);
    	void Publish(object message, Action<Action> marshal);
    }

// Creating the EventAggregator as a singleton.publicclass Bootstrapper : BootstrapperBase {
        privatereadonly SimpleContainer _container =
            new SimpleContainer();

         // ... Other Bootstrapper Configprotectedoverridevoid Configure(){
            _container.Singleton<IEventAggregator, EventAggregator>();
        }

        // ... Other Bootstrapper Config
    }

    // Acquiring the EventAggregator in a viewModel.publicclass FooViewModel {
        privatereadonly IEventAggregator _eventAggregator;

        public FooViewModel(IEventAggregator eventAggregator) {
            _eventAggregator = eventAggregator;
        }
    }

publicclass FooViewModel {
        privatereadonly IEventAggregator _eventAggregator;

        public FooViewModel(IEventAggregator eventAggregator) {
            _eventAggregator = eventAggregator;

            _eventAggregator.Publish(newobject());
            _eventAggregator.Publish("Hello World");
            _eventAggregator.Publish(22);
        }
    }

    _eventAggregator.Publish(newobject(), action => {
                    Task.Factory.StartNew(action);
                });

    IHandle<TMessage> : IHandle {
	    void Handle<TMessage>(TMessage message);
    }

publicclass FooViewModel : IHandle<object> {
        privatereadonly IEventAggregator _eventAggregator;

        public FooViewModel(IEventAggregator eventAggregator) {
            _eventAggregator = eventAggregator;
            _eventAggregator.Subscribe(this);
        }

        publicvoid Handle(object message) {
            // Handle the message here.
        }
    }

publicclass FooViewModel : IHandle<string>, IHandle<bool> {
        privatereadonly IEventAggregator _eventAggregator;
    
        public FooViewModel(IEventAggregator eventAggregator) {
            _eventAggregator = eventAggregator;
            _eventAggregator.Subscribe(this);
        }
    
        publicvoid Handle(string message) {
            // Handle the message here.
        }

        publicvoid Handle(bool message) {
            // Handle the message here.
        }
    }

publicclass FooViewModel : IHandle<object>, IHandle<string> {
        privatereadonly IEventAggregator _eventAggregator;
    
        public FooViewModel(IEventAggregator eventAggregator) {
            _eventAggregator = eventAggregator;
            _eventAggregator.Subscribe(this);
            _eventAggregator.Publish("Hello");
        }
    
        publicvoid Handle(object message) {
            // This will be called
        }

        publicvoid Handle(string message) {
            // This also
        }
    }

publicclass FooViewModel : IHandle<object> {
        privatereadonly IEventAggregator _eventAggregator;

        public FooViewModel(IEventAggregator eventAggregator) {
            _eventAggregator = eventAggregator;
            _eventAggregator.Subscribe(this);
        }

        publicvoid Handle(object message){
            if (_eventAggregator.HandlerExistsFor(typeof(SpecialMessageEvent))){
                _eventAggregator.Publish(new SpecialEventMessage(message));
            }
        }
    }

publicinterface IHandleWithCoroutine<TMessage> : IHandle {
		IEnumerable<IResult> Handle(TMessage message);
    }

publicclass FooViewModel : Screen, IHandleWithCoroutine<EventWithCoroutine> {
        privatereadonly IEventAggregator _eventAggregator;

        public FooViewModel(IEventAggregator eventAggregator) {
            _eventAggregator = eventAggregator;
            _eventAggregator.Subscribe(this);
        }

        public IEnumerable<IResult> Handle(EventWithCoroutine message) {
            yieldreturn message.Activate();
            yieldreturn message.DoWork();
        }
    }

publicclass EventWithCoroutine {
        public IResult Activate() {
            returnnew TaskResult(Task.Factory.StartNew(() => {
                    // Activate logic
                }));
        }

        public IResult DoWork() {
            returnnew TaskResult(Task.Factory.StartNew(() => {
                // Do work logic
            }));
        }
    }

publicinterface IHandleWithTask<TMessage> : IHandle {
        Task Handle(TMessage message);
    }

publicclass FooViewModel : Screen, IHandleWithTask<object> {
        privatereadonly IEventAggregator _eventAggregator;

        public FooViewModel(IEventAggregator eventAggregator) {
            _eventAggregator = eventAggregator;
            _eventAggregator.Subscribe(this);
        }

        public Task Handle(object message) {
            return Task.Factory.StartNew(() => message);
        }
    }

publicclass FooViewModel : Screen, IHandle<object> {
        privatereadonly IEventAggregator _eventAggregator;

        public FooViewModel(IEventAggregator eventAggregator) {
            _eventAggregator = eventAggregator;
            _eventAggregator.Subscribe(this);
        }

        publicvoid Handle(object message) {
            // Handle the message here.
        }

        protectedoverridevoid OnActivate() {
            _eventAggregator.Subscribe(this);
            base.OnActivate();
        }

        protectedoverridevoid OnDeactivate(bool close) {
            _eventAggregator.Unsubscribe(this);
            base.OnDeactivate(close);
        }
    }

    IHandleAndReturnString<T> : IHandle {
	    string Handle<T>(T message);
    }

var standardResultProcesser = EventAggregator.HandlerResultProcessing;
    EventAggregator.HandlerResultProcessing = (target, result) =>
    {
        var stringResult = result asstring;
        if (stringResult != null)
            MessageBox.Show(stringResult);
        else
            standardResultProcesser(target, result);
    };

publicstaticclass IoC {
	publicstatic Func<Type, string, object> GetInstance;
        publicstatic Func<Type, IEnumerable<object>> GetAllInstances;
        publicstatic Action<object> BuildUp;

        publicstatic T Get<T>(string key = null);
	publicstatic IEnumerable<T> GetAll<T>();
}

publicclass CustomBootstrapper : Bootstrapper {
	private SimpleContainer _container = new SimpleContainer();
		
	//...protectedoverrideobject GetInstance(Type service, string key) {
		return _container.GetInstance(service, key);
	}

	protectedoverride IEnumerable<object> GetAllInstances(Type service) {
		return _container.GetAllInstances(service);
	}

	protectedoverridevoid BuildUp(object instance) {
		_container.BuildUp(instance);
	}

	//...
}

var windowManager = IoC.Get<IWindowManager>();
var windowManager = IoC.Get<IWindowManager>("windowManager");

var viewModelCollection = IoC.GetAll<IViewModel>();
var viewModel = IoC.GetAll<IViewModel>()
                              .FirstOrDefault(vm => vm.GetType() == typeof(ShellViewModel));

var viewModel = new LocallyCreatedViewModel();
IoC.BuildUp(viewModel);