SeeSharp

Distributed Transactions Tweaks in NServiceBus

Tue, 29 May 2012 02:00:10 GMT

While using NServiceBus on the first engagement at Readify, we had an interesting configuration. Development environment has a shared database which runs on a server but when creating the backend application, we're running NServiceBus on our local developer machines. When handling messages, NServiceBus creates an ambient transaction using MSDTC which spans multiple resources/machines and is of course a valuable feature because if an exception is thrown somewhere in your code when a message is being processed, database transactions (or any other DTC enlisted transactions for that matter) will automatically rollback so you won't have to write boilerplate code. This was problematic for us because DTC was not enabled on the database server so we couldn't test the application at all. We needed to tell NServiceBus not to use DTC around message consumers. You gotta love open-source projects because just by looking at the code we found out there is a property on TransactionalTransport named SuppressDTC which exactly does that, but how to set that?

You see, NServiceBus uses IoC containers to find its components, so in this case TransactionalTransport (an ITransport implementation) is created by the container, so we'd have limited access to where it is created or how it is being registered in the container and have no elegant way to set this property, but luckily we were using Castle Windsor container we could do much better with its extensibility model.

In case you don't know, Castle Windsor allows you to tap into creation of an object using ICommissionConcern (and a similar thing for when destroying an object). So all you needed to do to get called when an object of a certain type is created is to create a class implementing ICommissionConcern, which has only one method to implement. You also need to plug this class in and let the container know which component type is bound to this commission concern. This is done by implementing IContributeComponentModelConstruction interface and checking the interface or concrete type of the component that is being created. Too much said, you can see it all in one piece of code.

public class TransportTransactionConfig : IContributeComponentModelConstruction
{
    public void ProcessModel(IKernel kernel, ComponentModel model)
    {
        if (model.Implementation != typeof(TransactionalTransport))
            return;
	
        var concern = new TransactionSuppressConcern();
        model.Lifecycle.Add(concern);
    }
	
    private class TransactionSuppressConcern : ICommissionConcern
    {
        public void Apply(ComponentModel model, object component)
        {
            ((TransactionalTransport)component).SupressDTC = ShouldSuppressDTC;
        }

        private bool ShouldSuppressDTC
        {
            get { return bool.Parse(ConfigurationManager.AppSettings["SuppressDTC"]); }
        }
    }
}

Fun with Expression Trees

Mon, 21 May 2012 07:00:21 GMT

Logging is easy. We've all been there and done that, but when how do you log a request/response object of a webservice, specially when the WSDLs are being changed constantly? The requirements were easy, just log all the property names along with their values. The first obvious approach is the good old fashioned style:

public static string GetRequestLog(this ServiceRequest request)
{
    var sb = new StringBuilder();
    sb.AppendFormat("FirstProperty:{0}", request.FirstProperty);
    sb.AppendFormat("SecondProperty:{0}", request.FirstProperty);
    ... 
    sb.AppendFormat("LastProperty:{0}", request.LastProperty);
    return sb.ToString();
}

The problem is you code includes name and value of the property in two separate places and when you get an updated WSDL with most of the property names changed, you have to update two places, one of them being the property name in a string which makes it just harder to refactor and rename, but what can you do? You can shrug and say so be it, that is the problem at hand, until the next day you'll be handled the newer version of the WSDL, or you can do something about it.

If performance is not an issue (well you should know better to turn the debugging on in production), you can get away by passing in an expression of the property. This was you're passing in the property as well as it's value!

public static string GetRequestLog(this ServiceRequest request) 
{
    var sb = new StringBuilder();
    sb.AppendProperty(() => request.FirstProperty);
    sb.AppendProperty(() => request.SecondProperty);
    ...
    sb.AppendProperty(() => request.HundredthProperty);
    return sb.ToString();
}
    
public static class StringBuilderExtension
{
    public static void AppendProperty<T>(this StringBuilder sb, Expression<Func<T>> property)
    {
        var memberInfo = GetMemberInfo(property);
        sb.AppendFormat("{0}: {1}", memberInfo.Name, SafeToString(property.Compile().Invoke()));
    }

    private static MemberInfo GetMemberInfo(Expression expression)
    {
        var lambda = (LambdaExpression)expression;
        MemberExpression memberExpression;
        if (lambda.Body is UnaryExpression)
        {
            var unaryExpression = (UnaryExpression)lambda.Body;
            memberExpression = (MemberExpression)unaryExpression.Operand;
        }
        else
        {
            memberExpression = (MemberExpression)lambda.Body;
        }
        return memberExpression.Member;
    }

    private static string SafeToString(object obj)
    {
        return obj == null ? ("null") : obj.ToString();
    }
}

This of course is no magic these days, you probably have seen this when raising NotifyPropertyChange event in Caliburn or reading my blog post back in September 2008.

God Class and Helpers

Tue, 31 Jan 2012 14:29:24 GMT

While code reviewing a client's code base I found this gem.

Enough has been said about God Classes and Separation of Concerns but I still wonder how putting everything in one place and call it "Helper" can help you. Their argument? It is easier to find the function we are looking for if everything is in one class.

My Geek Origin Story

Thu, 19 Jan 2012 20:16:50 GMT

While spending my last days at my country and not working on an interesting project to blog about, I thought a post about how I happen to be what I am today is in order. While reading a blog post by Richard Banks, I was inspired to write my Geek Origin Story, a movement initially started by Michael Kordahi.

My dad used to work in department of power as an engineer as far as I can remember. I used to go with him to all power stations all around the country so eating out with other engineers and playing around gas turbines was something I was used to. Later when personal computers were taking off they grabbed one of the Siemens computers - they already had a lot of contracts with Siemens - and it was sitting there collecting dust in an office at the same floor as my dad's. The curious geek in me was getting itchy.

When I was only nine years old, on his visit to Italy my father brought home the best gift ever! A Casio PB-700 computer with four 4 KB memory modules, and it was attachable to an extension unit with a tape drive and a printer. With BASIC programming language built-in opportunities seemed endless. Ain't that a beaut?

