caliburn Wiki & Documentation Rss Feed

New Comment on "Action Basics"

alamb — Thu, 19 Nov 2009 22:16:06 GMT

The button markup for Trigger Collection w/ Inferred Parameters, Attachment w/ Inferred Parameters, and Attachment w/ Defaults doesn't work in Silverlight either. The button stays disabled even when valid parameters are entered for left and right.

New Comment on "Action Basics"

alamb — Thu, 19 Nov 2009 21:58:47 GMT

The Silverlight code for this example seems to be out of date. I had to change the namespaces to: xmlns:ca="clr-namespace:Caliburn.PresentationFramework.Actions;assembly=Caliburn.PresentationFramework" xmlns:cm="clr-namespace:Caliburn.PresentationFramework;assembly=Caliburn.PresentationFramework" xmlns:ct="clr-namespace:Caliburn.PresentationFramework.Triggers;assembly=Caliburn.PresentationFramework" Also the prefix for RoutedMessageTriggerCollection changed to cm instead of ct.

Updated Wiki: BlogsArticlesProjects

EisenbergEffect — Sun, 15 Nov 2009 23:12:22 GMT

Blogs, Articles and Related Projects

Below are a list of blogs, articles and projects related to Caliburn in some way. If you are writing or building anything with Caliburn, we would love to discuss getting you on the site.

Prism Stock Trader with Caliburn

You may or may not be familiar with the Prism Stockc Trader. It is a reference application created by the p&p team at Microsoft for the purpose of demonstrating solid testable UI architecture. It addresses several issues related to composite application development. It is an excellent application to study and learn from. Marco Amendola is going further by taking the Stock Trader and converting it to take advantage of Caliburn. You can follow his efforts on his blog.

Testing with Caliburn and unhaddins

unhaddins is a project led by Fabio Maulo. It's goal is to provide you with an all-in-one stop shop for NHibernate based projects. It has some nice extensions for basic NHibernate development and some specific work around using NHibernate on WPF projects. José F. Romaniello is using unhaddins to build his Chinook Media Manager. While he is not using Caliburn for the architecture, he is using it for testing. Here, you can find a very nice bit of code that uses Caliburn to test all his application's view models. You may also be interested in following the the development of his media manager on his blog.

Build an Application with Caliburn And Prism

Ryan Rauh is responsible for adding the Prism integration for Caliburn. If you are interested in using Prism and Caliburn together, have a look at his blog series Build an Application with Caliburn And Prism.

Devlicios

Please visit my blog where you can read more about Caliburn. I will be running some how to's and talking more extensively about UI architecture.

New Comment on "Action Basics"

EisenbergEffect — Wed, 04 Nov 2009 03:00:21 GMT

Thanks for the fix.

Updated Wiki: Action Basics

EisenbergEffect — Wed, 04 Nov 2009 03:00:01 GMT

Action Basics

Prerequisites

Referenced Assemblies

Caliburn.Core
Caliburn.PresentationFramework
Microsoft.Practices.ServiceLocation

Minimum Configuration

Note: Configuration should be placed in the App.xaml.cs constructor for WPF or the App.xaml.cs Application_Startup for Silverlight.

CaliburnFramework
    .ConfigureCore()
    .WithPresentationFramework()
    .Start();

Using Actions (Based on Samples - Actions)

Actions are a core feature of Caliburn which can enable a number of UI patterns such as MVC, MVP and Presentation Model (MVVM). Let's look at a basic usage of Actions.

In your project, create a new class named Calculator. This will serve as your first controller, and will be the type where we place actions. Use the code below:

public class Calculator
{
    public int Divide(int left, int right)
    {
        return left / right;
    }
}

Next, use the following markup to implement your main Page (for Silverlight) or your Window (for WPF):

Silverlight

<UserControl x:Class="Actions.Page"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:ca="clr-namespace:Caliburn.Actions;assembly=Caliburn.Actions"
             xmlns:local="clr-namespace:Actions"
             xmlns:cm="clr-namespace:Caliburn.RoutedUIMessaging;assembly=Caliburn.RoutedUIMessaging"
             xmlns:ct="clr-namespace:Caliburn.RoutedUIMessaging.Triggers;assembly=Caliburn.RoutedUIMessaging"
             Width="400"
             Height="300">
    <ca:Action.Target>
        <local:Calculator />
    </ca:Action.Target>
 
    <StackPanel x:Name="LayoutRoot">
        <Grid Margin="10">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="*" />
                <ColumnDefinition Width="Auto" />
                <ColumnDefinition Width="*" />
                <ColumnDefinition Width="*" />
            </Grid.ColumnDefinitions>
 
            <TextBox x:Name="left"
                     Grid.Column="0" />
            <TextBlock Text="/"
                       Margin="10 0"
                       Grid.Column="1" />
            <TextBox x:Name="right"
                     Grid.Column="2" />
            <Border BorderBrush="Black"
                    BorderThickness="0 0 0 1"
                    Margin="10 0 0 0"
                    Grid.Column="3">
                <TextBlock x:Name="DivideResult" />
            </Border>
        </Grid>
 
        <Button Content="Divide (Trigger Collection w/ Explicit Parameters)">
            <cm:Message.Triggers>
                <ct:RoutedMessageTriggerCollection>
                    <ct:EventMessageTrigger EventName="Click">
                        <ct:EventMessageTrigger.Message>
                            <ca:ActionMessage MethodName="Divide"
                                              OutcomePath="DivideResult.Text">
                                <cm:Parameter ElementName="left"
                                              Path="Text" />
                                <cm:Parameter ElementName="right"
                                              Path="Text" />
                            </ca:ActionMessage>
                        </ct:EventMessageTrigger.Message>
                    </ct:EventMessageTrigger>
                </ct:RoutedMessageTriggerCollection>
            </cm:Message.Triggers>
        </Button>
    </StackPanel>
</UserControl>

WPF

<Window x:Class="Actions.Window1"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:local="clr-namespace:Actions"
        xmlns:cal="http://www.caliburnproject.org"
        Title="Window1"
        SizeToContent="WidthAndHeight">
    <cal:Action.Target>
        <local:Calculator />    
    </cal:Action.Target>
     
    <StackPanel>
        <Grid Margin="10">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="*" />
                <ColumnDefinition Width="Auto" />
                <ColumnDefinition Width="*" />
                <ColumnDefinition Width="*" />
            </Grid.ColumnDefinitions>
            
            <TextBox x:Name="left" 
                     Grid.Column="0"/>
            <TextBlock Text="/"
                       Margin="10 0"
                       Grid.Column="1"/>
            <TextBox x:Name="right" 
                     Grid.Column="2"/>
            <Border BorderBrush="Black"
                    BorderThickness="0 0 0 1"
                    Margin="10 0 0 0"
                    Grid.Column="3">
                <TextBlock x:Name="DivideResult" />
            </Border>
            
        </Grid>
         
        <Button Content="Divide (Trigger Collection w/ Explicit Parameters)">
            <cal:Message.Triggers>
                <cal:RoutedMessageTriggerCollection>
                    <cal:EventMessageTrigger EventName="Click">
                        <cal:EventMessageTrigger.Message>
                            <cal:ActionMessage MethodName="Divide"
                                           OutcomePath="DivideResult.Text">
                                <cal:Parameter Value="{Binding ElementName=left, Path=Text}"/>
                                <cal:Parameter Value="{Binding ElementName=right, Path=Text}"/>
                            </cal:ActionMessage>
                        </cal:EventMessageTrigger.Message>
                    </cal:EventMessageTrigger>
                </cal:RoutedMessageTriggerCollection>
            </cal:Message.Triggers>
        </Button>
    </StackPanel>
</Window>

Note: There are a couple of subtle differences between the WPF and Silverlight versions that should be pointed out. First, the WPF version can use a single namespace for all of Caliburn's features. WPF supports this through the use of the XmlnsDefinition attribute which does not function properly in Silverlight. Second, the syntax for declaring Parameters is slightly different. Silverlight does not support ElementName binding and Freezables in v2 and only partially in v3, therefore it is unable to use straight databinding for parameters values, like WPF. Instead, it must use ElementName and Path properties to achieve this effect. You can learn more about the details of parameters here.

So, what does all this markup do? (Don't worry about the quantity of markup, I'll show you how to greatly reduce that later.) Let's begin by looking at the <Button /> element. Notice the use of the Message.Triggers attached property. With this property we can add a set of message sending triggers to any element. In this case, we have specified the use of a single EventMessageTrigger (see Message Triggers). EventMessageTriggers allow us to use the firing of an event to send a message to our controller. So, when the Button's Click event is fired, we will send the enclosed message to the controller. The message we are sending is an ActionMessage, specifying that the method to call is "Divide." It also indicates that the text properties of the "left" and "right" elements should be passed as the parameters to this method. Finally, the return value of the "Divide" method should be bound back to the "DivideResult" element's text property.

Now that we have a trigger that can send a specific message, who will handle this message? Notice that the root element UserControl/Window also has an attached property value specified. By using the Action.Target property we can specify an instance of a class to handle ActionMessages. For this simple example, we have declared the instance inline, however in most non-trivial applications it's likely that the Action.Target will be set via databinding or by using the Resolve Extension.

