We just released Catel 3.1. You can grab the latest version:

• Via NuGet
• Via installer

In this blog post, we already described the most important changes, but you can find a full list of changes here.

As always, if you have any questions or feature requests, don’t hesitate to contact us or create an issue!

So, it’s been another month since we released Catel 3.0. This means that soon, we will release a new version, and it will be 3.1. You can grab the latest version:

• Via NuGet
• Via installer

Below is a list of the most important changes.

OnDataContextChanged and OnPropertyChanged methods

Since lots of people need to write handlers (but forget to unsubscribe thus cause memory leaks), we made these available as default to all controls that Catel provides.

AsynchronousCommand

Asynchronous development becomes more and more important. In the latest version, we proudly introduce the AsynchronousCommand, which is a command that runs in the background and doesn’t block and UI. It is able to provide thread-safe callbacks to the UI as well.

You can read all about it in the official docs.

Memento pattern

The memento pattern is something hardly any custom made application implements due to its complexity. Catel now includes a memento service which allows to undo/redo changes on properties, collections and custom actions.

If you ever need to build in undo/redo support, this is what you are looking for! You can read all about it in the official docs.

Note that this feature is also available for non-xaml solutions

Improved handling of datacontext changes for nested user control scenarios

If you are using Catel, you are probably aware that you sometimes get false reports of binding errors. Catel now uses an improved way of determining the right datacontext in nested user control scenarios so these false errors no long appear in your output window.

What to expect next?

We are currently investigating what it takes to port Catel to WinRT. However, since reflection in WinRT is very basic (for example, we cannot get the name of a method), it is really hard to implement the WeakEventListener and MessageMediator in WinRT. However, we will keep trying…

You can also checkout the road map.

For a long time, the PleaseWaitService is available for WPF and Silverlight in Catel. However, in the latest version (3.0), we have added support for Windows Phone 7 as well.

The PleaseWaitService is a service that can be used in MVVM scenario’s to show the user that a view model is currently performing an action. The cool thing about this is that Catel also offers test implementations that can be used during unit tests so all your view models maintain testability.

The advantages of this service are:

1. You no longer have to put a busy indicator on every page
2. You maintain testability
3. No more “IsBusy” properties on your view model which are stupid

Below is a video demonstrating the default implementation of the PleaseWaitService:

How to use this beauty?

1) First, you have to register it in your IoC container. If you are using Catel, it is all done automatically for you!

  1: serviceLocator.RegisterType<IPleaseWaitService, PleaseWaitService>();

2) Resolve the service in your view model from the IoC container. If you are using Catel, you can use the GetService method:

  1: var pleaseWaitService = GetService<IPleaseWaitService>();

3) Last but not least, you need to show and hide it. Since on WP7, you are probably using lots of asynchronous calls, it is recommended to use the Push and Pop methods:

When starting an operation:

  1: pleaseWaitService.Push();

When an operation finishes:

  1: pleaseWaitService.Pop();

This way, the PleaseWaitService will hide the busy indicator when all operations are finished.

In Catel (2.5, not released yet, only beta available), it is possible to hook the CanExecute of a Command to the IValidationSummary automatically. This way, there is no need to check for errors manually in the CanExecute. The example below first adds a validation summary to a view model to get the validation result. Then, it uses this validation summary to automatically determine whether a command can be executed.

1. Add validation to a person view model (note how the validation adds the tag PersonValidation to a validation):

   1: /// <summary>

   2: /// Validates the field values of this object. Override this method to enable

   3: /// validation of field values.

   4: /// </summary>

   5: /// <param name="validationResults">The validation results, add additional results to this list.</param>

   6: protected override void ValidateFields(System.Collections.Generic.List<IFieldValidationResult> validationResults)

   7: {

   8:     if (string.IsNullOrEmpty(FirstName))

   9:     {

  10:         validationResults.Add(FieldValidationResult.CreateError(FirstNameProperty, "First name cannot be empty", "PersonValidation"));

  11:     }

  12:  

  13:     if (string.IsNullOrEmpty(LastName))

  14:     {

  15:         validationResults.Add(FieldValidationResult.CreateError(LastNameProperty, "Last name cannot be empty", "PersonValidation"));

  16:     }

  17: }

2. Add a property to the view model containing the validation summary using the ValidationToViewModel attribute.

   1: [ValidationToViewModel(Tag = "PersonValidation")]

   2: public IValidationSummary PersonValidationSummary { get; set; }

3. Define a command on the view model:

   1: /// <summary>

   2: /// Gets the Save command.

   3: /// </summary>

   4: public Command Save { get; private set; }

   5:  

   6: /// <summary>

   7: /// Method to invoke when the Save command is executed.

   8: /// </summary>

   9: private void OnSaveExecute()

  10: {

  11:     // TODO: Handle command logic here

  12: }

4. Create the command that automatically uses the validation summary using the CommandHelper class:

   1: Save = CommandHelper.CreateCommand(OnSaveExecute, () => PersonValidationSummary);

With this example, the Save command on the view model can only be executed when there are no errors with the PersonValidation tag.

In every release of Catel, we try to improve a significant part of the code based on user requests. For release 2.4, it was the turn of the validation.

The validation in Catel is extremely flexible, and allows to use validation in the model (exposed via INotifyDataErrorInfo or IDataErrorInfo), validation in the view model (via the Validate methods) or via attributes (data annotations) on either the model or view model. However, this doesn’t seem enough for some users that require the absolute freedom in validation. Therefore, after intense discussions with the users, we came up with the following changes.

Introduction of IValidator and IValidatorProvider

The first request was to allow external validators to get involved into the validation process. For example, some use Fluent Validation for advanced validation checks. In previous versions of Catel, the calls to the external validators had to be implemented manually and converted to IValidationResult interfaces.

To make it much easier to hook into the validation process, the IValidatorProvider and IValidator were developed. The IValidatorProvider is a class that returns the right IValidator for a specific type. If no validator is available, it will return null. The ViewModelBase will automatically check the ServiceLocator whether an IValidatorProvider is available, and will then retrieve the IValidator for the current instance automatically.

The IValidator itself contains lots of methods, and allows to hook into the following events:

• BeforeValidation
• BeforeFieldValidation
• FieldValidation
• AfterFieldValidation
• BeforeBusinessRuleValidation
• BusinessRuleValidation
• AfterBusinessRuleValidation
• AfterValidation

For example, it can use Fluent Validation in the FieldValidation  and BusinessRuleValidation, and can translate the errors in AfterValidation.

Introduction of IValidationContext

Another nice improvement is the creation of the IValidationContext. It takes over the responsibility as validation container from the DataObjectBase. This way, the DataObjectBase becomes a bit less complicated and at the same time, the new container allows querying of all validations of a specific object in a very flexible way. Below are a few examples on how to query validations of a specific object:

First, the ValidationContext can be retrieved from a view model like this:

   1: var viewModel = new MyViewModel();

   2: var validationContext = viewModel.ValidationContext;

Get all field errors with a specific tag

   1: var fieldErrorsWithTag = validationContext.GetFieldErrors((object)"myTag");

Get all field validations of a specific property

   1: var fieldValidationResultsForProperty = validationContext.GetFieldValidationResults("MyProperty");

Get all business rule warnings

   1: var businessRuleWarnings = validationContext.GetBusinessRuleWarnings();

We hope to release Catel 2.4 this weekend (waiting on the last feedback), so you don’t have to wait long for these features .