Unfortunately the manual was in Italian, but I started pushing the program samples into it and somehow deciphered how it worked. Soon I was heading to my cousin's computer bookshop - almost one and the only bookshop dedicate to selling computer books in the capital city - to borrow or read a book or two. Around that time ZX-Spectrum were becoming more common and it supported another variation of Basic language. I had very hard time adjusting the samples for ZX-Spectrum books to run on my Casio computer but I managed to do it to some good extent and did a lot of PEEK / POKE in the making.

My next big computer was an Amiga 500. This one had a lot more juice in it and you could program it with C/C++, various Basic dialects, Pascal or other languages such as Oberon and Fortran - I barely knew any of them - but it also had a giant GPU so it suited very good for graphic applications. You see, personal computers back then mostly had a monochrome display and a command base OS while Amiga 500 had Graphical User Interface (GUI), a very rich music channels and a decent full-color monitor, so I was in for a good ride. This meant lots of Games, Music and Graphics, and did I mention games?

Once I was in high school my father ordered a 80-386 PC computer, with a 5 ¼” and 3 ½” floppy drives and 10 MB of hard disk! No it didn’t even have a mouse and no UI based OS. It ran MS-DOS 3.0 and it looked archaic comparing to my Amiga 500, but from the looks of how things were moving forward it seemed to be the future so I started reading more books and my cousin’s bookstore was a more common place. One of the best professional books I read was Dennis Ritchie's C programming language that put some sense into my brain.

By the time I was finishing high school, I helped the school's network administrator in removing the viruses or setup networking. After high school, being so fond of languages, I decided to study English language at university and learned French and Spanish - although not as good as I intended - in the process. Now although some find it strange and some other find it flat unacceptable, I see studying [real] languages has helped me lean computer languages and achieving my principal goal, which would have been next to impossible otherwise.

Well that was my geek story…what is yours?

Caliburn Meets TPL / Async

Tue, 18 Oct 2011 06:35:56 GMT

With C# and Async integration in the language, you'll wonder how this fits in your current application infrastructure. I have started porting an old application into Silverlight 5.0 which comes with new C# 5.0 and Async features and I needed a way to integrate this with the Calibrun framework I had in place.

Caliburn Async Abstractions

In Caliburn you could expose your ViewModel actions as IResult / IEnumerable<IResult>. I have blogged about this before, but in short, it is a good way to abstract away the whole async stuff you have in your ViewModel and it made testing async actions in the view model much easier. Here's a typical action I had on a ViewModel:

public IEnumerable<IResult> LoadEmployee()
{
    yield return Show.Busy();

    yield return new ServiceResult().Invoke(new EmployeeServiceClient().GetEmployeeAsync, SelectedEmployee.Id);

    yield return Show.NotBusy();
}

By using IResult we have modified the whole async and continuation into coroutines which is much cleaner to read and easier to follow.

Hello Async

Now with async stuff in the horizon, how would async / await fit this scenario? Let's suppose we have the following async method in our View Model:

private void LoadEmployeeAsync()
{
    var service = new EmployeeServiceClient();
    service.GetEmployeeCompleted += (s, e) => { CurrentEmployee = e.Result };
    var employee = service.GetEmployee(SelectedEmployee.Id);
}

At first we should convert this service call into the new async pattern:

private async Task<Employee> LoadEmployeeAsync()
{
    IEmployeeSevice service = new EmployeeServiceClient();

    return await Task.Factory.FromAsync<Employee>(client.BeginGetEmployee(SelectedEmployee.Id, null, null), ar => client.EndGetEmployee(ar));
}

A couple of things to notice: We are now using the interface of the generated service, which exposes IAsyncResult and we're returning the method call with a Task<TResult>. With the new async pattern, your method should either return void or Task / Task<T> before you can use the async keyword.

There's an IResult for that

Now the question is how to call the async method in a sequence of IResults. This would be the first attempt:

public IEnumerable<IResult> LoadEmployee()
{
    yield return Show.Busy();

    yield return new ActionResult(() => LoadEmployeeAsync());

    yield return Show.NotBusy();
} 

public class ActionResult : IResult
{
        public ActionResult(Action action)
        {
            ToExecute = action;
        }

        public Action ToExecute { get; set; }

        public override void Execute(ResultExecutionContext context)
        {
            ToExecute.Invoke();
            RaiseCompleted();
        }
}

Apparently this won't work as expected because as soon as we call the async method it will return and we'll fire the Completed event on IResult which will move to execution of the next IResult in the sequence. What we want to do is to wait for the completion of the Task and then raise the Completed event, so I came up with this implementation:

public class TaskResult : IResult
{
    public TaskResult(Func<Task> task)
    {
        ToExecute = task;
    }

    public Func<Task> ToExecute { get; set; }

    public override void Execute(ResultExecutionContext context)
    {
        ToExecute.Invoke().ContinueWith(task => 
         {
             Execute.OnUIThread(() => RaiseCompleted(task.IsCanceled, task.Exception));
         });
    }
}

This is just the same API that is available today on TPL, so nothing fancy, the only thing worth mentioning here is that we're raising the Completed event on the UI thread using Execute class of Caliburn. The Execute class uses IDispatcher interface that wraps Silverlight / WPF dispatcher object. The final version of the TaskResult can be used like this:

public IEnumerable<IResult> LoadEmployee()
{
    yield return Show.Busy();

    yield return new TaskResult<Employee>().Invoke(LoadEmployeeAsync).ContinueWith(task => CurrentEmployee = task.Result);

    yield return Show.NotBusy();
}

This now fully supports calling Task or Task<T> methods and also has its own continuation support. This works right alongside other IResult implementations. Ideas?

Introduction to WF Designer Rehosting - Part Three

Mon, 26 Sep 2011 18:06:04 GMT

In previous posts we saw how to bind our designer properties to our activity and use VB.NET syntax for more complex values. In this post let's see how to show variables and work with namespaces.

Importing Namespaces
If you want to use certain types in your Xaml, you need to import necessary namespaces, as an example our List<T> type is in Sysem.Collections.Generic namespace which needs to be imported for a valid WF Xaml. Let's see how this is done. When creating the WorkflowDesigner control, you initially need to create an empty workflow, like an empty Sequence or Flowchart and feed it to the Load method of the WorkflowDesigner:

private void CreateDesigner()
{
    designer = new WorkflowDesigner();
    designer.Load(CreateDefaultSequence());
    designer.Flush();
}

public Sequence CreateDefaultSequence()
{
    var seq = new Sequence {DisplayName = "Empty Sequence"};
    var settings = new VisualBasicSettings();
    var references = new VisualBasicImportReference {Assembly = "System", Import = "System.Collections.Generic"};
	
    settings.ImportReferences.Add(x));
    VisualBasic.SetSettings(seq, settings);

    return seq;
}

Although user can import necessary namespaces using the designer, it'd be ideal to automatically import mostly used namespaces upon designer startup.

Note: Load method of designer accepts "Object" which is ambiguous as the only type of objects I managed to feed it was ActivityBuilder, Sequence and Flowchart.

Displaying Variables
Sometimes you need to allow user to select an existing variable name and bind it to a property of your Activity. How do you do that? Remember the ModelItem property on your designer? The ModelItem property is hierarchical so traversing this you can gain access to the root element of your workflow (here we use a SequenceActivity) where defined variables can be found. ModelItem also has information about the type of the property so you can just select properties of certain type. The following extension method finds all available variables, regardless of their types:

public static IEnumerable<ModelItem> FindAllVariables(this ModelItem selectedItem)
{
    var variables = new List<ModelItem>();
    while (selectedItem.Parent != null)
    {
        Type parentType = selectedItem.Parent.ItemType;
        if (typeof(System.Activities.Activity).IsAssignableFrom(parentType))
        {
            var mp = selectedItem.Parent.Properties["Variables"];
            if (mp != null && mp.Collection != null && mp.PropertyType == typeof(Collection<Variable>))
            {
                mp.Collection.ToList().ForEach(variables.Add);
            }
        }
		
        var dels = selectedItem.Properties.Where(p => typeof(ActivityDelegate).IsAssignableFrom(p.PropertyType));
        foreach (var actdel in dels)
        {
            if (actdel.Value != null)
            {
                foreach (var innerProp in actdel.Value.Properties)
                {
                    if (typeof(DelegateArgument).IsAssignableFrom(innerProp.PropertyType) && null != innerProp.Value)
                    {
                        variables.Add(innerProp.Value);
                    }
                }
            }
        }
        selectedItem = selectedItem.Parent;
    }

    return variables;
}

Now to make this easier, let's think what is it that we want to select? We need the name of the variable, along with related ModelItem information, so let's create a Model class to contain this information:

public class VariableItem : Observable
{
    public VariableItem(string name, ModelItem variable)
    {
        Name = name;
        Variable = variable;
    }

    public string Name { get; set; }

    public ModelItem Variable { get; set; }
}

It is easier now to bind a ComboBox to a list of VariableItem instances. All we need to do is to get all the variable of certain types (or all the variables, regardless of their types) as a list of VariableItems and bind it in the designer. This extension method will do the trick for you and has both generic and non-generic flavors:

public static IEnumerable<VariableItem> FindVariableOfType(this ModelItem selectedItem, Type typeToFind)
{
	var variables = FindAllVariables(selectedItem);
	var found = new Dictionary<string, ModelItem>();

	variables.ForEach(x =>
	{
		var name = x.Properties.GetValue<string>("Name");
		var type = x.Properties.GetValue<Type>("Type");

		if (type == typeToFind)
		{
			found.Add(name, x);
		}
	});

	return found.Select(x => new VariableItem(x.Key, x.Value));
}

public static IEnumerable<VariableItem> FindVariableOfType<T>(this ModelItem selectedItem)
{
	return FindVariableOfType(selectedItem, typeof (T));
}

Notice ModelItem has information about the variable, like name of the variable and the underlying type of the variable. In next post we'll see how to use complex objects in our activities and how to fill and serialize them to / from xaml from our custom designers.

Introduction to WF Designer Rehosting - Part Two

Mon, 26 Sep 2011 18:05:53 GMT

In first part of this serie we saw how to bind our designer properties to activity properties and create a custom designer for our activity. Let's see how to bind to activity properties through the designer and allow user to enter values in the designer.

If you have some experience with WF Activities you know that input properties are of type InArgument<T> so how do we convert and bind our regular types to a InArgument<T>?

Let's go with simple types like String, supposing our SendTo activity has an Enabled property of type InArgument<bool> and we have a CheckBox on our designer. First approach would be to bind directly through ModelItem property of the designer, inherited from the base class by using a ValueConverter:

<CheckBox IsChecked="{Binding Path=ModelItem.IsEnabled, Mode=TwoWay, Converter={StaticResource ValueToInArgumentLiteralConverter}}" />

public class ValueToInArgumentLiteralConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        if (value != null)
        {
            var modelItem = value as ModelItem;
            if (modelItem != null)
            {
                var expr = modelItem.Properties["Expression"];
                if(expr != null)
                {
                    return expr.Value;
                }
            }
        }

        return null;
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        if (value == null) return null;

        var type = typeof (InArgument<>);
        var genericArgument = type.MakeGenericType(value.GetType());
        var argument = Activator.CreateInstance(genericArgument, value);
			
        return argument;
    }
}

This approach works fine but only for simple scenarios. If you want more control on selected properties, changing values, having dependent properties or if your designer UI is complex, I advise using a ViewModel instead. You can access current ModelItem from your view:

public interface ISendToDesigner
{
    ModelItem ModelItem { get; }
}

public class SendToViewModel 
{
    public virtual dynamic SelectedModelItem
    {
        get { return View != null ? View.ModelItem : null; }
    }

    public virtual bool IsEnabled
    {
        get { return isEnabled; }
        set
        {
            isEnabled = value;
            RaisePropertyChanged(() => IsEnabled);
            UpdateModelProperties();
        }
    }

    private void UpdateModelProperties()
    {
        SelectedModelItem.IsEnabled = IsEnabled.ToInArgument();
    }
}

Did you see SelectedModelItem is of dynamic type? Exposing underlying ModelItem as dynamic allows us to directly assign properties without going through indexers. This trick results in much cleaner and better maintainable code, supposing you have unit tests for your view models! Also I'm using an extension method named ToInArgument which converts the primitive values to InArgument. Here's the extension method:

public static InArgument<T> ToInArgument<T>(this T value)
{
    return new InArgument<T>(value);
}

This works for primitive values but what if you have Enums, Guids, Lists or Dictionary properties on your Activity? Unfortunately though this seem to work, it won't and designer shows an error. The alternative would be to use VisualBasicValue<T> instead. If you are a C# developer, welcome yourself to the world of VB.NET!

Seems VisualBasicValue<T> can be assigned as InArgument<T> so you just need to convert your values to a VisualBasicValue. This approach works file with Enums as well, too bad you can not create an extension method with Enum constraint. Here's an extension method that converts your enum to VisualBasicValue:

public static InArgument<T> ToExpression<T>(this T value)
{
    return new VisualBasicValue<T>(string.Format("{0}.{1}", typeof(T).Name, value));
}

Now List and Dictionaries are a little bit different. Let's see how I convert List<Guid> to a VisualBasicValue and you can use the same approach to make it work for all generic types:

public static InArgument<List<Guid>> ToExpression(this List<Guid> list)
{
    var expr = "New List(Of Guid) From {{{0}}}";
    var item = list.Select(i => string.Format("New Guid(\"{0}\")", i));
    var items = string.Join(",", item);

    return new VisualBasicValue<List<Guid>>(string.Format(expr, items));
}

On the next part of this post, we'll see how to allow user to select existing variables (of a specific types) and import needed namespaces into our workflow xaml.

Introduction to WF Designer Rehosting - Part One

Mon, 15 Aug 2011 17:32:53 GMT

I've recently been creating custom designer for Workflow Activities and hosting the whole WF designer in a web application. As there is very limited documentation and guide other than Microsoft Forums, here I'll try to shed some lights to some of the problems I have encountered.

WF 4.0 designer is a set of WPF controls and classes designed with re-hosting in mind, so hosting the designer in an XBAP application works to some extent without any pain. To start create a WPF (either browser or desktop) application that will be used as your WF Designer. There are a couple of controls you can add to your main window that make it look like out of the box designer:

Toolbox Control: Is the toolbox control that contains your activities. You can create Categories and place your own and system activities into separate categories.

Workflow Designer: Is the control that does all the heavy lifting like hosting the activities, generating xaml, loading and saving, etc.

Property Editor: Workflow designer has a UIElement that is the property editor you can use to edit properties of the workflow/activity.

Let's say you have a Send activity that sends out an email to selected recipients. You need to create a custom designer for the activity. The good thing is you don't need to anything to the source code of the activity, thanks to IRegisterMetadata interface, you can add attributes to your activities from the outside. For those familiar with WPF Design Time integrations, this is the same thing. To add necessary designer attribute to your Activity, you should do something like this:

public class SendToRegisterer : IRegisterMetadata
{
    [SecurityCritical]
    public void Register()
    {
        var builder = new AttributeTableBuilder();

        builder.AddCustomAttributes(typeof(SendTo), new DesignerAttribute(typeof(SendToDesigner)));
        builder.AddCustomAttributes(typeof(SendTo), "Receiver", new BrowsableAttribute(false));
        builder.AddCustomAttributes(typeof(SendTo), "Subject", new BrowsableAttribute(false));
			
        MetadataStore.AddAttributeTable(builder.CreateTable());
    }
}

There are two things happening here: First we set the designer of SendTo activity to SendToDesigner, then we set BrowsableAttribute with False value to the properties of SendTo. This makes the properties hidden on the property editor so you can make sure user can only interact with your activity through the designer.

To create the designer class you need to create a WPF UserControl and make it derive from ActivityDesigner in http://schemas.microsoft.com/netfx/2009/xaml/activities/presentation namespace. Among many things, this base class has a ModelItem property that allows interacting with the activity that is being displayed. You can bind activity properties to your designer directly using this property or alternatively bind the designer UI to your ViewModel and update the ModelItem property when you want to replicate the changes to the Model Item and update / generate WF Xaml.

On the next post, we'll see how to bind designer UI to our activity properties.

Installing Microsoft Dynamics on a XP machine

Wed, 06 Jul 2011 09:10:42 GMT

The other day, I was starting a new gig to integrate an in-house sales system with Microsft Dynamics and naturally I needed to install MSDynamics on my machine. The best option was to install it on a VM so that I get rid of it after the project is done. I decided to install it on a Windows XP machine that needs less resource to run, but I bumped into something interesting:

It seems Micorosft Dynamics only installs on your machine if you have connected to a domain controller. But I don't have any domain controller, now what?

The first solution is to download and install a [trial] version of Windows Server 2003/2008, add your XP machine to the domain, install, and then you are free to kill the domain controller altogether, but all these efforts just to install an application seems ridiculous.

A better solution was to modify registery keys to fool your OS and make it think you are connected to a domain controller, but the server is not reachable at the moment! To do this, go to this registery key:

HKLM\System\CurrentControlSet\Control\ComputerName\ActiveComputerName

Enter any new name e.g. "VM" into this registery key. Now you also need to set an environment variable. You can do this using command prompt or by going to Control Panel, System, System Properties, Environment Variables. Add a new environment variable under System variables. The variable key is "UserDnsDomain" and you need to enter the same value you have entered in the registery key. You are all set. Run the installation and it will work this time. Remember to revert the registery key back to its original value when you are finished installing.

One day in Kanban Land (Farsi)

Mon, 20 Jun 2011 08:39:12 GMT

If you are into agile methodologies, you probably have seen the comic strips "One Day In Kanban Land" by Henrik Kniberg. He discussed it in mode depth with us in his Scrum Master course a while ago. This is the Farsi translated version. If you have seen the original one, or don't speak Farsi, you may skip this post.

WPF Application with Caliburn - Part Four

Mon, 06 Jun 2011 05:27:30 GMT

This is the next serie in the Caliburn tutorials. You can find previous post: Part One, Part Two, Part Three

One of the best features of Caliburn framework that I haven't seen in other MVVM frameworks, is a feature called Coroutines. Coroutines are according to Wikipedia:

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