Note: The ResolveExtension is only available in WPF becuase Silverlight does not currently support custom markup extensions. To get around this problem in Silverlight, you can specify a string value for Action.Target. In this case the string will be used to look up an instance from the IContainer. If you are using SimpleContainer (Caliburn's default) all services registered by type can also be accessed this way, using the type's FullName as key.

Now that we have all of our code and markup in place and we understand the basic usage, run the application. Fill in the text boxes with various numbers and click the button. You should see the results of a successful divide operation appear in the UI. Try placing a break point in the "Divide" method and repeat the process. Next, try entering zero for the "right" value. Click the button and an exception is thrown. Youch! That's not good. Let's fix that.

Change the Calculator class to match the following definition (you will need to add a using/import statement for Caliburn.PresentationFramework.Filters):

[Rescue("GeneralRescue")]
public class Calculator
{
    public int Divide(int left, int right)
    {
        return left / right;
    }
 
    public void GeneralRescue(Exception ex)
    {
        MessageBox.Show(ex.Message);
    }
}

Now, run the code, type in zero for the "right" value and click the button. This time a message box is displayed and your application is prevented from crashing. A rescue is a special type of filter that can catch exceptions. The only parameter it requires is the name of the method to pass the exception to. If a Rescue is placed on the class (as it is here), any action invoked by Caliburn on that class is protected from unhandled exceptions by that method. Additionally, rescues can be placed on specific methods. In this case, the class rescue will be overridden by the method level rescue. This fixes our application crash, but it doesn't provide us with our desired user experience. Ideally, we would like the button to be disabled if the text boxes have invalid values. Let's see how another type of filter can help us out.

Once again update the Calculator class to match the following definition:

[Rescue("GeneralRescue")]
public class Calculator
{
    [Preview("CanDivide", AffectsTriggers = true)]
    public int Divide(int left, int right)
    {
        return left / right;
    }
 
    public bool CanDivide(int left, int right)
    {
        return right != 0;
    }
  
    public void GeneralRescue(Exception ex)
    {
        MessageBox.Show(ex.Message);
    }
}

Now we've added the Preview filter. This method occurs before the execution of the decorated Action. If it returns false the action will not be allowed to execute. Notice that it takes the same parameters as the action it decorates. Also, if the AffectsTriggers property is set to true, the preview filter will affect the state of the UI. This is the default value, so you really don't need to specify it unless you want to turn this behavior off. Run the application now and type various values in the text boxes. Notice that the button is now automatically disabled if you provide invalid values.

Note: By convention, if you name a method Can{ActionName}, Caliburn will automatically add the Preview filter to the action without you needing to add the attribute.
Note: You can also use a Can{ActionName} as a property. It too will be wired automatically. (So, you only have to use PreviewAttribute for nonconventional names.) When you do this, you can also raise property change notifications to force the associated triggers to reevaluate.

Now that you understand several of the main concepts, we're going to investigate some alternative markup syntaxes that should acutally make using the framework quite convenient. For the following examples, we'll use all the same Xaml as before, with the exception of the <Button /> element. We'll change this up each time so that you can learn a few different ways of declaring triggers and actions. All the remaining markup is identical for both WPF and Silverlight.

Replace the <Button /> element with the following markup:

<Button Content="Divide (Trigger Collection w/ Inferred Parameters)">
    <cm:Message.Triggers>
        <ct:RoutedMessageTriggerCollection>
            <ct:EventMessageTrigger EventName="Click">
                <ct:EventMessageTrigger.Message>
                    <ca:ActionMessage MethodName="Divide" />
                </ct:EventMessageTrigger.Message>
            </ct:EventMessageTrigger>
        </ct:RoutedMessageTriggerCollection>
    </cm:Message.Triggers>
</Button>

This markup is very similar to our initial trigger/message declaration. The only difference is that we have left off the paramaters. If we leave out the parameters, Caliburn will try to automatically determine the values by looking up UI elements based on the parameter names (it will also search resources). If the action has a return value, the name of the method + "Result" will be looked up in the UI for binding. Run the application and you'll notice that everything still works, almost. Notice that if you put a zero into the "right" box the button is still enabled, but the action never fires (you can confirm this by putting a break point in the divide method.) This is because Caliburn does not know what UI elements are involved in the message until it is sent, and thus cannot update the UI ahead of time, but it can still filter the action. Use inferred parameters only when you don't need the UI to update according to changes in input values.

Now, replace the <Button /> element with the following markup:

<Button Content="Divide (Attachment w/ Explicit Parameters)"
        cm:Message.Attach="[Event Click] = [Action Divide(left.Text, right.Text) : DivideResult.Text]" />

This is the preferred way of declaring triggers/messages. Notice that we are using a different attached property: Message.Attach. Using this property, we can provide a string that will be parsed out into a trigger. The declaration you see here is identical at runtime to our original example. Try running the application to confirm its behavior. On the left side of the equals sign, we indicate the trigger type and parameters. Here we are are declaring an EventMessageTrigger for the Click event. You can get more details on the shortened trigger syntax here. On the right side of the equals sign, we are declaring the type of message and it's contents. In this case, we have an ActionMessage with its parameter values coming from the text properties of the "left" and "right" text boxes and its return value being bound back to the text property of the "DivideResult" element. The brackets "[]" are optional in this syntax, but I prefer them because they add some visual clarity.

Note for WPF: You can also specify binding modes for the parameters if something other than the default is required. See below:

<Button Content="Divide (Attachment w/ Explicit Parameters and Modes)"
        cm:Message.Attach="[Event Click] = [Action Divide(left.Text:TwoWay, right.Text:OneWay) : DivideResult.Text]" />

Next, replace the <Button /> element with the following markup:

<Button Content="Divide (Attachment w/ Inferred Parameters)"
        cm:Message.Attach="[Event Click] = [Action Divide]" />

This is functionally equivalent to our second long markup example. In this case, our parameters will be inferred by Caliburn.

Replace the <Button /> element with the following markup:

<Button Content="Divide (Attachment w/ Default Trigger/Message and Explicit Parameters)"
        cm:Message.Attach="Divide(left.Text, right.Text) : DivideResult.Text" />

This is an interesting case. Here, Caliburn will choose a default trigger based on the type of element being attached to. Caliburn is also parsing with its default message parser. In this case the default trigger is an EventMessageTrigger for the Click event and the default message type is ActionMessage, so this markup produces the same runtime behavior as our first example. Even though this is extremely succinct, I still prefer to declare the trigger and message type explicitly, but you have this option available if you desire.

Replace the <Button /> element with the following markup:

<Button Content="Divide (Attachment w/ Defaults)"
        cm:Message.Attach="Divide" />

With this markup, everything will be inferred by Caliburn: trigger type, message type, parameters and return value. It works, but please use with caution.

After all of that, you may be wondering why anyone would use the long syntax. In 99% of cases you shouldn't need it, but it is there for maximum flexibility. One final thing to note. If you wish to attach multiple messages to the same element, you can do this by separating them with a semicolon. Here's an example:

<Button Content="Divide or Multiply"
        cm:Message.Attach="[Event Click] = [Action Divide(left.Text:TwoWay, right.Text:OneWay) : DivideResult.Text];
                           [Event MouseRightButtonUp] = [Action Multiply(left.Text:TwoWay, right.Text:OneWay) : MultiplyResult.Text]" />

Updated Wiki: Action Basics

EisenbergEffect — Wed, 04 Nov 2009 02:59:32 GMT

Action Basics

Prerequisites

Referenced Assemblies

Caliburn.Core
Caliburn.PresentationFramework
Microsoft.Practices.ServiceLocation

Minimum Configuration

Note: Configuration should be placed in the App.xaml.cs constructor for WPF or the App.xaml.cs Application_Startup for Silverlight.

CaliburnFramework
    .ConfigureCore()
    .WithPresentationFramework()
    .Start();

Using Actions (Based on Samples - Actions)

Actions are a core feature of Caliburn which can enable a number of UI patterns such as MVC, MVP and Presentation Model (MVVM). Let's look at a basic usage of Actions.

In your project, create a new class named Calculator. This will serve as your first controller, and will be the type where we place actions. Use the code below:

public class Calculator
{
    public int Divide(int left, int right)
    {
        return left / right;
    }
}

Next, use the following markup to implement your main Page (for Silverlight) or your Window (for WPF):

Silverlight

<UserControl x:Class="Actions.Page"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:ca="clr-namespace:Caliburn.Actions;assembly=Caliburn.Actions"
             xmlns:local="clr-namespace:Actions"
             xmlns:cm="clr-namespace:Caliburn.RoutedUIMessaging;assembly=Caliburn.RoutedUIMessaging"
             xmlns:ct="clr-namespace:Caliburn.RoutedUIMessaging.Triggers;assembly=Caliburn.RoutedUIMessaging"
             Width="400"
             Height="300">
    <ca:Action.Target>
        <local:Calculator />
    </ca:Action.Target>
 
    <StackPanel x:Name="LayoutRoot">
        <Grid Margin="10">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="*" />
                <ColumnDefinition Width="Auto" />
                <ColumnDefinition Width="*" />
                <ColumnDefinition Width="*" />
            </Grid.ColumnDefinitions>
 
            <TextBox x:Name="left"
                     Grid.Column="0" />
            <TextBlock Text="/"
                       Margin="10 0"
                       Grid.Column="1" />
            <TextBox x:Name="right"
                     Grid.Column="2" />
            <Border BorderBrush="Black"
                    BorderThickness="0 0 0 1"
                    Margin="10 0 0 0"
                    Grid.Column="3">
                <TextBlock x:Name="DivideResult" />
            </Border>
        </Grid>
 
        <Button Content="Divide (Trigger Collection w/ Explicit Parameters)">
            <cm:Message.Triggers>
                <ct:RoutedMessageTriggerCollection>
                    <ct:EventMessageTrigger EventName="Click">
                        <ct:EventMessageTrigger.Message>
                            <ca:ActionMessage MethodName="Divide"
                                              OutcomePath="DivideResult.Text">
                                <cm:Parameter ElementName="left"
                                              Path="Text" />
                                <cm:Parameter ElementName="right"
                                              Path="Text" />
                            </ca:ActionMessage>
                        </ct:EventMessageTrigger.Message>
                    </ct:EventMessageTrigger>
                </ct:RoutedMessageTriggerCollection>
            </cm:Message.Triggers>
        </Button>
    </StackPanel>
</UserControl>

WPF

<Window x:Class="Actions.Window1"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:local="clr-namespace:Actions"
        xmlns:cal="http://www.caliburnproject.org"
        Title="Window1"
        SizeToContent="WidthAndHeight">
    <cal:Action.Target>
        <local:Calculator />    
    </cal:Action.Target>
     
    <StackPanel>
        <Grid Margin="10">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="*" />
                <ColumnDefinition Width="Auto" />
                <ColumnDefinition Width="*" />
                <ColumnDefinition Width="*" />
            </Grid.ColumnDefinitions>
            
            <TextBox x:Name="left" 
                     Grid.Column="0"/>
            <TextBlock Text="/"
                       Margin="10 0"
                       Grid.Column="1"/>
            <TextBox x:Name="right" 
                     Grid.Column="2"/>
            <Border BorderBrush="Black"
                    BorderThickness="0 0 0 1"
                    Margin="10 0 0 0"
                    Grid.Column="3">
                <TextBlock x:Name="DivideResult" />
            </Border>
            
        </Grid>
         
        <Button Content="Divide (Trigger Collection w/ Explicit Parameters)">
            <cal:Message.Triggers>
                <cal:RoutedMessageTriggerCollection>
                    <cal:EventMessageTrigger EventName="Click">
                        <cal:EventMessageTrigger.Message>
                            <cal:ActionMessage MethodName="Divide"
                                           OutcomePath="DivideResult.Text">
                                <cal:Parameter Value="{Binding ElementName=left, Path=Text}"/>
                                <cal:Parameter Value="{Binding ElementName=right, Path=Text}"/>
                            </cal:ActionMessage>
                        </cal:EventMessageTrigger.Message>
                    </cal:EventMessageTrigger>
                </cal:RoutedMessageTriggerCollection>
            </cal:Message.Triggers>
        </Button>
    </StackPanel>
</Window>

Change the Calculator class to match the following definition (you will need to add a using/import statement for Caliburn.PresentationFramework.Filters):

[Rescue("GeneralRescue")]
public class Calculator
{
    public int Divide(int left, int right)
    {
        return left / right;
    }
 
    public void GeneralRescue(Exception ex)
    {
        MessageBox.Show(ex.Message);
    }
}

Once again update the Calculator class to match the following definition:

[Rescue("GeneralRescue")]
public class Calculator
{
    [Preview("CanDivide", AffectsTriggers = true)]
    public int Divide(int left, int right)
    {
        return left / right;
    }
 
    public bool CanDivide(int left, int right)
    {
        return right != 0;
    }
  
    public void GeneralRescue(Exception ex)
    {
        MessageBox.Show(ex.Message);
    }
}

Replace the <Button /> element with the following markup:

<Button Content="Divide (Trigger Collection w/ Inferred Parameters)">
    <cm:Message.Triggers>
        <ct:RoutedMessageTriggerCollection>
            <ct:EventMessageTrigger EventName="Click">
                <ct:EventMessageTrigger.Message>
                    <ca:ActionMessage MethodName="Divide" />
                </ct:EventMessageTrigger.Message>
            </ct:EventMessageTrigger>
        </ct:RoutedMessageTriggerCollection>
    </cm:Message.Triggers>
</Button>

Now, replace the <Button /> element with the following markup:

<Button Content="Divide (Attachment w/ Explicit Parameters)"
        cm:Message.Attach="[Event Click] = [Action Divide(left.Text, right.Text) : DivideResult.Text]" />

<Button Content="Divide (Attachment w/ Explicit Parameters and Modes)"
        cm:Message.Attach="[Event Click] = [Action Divide(left.Text:TwoWay, right.Text:OneWay) : DivideResult.Text]" />

Next, replace the <Button /> element with the following markup:

<Button Content="Divide (Attachment w/ Inferred Parameters)"
        cm:Message.Attach="[Event Click] = [Action Divide]" />

This is functionally equivalent to our second long markup example. In this case, our parameters will be inferred by Caliburn.

Replace the <Button /> element with the following markup:

<Button Content="Divide (Attachment w/ Default Trigger/Message and Explicit Parameters)"
        cm:Message.Attach="Divide(left.Text, right.Text) : DivideResult.Text" />

Replace the <Button /> element with the following markup:

<Button Content="Divide (Attachment w/ Defaults)"
        cm:Message.Attach="Divide" />

<Button Content="Divide or Multiply"
        cm:Message.Attach="[Event Click] = [Action Divide(left.Text:TwoWay, right.Text:OneWay) : DivideResult.Text];
                                       [Event MouseRightButtonUp] = [Action Multiply(left.Text:TwoWay, right.Text:OneWay) : MultiplyResult.Text]" />

Updated Wiki: Action Basics

EisenbergEffect — Wed, 04 Nov 2009 02:57:59 GMT

Action Basics

Prerequisites

Referenced Assemblies

Caliburn.Core
Caliburn.PresentationFramework
Microsoft.Practices.ServiceLocation

Minimum Configuration

Note: Configuration should be placed in the App.xaml.cs constructor for WPF or the App.xaml.cs Application_Startup for Silverlight.

CaliburnFramework
    .ConfigureCore()
    .WithPresentationFramework()
    .Start();

Using Actions (Based on Samples - Actions)

Actions are a core feature of Caliburn which can enable a number of UI patterns such as MVC, MVP and Presentation Model (MVVM). Let's look at a basic usage of Actions.

In your project, create a new class named Calculator. This will serve as your first controller, and will be the type where we place actions. Use the code below:

public class Calculator
{
    public int Divide(int left, int right)
    {
        return left / right;
    }
}

Next, use the following markup to implement your main Page (for Silverlight) or your Window (for WPF):

Silverlight

<UserControl x:Class="Actions.Page"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:ca="clr-namespace:Caliburn.Actions;assembly=Caliburn.Actions"
             xmlns:local="clr-namespace:Actions"
             xmlns:cm="clr-namespace:Caliburn.RoutedUIMessaging;assembly=Caliburn.RoutedUIMessaging"
             xmlns:ct="clr-namespace:Caliburn.RoutedUIMessaging.Triggers;assembly=Caliburn.RoutedUIMessaging"
             Width="400"
             Height="300">
    <ca:Action.Target>
        <local:Calculator />
    </ca:Action.Target>
 
    <StackPanel x:Name="LayoutRoot">
        <Grid Margin="10">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="*" />
                <ColumnDefinition Width="Auto" />
                <ColumnDefinition Width="*" />
                <ColumnDefinition Width="*" />
            </Grid.ColumnDefinitions>
 
            <TextBox x:Name="left"
                     Grid.Column="0" />
            <TextBlock Text="/"
                       Margin="10 0"
                       Grid.Column="1" />
            <TextBox x:Name="right"
                     Grid.Column="2" />
            <Border BorderBrush="Black"
                    BorderThickness="0 0 0 1"
                    Margin="10 0 0 0"
                    Grid.Column="3">
                <TextBlock x:Name="DivideResult" />
            </Border>
        </Grid>
 
        <Button Content="Divide (Trigger Collection w/ Explicit Parameters)">
            <cm:Message.Triggers>
                <ct:RoutedMessageTriggerCollection>
                    <ct:EventMessageTrigger EventName="Click">
                        <ct:EventMessageTrigger.Message>
                            <ca:ActionMessage MethodName="Divide"
                                              OutcomePath="DivideResult.Text">
                                <cm:Parameter ElementName="left"
                                              Path="Text" />
                                <cm:Parameter ElementName="right"
                                              Path="Text" />
                            </ca:ActionMessage>
                        </ct:EventMessageTrigger.Message>
                    </ct:EventMessageTrigger>
                </ct:RoutedMessageTriggerCollection>
            </cm:Message.Triggers>
        </Button>
    </StackPanel>
</UserControl>

WPF

<Window x:Class="Actions.Window1"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:local="clr-namespace:Actions"
        xmlns:cal="http://www.caliburnproject.org"
        Title="Window1"
        SizeToContent="WidthAndHeight">
    <cal:Action.Target>
        <local:Calculator />    
    </cal:Action.Target>
     
    <StackPanel>
        <Grid Margin="10">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="*" />
                <ColumnDefinition Width="Auto" />
                <ColumnDefinition Width="*" />
                <ColumnDefinition Width="*" />
            </Grid.ColumnDefinitions>
            
            <TextBox x:Name="left" 
                     Grid.Column="0"/>
            <TextBlock Text="/"
                       Margin="10 0"
                       Grid.Column="1"/>
            <TextBox x:Name="right" 
                     Grid.Column="2"/>
            <Border BorderBrush="Black"
                    BorderThickness="0 0 0 1"
                    Margin="10 0 0 0"
                    Grid.Column="3">
                <TextBlock x:Name="DivideResult" />
            </Border>
            
        </Grid>
         
        <Button Content="Divide (Trigger Collection w/ Explicit Parameters)">
            <cal:Message.Triggers>
                <cal:RoutedMessageTriggerCollection>
                    <cal:EventMessageTrigger EventName="Click">
                        <cal:EventMessageTrigger.Message>
                            <cal:ActionMessage MethodName="Divide"
                                           OutcomePath="DivideResult.Text">
                                <cal:Parameter Value="{Binding ElementName=left, Path=Text}"/>
                                <cal:Parameter Value="{Binding ElementName=right, Path=Text}"/>
                            </cal:ActionMessage>
                        </cal:EventMessageTrigger.Message>
                    </cal:EventMessageTrigger>
                </cal:RoutedMessageTriggerCollection>
            </cal:Message.Triggers>
        </Button>
    </StackPanel>
</Window>

Change the Calculator class to match the following definition (you will need to add a using/import statement for Caliburn.PresentationFramework.Filters):

[Rescue("GeneralRescue")]
public class Calculator
{
    public int Divide(int left, int right)
    {
        return left / right;
    }
 
    public void GeneralRescue(Exception ex)
    {
        MessageBox.Show(ex.Message);
    }
}

Once again update the Calculator class to match the following definition:

[Rescue("GeneralRescue")]
public class Calculator
{
    [Preview("CanDivide", AffectsTriggers = true)]
    public int Divide(int left, int right)
    {
        return left / right;
    }
 
    public bool CanDivide(int left, int right)
    {
        return right != 0;
    }
  
    public void GeneralRescue(Exception ex)
    {
        MessageBox.Show(ex.Message);
    }
}

Replace the <Button /> element with the following markup:

<Button Content="Divide (Trigger Collection w/ Inferred Parameters)">
    <cm:Message.Triggers>
        <ct:RoutedMessageTriggerCollection>
            <ct:EventMessageTrigger EventName="Click">
                <ct:EventMessageTrigger.Message>
                    <ca:ActionMessage MethodName="Divide" />
                </ct:EventMessageTrigger.Message>
            </ct:EventMessageTrigger>
        </ct:RoutedMessageTriggerCollection>
    </cm:Message.Triggers>
</Button>

Now, replace the <Button /> element with the following markup:

<Button Content="Divide (Attachment w/ Explicit Parameters)"
        cm:Message.Attach="[Event Click] = [Action Divide(left.Text, right.Text) : DivideResult.Text]" />

<Button Content="Divide (Attachment w/ Explicit Parameters and Modes)"
        cm:Message.Attach="[Event Click] = [Action Divide(left.Text:TwoWay, right.Text:OneTime) : DivideResult.Text]" />

Next, replace the <Button /> element with the following markup:

<Button Content="Divide (Attachment w/ Inferred Parameters)"
        cm:Message.Attach="[Event Click] = [Action Divide]" />

This is functionally equivalent to our second long markup example. In this case, our parameters will be inferred by Caliburn.

Replace the <Button /> element with the following markup:

<Button Content="Divide (Attachment w/ Default Trigger/Message and Explicit Parameters)"
        cm:Message.Attach="Divide(left.Text, right.Text) : DivideResult.Text" />

Replace the <Button /> element with the following markup:

<Button Content="Divide (Attachment w/ Defaults)"
        cm:Message.Attach="Divide" />

<Button Content="Divide or Multiply"
        cm:Message.Attach="[Event Click] = [Action Divide(left.Text:TwoWay, right.Text:OneTime) : DivideResult.Text];
[Event MouseRightButtonUp] = [Action Multiply(left.Text:TwoWay, right.Text:OneTime) : MultiplyResult.Text]" />

Updated Wiki: Action Basics

EisenbergEffect — Wed, 04 Nov 2009 02:57:29 GMT

Action Basics

Prerequisites

Referenced Assemblies

Caliburn.Core
Caliburn.PresentationFramework
Microsoft.Practices.ServiceLocation

Minimum Configuration

Note: Configuration should be placed in the App.xaml.cs constructor for WPF or the App.xaml.cs Application_Startup for Silverlight.

CaliburnFramework
    .ConfigureCore()
    .WithPresentationFramework()
    .Start();

Using Actions (Based on Samples - Actions)

Actions are a core feature of Caliburn which can enable a number of UI patterns such as MVC, MVP and Presentation Model (MVVM). Let's look at a basic usage of Actions.

In your project, create a new class named Calculator. This will serve as your first controller, and will be the type where we place actions. Use the code below:

public class Calculator
{
    public int Divide(int left, int right)
    {
        return left / right;
    }
}

Next, use the following markup to implement your main Page (for Silverlight) or your Window (for WPF):

Silverlight

<UserControl x:Class="Actions.Page"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:ca="clr-namespace:Caliburn.Actions;assembly=Caliburn.Actions"
             xmlns:local="clr-namespace:Actions"
             xmlns:cm="clr-namespace:Caliburn.RoutedUIMessaging;assembly=Caliburn.RoutedUIMessaging"
             xmlns:ct="clr-namespace:Caliburn.RoutedUIMessaging.Triggers;assembly=Caliburn.RoutedUIMessaging"
             Width="400"
             Height="300">
    <ca:Action.Target>
        <local:Calculator />
    </ca:Action.Target>
 
    <StackPanel x:Name="LayoutRoot">
        <Grid Margin="10">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="*" />
                <ColumnDefinition Width="Auto" />
                <ColumnDefinition Width="*" />
                <ColumnDefinition Width="*" />
            </Grid.ColumnDefinitions>
 
            <TextBox x:Name="left"
                     Grid.Column="0" />
            <TextBlock Text="/"
                       Margin="10 0"
                       Grid.Column="1" />
            <TextBox x:Name="right"
                     Grid.Column="2" />
            <Border BorderBrush="Black"
                    BorderThickness="0 0 0 1"
                    Margin="10 0 0 0"
                    Grid.Column="3">
                <TextBlock x:Name="DivideResult" />
            </Border>
        </Grid>
 
        <Button Content="Divide (Trigger Collection w/ Explicit Parameters)">
            <cm:Message.Triggers>
                <ct:RoutedMessageTriggerCollection>
                    <ct:EventMessageTrigger EventName="Click">
                        <ct:EventMessageTrigger.Message>
                            <ca:ActionMessage MethodName="Divide"
                                              OutcomePath="DivideResult.Text">
                                <cm:Parameter ElementName="left"
                                              Path="Text" />
                                <cm:Parameter ElementName="right"
                                              Path="Text" />
                            </ca:ActionMessage>
                        </ct:EventMessageTrigger.Message>
                    </ct:EventMessageTrigger>
                </ct:RoutedMessageTriggerCollection>
            </cm:Message.Triggers>
        </Button>
    </StackPanel>
</UserControl>

WPF

<Window x:Class="Actions.Window1"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:local="clr-namespace:Actions"
        xmlns:cal="http://www.caliburnproject.org"
        Title="Window1"
        SizeToContent="WidthAndHeight">
    <cal:Action.Target>
        <local:Calculator />    
    </cal:Action.Target>
     
    <StackPanel>
        <Grid Margin="10">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="*" />
                <ColumnDefinition Width="Auto" />
                <ColumnDefinition Width="*" />
                <ColumnDefinition Width="*" />
            </Grid.ColumnDefinitions>
            
            <TextBox x:Name="left" 
                     Grid.Column="0"/>
            <TextBlock Text="/"
                       Margin="10 0"
                       Grid.Column="1"/>
            <TextBox x:Name="right" 
                     Grid.Column="2"/>
            <Border BorderBrush="Black"
                    BorderThickness="0 0 0 1"
                    Margin="10 0 0 0"
                    Grid.Column="3">
                <TextBlock x:Name="DivideResult" />
            </Border>
            
        </Grid>
         
        <Button Content="Divide (Trigger Collection w/ Explicit Parameters)">
            <cal:Message.Triggers>
                <cal:RoutedMessageTriggerCollection>
                    <cal:EventMessageTrigger EventName="Click">
                        <cal:EventMessageTrigger.Message>
                            <cal:ActionMessage MethodName="Divide"
                                           OutcomePath="DivideResult.Text">
                                <cal:Parameter Value="{Binding ElementName=left, Path=Text}"/>
                                <cal:Parameter Value="{Binding ElementName=right, Path=Text}"/>
                            </cal:ActionMessage>
                        </cal:EventMessageTrigger.Message>
                    </cal:EventMessageTrigger>
                </cal:RoutedMessageTriggerCollection>
            </cal:Message.Triggers>
        </Button>
    </StackPanel>
</Window>

Change the Calculator class to match the following definition (you will need to add a using/import statement for Caliburn.PresentationFramework.Filters):

[Rescue("GeneralRescue")]
public class Calculator
{
    public int Divide(int left, int right)
    {
        return left / right;
    }
 
    public void GeneralRescue(Exception ex)
    {
        MessageBox.Show(ex.Message);
    }
}

Once again update the Calculator class to match the following definition:

[Rescue("GeneralRescue")]
public class Calculator
{
    [Preview("CanDivide", AffectsTriggers = true)]
    public int Divide(int left, int right)
    {
        return left / right;
    }
 
    public bool CanDivide(int left, int right)
    {
        return right != 0;
    }
  
    public void GeneralRescue(Exception ex)
    {
        MessageBox.Show(ex.Message);
    }
}

Replace the <Button /> element with the following markup:

<Button Content="Divide (Trigger Collection w/ Inferred Parameters)">
    <cm:Message.Triggers>
        <ct:RoutedMessageTriggerCollection>
            <ct:EventMessageTrigger EventName="Click">
                <ct:EventMessageTrigger.Message>
                    <ca:ActionMessage MethodName="Divide" />
                </ct:EventMessageTrigger.Message>
            </ct:EventMessageTrigger>
        </ct:RoutedMessageTriggerCollection>
    </cm:Message.Triggers>
</Button>

Now, replace the <Button /> element with the following markup:

<Button Content="Divide (Attachment w/ Explicit Parameters)"
        cm:Message.Attach="[Event Click] = [Action Divide(left.Text, right.Text) : DivideResult.Text]" />

<Button Content="Divide (Attachment w/ Explicit Parameters and Modes)"
        cm:Message.Attach="[Event Click] = [Action Divide(left.Text:TwoWay, right.Text:OneTime) : DivideResult.Text]" />

Next, replace the <Button /> element with the following markup:

<Button Content="Divide (Attachment w/ Inferred Parameters)"
        cm:Message.Attach="[Event Click] = [Action Divide]" />

This is functionally equivalent to our second long markup example. In this case, our parameters will be inferred by Caliburn.

Replace the <Button /> element with the following markup:

<Button Content="Divide (Attachment w/ Default Trigger/Message and Explicit Parameters)"
        cm:Message.Attach="Divide(left.Text, right.Text) : DivideResult.Text" />

Replace the <Button /> element with the following markup:

<Button Content="Divide (Attachment w/ Defaults)"
        cm:Message.Attach="Divide" />

<Button Content="Divide or Multiply"
        cm:Message.Attach="[Event Click] = [Action Divide(left.Text:TwoWay, right.Text:OneTime) : DivideResult.Text]; 
                                       [Event MouseRightButtonUp] = [Action Multiply(left.Text:TwoWay, right.Text:OneTime) : MultiplyResult.Text]" />

Updated Wiki: Action Basics

EisenbergEffect — Wed, 04 Nov 2009 02:56:05 GMT

Action Basics

Prerequisites

Referenced Assemblies

Caliburn.Core
Caliburn.PresentationFramework
Microsoft.Practices.ServiceLocation

Minimum Configuration

Note: Configuration should be placed in the App.xaml.cs constructor for WPF or the App.xaml.cs Application_Startup for Silverlight.

CaliburnFramework
    .ConfigureCore()
    .WithPresentationFramework()
    .Start();

Using Actions (Based on Samples - Actions)

Actions are a core feature of Caliburn which can enable a number of UI patterns such as MVC, MVP and Presentation Model (MVVM). Let's look at a basic usage of Actions.

In your project, create a new class named Calculator. This will serve as your first controller, and will be the type where we place actions. Use the code below:

public class Calculator
{
    public int Divide(int left, int right)
    {
        return left / right;
    }
}

Next, use the following markup to implement your main Page (for Silverlight) or your Window (for WPF):

Silverlight

<UserControl x:Class="Actions.Page"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:ca="clr-namespace:Caliburn.Actions;assembly=Caliburn.Actions"
             xmlns:local="clr-namespace:Actions"
             xmlns:cm="clr-namespace:Caliburn.RoutedUIMessaging;assembly=Caliburn.RoutedUIMessaging"
             xmlns:ct="clr-namespace:Caliburn.RoutedUIMessaging.Triggers;assembly=Caliburn.RoutedUIMessaging"
             Width="400"
             Height="300">
    <ca:Action.Target>
        <local:Calculator />
    </ca:Action.Target>
 
    <StackPanel x:Name="LayoutRoot">
        <Grid Margin="10">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="*" />
                <ColumnDefinition Width="Auto" />
                <ColumnDefinition Width="*" />
                <ColumnDefinition Width="*" />
            </Grid.ColumnDefinitions>
 
            <TextBox x:Name="left"
                     Grid.Column="0" />
            <TextBlock Text="/"
                       Margin="10 0"
                       Grid.Column="1" />
            <TextBox x:Name="right"
                     Grid.Column="2" />
            <Border BorderBrush="Black"
                    BorderThickness="0 0 0 1"
                    Margin="10 0 0 0"
                    Grid.Column="3">
                <TextBlock x:Name="DivideResult" />
            </Border>
        </Grid>
 
        <Button Content="Divide (Trigger Collection w/ Explicit Parameters)">
            <cm:Message.Triggers>
                <ct:RoutedMessageTriggerCollection>
                    <ct:EventMessageTrigger EventName="Click">
                        <ct:EventMessageTrigger.Message>
                            <ca:ActionMessage MethodName="Divide"
                                              OutcomePath="DivideResult.Text">
                                <cm:Parameter ElementName="left"
                                              Path="Text" />
                                <cm:Parameter ElementName="right"
                                              Path="Text" />
                            </ca:ActionMessage>
                        </ct:EventMessageTrigger.Message>
                    </ct:EventMessageTrigger>
                </ct:RoutedMessageTriggerCollection>
            </cm:Message.Triggers>
        </Button>
    </StackPanel>
</UserControl>

WPF

<Window x:Class="Actions.Window1"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:local="clr-namespace:Actions"
        xmlns:cal="http://www.caliburnproject.org"
        Title="Window1"
        SizeToContent="WidthAndHeight">
    <cal:Action.Target>
        <local:Calculator />    
    </cal:Action.Target>
     
    <StackPanel>
        <Grid Margin="10">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="*" />
                <ColumnDefinition Width="Auto" />
                <ColumnDefinition Width="*" />
                <ColumnDefinition Width="*" />
            </Grid.ColumnDefinitions>
            
            <TextBox x:Name="left" 
                     Grid.Column="0"/>
            <TextBlock Text="/"
                       Margin="10 0"
                       Grid.Column="1"/>
            <TextBox x:Name="right" 
                     Grid.Column="2"/>
            <Border BorderBrush="Black"
                    BorderThickness="0 0 0 1"
                    Margin="10 0 0 0"
                    Grid.Column="3">
                <TextBlock x:Name="DivideResult" />
            </Border>
            
        </Grid>
         
        <Button Content="Divide (Trigger Collection w/ Explicit Parameters)">
            <cal:Message.Triggers>
                <cal:RoutedMessageTriggerCollection>
                    <cal:EventMessageTrigger EventName="Click">
                        <cal:EventMessageTrigger.Message>
                            <cal:ActionMessage MethodName="Divide"
                                           OutcomePath="DivideResult.Text">
                                <cal:Parameter Value="{Binding ElementName=left, Path=Text}"/>
                                <cal:Parameter Value="{Binding ElementName=right, Path=Text}"/>
                            </cal:ActionMessage>
                        </cal:EventMessageTrigger.Message>
                    </cal:EventMessageTrigger>
                </cal:RoutedMessageTriggerCollection>
            </cal:Message.Triggers>
        </Button>
    </StackPanel>
</Window>

Change the Calculator class to match the following definition (you will need to add a using/import statement for Caliburn.PresentationFramework.Filters):

[Rescue("GeneralRescue")]
public class Calculator
{
    public int Divide(int left, int right)
    {
        return left / right;
    }
 
    public void GeneralRescue(Exception ex)
    {
        MessageBox.Show(ex.Message);
    }
}

Once again update the Calculator class to match the following definition:

[Rescue("GeneralRescue")]
public class Calculator
{
    [Preview("CanDivide", AffectsTriggers = true)]
    public int Divide(int left, int right)
    {
        return left / right;
    }
 
    public bool CanDivide(int left, int right)
    {
        return right != 0;
    }
  
    public void GeneralRescue(Exception ex)
    {
        MessageBox.Show(ex.Message);
    }
}

Replace the <Button /> element with the following markup:

<Button Content="Divide (Trigger Collection w/ Inferred Parameters)">
    <cm:Message.Triggers>
        <ct:RoutedMessageTriggerCollection>
            <ct:EventMessageTrigger EventName="Click">
                <ct:EventMessageTrigger.Message>
                    <ca:ActionMessage MethodName="Divide" />
                </ct:EventMessageTrigger.Message>
            </ct:EventMessageTrigger>
        </ct:RoutedMessageTriggerCollection>
    </cm:Message.Triggers>
</Button>

Now, replace the <Button /> element with the following markup:

<Button Content="Divide (Attachment w/ Explicit Parameters)"
        cm:Message.Attach="[Event Click] = [Action Divide(left.Text, right.Text) : DivideResult.Text]" />

<Button Content="Divide (Attachment w/ Explicit Parameters and Modes)"
        cm:Message.Attach="[Event Click] = [Action Divide(left.Text:TwoWay, right.Text:OneTime) : DivideResult.Text]" />

Next, replace the <Button /> element with the following markup:

<Button Content="Divide (Attachment w/ Inferred Parameters)"
        cm:Message.Attach="[Event Click] = [Action Divide]" />

This is functionally equivalent to our second long markup example. In this case, our parameters will be inferred by Caliburn.

Replace the <Button /> element with the following markup:

<Button Content="Divide (Attachment w/ Default Trigger/Message and Explicit Parameters)"
        cm:Message.Attach="Divide(left.Text, right.Text) : DivideResult.Text" />

Replace the <Button /> element with the following markup:

<Button Content="Divide (Attachment w/ Defaults)"
        cm:Message.Attach="Divide" />

<Button Content="Divide or Multiply"
        cm:Message.Attach="[Event Click] = [Action Divide(left.Text:TwoWay, right.Text:OneTime) : DivideResult.Text]; 
                                       [Event MouseRightButtonUp] = [Action Multiply(left.Text:TwoWay, right.Text:OneTime) : MultiplyResult.Text]" />

New Comment on "Action Basics"

JMichelson — Tue, 03 Nov 2009 19:25:06 GMT

The OneTime parameter in this example causes the framework to disable the button. Removing the OneTime parameter or changing it to OneWay fixes the problem.

Updated Wiki: Action Basics

EisenbergEffect — Mon, 02 Nov 2009 16:06:49 GMT

Action Basics

Prerequisites

Referenced Assemblies

Caliburn.Core
Caliburn.PresentationFramework
Microsoft.Practices.ServiceLocation

Minimum Configuration

Note: Configuration should be placed in the App.xaml.cs constructor for WPF or the App.xaml.cs Application_Startup for Silverlight.

CaliburnFramework
    .ConfigureCore()
    .WithPresentationFramework()
    .Start();

Using Actions (Based on Samples - Actions)

Actions are a core feature of Caliburn which can enable a number of UI patterns such as MVC, MVP and Presentation Model (MVVM). Let's look at a basic usage of Actions.

In your project, create a new class named Calculator. This will serve as your first controller, and will be the type where we place actions. Use the code below:

public class Calculator
{
    public int Divide(int left, int right)
    {
        return left / right;
    }
}

Next, use the following markup to implement your main Page (for Silverlight) or your Window (for WPF):

Silverlight

<UserControl x:Class="Actions.Page"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:ca="clr-namespace:Caliburn.Actions;assembly=Caliburn.Actions"
             xmlns:local="clr-namespace:Actions"
             xmlns:cm="clr-namespace:Caliburn.RoutedUIMessaging;assembly=Caliburn.RoutedUIMessaging"
             xmlns:ct="clr-namespace:Caliburn.RoutedUIMessaging.Triggers;assembly=Caliburn.RoutedUIMessaging"
             Width="400"
             Height="300">
    <ca:Action.Target>
        <local:Calculator />
    </ca:Action.Target>
 
    <StackPanel x:Name="LayoutRoot">
        <Grid Margin="10">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="*" />
                <ColumnDefinition Width="Auto" />
                <ColumnDefinition Width="*" />
                <ColumnDefinition Width="*" />
            </Grid.ColumnDefinitions>
 
            <TextBox x:Name="left"
                     Grid.Column="0" />
            <TextBlock Text="/"
                       Margin="10 0"
                       Grid.Column="1" />
            <TextBox x:Name="right"
                     Grid.Column="2" />
            <Border BorderBrush="Black"
                    BorderThickness="0 0 0 1"
                    Margin="10 0 0 0"
                    Grid.Column="3">
                <TextBlock x:Name="DivideResult" />
            </Border>
        </Grid>
 
        <Button Content="Divide (Trigger Collection w/ Explicit Parameters)">
            <cm:Message.Triggers>
                <ct:RoutedMessageTriggerCollection>
                    <ct:EventMessageTrigger EventName="Click">
                        <ct:EventMessageTrigger.Message>
                            <ca:ActionMessage MethodName="Divide"
                                              OutcomePath="DivideResult.Text">
                                <cm:Parameter ElementName="left"
                                              Path="Text" />
                                <cm:Parameter ElementName="right"
                                              Path="Text" />
                            </ca:ActionMessage>
                        </ct:EventMessageTrigger.Message>
                    </ct:EventMessageTrigger>
                </ct:RoutedMessageTriggerCollection>
            </cm:Message.Triggers>
        </Button>
    </StackPanel>
</UserControl>

WPF

<Window x:Class="Actions.Window1"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:local="clr-namespace:Actions"
        xmlns:cal="http://www.caliburnproject.org"
        Title="Window1"
        SizeToContent="WidthAndHeight">
    <cal:Action.Target>
        <local:Calculator />    
    </cal:Action.Target>
     
    <StackPanel>
        <Grid Margin="10">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="*" />
                <ColumnDefinition Width="Auto" />
                <ColumnDefinition Width="*" />
                <ColumnDefinition Width="*" />
            </Grid.ColumnDefinitions>
            
            <TextBox x:Name="left" 
                     Grid.Column="0"/>
            <TextBlock Text="/"
                       Margin="10 0"
                       Grid.Column="1"/>
            <TextBox x:Name="right" 
                     Grid.Column="2"/>
            <Border BorderBrush="Black"
                    BorderThickness="0 0 0 1"
                    Margin="10 0 0 0"
                    Grid.Column="3">
                <TextBlock x:Name="DivideResult" />
            </Border>
            
        </Grid>
         
        <Button Content="Divide (Trigger Collection w/ Explicit Parameters)">
            <cal:Message.Triggers>
                <cal:RoutedMessageTriggerCollection>
                    <cal:EventMessageTrigger EventName="Click">
                        <cal:EventMessageTrigger.Message>
                            <cal:ActionMessage MethodName="Divide"
                                           OutcomePath="DivideResult.Text">
                                <cal:Parameter Value="{Binding ElementName=left, Path=Text}"/>
                                <cal:Parameter Value="{Binding ElementName=right, Path=Text}"/>
                            </cal:ActionMessage>
                        </cal:EventMessageTrigger.Message>
                    </cal:EventMessageTrigger>
                </cal:RoutedMessageTriggerCollection>
            </cal:Message.Triggers>
        </Button>
    </StackPanel>
</Window>

Change the Calculator class to match the following definition (you will need to add a using/import statement for Caliburn.PresentationFramework.Filters):

[Rescue("GeneralRescue")]
public class Calculator
{
    public int Divide(int left, int right)
    {
        return left / right;
    }
 
    public void GeneralRescue(Exception ex)
    {
        MessageBox.Show(ex.Message);
    }
}

Once again update the Calculator class to match the following definition:

[Rescue("GeneralRescue")]
public class Calculator
{
    [Preview("CanDivide", AffectsTriggers = true)]
    public int Divide(int left, int right)
    {
        return left / right;
    }
 
    public bool CanDivide(int left, int right)
    {
        return right != 0;
    }
  
    public void GeneralRescue(Exception ex)
    {
        MessageBox.Show(ex.Message);
    }
}

Replace the <Button /> element with the following markup:

<Button Content="Divide (Trigger Collection w/ Inferred Parameters)">
    <cm:Message.Triggers>
        <ct:RoutedMessageTriggerCollection>
            <ct:EventMessageTrigger EventName="Click">
                <ct:EventMessageTrigger.Message>
                    <ca:ActionMessage MethodName="Divide" />
                </ct:EventMessageTrigger.Message>
            </ct:EventMessageTrigger>
        </ct:RoutedMessageTriggerCollection>
    </cm:Message.Triggers>
</Button>

Now, replace the <Button /> element with the following markup:

<Button Content="Divide (Attachment w/ Explicit Parameters)"
        cm:Message.Attach="[Event Click] = [Action Divide(left.Text, right.Text) : DivideResult.Text]" />

<Button Content="Divide (Attachment w/ Explicit Parameters and Modes)"
        cm:Message.Attach="[Event Click] = [Action Divide(left.Text:TwoWay, right.Text:OneTime) : DivideResult.Text]" />

Next, replace the <Button /> element with the following markup:

<Button Content="Divide (Attachment w/ Inferred Parameters)"
        cm:Message.Attach="[Event Click] = [Action Divide]" />

This is functionally equivalent to our second long markup example. In this case, our parameters will be inferred by Caliburn.

Replace the <Button /> element with the following markup:

<Button Content="Divide (Attachment w/ Default Trigger/Message and Explicit Parameters)"
        cm:Message.Attach="Divide(left.Text, right.Text) : DivideResult.Text" />

Replace the <Button /> element with the following markup:

<Button Content="Divide (Attachment w/ Defaults)"
        cm:Message.Attach="Divide" />

<Button Content="Divide or Multiply"
        cm:Message.Attach="[Event Click] = [Action Divide(left.Text:TwoWay, right.Text:OneTime) : DivideResult.Text]; [Event MouseRightButtonUp] = [Action Multiply(left.Text:TwoWay, right.Text:OneTime) : MultiplyResult.Text]" />

Updated Wiki: IResult

EisenbergEffect — Mon, 02 Nov 2009 15:59:26 GMT

IResult and IEnumerable<IResult> (Coroutines)

IResult is one of the most powerful features of Actions. Any action can return an instance of IResult or IEnumerable<IResult>. Doing so allows you to hand custom code to the runtime which will be executed upon completion of the action. In fact, the entire OutputPath binding is implemented as a single IResult which the framework executes by default. You can find this implementation in the framework class named DefaultResult.

IResult enables handling many difficult programming scenarios with ease, mainly asynchronous programming. Here's an example of what you can do:

public IEnumerable<IResult> Login(string username, string password)
{
    var authenticator = new AuthenticateResult(username, password);
    yield return authenticator;

    if(!authenticator.Succeeded)
    {
        yield return Show.MessageBox("The username or password provided is incorrect.", "Access Denied");
        yield break;
    }

    var result = new Result();
    var request = new GetUserSettings(username);

    yield return new ProcessQuery(request, result, "Logging In...");

    if (result.HasErrors)
    {
        var error = result.Errors.First();

        yield return Show.MessageBox(error.Message, "Error");
        yield break;
    }

    var response = result.GetResponse(request);

    if(response.Permissions == null || response.Permissions.Count < 1)
    {
        yield return Show.MessageBox("You do not have permission to access the dashboard.", "Access Denied");
        yield break;
    }

    _context.Permissions = response.Permissions;

    yield return Show.Child<IDashboard>().In<IShell>();
}

Note: "Show" is a static factory for instances of IResult. It is not included as part of the Caliburn framework, but is a common pattern I use to simplify these scenarios.

Each yield statement returns some instance of IResult which Caliburn executes. These results can execute synchronously or asynchronously. For example, the AuthenticateResult calls a web service asynchronously. This causes execution of the action to 'pause' until the asynchronous action completes. When the web service has returned its result, execition then begins on the line immediately following the yield. In fact, every yield in this action executes asynchronous code. Using this programming paradigm we can have very intricate asynchronous workflows that are easy to read and understand because they are written sequentially. This technique is know as Coroutines.

To create your own IResult simply implement the interface on your own class. This involves implementing the Execute method and being sure to raise the Completed event when your work is done. Here is an example of how the ProcessQuery result was written:

public class ProcessQuery : IResult
{
    private readonly Query _query;
    private readonly Result _result;
    private readonly string _waitMessage;

    public ProcessQuery(Query query, Result result, string waitMessage)
    {
        _query = query;
        _result = result;
        _waitMessage = waitMessage;
    }

    public ProcessQuery(Query query, Result result)
    {
        _query = query;
        _result = result;
    }

    public string WaitMessage
    {
        get { return _waitMessage; }
    }

    public Query Query
    {
        get { return _query; }
    }

    public Result Result
    {
        get { return _result; }
    }

    public void Execute(IRoutedMessageWithOutcome message, IInteractionNode handlingNode)
    {
        var service = ServiceLocator.Current.GetInstance<IServer>();

        if(!string.IsNullOrEmpty(_waitMessage))
            ServiceLocator.Current.GetInstance<ILoadScreen>().StartLoading(_waitMessage);

        service.ProcessQueryAsync(_query, result =>{
            _result.Add(result);

            if (!string.IsNullOrEmpty(_waitMessage))
                ServiceLocator.Current.GetInstance<ILoadScreen>().StopLoading();

            Completed(this, null);
        });
    }

    public event Action<IResult, Exception> Completed = delegate { };
}

This is just one example of the endless possibilities and was developed for a specific application where this type of interaction was common. Notice the signature of the Execute method. Caliburn will provide you with contextual information as well. The IRoutedMessageWithOutcome is the original message sent from the UI which caused the action to be executed and the IInteractionNode is the node within the UI that caught and handled the message. You can drill through the properties of these interfaces to discover much about the current scenario. Again, see the framework's DefaultResult for an example of this.

Note: Raising Completed with it's second parameter being an instance of Exception will cause IResult enumeration to immediately stop. The exception will then be thrown. However, there is a special exception, CancelResult, which can be sent. It only causes the cancellation of enumeration and does not get thrown as a normal exception would.

Note: Using IResult also aids in unit testing because the extremely complex interaction testing that would normally take place can be replaced with simple state-based testing by enumerating the results and checking their properties. (You don't need to call the Execute method during Action testing because you are not testing the IResults themselves, rather what results are returned and how they are configured. You should have separate unit tests for each type of IResult.)

Updated Wiki: IResult

EisenbergEffect — Mon, 02 Nov 2009 15:53:31 GMT

IResult and IEnumerable<IResult> (Coroutines)

public IEnumerable<IResult> Login(string username, string password)
{
    var authenticator = new AuthenticateResult(username, password);
    yield return authenticator;

    if(!authenticator.Succeeded)
    {
        yield return Show.MessageBox("The username or password provided is incorrect.", "Access Denied");
        yield break;
    }

    var result = new Result();
    var request = new GetUserSettings(username);

    yield return new ProcessQuery(request, result, "Logging In...");

    if (result.HasErrors)
    {
        var error = result.Errors.First();

        yield return Show.MessageBox(error.Message, "Error");
        yield break;
    }

    var response = result.GetResponse(request);

    if(response.Permissions == null || response.Permissions.Count < 1)
    {
        yield return Show.MessageBox("You do not have permission to access the dashboard.", "Access Denied");
        yield break;
    }

    _context.Permissions = response.Permissions;

    yield return Show.Child<IDashboard>().In<IShell>();
}

public class ProcessQuery : IResult
{
    private readonly Query _query;
    private readonly Result _result;
    private readonly string _waitMessage;

    public ProcessQuery(Query query, Result result, string waitMessage)
    {
        _query = query;
        _result = result;
        _waitMessage = waitMessage;
    }

    public ProcessQuery(Query query, Result result)
    {
        _query = query;
        _result = result;
    }

    public string WaitMessage
    {
        get { return _waitMessage; }
    }

    public Query Query
    {
        get { return _query; }
    }

    public Result Result
    {
        get { return _result; }
    }

    public void Execute(IRoutedMessageWithOutcome message, IInteractionNode handlingNode)
    {
        var service = ServiceLocator.Current.GetInstance<IServer>();

        if(!string.IsNullOrEmpty(_waitMessage))
            ServiceLocator.Current.GetInstance<ILoadScreen>().StartLoading(_waitMessage);

        service.ProcessQueryAsync(_query, result =>{
            _result.Add(result);

            if (!string.IsNullOrEmpty(_waitMessage))
                ServiceLocator.Current.GetInstance<ILoadScreen>().StopLoading();

            Completed(this, null);
        });
    }

    public event Action<IResult, Exception> Completed = delegate { };
}

This is just one example of the endless possibilities and was developed for a specific application where this type of interaction was common. Notice the signature of the Execute method. Caliburn will provide you with contextual information as well. The IRoutedMessageWithOutcome is the original message sent from the UI which caused the action to be executed and the IInteractionNode is the node within the UI that caught and handled the message. You can drill through the properties of these interfaces to discover much about the current scenario. Again, see the framework's DefaultResult for an example of this.

Note: Using IResult also aids in unit testing because the extremely complex interaction testing that would normally take place can be replaced with simple state-based testing by enumerating the results and checking their properties. (You don't need to call the Execute method during Action testing because you are not testing the IResults themselves, rather what results are returned and how they are configured. You should have separate unit tests for each type of IResult.)

New Comment on "Dependent Actions"

RDotlee — Sat, 31 Oct 2009 01:08:18 GMT

I was not implementing INotifyPropertyChanged in my calculator class. Easy fix.

New Comment on "Dependent Actions"

RDotLee — Fri, 30 Oct 2009 01:21:06 GMT

Hello Rob! At one time the RoutedUIMessaging namespace obviously existed. It does not exist now but your sample code in the documentation usually references it. Also, i'm not able to get this sample to work using Silverlight 3. I have the latest Caliburn source. The button does not enable. If ialways return true from the CanDivide method the button enables but the Divide method does not get called. I am going t o keep working on it but if you have any thoughts that would be great.

Updated Wiki: BlogsArticlesProjects

EisenbergEffect — Wed, 28 Oct 2009 03:28:34 GMT

Blogs, Articles and Related Projects

Below are a list of blogs, articles and projects related to Caliburn in some way. If you are writing or building anything with Caliburn, we would love to discuss getting you on the site.

Prism Stock Trader with Caliburn

Testing with Caliburn and unhaddins

Build an Application with Caliburn And Prism

Devlicios

Please visit my blog where you can read more about Caliburn. I will be running some how to's and talking more extensively about UI architecture.

New Comment on "BlogsArticlesProjects"

jfromaniello — Tue, 27 Oct 2009 23:22:09 GMT

Thank you very much for the mention I'm not the PL of unhaddins, Fabio Maulo is the PL and creator of the project.

Updated Wiki: Products

EisenbergEffect — Tue, 27 Oct 2009 16:07:38 GMT

Products

Caliburn has been used in the development of products for state and local governments, startups and even multi-billion dollar corporations. Many of these projects cannot be publicly discussed, but we have a small sample of the ones that can below. If you are currently working on an application that uses Caliburn, please contact us. We would love to discuss adding it to the gallery.

NHibernate Profiler

NHibernate Profiler is a real-time visual debugger allowing a development team to gain valuable insight and perspective into their practice of using NHibernate or Hibernate. The product is architected with input coming from many top industry leaders within the NHibernate community. Alerts are presented in a concise code-review manner indicating patterns of misuse by your application. To streamline your efforts to correct the misuse, we provide links to the problematic code section that triggered the alert. This product primarily takes advantage of Caliburn's Actions and Commands. Development was started towards the end of 2008 and was influential on Caliburn's implementation of IViewStrategy, the IPresenter model and the IDispatcher. More information about the product can be found here.

Clean Water Services

The local stormwater/wastewater utility near Portland, OR needed an application to report on the status of equipment in the treatment plants. This app was developed for Toughbook CF-U1 handhelds with a 7” screen – so everything is huge (and simple) on purpose.

MapDotNet UX Studio

MapDotNet UX Studio is a Windows™ desktop application that provides a rich and user friendly interface for designing interactive maps. Users can visualize and design all types of interactive maps using Studio, including thematic maps, overlay maps, and data-driven dynamic maps. These interactive maps can then be shared with others, integrated into desktop applications, or exported to a MapDotNet UX Web Services server where they can be served up for use in enterprise applications. The development of this product was being done while Caliburn's alpha was being prepared. As such, it doesn't use Caliburn.Core.dll or Caliburn.PresentationFramework.dll but borrowed directly from the Caliburn source code base as well as inspired several of its features, such as the IPresenter model.

Updated Wiki: Home

EisenbergEffect — Mon, 26 Oct 2009 16:59:55 GMT

Project Description

Designed to aid in the development of WPF and Silverlight applications, Caliburn implements a variety of UI patterns for solving real-world problems. Patterns that are enabled by the framework include MVC, MVP, Presentation Model (MVVM), Commands and Application Controller.

Goals

Support building WPF/SL application that are TDD friendly.
Implement functionality for simplifying various UI design patterns in WPF/SL. These patterns include MVC, MVP, Presentation Model (MVVM), Commands, etc.
Ease the use of a dependency injection container with WPF/SL.
Simplify or provide alternatives to common WPF/SL related tasks.
Provide solutions to common UI architecture problems.

Get the Caliburn V1 RTW and have a look at the improved documentation.

.NET & Funky Fresh News Feed

Caliburn RC3

Thursday, September 10, 2009 | From .NET & Funky Fresh

Today I’ve made the RC3 of Caliburn v1 available. I’m going to let it sit for a couple of weeks, then I will RTW. Please take time to update your code to this new version and post any bugs to the codeplex site. Any bugs not found in the next couple of weeks will have to be fixed in v2. Below is a list of changes/fixes between RC2 and RC3. You can also take a look at the recently extended documentation online.

Updated the StructureMap.dll to version 2.5.3.
Made a slight alteration to CoreConfiguration that makes it more friendly when run in a unit test.
Added an AutofacAdapter for .NET 3.5, Silverlight 2.0 and Silverlight 3.0.
Fixed bugs in the DefaultWindowManager.
Added IPresenterNode which allows presenters to be hooked up with a reference to their parent. All implementors of IPresenterHost now wire themselves when opening children and unwire themselves during a shutdown.
Created the IBinder interface. This replaces the functionality that was in the extension method AttachTo. This interface is meant to provide a pluggable way to change the behavior of Model/View wire-up.
Updated DefaultBinder to allow for convention-based action wire-up.
Fixed a bug in auto-registration with CommandAttribute.
Fixed several bugs with CaliburnApplication
Fixed a bug where certain module scenarios would cause the PresentationFrameworkModule to be configured twice.
Fixed some inconsistencies in the DefaultWindowManager and CaliburnApplication.silverlight.cs.
Removed a pesky attribute in the WPF ContactManager's .config file that was causing bugs for some people.
Removed Message.Attach2nd, Message.Attach3rd and Message.Attach4th. You can now attach an arbitrary number of messages with Message.Attach by separating each message with a semicolon. This caused a breaking change to the IParser implementation, but it is unlikely that will affect many people.
Fixed some bugs in Parameter.silverlight.cs related to event defaults for elements that are bound.
Improved the BackgroundProcessing sample.
Fixed some bugs in parsing of parameters for messages. There were certain scenarios where the parser could not differentiate between string literals and references to control. To pass literals as a message parameter (short syntax only), you must surround it with single quotes.
Added AttachedEventTriggerParser. We can all now use attached event triggers in the short syntax. Usage is as follows: cal:Message.Attach="[AttachedEvent ButtonBase.Click] = [Action MyAction]" The caveat is that we cannot map namespaces from xaml into the parser. To work around this problem, we search through all AppDomain assemblies by default. If you would like to optimize this, simply inherit from AttachedEventTriggerParser and override GetSearchableAssemblies. Then register your ITriggerParser with IParser under the name "AttachedEvent"
Enabled the DefaultViewStrategy to handle custom contexts without the need of a ViewStrategyAttribute. If a context is the DefaultViewStrategy will treat the view name as a folder name by adding an "s" and search that folder for views with the context as their name.
Fixed various bugs in DefaultViewStrategy.
Fixed various bugs in AsynchronousAction and in the BackgroundProcessing sample.
Updated MEF to Preview 7.
Changed IMessageBinder.BindOutcome to IMessageBinder.CreateResult.
Enabled the DefaultBinder to look for properties named with the pattern Can + Action and wire up the IsEnabled property automatically.
Fixed the signatures of extension methods for IWindowManager.
Fixed a bug in binding validation that occurs when properties are overridden on a bound type.
Provided a way for a presenter to pass a dialog result to the view on close.
Made some improvements to exception messages in the case of parameter count mismatch during invocation.
Updated Caliburn's build to work with Silverlight 3.0.40818.0 service release.
Extended the IDispatcher to allow async UI invocation.

Dispelling a Common WPF/SL Myth

Tuesday, September 08, 2009 | From .NET & Funky Fresh

Everywhere I look I find WPF/Silverlight developers who believe a very popular myth: You cannot update a ViewModel or an ObservableCollection from a non-UI thread. Like most myths, there is an element of truth here. But not understanding that truth can lead you to some very elaborate solutions. Here’s the truth: You cannot fire the change notification from a non-UI thread. So with that in mind, it becomes very easy to abstract thread synchronization away. Here’s how we do it in Caliburn:

public abstract class PropertyChangedBase : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged = delegate { };

    public virtual void NotifyOfPropertyChange(string propertyName)
    {
        Execute.OnUIThread(() => RaisePropertyChangedEventImmediately(propertyName));
    }

    public virtual void RaisePropertyChangedEventImmediately(string propertyName)
    {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    }
}

public class BindableCollection<T> : ObservableCollection<T>, IObservableCollection<T>
{
    public BindableCollection() {}

    protected override void OnPropertyChanged(PropertyChangedEventArgs e)
    {
        Execute.OnUIThread(() => RaisePropertyChangedEventImmediately(e));
    }

    protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
    {
        Execute.OnUIThread(() => RaiseCollectionChangedEventImmediately(e));
    }

    public void RaiseCollectionChangedEventImmediately(NotifyCollectionChangedEventArgs e)
    {
        base.OnCollectionChanged(e);
    }

    public void RaisePropertyChangedEventImmediately(PropertyChangedEventArgs e)
    {
        base.OnPropertyChanged(e);
    }
}

The Execute.OnUIThread is a helper that Caliburn provides to abstract away the underlying IDispatcher. When Caliburn’s dispatcher is asked to execute something on the UI thread it first checks the thread it is on. If it is already on the UI thread, it simply invokes the delegate normally. Otherwise it marshals the call to the UI thread. This approach also makes testing easy, because you will never find any threading code in a ViewModel. Everything ultimately goes through an IDispatcher which Caliburn provides a fake implementation of for testing purposes.

Tallahassee Code Camp is Upon Us!

Friday, September 04, 2009 | From .NET & Funky Fresh

Tomorrow at the FSU College of Communication and Information we will hold Tallahassee’s 5th Annual Code Camp! We have a great list of speakers and some awesome sessions planned. Please check out our official site.

.NET & Funky Fresh News Feed

Updated Wiki: BlogsArticlesProjects

EisenbergEffect — Mon, 26 Oct 2009 01:21:17 GMT

Blogs, Articles and Related Projects

Below are a list of blogs, articles and projects related to Caliburn in some way. If you are writing or building anything with Caliburn, we would love to discuss getting you on the site.

Prism Stock Trader with Caliburn

Testing with Caliburn and unhaddins

unhaddins is a project led by José F. Romaniello. It's goal is to provide you with an all-in-one stop shop for NHibernate based projects. He has some nice extensions for basic NHibernate development and some specific work around using NHibernate on WPF projects. José is using unhaddins to build his Chinook Media Manager. While he is not using Caliburn for the architecture, he is using it for testing. Here, you can find a very nice bit of code that uses Caliburn to test all his applications view models. You may also be interested in following the the development of his media manager on his blog.

Build an Application with Caliburn And Prism

Devlicios

Please visit my blog where you can read more about Caliburn. I will be running some how to's and talking more extensively about UI architecture.