This feature is extremely useful if you do async programming like accessing data over a webservice or execution of long running tasks on the background thread. Let's take a closer look on how to use this feature and how it helps us developing better applications and results in more maintainable code.

Note: This post will work equally on Caliburn 1.1 and 2.0.

A Recap on Actions
If you have seen other parts of Caliburn posts, Caliburn facilitates implementing MVVM by eliminating usage of ICommands. Forget about implementing ICommand interface or using RelayCommands. You can not directly bind your events to public actions on your ViewModel class. You no longer are limited by controls having commands, you can bind any arbitrary event to any public method on your ViewModel. Caliburn also checks for any existing preconditions based on the convention. The precondition, called Filters, are properties name the same as your action, but with a "Can" prefix. Here's how it looks to bind:

<Button cal:Message.Attach="[Event Click] = [Action ShowCustomers]">

public virtual bool CanShowOrders 
{
    get { return _canShowOrders; }
    set 
    {
        _canShowOrders = value;
        NotifyOfPropertyChanged(() => CanShowOrders);    
    }
}

public virtual void ShowOrders()
{
    CurrentPresenter = ViewModelFactory.Create<IOrderViewModel>();
}

Using Coroutines
Your action that used to return void can return a special return type that will be handeld by Caliburn upon execution. If your method returns an instance of IResult interface it will be treated differently. First let us look at IResult interface:

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

Very simple to implement! Basically, Execute method is called by Caliburn and this is where you implement the execution logic of this action. Caliburn then pauses unitl your action fires "Completed" event at which point it understands that action has compeleted and is finished. Where's the power, you may ask? Well you can send multiple IResults instanced from your action method by returning an IEnumerable<IResult> and since Caliburn waits for each action to fire its Completed event, all IResult instances are processed sequentially. An example is displaying a progress window, firing up a background worker to do a long running process data and stop progress window when the background worker is finished, let's see how:

public IEnumerable<IResult> LoadOrders()
{
    yield return ProgressResult.Show("Loading Orders");
    yield return new ServiceFetchResult(...);
    yield return ProgressResult.Hide();
}

And the outcome is that the progress window is still showing until ServiceFetchResult has finished the long running procedure.

Remember how specially IResults are treated. In the above example, enumerable items are only processed if the previous one's Completed event is fired. This helps a lot when you do async style programming, specially in Silverlight which almost every outgoing request should run asynchronously.

Testability
If you have used an async service, you know how painful it is when it comes down to testing. The problem is how the Async model works, and the easiest way is the same way you connect to webservices in Silverlight: First you subscribe to the event that is called when operation is completed, then you call the async method and wait for it to call you back on the callback handler. If you want to abstract it in an interface, it'd be something like this:

public class FetchOrdersCompletedEventArgs : AsyncCompletedEventArgs
{
    public FetchOrdersCompletedEventArgs(Exception error, bool cancelled, object userState) 
        : base(error, cancelled, userState)
    {
    }
}

public class OrdersDataClient
{
    public void FetchOrdersAsync()
    {
        //some stuff
    }

    public event EventHandler<FetchOrdersCompletedEventArgs> FetchOrdersCompleted;
}

The problem with this code which makes it unsuitable for testing is that you usually generate proxies for your services and this piece of generated code has numerous problems: there's no clean interface and even generated methods are not virtual, making the whole thing unreplaceable in testing (at least by conventional tools). Notice that this implemnentation of async pattern which uses events is much cleaner than the one using IAsyncResult and callbacks, but still not much good in unit testing.

Now lets sit back and see what is it that we want to test? Let's suppose we want to test that LoadOrders will load orders from the correct service operation, how would we do that?

[Test]
public void Orders_Are_Loaded_From_Service()
{
    var mockService = Mock<OrdersServiceClient>();

    var vm = new OrderViewModel(mockService);

    vm.LoadOrders();

    mockService.AssertWasCalled(x => x.FetchOrdersAsync());
}

This code would have worked unless you can't mocked out the service that easily, remember? Now here's how using IResult would help you test the same thing, but with a changed mindset:

[Test]
public void Orders_Are_Loaded_From_Service()
{
    var vm = new OrderViewModel();

    var results = vm.LoadOrders().ToList();
    var fetchRequest = results[1] as ServiceFetchResult;
            
    Assert.NotNull(fetchRequest);
    Assert.That(fetchRequest.Action.Method.Name, Is.EqualTo("FetchOrdersAsync"));
}

Conclusion

If you need to go through this in more detail, feel free to grab the source code of this part from here. This one uses the latest Caliburn 2.x version. We'll cover how to migrate from version 1.5 in the next post.

Farsi Library - Version 2.0 now available

Fri, 27 May 2011 12:08:12 GMT

Version 2.0 of FarsiLibrary is now available. The following changes are made in this release :

Modified : Migrated to Visual Studio .NET 2008. Still using .NET Framework 2.0, so you just need the new IDE to compile. Might affect clients using old .NET Framework 2.0 (without the new SP Installed).
Modified : IComparer and IComparer are converted to explicit implementation in PersianDate class.
Modified : ICloneable interface implementation is converted to explicit implementation in PersianDate class.
Modified : Assign method of PersianDate to internal.
Modified : Changed the Day/Month/Year change eventhandler type to EventHandler. You can use the New/Old value properties to access the underlying values.
Modified : FALocalizeManager now is a singleton class. Use the Instance property instead of static methods.
Modified : FAMessageBoxManager.Delete method now returns boolean value based on whether the delete operation was successful or not.
Added : Implementation of IsLeapMonth method in PersianCalendar.
Added : Solution Items folder.
Added : Partial Office 2007 Blue theme. Drawing of dropdown buttons of FADatePicker control need a better visualization.
Added : PainterFactory to create painters based on the state of BaseStyledControl.
Added : FAMessageBox now implementes IDisposable interface explicitly. Dispose method is made internal.
Fixed : When changing the culture, Year value didn't change, e.g. when in Farsi culture in year 1385 culture is set to english, the year remain 1385 (which was a valid year in English calendar).
Fixed : When changing the DefaultCulture property, Day and Month properties did not return the culture-specific values.

Fixed : A bug when accessing Now property of PersianDate class.

Please report any bug you might encounter. You can download the source code from here and the binary (including test project executables) from here.

More information about this project can be found on my Code Project article at here.

Resharper 4.0 Released

Fri, 27 May 2011 11:57:18 GMT

You need to wait no longer! Resharper 4.0 is here.

Besides Support for C# 3.0, LINQ and XAML, which is great, there are lots of other enhancements in this release which makes it a "Must Have". Did I mention my little favorite feature, CamelHumps is also there? To get your hands dirty and know what's new in this release, check the Product's overview page here.

NHibernate 2.0 Released

Fri, 27 May 2011 11:56:43 GMT

The good news, after not-so-good news about Reflector, is that NHibernate 2.0 is finally released. This version's feature is comparable with Java Hibernate 3.2 so, this might be a giant step forward. If you're new to NHibernate, you definitely want to check out the http://www.summerofnhibernate.com web site, which contains screencasts that will minimize your learning curve. There'll be some sessions regarding new features of NHibernate 2.0, so keep an eye out.

Enhanced INotifyPropertyChanged - Revisited

Fri, 27 May 2011 11:55:02 GMT

A while a go, I had a post regarding how to implement the INotifyPropertyChanged event in a more proper fashion. You didn't have to hard-code the property name, and could instead use a linq expression, which with a help of an extension method, the name of the property is easily extracted, and passed to raise the PropertyChanged event. Simple, right?

public static class EventExtension
{
  public static void Notify<T, TValue>(this T instance, PropertyChangedEventHandler handler, Expression<Func<T, TValue>> selector)
     where T : INotifyPropertyChanged
  {
      if (handler != null)
      {
          var memberExpression = selector.Body as MemberExpression;
          if (memberExpression == null)
              throw new InvalidOperationException("selector should be a MemberExpression.");

          handler(instance, new PropertyChangedEventArgs(memberExpression.Member.Name));
      }
  }
}

public abstract class NotificationAwareBase : INotifyPropertyChanged
{
  public event PropertyChangedEventHandler PropertyChanged;
}

public class Customer : NotificationAwareBase
{
  private string _Name;

  public string Name
  {
      get { return _Name; }
      set
      {
          _Name = value;
          this.Notify(base.PropertyChanged, o => o.Name);
      }
  }
}

Should work like a charm, right? WRONG! you'll end up with a compile time error. It is like the extension method does not like my inherited PropertyChanged event. The drawback to the latter method was that you could not use it in inheritance context.

I need to implement INotifyPropertyChanged only once (Layer Supertype, anyone?). I had to come up with something to be able to work in inheritance context. Finally, here's it :

public abstract class NotificationAware : INotifyPropertyChanged
{
  private event PropertyChangedEventHandler propertyChangedEvent;

  public event PropertyChangedEventHandler PropertyChanged
  {
      add
      {
          propertyChangedEvent += value;
      }
      remove
      {
          propertyChangedEvent -= value;
      }
  }

   protected void Notify<T>(T obj, Expression<Func<T, object>> selector)
  {
      if (propertyChangedEvent != null)
      {
          MemberExpression memberExpression = selector.Body as MemberExpression;
          if (memberExpression == null)
          {
              UnaryExpression unary = selector.Body as UnaryExpression;
              if (unary != null)
              {
                  memberExpression = unary.Operand as MemberExpression;
              }
          }

          if(memberExpression == null)
              throw new ArgumentException("member should be of MemberExpression type", "selector");
        

          propertyChangedEvent(this, new PropertyChangedEventArgs(memberExpression.Member.Name));
      }
  }
}

public class Customer : NotificationAware
{
  private string _Name;
  public string Name
  {
      get { return _Name; }
      set
      {
          _Name = value;
          Notify(this, o => o.Name);
      }
  }
}

Happy coding!

L2S : Tale of an abandoned project

Fri, 27 May 2011 11:51:11 GMT

ADO.NET team announced that there will be no further development on Linq2Sql and investments on data access solution with Linq technology will be made on Entity Framework instead. The irony is that the Linq2Sql probably will not be removed from the next release of .NET Framework, because of backward compatibility, so it will not be completely dead! More users are likely switch to open-source ORM solutions like NHibernate, specially with Linq for NHibernate in the horizon.

Farsi Library 2.1 RC 2

Fri, 27 May 2011 11:49:18 GMT

Farsi Library RC 1 which released a few days ago, contains a new functionality : PersianCultueInfo. You can run your application setting an instance of this culture info on your application thread and you get the benefit of having a correct calendar for your application. Why is this important, you might say? Well, you'll have all the date related controls rendered to you in correct dates! Take a look :

Now, there was a bug in RC 1 regarding mapped week days in PersianCalendar, that is fixed in RC 2. So, if you intend using PersianCultureInfo, you're strongly advised to use RC 2. For more info about Persian Calendar problem see here.

Like before you can grab the files here.

Farsi Library - FAQ

Fri, 27 May 2011 11:47:42 GMT

A lot of people keep asking me to provide a VB.NET Sample on how to use Farsi Library component. The library is written in C# after all and no sample code is provided to demonstrate VB.NET usage. This post is not a tutorial to Farsi Library per se. I'm answering some of the question regarding VB.NET usage, and some common questions about Farsi Library you've kept asking.

Yet, there are still some people don't know how to create an explicit Main method in VB.NET, so if this post is a low-level for you professionals, just skip this post ;)

Q : I'm using VB.NET but there's no main method to set my thread's culture!

A : Since everything supposed to be easier in VB.NET, you normally do not create an entry point for an application written in VB.NET, but only select a form which is the startup form of your application. To have more control on application initializations, you need to write the application entry method as well. Simply add a new Module (e.g. Named Program) and add a method to initialize and run the main form :

Public Module Program
<STAThread()> _
Public Sub Main()
    Application.SetCompatibleTextRenderingDefault(True)
    Application.EnableVisualStyles()
    Application.Run(New MainForm())
End Sub
End Module

To actually use this Main method, open the Project's properties by double-clicking on "My Project" in solution explorer and in the Application Tab, uncheck the check box that reads "Enable Application Framework" and set your startup object as "Sub Main".

Now when running your application, the main form is created through the Main method in Program class. You can set a breakpoint to check if it is working. Easily add any additional initialization logic to the Main method. To set the running thread's Culture use this code :

Imports System.Threading
Imports System.Globalization

Public Class Program
<STAThread()> _
Public Shared Sub Main()
    Thread.CurrentThread.CurrentUICulture = New CultureInfo("fa-ir")
    Thread.CurrentThread.CurrentCulture = New CultureInfo("fa-ir")

    Application.Run(New MainForm())
End Sub
End Class

Q : I'm running a form with Farsi Library controls. All the dates are in Gregorian calendar.

A : You need to set the running thread's culture information to "fa-ir" culture to see the Persian Calendar information. For Arabic calendar, use "ar-sa" culture.

Q : I've downloaded the source files but it won't compile. When compiling the sources VS.NET says the license key is missing.

A : Farsi Library is an open source project. There's no such thing as license key in this project. To be able to use the compiled dll in certain scenarios (Putting them in GAC, etc.) you need to specify a key which VS.NET uses to sign the built assemblies. If you get the latest version of the source code, the key file is included.

Q : How can I use the Farsi Library on a Web Site or Web Project?

A : I was going to provide an ASP.NET Server control in one of the first releases, but since my web project was canceled, there's no ASP.NET control available. However, you can use the FarsiLibrary.Utils project to convert dates on a web project.

Q : I have downloaded the binary files. What should I do with them? How can I use the controls?

A : First, put the dll files somewhere near your solution / project (e.g. in a Lib folder). Then, you should add controls to VS.NET Toolbox. To do this, open the Toolbox window, right-click and select "Choose Items..." from the menu. On the next dialog, select "Browse..." button and select the "FarsiLibrary.Win.dll" file (or "FarsiLibrary.WPF" if you're working on a WPF project). All the controls will be added to your toolbox. You can simply drag-and-drop them on your form.

Q : I'm working on an application that uses a Database to store dates. On the UI I need to display dates in Persian Calendar. What should I do?

A : Since you only need to "display" the dates in Persian Calendar, you can use DateTime data type on your entities as well as in your database designs. On the front-end, you can use FarsiLibrary controls which will bind to Business Entities, or DataSets, to display the DateTime value in Persian Calendar. You don't need to (and you're strongly advised not to!) use string data type (or other types) to support dates in Persian or other Calendars.

Q : What type of look and feel does the control support?

A : Controls support System Theme (Windows XP, Vista, etc.) plus Office 2000, Office 2003, and partial Office 2007 themes. You can set each control's theme using Theme property, or use the global theme manager :

FAThemeManager.Theme = ThemeTypes.Office2007

Q : How do I change the strings used in controls? How can I localize the strings?

A : Create a class and inherit from one of the available Localizer classes in FarsiLibrary.Resources namespace. Override GetLocalizedString method and provide a suitable representation for StringIDs you want. Later set the instance of your localizer on FALocalizeManager :

Public Class ESLocalizer
Inherits ENLocalizer

Public Overrides Function GetLocalizedString(ByVal id As Resources.StringID) As String
    Select Case id
        Case StringID.Validation_NullText
            Return "<Ningun fecha esta seleccionada>"
        Case StringID.FAMonthView_None
            Return "Nada"
        Case StringID.FAMonthView_Today
            Return "Â¡Hoy!"
    End Select

    Return MyBase.GetLocalizedString(id)
End Function
End Class

FALocalizeManager.Instance.CustomLocalizer = New ESLocalizer()

Q : I want to use the controls in another calendar. Can I use other cultures (e.g. "es-ES" culture) when using these controls?

A : To globally change the culture set an instance of your culture on CustomCulture property of FALocalizeManager :

FALocalizeManager.Instance.CustomCulture = New CultureInfo("es-ES")

Q : How can I do validation to check if a selected date is correct? How do I restrict the selection to a specific date range?

A : Use the SelectedDateTimeChanging event and set the e.Cancel to true. You can also set an error message on e.Message :

Private Sub faDatePicker_SelectedDateTimeChanging(ByVal sender As System.Object, ByVal e As FarsiLibrary.Win.Events.SelectedDateTimeChangingEventArgs) Handles faDatePicker2.SelectedDateTimeChanging
Dim pd As PersianDate = e.NewValue

If pd.Day <> 20 And Not faDatePicker2.IsNull Then
   e.Message = "Invalid date. Default Date is applied."
   e.NewValue = New DateTime(2010, 1, 20, 0, 0, 0)
End If
End Sub

Q : How can I custom draw a certain day in calendar? How can I draw the holidays in red?

A : You need to plug-in your drawing logic on DrawCurrentDay event. You have access to Day / Month / Year values as well as Graphics object. A Rectange representing date bounds is also available. Remember to set the IsHandled to true if you want to override the base class drawing logic :

Private Sub faMonthView_DrawCurrentDay(ByVal sender As System.Object, ByVal e As FarsiLibrary.Win.Events.CustomDrawDayEventArgs) Handles faMonthView.DrawCurrentDay
If e.Date.DayOfWeek = DayOfWeek.Friday Then
    Dim br1 As New SolidBrush(Color.Wheat)
    Dim br2 As New LinearGradientBrush(e.Rectangle, Color.PaleVioletRed, Color.DarkRed, 45, True)
    Dim fnt As New Font("Tahoma", 8, FontStyle.Bold)
    Dim fmt As New StringFormat
    Dim dayNo As String = e.Day

    fmt.Alignment = StringAlignment.Center
    fmt.LineAlignment = StringAlignment.Center

    e.Graphics.FillRectangle(br2, e.Rectangle)
    e.Graphics.DrawString(dayNo, fnt, br1, e.Rectangle, fmt)

    br1.Dispose()
    br2.Dispose()
    fnt.Dispose()
    fmt.Dispose()

    e.Handled = True
End If
End Sub

Q : How do I convert dates from / to PersianCalendar to / from Gregorian Calendar?

A : You can convert instances of DateTime directly to PersianDate values, which represents their equivalance in PersianCalendar :

Dim pd As PersianDate = CType(DateTime.Now, PersianDate)
lblCastTo.Text = pd.ToString("G")

Dim dt As DateTime = CType(PersianDate.Now, DateTime)
lblCastFrom.Text = dt.ToString("G")

If you're using PersianCultureInfo (which uses standard .NET Framework Persian Calendar), you have access to all standard DateTime formattings as well. See MSDN page for standard and custom date formattings.

Q : I need to do calculations in Persian Calendar. I need to add / remove days to / from specific day in the Persian Calendar.

A : You can use the PersianCalendar class provided in .NET Framework to do so. There's an internal implementation of PersianCalendar in FarsiLibrary.Utils namespace which originally was historically developed before PersianCalendar appearing in .NET 2 :

Dim calendar As New PersianCalendar()
Dim pd = New PersianDate(calendar.AddYears(DateTime.Now, 10))
lblMessage.Text = pd.ToString()
lblToWritten.Text = pd.ToWritten()

You can download VB.NET code related to this FAQ from here.

Resharper : The Most frequently used feature

Fri, 27 May 2011 11:44:19 GMT

A while a go, Rory asked me to blog about Resharper add-in for Visual Studio.NET and which shortcut keys I use the most. This one has been waiting on my draft list for a couple of weeks now. This post is about Resharper shortcuts I mostly use.

Resharper is one the most advanced and useful add-in available for Visual Studio .NET. I've started using the tool when they published their release for Visual Studi 2003. Back then, Resharper added lots of feature and brought productivity to the IDE which without them, your programming life would have been a nightmare.

The problem with Resharper though, is that it has become so big and featureful, that is won't be possible to use it in large scale projects. We have a bloated Solution containing about 80 projects that started back in 2003 with only 10-12 projects. When I open the project in VS with Resharper running, the files with 2-3K LOC make Resharper run out of memory. 2-3K LOC might sound unrealistic to you, but automatically generated codes like DataSets or Forms code behinds are usually this large. So, it'd be a good idea if we could disable some Resharper features to gain some more speed, e.g. disabling code analysis in .Designer files, disabling XAML analysis, etc.

As said before, there are a lot of features in Resharper, which makes your programming experience a pleasant one. Here I'm only pointing to some of the ShortCut keys I mostly use.

Find Usage Window (Alt + F7)

I'm Sure you've tried to figure out how / where an interface is implemented, or where instance of a certain class is being used, or other similar scenarios. If you use plain VS, you have no other choice than to use "Find All References". That will work, but it takes time every time you do a search like this. This is due to the fact that VS does not keep an index of your application structure, but since Resharper does, you'll gain a lot of speed when doing these kind of operation.

Also, the "Find Usage Window" is more rich in Resharper than VS. You can sort and group the results based on Namespace, Usage, File, Folder, etc. and filter by Read, Writer, Invocation, etc. but in VS all you see is a flat search result. One of the great things about Find Usage function is that it actually finds the usage in Xaml code too!

Using Hints and Red / Yellow Bulb (Alt + Enter)

Resharper has a good way of letting you know that you can do something better, by displaying "Hints". Hints let you know if you've forgotten to import a namespace, if there's a refactoring available or suggest a context action. There are lots of things you can do in Resharper, just by pressing Alt + Enter! Some of them are :

Change scope of the Class or Method
Create overload for a method / Check if the variable is null
Create derived types
Import missing namespace / remove unused namespace
Implement an interface / abstract class
Change property to Automated property and vice versa
Invert if statement / Convert to conditional statement and vice versa
Join / Split declaration and assignment of the variable
Introduce variable / use var keyword
Generate body of the switch statement

...and a lot more. Depending on where the cursor is in the editor, where you click and the code you have written, you may get different options.

Goto Type / File (Ctrl + N, Ctrl + Shift + N)

If you're looking for a specific file in your large project or if you're using multiple class per file strategy, you might get lost easily. If you need to know where that file is located, or in which file you class resides, you can use these shortcuts to get you there. The "Goto Type" function has support for a feature called CammleHumps. Using this feature, if you're looking for OrderApprovalService, you can search for OAS instead and Resharper will find it for you.

Code Completion and Type Lookup (Ctrl + Space, Ctrl + Alt + Space)

When you're working with large libraries you may easily get lost. Sometimes you know the name of type you're going to use, but can't remember the darn namespace! This shortcut will help you find the type you are looking for in ALL the namespaces in an easy to use fasion.

Code Generation (ALT + Ins, Ctrl + J)

The code generation feature in Resharper is just great. You can use the primary code generation function by ALT + Ins that will let you generate :

Constructors
Properties / Readonly Properties from backing fields
Implement Method / Property stubs for an Interface
Override base class Methods
Provide equality implementation (Equality Operators, IEquatable<T> interface, overriding Equals and GetHashCode methods)

While this is great, Resharper gives you the power to write your own snippets! A lot of people have already created snippet templates for Resharper to create Unit tests, Mocks, NHibernate, ActiveRecord and WPF stuff, etc.

You can download Resharper templates on Joey Beninghove's blog, or see what other people use on StackOverflow page.

Summary

There is a document on JetBrain's website that shows all the ShortCut keys you'll ever need to know. Intense Resharper users might need to hang it on their wall. There are lots of other features I use like Unit Test Runner, Stack Trace browser, File Structure window, and ToDo List, but that's for another post. Do you use productivity tools too? Which one? Which feature do you use the most?

Java & .NET Integration : Who is Who?

Fri, 27 May 2011 11:43:48 GMT

There's a new kid on the block! An effort to port Java frameworks to .NET is not a new thing and it's been around since the early days of .NET 1, but integration of .NET Framework and Java Development Kit (JDK) is something I'm not used to see everyday! The new project named Ja.NET enables you to use first class development and runtime environment for .NET in which you use supposedly can use your existing Java SE code base and knowledge but also leverage existing functionalities available .NET Framework!

Ja.NET provides you with equivalence of Java 5 SE SDK implemented from scratch, JDK tools, class libraries and .NET CLR runtime environment. Also you can use available functionalities in .NET world such as Custom Attributes, Value Types, Extension Methods, etc. The question is : Are we back on J# days? Definetly no. I'm talking about an open-source community here and the roadmap says there will be release comparable to J2ME and J2EE sometime in the future.