SeeSharp - SeeSharp

Deserting SVN for good: Using Git

2010-03-08T08:32:16.043

I've been having tremendous amount of problems lately using TortoiseSVN. Although server seemed to work fine, my SVN client had lots of problems, so I decided it was time to switch to Git. I was using the free service available at xp-dev but the free service only includes SVN repositories, so I tried the next best thing: GIT-SVN. Let's see how it worked out for me.

Git is not (yet) natively supported on windows. The only way to run it on Windows was to use Cygwin, a linux like environment for Windows, but the new project called msysgit is trying to make a native Windows client. To get started download and install msysgit from google code. I'm using version 1.6.5.1 preview 20091022 at the time of this post, but it is updated regularly.

To connect to SVN repository, open a Git Bash window on your destination folder and enter the following command:

git svn -s clone http://your-svn-address

If your SVN repository has no standard folders such as "trunk", "tag" and "branch" you should remove "-s" parameter. This command would get all the sources, except empty folders in your existing SVN repository because Git does not track folders but file content. It would take some time for git to get all the revisions but when it finishes, you're all set.

From this point on, you can use git commands but before committing changes back into your SVN repository, you should update your working folder by the following commands:

git svn fetch
git svn rebase

This will update your local git working copy by getting all the changes made by other people and then applies your local changes over that.

The last command to send your changeset to the SVN repository is the following:

git svn dcommit

To find out more about git commands, try this cheat sheet that comes handy.

Silverlight Applications with J2EE Backend - Part Two

2010-03-07T06:43:16.933

In previous post, we saw how easy it is to use J2EE as a rich backend. Let's continue with our example and show how to fetch and send some data from our J2EE backend to a Silverlight rich client application. Let's continue our work using a simple Blog domain model.

To create our simple domain model, let's create the domain classes in java and let JPA create the database for us. For .NET developers familiar with NHibernate and NHibernate Mapping Attributes project, when comparing this to .NET coding style, there should be nothing new here. Here's a piece of code:

package ir.hightech.silverbox.domain;

import javax.persistence.*;
import java.util.List;

@Table(name = "sl_Post")
@Entity
public class Post {

    private int postId;
    private String title;
    private Blog blog;
    private List<Comment> comments;

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "PostId", nullable = false)
    public int getPostId() {
        return postId;
    }

    public void setPostId(int postId) {
        this.postId = postId;
    }

    @ManyToOne
    public Blog getBlog() {
        return blog;
    }

    public void setBlog(Blog blog) {
        this.blog = blog;
    }

    @Column(name = "Title", nullable = false)
    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    @OneToMany(mappedBy = "post")
    public List<Comment> getComments() {
        return comments;
    }

    public void setComments(List<Comment> comments) {
        this.comments = comments;
    }
}

package ir.hightech.silverbox.domain;

import javax.persistence.*;

@Table(name = "sl_Comment")
@Entity
public class Comment {

    private int commentId;
    private Post post;
    private String text;

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "CommentId", nullable = false)
    public int getCommentId() {
        return commentId;
    }

    public void setCommentId(int commentId) {
        this.commentId = commentId;
    }

    @ManyToOne()
    public Post getPost() {
        return post;
    }

    public void setPost(Post post) {
        this.post = post;
    }

    @Column(name = "CommentText", nullable = false)
    public String getText() {
        return text;
    }

    public void setText(String text) {
        this.text = text;
    }
}

Let's create a service to return a list of all available Posts and display them on our Silverlight client. Continuing from previous post, you've already learned how to create services (or SessionBeans as called in EJB context) but when you actually have an entity model and want to expose it through service, you'd better think twice. There are a lot of things that can go wrong if you do so:

Your change in domain model will ripple to your clients because of changes in service contract and will probably break all your clients.
Your domain model might contain sensitive information which is best kept on your service tier.
Other technical stuff such as your entities beiing lazy and having problems with serialization process.

So before continuing, let's create some DTO objects which will be sent across the service boundary. For this sample, a POJO class resembling your existing Post entity would suffice. To map between Entities and DTOs, you can roll your own mapper classes.

package ir.hightech.silverbox.common;

import ir.hightech.silverbox.domain.Post;
import javax.ejb.Remote;
import java.util.List;

@Remote
public interface BlogService {
    List<PostDto> getAllPosts();
}


package ir.hightech.silverbox.services;

import ir.hightech.silverbox.common.BlogService;
import ir.hightech.silverbox.domain.Post;
import javax.ejb.*;
import javax.jws.*;
import javax.persistence.*;
import java.util.*;

@Stateless(name = "BlogService")
@Remote(BlogService.class)
@WebService
public class BlogServiceImpl implements BlogService {

    @PersistenceContext
    protected EntityManager em;

    public List<PostDto> getAllPosts() {
        Query query = em.createQuery("FROM Post");
        List<Post> result = query.setMaxResults(10)
                                 .getResultList();

        return new PostMapper().MapMany(result);
    }
}

Did you notice the EntityManager? It is injected automatically by EJB container and the good thing is you can inject other services, even your other EJB session beans too. EntityManager provides functionalities similar to ISession in N/Hiberante such as CreateQuery, Find, Attach/Detach, Flush, etc.

Now let's create a new Silverlight application and add a new "Service Reference" to your project which points to our new service at:

http://localhost:9090/Silverbox/BlogService?WSDL

Note: Use IP / Port of your JBoss server, port is usually 8080. Mind the small / caps characters.

If you open the proxy sources which is automatically generated, you'll notice our DTO objects are all here in our Silverlight application now! There's a slight modification though: All the classes and properties are named according to java naming conventions so our PostDto class is now named "postDto" on the Silverlight client. This is happened to all the properties of the proxy classes too so if you're binding generated classes directly to your UI keep in mind that Xaml binding are case sensitive. What is good is that INotifyPropertyChange is already implemented. The rest is just regular Silverlight application calling a remote service:

<Grid x:Name="LayoutRoot">
    <ListBox x:Name="RecentPosts">
        <ListBox.ItemTemplate>
            <DataTemplate>
                <StackPanel Orientation="Horizontal">
                    <TextBlock Text="{Binding Path=postDate}" />
                    <TextBlock Text="{Binding Path=title}" />
                </StackPanel>
            </DataTemplate>
        </ListBox.ItemTemplate>
    </ListBox>
</Grid>

and to call the service:

private void MainPage_Loaded(object sender, RoutedEventArgs e)
{
    var service = new BlogServiceImplClient();
    service.GetAllPostsCompleted += (snd, arg) => 
    {
        if(arg.Error == null)
        {
            RecentPosts.ItemsSource = arg.Result;
        }
    };
    service.GetAllPostsAsync();
}

You should have a rich application that is bound to your database using your service layer on J2EE. Pretty easy so far, don't you think?

Next post in this serie will show you how to handle business validation using SoapFaults, how to serialize Java exceptions into Silverlight client and how to actually deploy the whole application. Get the sources of this part from here.

PersianCalendar support for DevExpress

2010-02-27T07:43:28.787

Creating Line of Business applications using DevExpress WPF controls is just a breeze. The actual application is nice looking too! Since there are a couple of skins available and the good thing is the skin also changes the look and feel of standard WPF controls!

I've used my calendar library to develop a fully localizable solution. These controls support Gregorian, Hijri and Persian calendars so multicultural application development would be seamless, but the look and feel of my controls were a lot different than the ones provided by DevExpress. On the other hand, DevExpress only supports Gregorian calendar! So I needed to apply look and feel of DevExpress to my controls. It goes without saying that you can open the controls in Expression Blend and give it a style that mimics DevExpress look and feel, but that is not easy to do.

DevExpress provides a PopupEditBase control that can be used to display any control as a Popup. That seemed to be a good choice and it was easy to create a new control all in xaml markup:

<Window x:Class="DXCustomEditor.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
        xmlns:dxe="http://schemas.devexpress.com/winfx/2008/xaml/editors" 
        xmlns:fx="http://schemas.hightech.ir/wpf/2008/FarsiLibrary"
        Title="DX Editors" Height="350" Width="525"
        xmlns:loc="clr-namespace:DXCustomEditor">
    <Window.Resources>
        <loc:DateConverter x:Key="DateConverter"/>
        <ControlTemplate x:Key="DatePickerTemplate">
            <fx:FXMonthView SelectedDateTime="{Binding Path=(dxe:BaseEdit.OwnerEdit).EditValue, Mode=TwoWay, RelativeSource={RelativeSource Mode=TemplatedParent}, Converter={StaticResource DateConverter}}"/>
        </ControlTemplate>
    </Window.Resources>
    <StackPanel Margin="10">
        <dxe:PopupBaseEdit IsTextEditable="False" PopupContentTemplate="{StaticResource ResourceKey=DatePickerTemplate}" />
    </StackPanel>
</Window>

The outcome is pretty good: seamless calendar support and look and feel.

Silverlight Binding: Lesson Learned

2010-02-17T14:10:19.227

When working on a Silverlight application that recieved data from a WebService I notice that loading of an array of 1500 items takes a lot of time. With this problem, application launch that has 3 separate webservice lookups, took almost 5 minutes to complete.

The problem became more interesting when my colleague actually ran get the same data bound UI in WinForms in 2 seconds, so there were something fishy going on in out Silverlight application. Let's see the original code that loaded the data from the webservice:

public virtual void Load()
{
    var client = new ServiceClient();
    client.GetAllFirstLookupCompleted += (s, e) => Lookup.AddRange(e.Result.MapMany<LookupResult, LookupResultDTO>());
    client.GetAllFirstLookupAsync();
}

public virtual ObservableCollection<LookupResultDTO> Lookup
{
    get; private set;
}

WebService call returned a "LookupResult" but we used LookupResultDTO object bound to UI so the first thing we needed to do was to convert between these types. Then our bound collection was a ObservableCollection. Unlike the same type in WPF, ObservableCollction in Silverlight has no construct that accepts an IList so you have to add individual items one by one! To make things "look" niceer, we've created an AddRange extension method that add items of an IList to an ObservableCollection.

So, why would the above code take this long?

First Mistake

First mistake was to use AutoMapper! Yes, it makes life easier by automagically map two unconvertable types by using reflection and flatting structure. It even works great if your collections are relatively small but avoid using it if you have a large collection (I don't even consider a collection of 1000 items large!).

You can always roll your own mappers and it is easy to create and use. Our mapper looked like this:

public class LookupResultMapper
{
    public LookupResultDTO MapOne(LookupResult result)
    {
        return new LookupResultDTO(result.PrimaryKey, result.Name, result.Number);
    }

    public IList<LookupResultDTO> MapMany(LookupResult[] results)
    {
        var list = new List<LookupResultDTO>();

        foreach (var result in results)
        {
            list.Add(MapOne(result));
        }

        return list;
    }
}

The reason is obvious! Using reflection is a lot slower and when you're doing it for 1000 times, you'll get 1000 times slower! This small change improved the performance more than 50%.

public virtual void Load()
{
    var client = new ServiceClient();
    client.GetAllFirstLookupCompleted += (s, e) => Lookup.AddRange(new LookupResultMapper().MapMany(e.Result));
    client.GetAllFirstLookupAsync();
}

Second Mistake

When a UI element is bound to an observable collection, every addition and removal of an Item probably lead to some calculation in the element for things such as draing and layout calculation. Second problem was to add the collection one by one to the observable collection.

Unfortunately, as mentioned, ObservableCollection unlike WPF version has no construct that accepts an IList. You have some options though:

Make your UI element Invisible (Visibility=Collapsed or Hidden) then add the items to the bound collection. This will prevent exhaustive calculation.
Change the collection type from ObservableCollection to IList, if possible.

Depending on your scenarios, one of the above mentioned solutions may work for you. In our case, we didn't need to add / remove items from the collection at a later time so switching to IList did the trick.

After refactoring, application that took almost 5 minutes to launch now runs in seconds!

Silverlight Applications with J2EE Backend - Part One

2010-02-13T16:21:09.76

If you have not heard, Silverlight is the latest rich client technology from Microsoft. The good thing about it is that it works almost on all browsers and operating systems and you can host your application on non-microsoft stack too, but there are things such as database connectivity that you can't benefit from when creating Silverlight applications. The only way to create data-driven applications would be to use a service backend. Here I'll show you how to create a J2EE backend for your Silverlight application and host it on a JBoss application server.

To create the backend for the Silverlight application, I'll show you how you can use J2EE technology which provides rich infrastructure for your backend. I'll be using JBoss 4.2.3 GA application server to run this sample, and IntelliJ IDEA 9.0 Enterprise to develop the backend. IntelliJ IDEA Enterprise is not a free IDE (there's a free Community version), but using it is natural for .NET developers having experience with Resharper addin tool for Visual Studio .NET. Of course, both tools are from the same company, but if you use Resharper with IntelliJ shortcuts most of them work in IntelliJ IDEA too. You can get a trial version from here for this experiment if you're an experienced java developer, you can still use your favorite IDE.

This post is intented for .NET developers with (almost) no experience with Java language. If you're familiar with NHiberanate, theorethically you should be able to use JPA in no time because of a lot API similarities: JPA provides APIs that are very familiar with (N)Hiberante.

Project Structure
For our backend we'll use a standard J2EE project, with support for JPA, JAXWS WebServices and other J2EE services. Fire up your IntellliJ IDEA and create a new project. In the project wizard, select "Java Module" and set path for your project sources. From the technologies page in the wizard, select "JavaEE Persistence", "Enterprise JavaBeans", "JavaEE Application" and "WebServices". The wizard will download the JAR filles and libraries that are necessary from JetBrain's website and set the project structure for you. Before we're done with the project structure, we need to do some modifications.

Thanks to EJB 3.0 and its annotation-based EJBs no xml configuration would be necessary, so open "ejb-jar.xml" file and remove its content (enterprise-beans tag and its content). This file is in META-INF folder in the root of the project. Then open the "persistence.xml" from META-INF folder under the "src" folder and setup the persistence API.

Note: If you have hard time finding any class or file use the same shortcut as in Resharper (CTRL+SHIFT+N for files and CTRL+N for classes and interfaces).

This file is almost like hibernate configuration file so most of the content should be self explanatory:

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">
    <persistence-unit name="NewPersistenceUnit">
        <provider>org.hibernate.ejb.HibernatePersistence</provider>
        <jta-data-source>java:/silverbox-ds</jta-data-source>
        <properties>
            <property name="hibernate.connection.url" value="jdbc:sqlserver://127.0.0.1;databaseName=silverboxdb"/>
            <property name="hibernate.connection.driver_class" value="com.microsoft.sqlserver.jdbc.SQLServerDriver"/>
            <property name="hibernate.connection.username" value="sa"/>
            <property name="hibernate.connection.password" value="12345"/>
            <property name="hibernate.archive.autodetection" value="class"/>
            <property name="hibernate.show_sql" value="true"/>
            <property name="hibernate.format_sql" value="true"/>
            <property name="hbm2ddl.auto" value="update"/>
        </properties>
    </persistence-unit>
</persistence>

Other than database configuration, notice the "jta-data-source" tag which points to a specified datasource name. We'll learn about this in a bit.

IntelliJ Enterprise integrates with most of the application servers, including JBoss. First make sure you have a working version of JBoss application server which you can download from here. Open the Settings menu (CTRL+ALT+S) and from the Application Servers add a new JBoss Server and select the folder where you unzipped the JBoss package. Then in IntelliJ open the "Edit Configurations" submenu from "Run" menu and add a local JBoss Server. The already added JBoss server will be added. Select the default "Server Instance". Notice the warning message in the dialog that says "Warning: No artifacts marked for deployment".

Note: Your applications may contain libraries, compiled binaries, services, etc. all will be packaged in a deployable unit. The standard deployment unit in Java is JAR (java archive) but other packages exists, namingly WAR (web archive) and SAR (service archive). All the mentioned packages can be packed and deployed in a single deployment unit named EAR (enterprise archive) file.

To specify what should be contained in the deployable package, we need to specify the deployment artifacts. To do this, go to "Project Structure" dialog (CTRL+ALT+SHIFT+S) and select the "Artifact" from the side list. Add a new artifact by pressing "+" button. Enter a name for your artifact and select the "JavaEE Application: Exploded" as the type. From the "Output Layout" add the "Module Output" and a "JPA Descriptors". From the bottom of the page, click "Create Manifest" button to create an empty manifest in your "src\META-INF" folder.

Open up the "Project Structure" dialog again and check the "Build Artifacts..." check mark and from the dialog select the artifact name you've just created.

The project structure is almost ready. Now let's add some code.

Create Enterprise Beans
Under the "src" folder create two packages (a.k.a namespaces). I've named the packages as "ir.hightech.silverbox.common" and "ir.hightech.silverbox.services". I will separate the service interfaces and implementation in separate folders. To create a basic loopback service create the following interface in the "common" package:

package ir.hightech.silverbox.common;

import javax.ejb.Remote;

@Remote
public interface LoopbackService {
    void echo();
}

...and create the implementation in the "services" folder:

package ir.hightech.silverbox.services;

import ir.hightech.silverbox.common.LoopbackService;
import javax.ejb.Remote;
import javax.ejb.Stateless;

@Stateless(name = "LoopbackService")
@Remote(LoopbackService.class)
public class LoopbackServiceImpl implements LoopbackService{
    public void echo() {
        System.out.println("Hello, world!");
    }
}

Note: Each EJB can be used locally or remotely so different annotations are required based on usage context. Since we need to only expose the EJBs as a service, we've only specified it to be a "Remote" service / interface.

Final step would be to expose the EJB as a Webservice. That is as easy as adding an annotation to our service implementation:

@Stateless(name = "LoopbackService")
@Remote(LoopbackService.class)
@WebService
public class LoopbackServiceImpl implements LoopbackService{
   ...
}

Data Sources
Before we deploy and run the application, we need to setup the datasource specified as "jta-data-source" in our "persistence.xml" file. JBoss when ran searches the deploy folder for the specified datasource. Datasource file names are ended with "ds" suffix by convention. The datasource file contains connection information that will be used in our application. Here the "jndi-name" is important and it should be the same thing as what we've specified in persistence.xml file. To use MS-SQL 2005 database create the following file and copy the file in the "deploy" folder of the JBoss. You can create an ANT script and automatically copy this file into the destination folder, if you prefer.

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<datasources>
    <local-tx-datasource>
        <jndi-name>silverbox-ds</jndi-name>
        <connection-url>jdbc:sqlserver://127.0.0.1;databaseName=silverboxdb</connection-url>
        <driver-class>com.microsoft.sqlserver.jdbc.SQLServerDriver</driver-class>
        <user-name>sa</user-name>
        <password>12345</password>
        <metadata>
            <type-mapping>MS SQLSERVER2000</type-mapping>
        </metadata>
    </local-tx-datasource>
</datasources>

Deployment
We're almost there now. From the main toolbar, click the "Run" button to fire up the JBoss server. Notice the logs that appear in Output window of the IntelliJ IDEA. If you see that artifact is deployed successfully, you're good. Fire up your browser and enter the services url to see the automatically generated WSDL. The deployed URL would be http://localhost:8080/Silverbox/LoopbackService?WSDL but if you've named your artifact and service something different it is in the format of http://jbossmachine:port/artifactname/Servicename (you can also see the registered Endpoint in the output window).

Next we'll see how to extend the service and create a Silverlight client that accesses our backend. Get the source files for this part from here.

Must Read Books For Programmers

2010-01-25T10:22:25.323

It's been a while that I wanted to prepare a list of books that, in my opinion, every programmer should read. These are the most influential books I've read so far in my career. It is not supposed to be a complete list of any kind and this is just my idea of a must read. Books mentioned here may or may not be specific to a programming language, so check it before you buy the book.

With the fact (or is it a fiction?) that programmers don't like to read books in mind, I limited the list to only ten books, but there are certainly other great books out there that either I'm not aware of or may be have not read yet. I was already a programmer when I read most of these books, but these really helped me open my mind towards how professionals are doing it and why.

Enough said, here's the list:

10- Design Patterns: Elements of Reusable Object-Oriented Software by Gang of Four
9- Clean Code A Handbook of Agile Software Craftsmanship by Robert C. Martin
8- Agile Project Management with Scrum by Ken Schwaber
7- Applying Domain-Driven Design and Patterns by Jimmy Nilsson
6- Working Effectively with Legacy Code by Michael Feathers
5- Patterns of Enterprise Application Architecture by Martin Fowler
4- Refactoring: Improving the Design of Existing Code by Martin Fowler
3- Test Driven Development By Example by Kent Beck
2- Agile Principles Patterns and Practices by Robert C. Martin
1- Domain-Driven Design: Tackling Complexity in the Heart of Software by Eric Evans

Thoughts?

Java and .NET Interoperability

2010-01-18T10:53:46.093

We've been doing a lot of Java / .NET interop for last couple of years in our enterprise applications. On one hand, our customers used their existing expertise and infrastructure that worked better with Java based technologies like their existing Unix based servers, Sybase database (on Unix) and the knowledge of their DBA team, and we using our existing Java developers and expertise. But what Java based technology provides that we don't have on .NET world? Is it important at all?

With rise of Silverlight presentation framework working the interop becomes more important. You can now create a sophisticated user interface and make it work with your existing EJBs on your JBoss backend and you have best of both worlds. As a .NET developer you might not be familiar what this provides, so here's a few things you'll get right out of the box:

Standard JPA (Java Persistance API)
When you create applications on top of EJB 3.0 using any EJB compliant application server, one thing you get is a standard, pluggable persistence API. The idea behind JPA was to provide a standard set of interfaces to application developers and let the application server provide different implementations of these interfaces using various persistence frameworks. Great idea, right? This means you don't need to learn how to use another persistence framework, because now they all support an standard interface.

JBoss actually uses Hiberante under the hood to implement this API but other application servers may have different engines. If you're familiar with NHibernate, you'll feel right at home!

JAX-WS WebServices
Should you need to expose your business logic through WebServices, all you need to do is to decorate your existing services with an Annotation to signify the application service that the class provides a WebService endpoint. An Annotation is actually a Java term for almost the same thing we call an Attribute in .NET world.

Infrastructural Services
There are a lot of cross cutting concerns your application server provides. Things such as standard logging framework, inversion of control container, queues, scheduling, Message Driven Bean (which is a very simple ESB) , hot deployment of applications, etc.

Price Tag
Yes, the best part of it is that all of this comes as free (as in free food). You don't have to pay for licenses for your application server, you don't have to pay for IDEs because there are a lot of great IDEs available, you don't have to buy license for your Linux based Server and there's a large community out there that can help you freely, if you're stuck. Of course there are paid services too, mostly for services such as support, but you hardly need it. If you're pairing Silverlight frontend with Java backend, you can use Eclipse to handle both in one place!

This is just a scratch on the surface. I'll shed more light on the subject on upcoming posts.

WPF Application with Caliburn - Part Two

2010-01-15T12:04:49.06

In this part of the tutorial, we'll enhance our shell view to display other presenters and add Save and Print support for presenters supporting it. You can use generalize this example and learn how to implement generic features in your shell.

Caliburn has several existing classes that can be used as a base class for our presenters. Let's explain some of them and see where do they fit:

Presenter
This class implements IPresenter interface and provides life time methods such as Initialize, Shutdown, Active and Deactive. You can use this class for other views that are going to be displayed in the Shell View.

Presenter Manager
Using a presenter manager, as the name implies, you can host and display a single instance of a Presenter. It only allows displaying of one Presenter only so you have only one view displayed to the user when using it.

MultiPresenterManager
Same as PresenterManager but can host multiple Presenters at the same time, but only one of them is Active at a time.

When we display a Presenter, the PresenterManager will call the lifetime methods on the Presenter instance. The following diagram shows this flow:

For now, it is obvious that we need to change the base class of our ShellViewModel to PresenterManager (too keep it simple for the time being), but how should we change the xaml code to host the views (other Presenters)? Your first guess would be to bind CurrentPresenter property of the PresenterManager to a ContentControl in the Shell.xaml, but you don't need to do that as Caliburn will do the plumbing for us, just add a ContentControl to the Shell view where you want the views to be displayed and name it as "CurrentPresenter".

To make Caliburn bind Views to the content control, you need to enable additional Conventions that are not enabled by default. Placing the following snippet in Caliburn configuration will do the trick:

var binder = (DefaultBinder)Container.GetInstance<IBinder>();
binder.EnableBindingConventions();

The bare bone of the shell view that displays a single presenter is this:

<Window x:Class="PayRoll.Views.ShellView"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Width="640" Height="400">
    <DockPanel LastChildFill="True">

        <ScrollViewer>
            <ContentControl x:Name="CurrentPresenter" />
        </ScrollViewer>

    </DockPanel>
</Window>

Adding Custom Controls
Now to handle user interaction with the shell and the open presenter, we need some kind of a Toolbar / Menu control. WPF comes with a very basic menu and toolbar control, but to show how to use custom controls and see how Caliburn facilitates this, let's use DevExpress BarManager control in this example.

DevExpress, among other nice things, provides presentation layer controls for WPF such as Editors, Bars (MenuBar, ToolBar and soon Ribbon), Grid and Printing. One other thing they've also done is that they also have skinned native WPF controls so if used together with DevExpress controls, you'll have a seemless look and feel.

To add the BarManager control to our ShellView, you need to download DevExpress WPF controls (trial version here) and install it. The add the necessary reference to devexpress WPF assemblies and import the xml namespaces. Here's the snippet that creates the BarButtonItems which is equivalent of a ToolbarItem. (Get the accompanied zip for complete source code):

<dxb:BarManager.Items>
	<!--General Actions-->
	<dxb:BarButtonItem Name="bSave"  CategoryName="File" Content="Save" Glyph="/Images/Save.png"  KeyGesture="Ctrl+S" />
	<dxb:BarButtonItem Name="bPrint" CategoryName="File" Content="Print" Glyph="/Images/Print.png" KeyGesture="Ctrl+P" />
	<dxb:BarButtonItem Name="bExit"  CategoryName="File" Content="Exit" Glyph="/Images/Exit.png" KeyGesture="Ctrl+X" />
	
	<!--Status Bar-->
	<dxb:BarStaticItem Name="bStatus" CategoryName="Status" MinWidth="300" Content="Read" AutoSizeMode="Fill"/>
</dxb:BarManager.Items>

Same as Button object, BarButtonItems provide a Command property which you can bind to an ICommand instance on your ViewModel, but this is rather limited, don't you think? What if you want to bind another event (other then Click) to your ViewModel?

Caliburn provides Actions and Messages with which you can bind a regular Event on your View and Controls to a method on your ViewModel, without using ICommand. You can even run the event handler (on your VM) asynchronously! There are a few ways to do this but the best way, in my opinion, is to this format:

cal:Message.Attach="[Event EventNameOnControl] = [Action ActionNameOnViewModel()]"

Note that you can actually bind two actions to one event, just like you can have two methods listening to a regular event. Let's change the snippet above and add the messaging support:

<dxb:BarButtonItem Name="bSave" cal:Message.Attach="[Event ItemClick] = [Action SavePresenter()]"/>
	<dxb:BarButtonItem Name="bPrint" cal:Message.Attach="[Event ItemClick] = [Action PrintPresenter()]"/>
	<dxb:BarButtonItem Name="bExit" cal:Message.Attach="[Event ItemClick] = [Action Exit()]" />

Note: Unlike a regular Button, BarButtonItem has no "Click" event and provides an "ItemClick" event instead. Clearly, we need the specified methods on our ViewModel, so let's add them too:

public class ShellViewModel : PresenterManager, IShellViewModel
{
    public virtual void SavePresenter()
    {
    }

    public virtual void PrintPresenter()
    {
    }

    public virtual void Exit()
    {
    }
}

At this point, you can run the shell and click the tool bar items, which will call the specified method on the view model. Now the question is, what if a presenter is not in a suitable state to be saved (dirty checking, already saved, etc.). What if a presenter does not even support printing? How can we disable the BarButtonItem responsible for an action, if the presenter does not support it?

With Conventions already enabled, you can have additional "Can*" methods acting as a Filter for your actions. These filters will be checked on runtime for returning false value indicating the action can not be performed, or true value for allowed actions. Caliburn will try to disable the piece of UI through an "IAvailabilityEffect" interface. Let's see this in more dept.

Working with Actions
As mentioned, Caliburn checks for availability of an action automagically if it finds a pairing "Can*" filter method on the presenter. So let's add those and see how it works:

public virtual bool CanExit()
{
    return base.CanShutdown();
}

public virtual bool CanPrintPresenter()
{
    var presenter = CurrentPresenter as IPrintablePresenter;
    return presenter != null &&
           presenter.CanPrint;
}

public virtual bool CanSavePresenter()
{
    var presenter = CurrentPresenter as ISaveablePresenter;
    return presenter != null &&
           presenter.CanSave;
}

When you run the application and set a break point on CanSave and Save methods, you'll notice two things:

A. While CanPrint method returns False value, UI element (BarButtonItem) is not disabled!

B. By clicking the BarButtonItem, the Save method will not be called.

So there seems to be a problem...Why isn't BarButtonItem disabled? Wasn't Caliburn supposed to do that for us? Well...The default "Disable" effect, only works for UIElements, but BarButtonItem is actually a FrameworkContentElement. Those are two different beasts and Caliburn can not handle our UI control. The solution is easy though. You can create your own IAvailabilityEffect that works with FrameworkContentElements.

public class DisableMenuEffect : IAvailabilityEffect
{
    public void ApplyTo(DependencyObject target, bool isAvailable)
    {
        var element = target as FrameworkContentElement;
        if(element == null)
            return;

        element.IsEnabled = isAvailable;
    }
}

...and set it along with the action on the View:

<dxb:BarButtonItem cal:Message.Attach="[Event ItemClick] = [Action SavePresenter()]" cal:Message.AvailabilityEffect="DisableMenuEffect" />
    <dxb:BarButtonItem cal:Message.Attach="[Event ItemClick] = [Action PrintPresenter()]" cal:Message.AvailabilityEffect="DisableMenuEffect" />
    <dxb:BarButtonItem cal:Message.Attach="[Event ItemClick] = [Action Exit()]" cal:Message.AvailabilityEffect="DisableMenuEffect" />

There's one last trick to make this work. Caliburn has no way to convert the specified string to an IAvailabilityEffect instance! The existing ValueCovertor, asks our Container for any object named "DisableMenuEffect". The final piece of code would be to register all instances of IAvailabilityEffects you might want to use on the container:

_container.Register(Component.For<DisableMenuEffect>()
                             .Named("DisableMenuEffect")
                             .LifeStyle.Singleton);

When running the application, and there's no open view, the toolbar items are disabled.

To show how it works, let's add a new View and ViewModel to our application, and also add a button to the shell that allows us to open this view. As mentioned before, to do this, you need to create a UserControl for you View and a class deriving from Presenter base class for your ViewModel.

public class PersonViewModel : Presenter
{
    private Person _person;
    private ObservableCollection<Person> _personnelList;
    private ObservableCollection<Job> _jobs;
    private readonly IPersonDataService _service;

    public PersonViewModel(IPersonDataService service)
    {
        _service = service;
    }

    public override void Initialize()
    {
        _jobs = new ObservableCollection<Job>(_service.GetJobs());
        _personnelList = new ObservableCollection<Person>(_service.GetPersonnel());
    }

    public Person CurrentPerson
    {
        get { return _person; }
        set
        {
            _person = value;
            base.NotifyOfPropertyChange("CurrentPerson");
        }
    }

    public ObservableCollection<Person> Personnel
    {
        get { return _personnelList; }
    }

    public ObservableCollection<Job> Jobs
    {
        get { return _jobs; }
    }
}

Now create a UserControl for PersonView using DevExpress editors looking like this:

To support saving, let's add ISaveablePresenter interface to our ViewModel and check if DateOfBirth property of the current person is valid before saving:

public bool CanSave
{
    get 
    {
        return CurrentPerson != null &&
               CurrentPerson.DateOfBirth.Year > 1900;
    }
}

public void Save()
{
    MessageBox.Show("Saved");
}

You can observe that CanSave property will never get executed! The reason is that when application starts, Caliburn checks if any of the Action methods are available by checking their respective Filters (here CanSavePresenter and CanPrintPresenter), but it never checks them again. In other words, by default action filters (Can* methods) are only called once. How can we change this behavior?

There's an attribute called "AutoCheckAvailability" that you can place on your action methods. This will tell WPF Command Manager to look out for availability of the bound action. Doing this will call the action filters periodically, so make sure if you really need it before actually using it. So apply this to our ViewModel, let's get back to our ShellViewModel class and place the attribute on our actions:

[AutoCheckAvailability]
public virtual void SavePresenter()
{
    var presenter = (ISaveablePresenter)CurrentPresenter;
    presenter.Save();
}

[AutoCheckAvailability]
public virtual void PrintPresenter()
{
    var presenter = (IPrintablePresenter)CurrentPresenter;
    presenter.Print();
}

Note: You need to place this on your actions, not on filters.

...et voila!

Our shell now can host other views and has generic actions that is automagically enabled / disabled for views supporting it.

In the next post, I'll show you how to change our existing shell to display a Tabbed interface and display multiple views at the same time. The attached zip file contains the complete source code.

WPF Application with Caliburn - Part One

2009-12-30T13:31:53.05

Back in May 2008, I did two posts on how to implement a composite application using Caliburn framework. By that time, Caliburn was still in pre-alpha stage. With lots of the changes along the way to reach Release Candidate, those content are not valid anymore, so I thought a new post to show how you can use Caliburn to build a WPF application is in order.

In fact, a while ago I started porting my old .NET 1.1 pay roll application to WPF and .NET 3.5 so I naturally chose to use Caliburn and it did facilitate things a lot, but to keep things simple, I'm not going to discuss my own application here. I'll show how you how can create your own application using Caliburn framework and how it will help you out.

Framework Setup

First thing you need to do, is to setup a new WPF application. Let's call it PayRoll application. After doing so, add reference to Caliburn and Castle assemblies. Caliburn honors the Dependency-Injection principle by depending only on abstractions. The idea is to allow you to easily plug in your own implementation of that abstraction and customize how Caliburn components work. To do so, Caliburn uses an IoC Container to lookup the services it requires.

If you're new to Dependency Injection stuff, don't worry, there is a built-in SimpleContainer which will do the job for you but I'll be using Castle container (Windsor) here. If you're using other IoC containers such as AutoFac, Ninject, StructureMap, Spring or even MEF (not technically an IoC container), Caliburn comes with existing adapters for those too, so no worries. To lookup instances of the services it needs, Caliburn uses the Common ServiceLocator and Service Locator design pattern. This allows looking up for services from various IoC containers, without actually depending on those containers.

Now to initialize Caliburn framework at startup there are various ways, but the easiest would be to create a CaliburnApplication. We already have an application object (App.xaml and App.xaml.cs) so we only need to change them to derive from CaliburnApplication class. To do so, open the App.xaml file first, and include the Caliburn namespace and change the type to Caliburn application. Also, we don't want to specify any StartupUri, so get rid of that too. The result would be this:

<cal:CaliburnApplication x:Class="PayRoll.App"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:cal="http://www.caliburnproject.org">
    <Application.Resources>
         
    </Application.Resources>
</cal:CaliburnApplication>

With this, the project won't compile! Because we've specified different base classes in our Xaml and Code Behind. Since the base class in code behind is inferred, open the code behind and remove the base class. The code would look like this:

namespace PayRoll
{
    /// <summary>
    /// Interaction logic for App.xaml
    /// </summary>
    public partial class App
    {
    }
}

So far so good. Now, If you look at the Caliburn Application class, there are interesting things that we can do. The obvious one is a method called CreateContainer. The default implementation, as said before, will create a SimpleContainer but we're going to use our own container, so let's do so:

    protected override IServiceLocator CreateContainer()
    {
        _container = new WindsorContainer();
        return new WindsorAdapter(_container);
    }

Next step would be specifying a RootViewModel (also called ShellViewModel) that will act as ViewModel for our MainWindow. Notice that we have nothing to do with the actual View (UI) that will be displayed, we just specify the ViewModel for it:

    protected override object CreateRootModel()
    {
        return _container.Resolve<IShellViewModel>();
    }

At this point, we need to create a ViewModel and a View for our Shell and register the VM in the container. Create two folders in your solution one named Views and the other ViewModels. Create an interface in ViewModels folder named IShellViewModel and create a class implementing this yet empty interface, named ShellViewModel. So now we need to register these (along with other services, view models, etc.) in the container:

    public App()
    {
        RegisterComponents();
    }

    private void RegisterComponents()
    {
        _container.Register(Component.For<IShellViewModel>()
                                     .ImplementedBy<ShellViewModel>()
                                     .LifeStyle.Singleton);
    }

Notice that lifestyle of ShellViewModel is set to singleton. This is logical because there's always one instance of the ShellView running. We'll see how this allow us interact from other ViewModels with Shell VM.

Marrying the View and ViewModel

Now, let's run the application and see what happens. When we run the application, Caliburn throws an exception complaining that a View can not be created for the ShellViewModel. Since we didn't specify any information about our Views, you might say: How is Caliburn supposed to create a View for my ViewModel anyway? Well, Caliburn tries many things before giving up and throwing an exception:

First, if your ViewModel implements the IMetadataContainer interface, the GetMetadata method is called on your VM, asking for a view. Since this not a good option for us, let's skip it.
Second, if the ViewModel is decorated with a ViewAttribute, the specified view will be created. This is relatively easy, but it clutters your ViewModel with an attribute and I don't like it.
Third, specified assemblies will be searched to find the matching view according to a specified naming convention. This sound interesting, let's use this method.
Fourth, if you don't like any of these behaviors, you can plug in your own IViewStrategy implementation.

If you remember, we've created an empty Views folder. If you create a UserControl named ShellView (mind the naming), Caliburn will automagically pick it up as the View for our ShellViewModel. How is this done, you may ask? According to pre-defined naming rules, Caliburn will look in folders named Presenter, Model, ViewModel and PresentationModel to create a ViewModel instance, and to create a View instance, it will look for it in the Views folder. An example might clear it up a little bit. Supposing you have an IShellPresenter, the implementation would be named ShellPresenter in the folder named Presenters. You should name the view for this presenter ShellView and place it in Views folder. The ViewModel names refers to different implementation of Presentation Model design pattern, but those terms are used interchangeably in Caliburn.

So, we're going to use the naming convention (fourth method). Let's create an empty UserControl named ShellView and put it in Views folder:

<UserControl x:Class="PayRoll.Views.ShellView"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
    
</UserControl>

You can run the application now and it works. Caliburn has created a View (UI) and a POCO class as ViewModel and set the DataContext property of the View to the instance of the ViewModel. If you've noticed, we've set a UserControl as our root View. While you can create a Window object as your root View, if you create a UserControl (or anything other than a Window), Caliburn will create a MainWindow for you and place the View object as its content. This behavior is for Caliburn v1.1 so if you're using older version 1.0 you can either upgrade or use a Window as your root view.

Binding

To check if View and ViewModel are really bound together, let's create a commmand on the ViewModel and invoke it from the View. When invoked, it will change a Message property on the ViewModel. So first, open the IShellViewModel interface and add the ICommand and Message properties to the interface definition:

    public interface IShellViewModel
    {
        /// <summary>
        /// A command that says hello when invoked.
        /// </summary>
        ICommand SayHelloCommand { get; }

        /// <summary>
        /// Message
        /// </summary>
        string Message { get; set; }
    }

...and implement the command property on your ShellViewModel class. To facilitate command handling, we'll use a DelegateCommand class (originally RelayCommand) introduced by Josh Smith. Then instead of just displaying a MessageBox, let's Create a TextBlock and bind it to the Message property on our ViewModel. When binding some element to a property on the ViewModel, we need to implement INotifyPropertyChanged interface on the ViewModel. Fortunately, there's a base class in Caliburn which does exactly that:

    public class ShellViewModel : PropertyChangedBase, IShellViewModel
    {
        private ICommand _sayHelloCommand;
        private string _message;

        public virtual ICommand SayHelloCommand
        {
            get
            {
                if (_sayHelloCommand == null)
                    _sayHelloCommand = new DelegateCommand(SayHello);

                return _sayHelloCommand;
            }
        }

        public virtual string Message
        {
            get { return _message; }
            set
            {
                _message = value;
                NotifyOfPropertyChange("Message");
            }
        }

        private void SayHello()
        {
            Message = "Greetings from Caliburn!";
        }
    }

...Finally, let's place a Button and a TextBlock on the View and bind those to our ViewModel:

<Window x:Class="PayRoll.Views.ShellView"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Width="320" Height="200" >
    <StackPanel>
        
        <Button Command="{Binding Path=SayHelloCommand}" Content="Say Hello"  />
        
        <TextBlock Text="{Binding Path=Message}" FontSize="16" FontWeight="Bold" />
        
    </StackPanel>
</Window>

In next post, I'll show you how to add DevExpress components to the pot and how to create a re-usable shell and along the way. We'll see how to host other ViewModels in our ShellView and how to manage them. You can get the source code of this part from here.

Entity Framework 4 - Part Three : Repository Pattern

2009-12-12T11:02:00.963

Last post showed how to use a “ObjectContext” derivation to automatically generate audit information. Now instead of using a “ObjectContext” directly, a rather different approach, a pattern called “Repository Pattern” is used to encapsulate access to the entities.

Note: I’m using the bits included in Visual Studio 2010 Beta 2 with additional features included in Entity Framework 4 CTP 2 (not included in VS 2010) which you can download here.

Specification Pattern

What is “Specification Pattern” and what does it have to do with “Repository Pattern”? In simple terms, a specification is a piece of business logic that specifies if an entity is matching a certain criteria. Let’s suppose we need to fetch list of high profile Customers. We can hard code this criteria in UI code behind which is a bad practice you probably agree. We can also place this on our entity class, the “Customer”. This may not seem so bad. Maybe it is even a good practice to build the business logics like these into the entity, right? But this will only lead to a polluted interface on our entity class as more business logic is introduced. Using “Specification Pattern” and Separation of Concerns, these pieces of business logic can be placed in a separate class where they belong. Later, we'll pass this criteria as a parameter into the repository to specify which entities we want to be returned.

The Specification interface we're going to use would look like this:

    public interface ISpecification<TEntity> where TEntity : EntityBase
    {
        Expression<Func<TEntity, bool>> IsSatisfied { get; }
    }

...and implementation for our example above would be this:

    public class HighProfileCustomersSpecification : ISpecification<Customer>
    {
        public Expression<Func<Customer, bool>> IsSatisfied
        {
            get 
            {
                return c => c.Orders.Count > 50;
            }
        }
    }

Generic Repository

First let’s specify an interface for our repository. We need generic method like FindByKey, Save, Update and methods that accept an ISpecification parameter like FindOne and FindMany.

    public interface IRepository<TEntity> where TEntity : EntityBase
    {
        /// 
        /// Saves the transient entity.
        /// 
        TEntity Save(TEntity entity);

        /// 
        /// Updates the existing entity.
        /// 
        TEntity Update(TEntity entity);

        /// 
        /// Finds the entity by its key.
        /// 
        TEntity FindByKey(long id);

        /// 
        /// Finds entities based on provided criteria.
        /// 
        IList<TEntity> FindMany(ISpecification<TEntity> criteria);

        /// 
        /// Finds one entity based on provided criteria.
        /// 
        TEntity FindOne(ISpecification<TEntity> criteria);
    }

Let’s start with the easiest one, FindByKey method. To find an entity an ObjectContext that exposes the entity using IObjectSet<TEntity> is needed so in our generic repository, we’ll create those.

    public abstract class Repository<TEntity> : IRepository<TEntity> where TEntity : EntityBase
    {
        private readonly ObjectContext _context;
        private readonly ObjectSet<TEntity> _entity;

        protected Repository(ObjectContext context)
        {
            _context = context;
            _entity = Context.CreateObjectSet<TEntity>();
        }

        protected ObjectContext Context
        {
            get { return _context; }
        }

        protected IObjectSet<TEntity> Entity
        {
            get { return _entity; }
        }
    }

With this a lot of our implementation would just call the related method on Entity property.

    public TEntity FindByKey(long id)
    {
        return Entity.Where(x => x.Id == id)
                         .FirstOrDefault();
    }

For Save and Update methods, the ObjectContext does provide a method that has a parameter accepting a fully qualified entity name. What’s FQEN, you may ask? Each object that is in a EntityFramework container has a fully qualified name which is in “ContainerName.EntityName” format. These are the MetaData information that is exposed through EntitySet property and usually are stored in the .edmx file which we don't have because we're using the "All Code" feature, remember? Fortunately, there is one place that we can get the EntitySet metadata for our POCO entity and that is through the ObjectSet instance.

    private string GetEntityName()
    {
        return string.Format("{0}.{1}", _entity.EntitySet.EntityContainer, _entity.EntitySet.Name);
    }

Now it is possible to write the generic Save and Update methods as follows:

    public TEntity Update(TEntity entity)
    {
        var fqen = GetEntityName();

        Context.ApplyCurrentValues(fqen, entity);
        Context.SaveChanges(SaveOptions.AcceptAllChangesAfterSave);

        return entity;
    }

    public TEntity Save(TEntity entity)
    {
        var fqen = GetEntityName();

        Context.AddObject(fqen, entity);
        Context.SaveChanges(SaveOptions.AcceptAllChangesAfterSave);

        return entity;
    }

Note: I’ve wraped the call to SaveChanges in Save and Update methods. You can provide additional SaveChanges method in the repository that will be called explicitly by the code that uses the repository instance.

For remaining query methods that return one or multiple instances of the Entity, we’ll use the generic CreateQuery method on the ObjectContext and feed the ISpecification’s criteria to the Where method.

    public TEntity FindOne(ISpecification<TEntity> spec)
    {
        var entityName = GetEntityName();
        var query = _context.CreateQuery<TEntity>(entityName)
                                      .Where(spec.IsSatisfied());

        return query.FirstOrDefault();
    }

    public IList<TEntity> FindMany(ISpecification<TEntity> spec)
    {
        var entityName = GetEntityName();
        var query = _context.CreateQuery<TEntity>(entityName)
                                     .Where(spec.IsSatisfied());

        return query.ToList();
    }

That sums it up. Our concrete repositories are now just a breeze to create. We can build any missing fine grained methods into our concrete repository using the Entity property. With this approach, you only need one Repository per each Aggregate Root and EF4 will take care of any related transient child entities that should be persisted when aggregate root is saved.

    public interface ICustomerRepository : IRepository<Customer>
    {
        IList<Customer> NewlySubscribed();
    }

    public class CustomerRepository : RepositoryBase<Customer>, ICustomerRepository
    {
        public CustomerRepository(ObjectContext context) 
            : base(context)
        {
        }

        public IList<Customer> NewlySubscribed()
        {
            var lastMonth = DateTime.Now.Date.AddMonths(-1);
            return base.Entity.Where(c => c.Inserted >= lastMonth)
                            .ToList();
        }
    }

You can get the whole project containing complete API from here.

EntityFramework 4 – Part Deux : Audit Info

2009-12-11T18:04:24.087

In last post showed how easy it was to use POCO classes in EntityFramework v4, a feature called “All Code”. This new feature, facilitates creating domain models but how about other features you may already have using other ORMs like NHibernate? Let’s see how we can achieve automatic audit logging in EF v4.

Note: I’m using the bits included in Visual Studio 2010 Beta 2 with additional features included in Entity Framework 4 CTP 2 (not included in VS 2010) which you can download here.

For running Linq queries, we probably already have an existing “ObjectContext” implementation (see previous post). The “ObjectContext” class provides. To create audit log, we need to tap into “SavingChanges” event and populate audit properties. Having an “EntityBase” class as layer super-type that contains “Inserted”, “InsertedBy”, “Updated” and “UpdatedBy” audit fields we can add this cross cutting concern, across all of our entities which is what I’ve done here, but obviously instead of using a base class, you can do this with an Interface. Let’s create an “AuditableObjectContext” which will do the auditing part when the entity is saved by either an Update or an Insert:

public class AuditableObjectContext : ObjectContext
{
    public AuditableObjectContext(EntityConnection connection) : base(connection)
    {
        SubscribeEvents();
    }

    protected override void Dispose(bool disposing)
    {
        if (disposing)
        {
            UnSubscribeEvents();
        }

        base.Dispose(disposing);
    }

    private void SubscribeEvents()
    {
        SavingChanges += OnSavingChangesCore;
    }

    private void UnSubscribeEvents()
    {
        SavingChanges -= OnSavingChangesCore;
    }

    private void OnSavingChangesCore(object sender, EventArgs e)
    {
        OnSavingChanges();
    }

    public virtual void OnSavingChanges()
    {
        FillAuditFields();
    }

    private void FillAuditFields()
    {
        var stateManager = ObjectStateManager;
        var inserted = stateManager.GetObjectStateEntries(EntityState.Added);
        var modified = stateManager.GetObjectStateEntries(EntityState.Modified);

        inserted.Where(x => x.Entity is EntityBase).Select(x => x.Entity).Cast<EntityBase>().ForEach(x =>
        {
            x.Inserted = DateTime.Now;
            x.InsertedBy = Thread.CurrentPrincipal.Identity.Name;
        });

        modified.Where(x => x.Entity is EntityBase).Select(x => x.Entity).Cast<EntityBase>().ForEach(x =>
        {
            x.Updated = DateTime.Now;
            x.UpdatedBy = Thread.CurrentPrincipal.Identity.Name;
        });
    }
}

Our existing “SalesObjectContext” class from previous post, now looks like this:

public class SalesObjectContext : AuditableObjectContext
{
    public SalesObjectContext(EntityConnection connection)
        : base(connection)
    {
    }

    public IObjectSet<Category> Categories
    {
        get { return CreateObjectSet<Category>(); }
    }

    public IObjectSet<Product> Products
    {
        get { return CreateObjectSet<Product>(); }
    }
}

It was pretty easy and painless to create auditing fields, don’t you think? In the next post, we'll see how to implement repository pattern using POCO mode and EF v4.

EntityFramework 4 - Part One : Persistence Ignorance

2009-12-02T09:54:36.347

With the release of EntityFramework v1 and lack of features such as Lazy Loading and Persistence Ignorance leading to Vote of No Confidence resulted the team working on Entity Framework project to actually change route and as the result, a lot of improvements has been made in EntityFramework v4. Wait a second…What happened to v2 and v3, you might ask? Well, EntityFramework vNext that will be released with .NET Framework 4 is named EntityFramework v4, so you didn’t miss anything. Let’s see how PI works in this version.

Note: I’m using the bits included in Visual Studio 2010 Beta 2 with additional features included in Entity Framework 4 CTP 2 (not included in VS 2010) which you can download here.

No base class required

Unlike previous version, your entity classes may have no base class at all and you don’t have to implement a lot of interfaces to make your POCO class an entity. Whether you’re designing your models in code or using the model designer, the choice for a base class on your entities is an optional one. This makes things a lot easier and you’ll end up with a much simpler domain model.

All Code Development

Also referred to as Model First, this is where you create the domain model without actually using a designer and use code instead. You now do this by creating regular Plain Old CLR Objects (POCO) to act as your domain entities. The good thing is, you don’t need XML mapping files, you don’t need to decorate your model with cluttering Attributes : just bare POCO classes will do.

Creating a domain model is self explanatory. Here’s the code for a simple Product / Category model:

    public class Category
    {
        public int Id
        {
            get; set;
        }

        public string Name
        {
            get; set;
        }

        public List Products
        {
            get; set;
        }
    }

    public class Product
    {
        public int Id
        {
            get; set;
        }

        public string Name
        {
            get; set;
        }
        
        public int CategoryId
        {
            get; set;
        }

        public Category Category
        {
            get; set;
        }
    }

To query your entity classes you need to create another class that inherits from ObjectContext. This model defines your interactions with your entities and returns your domain entities as a new queryable interface which is IObjectSet. This new interface is made up of IQuerable plus Attach, Detach, Add and Delete functions. Should you need to keep your domain model clean, you can move this class out of your main domain model assemblies:

    public class SalesObjectContext : ObjectContext
    {
        public SalesObjectContext(EntityConnection connection) : base(connection)
        {
        }

        private ObjectSet _categorySet;
        public IObjectSet Categories
        {
            get
            {
                return _categorySet ?? (_categorySet = CreateObjectSet());
            }
        }

        private ObjectSet _productSet;
        public IObjectSet Products
        {
            get
            {
                return _productSet ?? (_productSet = CreateObjectSet());
            }
        }
    }

What about Meta-Data?

As in almost any ORM framework, you need “some” meta-data regarding your domain entities. These metadata are normally data-centric things such as PrimaryKeys, Constraints, Indexes, etc. so are not considered as a part of the domain model, but are needed anyway. Since there’s no EDMX file, how does EntityFramework know about such things? The answer is: It does not. We need to create some mapping files for these metadata. This is like how FluentNHibernate works.

First create your mapping classes using the Fluent API available in EF v4:

    public class ProductMapping : EntityConfiguration
    {
        public ProductMapping()
        {
            HasKey(x => x.Id);

            Property(x => x.Id).IsIdentity();
            Property(x => x.Name).HasMaxLength(20).IsRequired();

            Relationship(x => x.Category).HasConstraint((x, y) => x.CategoryId == y.Id);
        }
    }

Although there could be some improvements here, things such as support for other PrimaryKey generation other than Identity, adding prefix / suffix to table names, etc. it works for now. Finally, you need to register these mappings when creating the ObjectContext:

    public static void FindDVDs()
    {
        var conn = new SqlConnection(); //or any DbConnection instance
        var builder = new ContextBuilder();

        builder.Configurations.Add(new ProductMapping());
        builder.Configurations.Add(new CategoryMapping());

        using(var ctx = builder.Create(conn))
        {
            var dvds = from c in ctx.Categories
                       where c.Name == "DVDs"
                       select c;

            var products = from p in ctx.Products
                           where p.Category == dvds
                           select p;
        }
    }

Closing

No doubt, there’s been a lot of improvements in EntityFramework v4 and it is going the right direction, but a lot needs to be done before I can call it a robust, full feature and more importantly mature framework, but it is not a released product yet. In next port, I’ll add some IoC to the pot and show how to implement repository pattern using EF v4.

BiDi applications with Silverlight 4

2009-11-26T10:46:18.97

I started checking out the new Silverlight 4 Beta this week and the most important feature (for me) added to this release : FlowDirection. If you’re not a WPF guy, this is the equivalent of RightToLeft in WinForm world, just recently added to Silverlight. If this works the way the same feature in WPF works, all custom controls built in this platform will automagically have correct RightToLeft behavior, “Almost” without any additional code from component vendor / developer. Sounds too good to be true, but it is.

To test how this works, we need a Silverlight 4 control first. Well, look no further! AgDataGrid from DevExpress is both free and open-source! Register and grab your version from here. Should you need to see some demos of this control's features go here.

The build is for latest released version of Silverlight 3, so you need to compile it against Silverlight 4 runtime. Open the solution and change the framework version to SL 4 and build it. That’s it.

Now a Silverlight Application and remember to select “Silverlight 4” runtime when Visual Studio asks which runtime version to use. Add reference to assemblies you just built and add a agDataGrid instance to your page:

<dg:AgDataGrid x:Name="grid" FlowDirection="RightToLeft" 
               ShowGroupPanel="Visible">
   <dg:AgDataGrid.Columns>
        <dg:AgDataGridTextColumn x:Name="colFirstname" FieldName="Firstname" HeaderContent="نام" />
        <dg:AgDataGridTextColumn x:Name="colLastname" FieldName="Lastname" HeaderContent="نام خانوادگی" />
        <dg:AgDataGridColumn x:Name="colDateOfBirth" FieldName="DateOfBirth" HeaderContent="تاریخ تولد"/>
    </dg:AgDataGrid.Columns>
</dg:AgDataGrid>

Note the new FlowDirection property on AgDataGrid is added automatically just by compiling it against SL 4.

To make it a better example, let’s add some more sugar to the pot. To localize the GroupPanel text, let’s use a DataTemplate. I also needed to display the DateOfBirth values in PersianCalendar, so I’m going to create a converter for that. The final xaml looks like this:

<UserControl.Resources>

    <cnv:PersianDateConverter x:Key="DefaultConverter" />

    <DataTemplate x:Key="DateTemplate">
        <TextBlock Text="{Binding Converter={StaticResource DefaultConverter}}" />
    </DataTemplate>

    <DataTemplate x:Key="GroupTemplate">
        <TextBlock Text="برای ایجاد یک گروه ، یک ستون را به اینجا بکشید" Foreground="White" Margin="15,11,0,11"/>
    </DataTemplate>
</UserControl.Resources>

<dg:AgDataGrid x:Name="grid" FlowDirection="RightToLeft" 
               ShowGroupPanel="Visible"
               EmptyGroupPanelTemplate="{Binding Source={StaticResource GroupTemplate}}">
   <dg:AgDataGrid.Columns>
        <dg:AgDataGridTextColumn x:Name="colFirstname" FieldName="Firstname" HeaderContent="نام" />
        <dg:AgDataGridTextColumn x:Name="colLastname" FieldName="Lastname" HeaderContent="نام خانوادگی" />
        <dg:AgDataGridColumn x:Name="colDateOfBirth" FieldName="DateOfBirth" HeaderContent="تاریخ تولد" CellDisplayTemplate="{StaticResource DateTemplate}" />
    </dg:AgDataGrid.Columns>
</dg:AgDataGrid>>

Unfortunately, unlike full version of .NET Framework, in beta version of Silverlight 4, there’s no PersianCalendar class! I’m not sure about the justification SL team has made in order to exclude this class, but I hope they’ll include it in the final version. I’ve opened a thread here, requesting this calendar to be added to SL 4, you may want to follow it up.

For now, to do the date conversion “sans” PersianCalendar, I’m going to use my old FarsiLibrary project, now supporting with Silverlight. It is in fact the same projects that existed for WinForm and WPF, now built against Silverlight. You can get it here if you’re interested.

Back to work, the date converted looks like this:

public class PersianDateConverter : IValueConverter 
{ 
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture) 
    { 
        var cell = (AgDataGridCellData) value; 

        if (cell.CellValue == null) 
            return null; 

        var date = DateTime.Parse(cell.CellValue.ToString()); 
        var converted = FarsiLibrary.Utils.PersianDateConverter.ToPersianDate(date); 

        return converted.ToString("D"); 
    } 

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) 
    { 
        throw new InvalidOperationException("one way conversion"); 
    } 
}

…and here’s the output.

You can get the sources of this demo from here.

Create your own validator, TDD style

2009-11-18T11:03:59.82

There are many validation frameworks out there but sometimes you need to build one your own. Let's see how easy it is to build a simple validation framework in TDD style using functionalities in System.ComponentModel.DataAnnotations. This is a rather new assembly introduced in .NET Framework 3.5, mainly used to define metadata for ASP.NET Dynamic Data controls. We're going to use the validation attributes containing in this assembly to validate our entities and models. There's a contrib project on CodePlex which contains extentions to this assembly, if you need to use it further.

Note: If you need to use a more powerful validation framework, it is advised to use CastleValidator, NHibernate Validator or other validation frameworks out there.

For starters, let's create a project structure. We need two projects, one for the unit tests with reference to NUnit assemblies, and another project containing our actual validation framework. Remember to add a reference to System.ComponentModel.DataAnnotations assembly.

When developing in TDD style, you write a failing test before you write the actual code, then implement the functionality and make the test pass. After the test is passed, you can do some refactoring and continue the procedure from the start. Other development styles that also use "some" kind of test or unit testing should not be thought of as TDD. The emphasis on TDD style is to write the test first, not after the implementation which is usually referred to as Test After style.

As the workflow suggests, let's create our very first test. We want to test that the default validator instance can validate a model / entity. Here's the test:

[TestFixture]
public class ValidatorTests
{
    [Test]
    public void Can_Validate_Models()
    {
        var validator = new DefaultValidator() as IValidator;
        var model = new Person();

        Assert.DoesNotThrow(() =< validator.Validate(model));
    }
}

As you can see, the test won't even compile. We need to create missing classes and compile the solution first to make sure the test fails.

Note: If you're using Resharper addin, it can create almost every missing piece of the puzzle for you. To do this, click the missing class, interface or method, press ALT + Enter and select proper option from appearing menu. Resharper has a plugin called TDD Productivity plugin which helps you create missing types in referenced projects more easily.

Create a new interface in the project containing the implementation named "IValidator" and create the "Validate" method:

/// <summary>
/// Validates an object
/// </summary>
public interface IValidator
{
    void Validate<TEntity>(TEntity entity);
}

We need a default implementation of "IValidator", to no surprise named "DefaultValidator":

public class DefaultValidator : IValidator
{
    public void Validate<TEntity>(TEntity entity)
    {
        throw new NotImplementedException();
    }
}

The last remaining bit before we can compile the project is to create a Person class in our test project. This will be used as the object which we'll try to validate:

public class Person
{
}

Let's compile and run the test. The test will fail as expected. Since our test was over simplified, making it pass would be as easy as removing the exception:

public void Validate<TEntity>(TEntity entity)
{
}

Not much of an implementation. Let's create a new test and change the Validate method to return a list of validation errors.

[Test]
public void Validate_Returns_ValidationErrors()
{
    //Arrange
    var validator = new DefaultValidator() as IValidator;
    var model = new Person();

    //Act
    var result = validator.Validate(model);
            
    //Assert
    Assert.That(result.Count, Is.EqualTo(0));
}

Note: The Arrange-Act-Assert (or AAA) is a readable test authoring pattern. Tests written in AAA are composed of 3 phases, Arrange in which test preconditions are defined, Act in which code under test is called and Assert in which results are inspected and failures are reported.

Once again, the code won't compile. Let's create missing pieces by changing the method signatures and adding ValidationError class.

/// <summary>
/// Validates an object
/// </summary>
public interface IValidator
{
    IList<ValidationError> Validate<TEntity>(TEntity entity);
}

public class DefaultValidator : IValidator
{
    public IList<ValidationError> Validate<TEntity>(TEntity entity)
    {
        return null;
    }
}

public class ValidationError
{
    public ValidationError(string property, string errorMessage)
    {
        Property = property;
        ErrorMessage = errorMessage;
    }

    public string Property
    {
        get; 
        private set;
    }

    public string ErrorMessage
    {
        get; 
        private set;
    }
}

Running the test, we'll see that it won't pass. Again, having "Doing the simplest thing possible" rule in mind, the implementation would be easy as:

public IList<ValidationError> Validate<TEntity>(TEntity entity)
{
    var errors = new List<ValidationError>();

    return errors;
}

Note: An important TDD principal is to "Do the simplest thing possible that works". This is closely related to YAGNI. We should have two passing tests so far.

It is time to implement the actual validation method. Let's start by creating a failing test:

[Test]
public void Validating_Invalid_Model_Will_Return_Errors()
{
    var validator = new DefaultValidator() as IValidator;
    var model = new Person { Firstname = "John" };

    var result = validator.Validate(model);

    Assert.That(result.Count, Is.EqualTo(1));
    Assert.That(result[0].Property, Is.EqualTo("Lastname"));
    Assert.That(result[0].ErrorMessage, Is.EqualTo("Lastname is required."));
}

Before we run the test, let's add missing properties to our Person class and decorate it with some validation attributes:

public class Person
{
    [Required(ErrorMessage = "Firstname is required.")]
    public string Firstname
    {
        get; set;
    }

    [Required(ErrorMessage = "Lastname is required.")]
    public string Lastname
    {
        get; set;
    }
}

Let's run the test which will fail at this state. We're going to use reflection to read the attributes on the model and see if the property values matches the decorating attribute. Combined with a LINQ query the implementation would be:

public IList<ValidationError> Validate<TEntity>(TEntity entity)
{
    var type = typeof (TEntity);
    var properties = TypeDescriptor.GetProperties(type);
    var errors = from PropertyDescriptor pd in properties
                      let value = pd.GetValue(entity)
                      from attrib in pd.Attributes.OfType<ValidationAttribute>()
                      where !attrib.IsValid(value)
                      select new ValidationError(pd.Name, attrib.ErrorMessage);

    return errors.ToList();
}

If you run the test, you still see one failing test, but that is actually another test that used to pass. So what went wrong? Check out the Assertion we made in test "Validate_Returns_ValidationErrors". The problem is that we have not specified "Firstname" and "Lastname" property on Person instance, and we're asserting that there won't be any errors. To make this test pass again, we should pass a valid person instance. So let's refactor this test into this:

[Test]
public void Validate_Returns_ValidationErrors()
{
    var validator = new DefaultValidator() as IValidator;
    var model = new Person { Firstname = "John", Lastname = "Doe" };
            
    var result = validator.Validate(model);

    Assert.That(result.Count, Is.EqualTo(0));
}

We're almost done. There are some things we can still improve, like reading the error message from resource files instead of ErrorMessage property but I'm satisfied with this implementation so I won't do it in this post. Finally, let's see how good we did implementing this using TDD style by creating a coverage report.

Programming in TDD style has lots of "hidden" benefits too: The effort making things testable will lead you to decoupled components and by creating the tests first, you'll have wider range of unit test compared to test-after style, hence better test coverage.

You can download the source code of this post here.

Reflecting on Interface Inheritance

2009-10-06T12:43:51.3

The other day I was working on an interceptor that listened to calls to some “Services” and redirected the calls to services hosted on remote machine, instead of running it locally when strangest thing happened. I was trying to find and invoke existing methods on my interface that according to reflection, were not there. Those services were using inherited interface:

public interface IServiceBase<T>
{
   T FindOne(Criteria c);
   
   T[] FindMany(Criteria c);
}

public interface ICustomerService : IServiceBase<Customer>
{
    Customer FindByName(string name);
}

I was trying to get methods of ICustomerSerivce defined and inherited from the base interface:

[TestMethod]
public void Can_Find_Base_Method_On_Interface()
{
    var service = typeof (ICustomerService);
    var method = service.GetMethod("FindOne");

    Assert.IsNotNull(method);
}

Unfortunately, this fails! It seems reflection does not work consistently on inherited interfaces. To solve this, you'd have all the base methods “redefined”, which becomes very nasty if you have multiple interface inheritances, or if you extensively use generics on interface level. So changing the above code to this will make the test go green:

public interface ICustomerService : IServiceBase<Customer>
{
    Customer FindByName(string name);
    
    new Customer FindOne(Criteria c);
   
    new Customer[] FindMany(Criteria c);
}

I still don't know why this behavior, or maybe this is a known issue?

Update: Found out that the behavior in fact is inline with ECMA CLI specifications. You can however check the methods on Interface's other interfaces. See a solution here

Anatomy of an ASP.NET MVC Control

2009-09-27T09:11:03.963

One of the great things about ASP.NET WebForms was that it wasy very easy to creat reuseable custom controls and components, but with appearance of ASP.NET MVC and lots of developers moving towards it, which is a good thing, what happens to component oriented development? Is is possible to create custom controls in MVC? Can we port our existing controls to MVC? ASP.NET MVC while may not be as good as WebForms when it comes to drag-and-drop style of using components, but it is fairly easy to use and to create custom controls in MVC! Let's see how. To create a control in WebForms world, you'd extend the existing WebControl class and override Render method which takes a HtmlTextWriter that you can use to output the desired HTML code to the browser. A control rendering Hello World on the screen would be as simple as this:

public class HelloWorldControl : WebControl 
{
    protected override void Render(HtmlTextWriter writer)
    {
        base.Render(writer);
        
        writer.Write("<span>HelloWorld</span>");
    }
}

You'd put this on your web page and you're all set. But what's the best approach in MVC controls? There's no WebControl or Control classes inside Mvc assemblies, so can either use any existing class you have as a base class or it from scratch.

public class WebControl
{
    /// <summary>
    /// Renders the control by writing the html code into the text writer.
    /// </summary>
    /// <param name="textWriter"></param>
    public virtual void Render(TextWriter textWriter)
    {
    }
    
    /// <summary>
    /// Renders the control and outputs the generated HTML code.
    /// </summary>
    /// <returns></returns>
    public string OnRender()
    {
        var tw = new StringWriter();
        
        Render(tw);
        
        return tw.ToString();
    }
}

With this, you have a ready to use base class for your controls. You need to override the Render method and construct the right HTML code. The code would look almost identical:

public class HelloWorldControl : WebControl
{
    public override void Render(TextWriter writer)
    {
        base.Render(writer);
        
        writer.Write("<span>Hello World!</span>");
    }
}

Note: There's a catch here. We'd use existing methods on HtmlTextWriter in WebForms, which emitted correct HTML code per Browser. If you're writing the HTML code manually (as I did in this example) you'd be careful in case you need to support different browsers. How do we use this in an MVC application you might ask? The way to do this, as it is already done in the MVC framework with other controls such as TextBox, CheckBox, etc. is to create an extension method on HtmlHelper class:

public static class HelloWorldControlExtensions
{
    public static string HelloWorld(this HtmlHelper helper)
    {
        var control = new HelloWorldControl();
        
        return control.OnRender();
    }
}

Now you can add this controls to your views, as easy as other controls such as TextBoxes:

<%= Html.HelloWorld() %>

That's almost it. The only thing remaining here is to implement control specific logic of your components and that part is left to you.

Caliburn = Less Code?

2009-09-27T12:02:39.413

Caliburn is an application framework for WPF / Silverlight. If you're developing applications for these platforms, there are many reasons why you definitely need to be using this framework, but today, I noticed how using this framework resulted writing less code while doing more. Let's see how writing a small WPF application using MVVM pattern is different when using Caliburn. Note: There are many other ways to skin a cat. This is how I do things, there may be other, better ways to do the same thing.

Application Startup
When creating an application using MVVM and ViewModel First development, you'd create the root View and VM, bind them through DataContext and show the main window of the application.

///
/// Interaction logic for App.xaml
///
public partial class App : Application
{
    protected override void OnStartup(StartupEventArgs e)
    {
        base.OnStartup(e);
        
        var container = new WindsorContainer();
        var rootView = new RootView();
        var rootModel = new RootViewModel();
        
        rootView.DataContext = rootModel;
        this.MainWindow = rootView;
        this.MainWindow.Show();
    }
}

With caliburn, all you need to do is to create the root VM. There's no trace of any View creation and binding the DataContext to VM. All this is done automatically by Caliburn. To do this, use CaliburnApplication as your base application class which will configure Caliburn framework upon startup. There are other ways to do the configuration but let's stick to this simple configuration scenario that installs default implementations of Calburn Components.

///
/// Interaction logic for App.xaml
///
public partial class App : CaliburnApplication
{
    protected override IServiceLocator CreateContainer()
    {
        var container = new WindsorContainer();
        var adapter = new WindsorAdapter(container);
        
        return adapter;
    }
    
    protected override object CreateRootModel()
    {
        return new RootViewModel();
    }
}

One thing a little different is that Caliburn uses IServiceLocator insterface (from Common Service Locator) and has no direct dependency on a vendor specific IoC Container, which is a good thing. This means, you can choose various IoC containers and adapters for major IoC containers like Windsor, Ninject, Autofac, etc. are already included in Caliburn bits. If you're not a fan of IoC containers and won't be using one in your application (now, come on!), Caliburn uses a lightweight built-in container, in case you don't specify any other.

Actions and Commands
Should you bind an action to a ICommand instance on the VM, in pure MVVM application you would bind the Command property to an ICommand instance on the VM. You can specify the condition on which the command will be executable and you'll also implement the action execute by the command.

<Button Command="{Binding ExitCommand}" Content="Exit Application">

public class RootViewModel : BaseViewModel
{
    private ICommand _exitCommand;
    public ICommand ExitCommand
    {
        get
        {
            if (_exitCommand == null)
                _exitCommand = new RelayCommand(this.Exit, this.CanExit);
            
            return _exitCommand;
        }
    }
    
    public bool CanExit()
    {
        return true;
    }
    
    public void Exit()
    {
        Application.Current.Shutdown();
    }
}

Notice there are other hidden code here too. You'll need to create a new Command, or use RelayCommand (kudos to Josh) and you probably need a common layer supertype that implements INotifyPropertyChanged interface. Using Caliburn you'd bind the action directly to the VM and there's no dependency to ICommand instances. The good thing is, you're not limited to Command property anymore and you can bind various other events such as Click, MouseOver, etc. to actions on your VM.

<Button cal:Message.Attach="[Event Click] = [Action Exit]" Content="Exit Application">

public class RootViewModel : Presenter
{
    public bool CanExit()
    {
        return true;
    }
    
    public void Exit()
    {
        Application.Current.Shutdown();
    }
}

There are lots of existing boilerplate functionalities already available in Caliburn, so you can drop BaseViewModel and use Presenter class (IPresenter implementation).

Displaying Views
To display other views in the RootView (e.g. Shell), we'd constructed a new VM and set it to a Content property of a ContentControl. This will actually pick up the view specified in the DataTemplate from Application Resources, and display it on the UI. You have to maintain a mapping between your Views and your VMs in a resource dictionary and as your application grows this gets harder to maintain.

<Application.Resources>
    <DataTemplate DataType="{x:Type vm:CustomerViewModel}">
        <view:CustomerView />
    </DataTemplate>
</Application.Resources>

<ContentControl Content="{Binding Path=CurrentView}"/>

public class RootViewModel : BaseViewModel
{
    public void ShowCustomer()
    {
        CurrentView = IoC.Resolve<Customerviewmodel>();
    }
    
    private BaseViewModel _currentView;
    public BaseViewModel CurrentView
    {
        get { return _currentView; }
        set
        {
            _currentView = value;
            RaisePropertyChanged("CurrentView");
        }
    }
}

Let's see how we can do this using Caliburn. First off, we do not need to maintain any ViewModel mapping if we name our Views and ViewModels according to the Caliburn Conventions that is, your view names should ending in View, presenters / VMs ending in ViewModelor Presenter and each should be in a separate namespace, namingly Views and ViewModels or Presenters. This is just by convention and you can always override if you need to. Caliburn will automatically create the view for you, set the CurrentPresenter property on the main window (i.e. IPresenterHost) and do any required bindings. Did I mention you don't need the whole mapping of View <-> DataTemplate in your Application / Form resource?

<ContentControl x:Name="CurrentPresenter" >

[Singleton("RootViewModel")]
public class RootViewModel : PresenterManager
{
    public void ShowCustomer()
    {
        var presenter = ServiceLocator.Current.GetInstance<Customerviewmodel>();
        this.Open(presenter);
    }
}

Conclusion
What's the catch? How does Caliburn do this? Caliburn uses Convention over Configuration pattern, so if you do things according to the convention you'll end up saving a lot of code. There's always the possibility to change the default behavior too. By complying to these conventions, clearly you'll end up writing less code, but more importantly the code you do write is cleaner, more robust and probably with better testabilty. With the help of Binding Tests utilities existing in Caliburn, you can test your bindings the easy way, which is some thought for later posts.

Windsor Registration : Service Interface

2009-09-27T12:11:23.283

Sometimes when registering classes on Windsor container, that extend an existing base class with an interface, using auto registration and FirstInterface method is useless, because first interface finds the interface implemented by base class:

[TestFixture]
public class RegistrationFixture : ContainerTest
{
    [Test]
    public void Can_Find_Service_Using_Interface()
    {
        var service = TryResolve<IService>();

        Assert.That(service, Is.Not.Null);
    }

    protected override void OnSetup()
    {
        base.OnSetup();

        Container.Register(AllTypes.From(typeof(ServiceImpl))
                     .Where(null)
                     .Configure(x => x.LifeStyle.Is(LifestyleType.Transient))
                     .WithService.FirstInterface());
    }
 
    private interface IBaseService
    {
    }

    private interface IService
    {
    }

    private class BaseService : IBaseService
    {
    }

    private class ServiceImpl : BaseService, IService
    {
    }
}

If you run the test, it will fail, because ServiceImpl is registered with IBaseService interface, which is the first interface on the class hierarchy. But that is not what I intended to do. I wanted the to register it using the first interface on the same type, e.g. IService. Extension methods come to the rescue:

public static class ContainerExtensions
{
   public static BasedOnDescriptor FirstInterfaceOnClass(this ServiceDescriptor serviceDescriptor)
   {
       return serviceDescriptor.Select((t, bt) =>
       {
           var baseInterfaces = t.BaseType.GetInterfaces();
           var interfaces = t.GetInterfaces().Except(baseInterfaces);

           return interfaces.Count() != 0 ? new[] {interfaces.First()} : null;
       });
   }
}

Changing the registration to this would pass the failing test:

    Container.Register(AllTypes.From(typeof(ServiceImpl))
                 .Where(null)
                 .Configure(x => x.LifeStyle.Is(LifestyleType.Transient))
                 .WithService.FirstInterfaceOfClass());

LOB Application in WPF

2009-10-18T14:07:33.827

I've been working on a small LoB application to manage sales of a small sales office. I thought it'd be a good idea to put to use my WPF knowledge and use WPF to create this application. The reason is obvious : Programming in WPF is as easy as it gets, more testable (as in Unit Testing and Acceptance Testing) and more end-user friendly.

Following applicaiton components and patterns were used:

NHibernate
NHibernate Validator to validate both entities and ViewModels
FarsiLibrary (globalizing Dates, DatePickers, etc.)
MVVM pattern

One part that took more effort than expected was localization and globalization of the application. In general, there are three things you need to check to achieve full localization, if you provide both Left-To-Right reading order languages (English) as well as Right-To-Left (Farsi, Arabic) :

Flow Direction

Thanks to WPF engine, most of the calculation of LTR reading order to RTL for Forms, UserControls and even Custom Controls is done automagically, although in custom controls, you might need to add some triggers to switch things like shadows, etc. and if you use a 3rd party custom control or library, you need to make sure component vendor has take care of issue like that.

Texts

WPF uses LocaBaml to extract localizable properties' values to an excel file and after translation (e.g. assigning values for other languages), puts them in a satelite assembly. This approach looks rough to maintain but there are lots of libraries on Codeplex that will help you do this with xml files or .resx files. My suggestion is to use WPF Localization Extension which supports localizing FlowDirection, Brush, Texts, Images, etc.

Dates

Not eveyone use Gregorian Calendar available in english language cultures. For example in Arabic language HijriCalendar is used and for Farsi, PersianCalendar is used and sometimes just setting thread's culture to the language (e.g. Farsi) would not be enough. If you use dates in your applications (who doesn't?) you need to use date controls that work fluently with various languages and cultures. I used my own FarsiLibrary control for WPF which allows you to work with PersianCalendar, HijriCalendar and GregorianCalendar seamlessly.

System Messages

With all the efforts and steps mentioned above, one part of the application still remains in native language of the Windows Installation. That is when using Windows's MessageBox to alert user and display messages. Fortunately, I already have my Expression Clone styles which come with a Expression style messagebox that come with localizable icons / button texts.

Styling

No doubt one of the features that comes with WPF is the ability to style everything that makes sense to provide a better UX. I used my Expression styles which you can download here to style your WPF applications very easily to make it look like Expression series.

Before Styling

Using Expression Styles

XamDataGrid Validation with NHibernate Validator

2009-09-27T12:05:59.017

One of the good grid controls in WPF world belongs to Infragistics. With all the bells and whistles, there are still some limitation, some are WPF engine limitation and some are not. One thing that is very limiting is validation of data prior them being added to datasource. This is rather a broad subject, but I intended to use NHibernate entities (POCO objects) decorated with NHiberante validator attributes to do the validation for me.

NHibernate Validator

NHibernate Validator is a subproject in NHibernate Contrib which allows you validate plain business classes by using predefined set of validation attributes. The good thing is, as good as NHibernate uses POCO (Plain Old CLR Object) objects you can also validate any kind of simple classes using NHibernate validator. There are other validation frameworks out there but I didn't wanted to clutter my object with the validation mechanism and I also didn't want to write unnecessary properties on my domain objects (e.g. IsValid, etc.) so NHibernate Validator was a right choice for me. Let's see how a POCO entity along with validation looks like:

public class Product
{
    public Product()
    {
    }

    public long ProductId
    {
        get;
        private set;
    }

    [NotNullNotEmpty]
    public string Title
    {
        get; set;
    }

    [NotNull]
    public Category Category
    {
        get; set;
    }

    public string Description
    {
        get; set;
    }

    [Min(0)]
    public long Quantity
    {
        get; set;
    }
}

Binding To XamDataGrid

XamDataGrid supports binding to IEnumerable interface, so an IList<Product> would work. Also, XamDataGrid needs a public parameterless constructor if you're going to add to that collection from the grid control. If this requirement is not met, grid control will silently ignore the NewLine setting value. Here's the xaml snippet to display a grid with predefined fields (columns) and a NewLine row:

<igdp:XamDataGrid DataSource="{Binding ProductList}">
    <igdp:XamDataGrid.FieldLayouts>
        <igdp:FieldLayout>
            <igdp:FieldLayout.Settings>
                <igdp:FieldLayoutSettings AddNewRecordLocation="OnTopFixed" AllowDelete="False"
                             AllowAddNew="True" ExpansionIndicatorDisplayMode="Never"
                />
            </igdp:FieldLayout.Settings>
            <igdp:FieldLayout.Fields>
                <igdp:Field Name="Title"       Label="Product Name" />
                <igdp:Field Name="Category"    Label="Category" />
                <igdp:Field Name="Description" Label="Comment"/>
                <igdp:Field Name="Quantity"    Label="Qtty" />
                <igdp:Field Name="ProductId"   Visibility="Collapsed"/>
            </igdp:FieldLayout.Fields>
        </igdp:FieldLayout>
    </igdp:XamDataGrid.FieldLayouts>
</igdp:XamDataGrid>

Now when you run the application and add a new Product object to the datasource, there's no way to check if all the predefined validation rules are okay. So, how do we change the behavior of the grid control to:

Validate the product object PRIOR being added to the datasource so if an object is not validate, it won't get added to the data source.
No redundant validation code should be written. We need to use NHibernate Validator infrastructure we already have in place.
A reusable mechanism. Our application might end up with lots of grid controls.

One way would be to subclass the grid control which although might work, is a heavy handed solution to our rather little problem. It is not right to put the code in our ViewModel (I'm using MVVM pattern), which introduces coupling betwee UI and ViewModel. Fortunately, this grid control exposes good events we can tap into and change the default validation behavior and we can do this by creating a new Attached Behavior.

Validation Attached Behavior

Attaching a behavior to an object, as the name puts it, means making the object do something that it would not do by default. According to Josh Smith:

“The idea is that you set an attached property on an element so that you can gain access to the element from the class that exposes the attached property. Once that class has access to the element, it can hook events on it and, in response to those events firing, make the element do things that it normally would not do. It is a very convenient alternative to creating and using subclasses, and is very XAML-friendly.”

and that's exactly what we're going to do. We're going to listen to one event in particular : “RecordUpdating” which fires when the user had edited an item and the control wants to submit the changes back to the data source. Here's the part that does the validation:

private static void OnRecordUpdating(object sender, RoutedEventArgs e)
{
    var arg = (RecordUpdatingEventArgs)e;
    var dataobject = arg.Record.DataItem;
    var rules = GetAllInvalidRules(dataobject);
    var grid = (XamDataGrid)sender;

    if (rules != null && rules.Count > 0)
    {
        var propertyName = rules[0].PropertyPath;
        var propertyTitle = grid.DefaultFieldLayout.Fields[propertyName].Label;

        arg.Action = RecordUpdatingAction.CancelUpdateRetainChanges;
        arg.Record.Tag = string.Format("Check Field : {0}", propertyTitle);
    }
    else
    {
        arg.Record.Tag = null;
    }

    e.Handled = true;
}

Note : We only display one error at a time. If you need to display all of them at once, you can do so by changing the code a little bit.

We place the error information on the Record object's Tag information. In our little RecordSelector style, we'll display an error icon in case Tag property is set to some error information:

<Style TargetType="{x:Type igdp:RecordSelector}">
    <Setter Property="Template">
        <Setter.Value>
            <ControlTemplate TargetType="{x:Type igdp:RecordSelector}">
                <Image x:Name="ErrorIcon" Source="pack://application:,,,/GridValidation;component/Images/FieldError.png"
                 Width="16" Height="16" Margin="4,0,0,0" Visibility="Collapsed" ToolTip="{Binding Tag}" />
                <ControlTemplate.Triggers>
                    <DataTrigger Binding="{Binding Path=Tag, Converter={StaticResource DefaultNullConverter}}" Value="False">
                        <Setter TargetName="ErrorIcon" Property="Visibility" Value="Visible" />
                    </DataTrigger>
                </ControlTemplate.Triggers>
            </ControlTemplate>
        </Setter.Value>
    </Setter>
</Style>

One last thing that is remaining, is to connect our attached behavior to our xamDataGrid control. The great thing about the attached behaviors (one of them, at least) is that you can use them from XAML code directly and no code-behind is required at all. So back to our xamDataGrid code, here's how to do the trick:

<igdp:XamDataGrid DataSource="{Binding ProductList}"
                                 bhv:DataGridValidationBehavior.HasRowValidation="true">

Conclusion
The final application looks like this picture. If you try to enter something wrong, either when creating a new item or editing one, validation mechanism will automagically kick in and does the work for you. The very important point is that data is retained in the new line but is it not added to the datasource, because the data is not validated.

You can download the source code from here. In order to fully compile and run the application, you need to install Infragistics WPF components which you can download here.

Infragistics WPF Reporting

2009-09-28T09:12:41.387

I've been looking for flexible Reporting components for the WPF application I'm working on, and strangely enough, there are just a few. I think WPF component in general is still a work in progress, and even if you have the chance to find a working component, there ALL have a lot of short comings and lack design-mode features, developer-friendliness, etc. and when it comes down to reporting component, there is Infragistics with very basic feature set, ComponentOne with years of background in reporting tools and Stimulsoft with complete reporting set for WinForm, WPF and Web.

So, I start evaluating each one. Stimusoft WPF reporting looked very promising with all bells and whistles like end-user WPF designer and the whole UI (designer and preview) were in WPF, but If I'm going to buy a component I need more that just a reporting tool, how about having bunch of other controls as well? I skipped to ComponentOne and after downloading their package (around 100 MB download), the damn installation did not work and I was staring at the installation error message that had to do something with packaging. So in reality, I had only one more choice : Infragistics.

Infragistics Reporting

With very basic feature, Infragistics reporting is also easy to use. Since there is no designer (yet?) you have to code your report and create various report sections (Header, Footer, etc.) and add related stuff into that sections, all in code. The great thing about this reporting control (also a feature of ComponentOne) is that you can print any kind of UIElement, this means you can print your whole UserControl or Form which comes in handy.

The real power of Infragistics reporting is when combined with their “Data Presenter” or “XamDataGrid” control. End-user can apply filtering, grouping, sorting, etc. and just print the result, easy as that.

RightToLeft Issue

When evaluating my application which is a multi-lingual application that supports RightToLeft and LeftToRight reading ordered languages, I came across a problem when printing controls with RightToLeft flow direction. The problem was that the whole control is “Mirrored”. Not that this mirroring is an issue, but all the texts and values printed are also mirrored which makes the whole report useless.

Workaround

The workaround is, of course, not to print the control in RightToLeft and use LeftToRight for the time being until the bug is fixed. As easy as this sounds, it is not very easy to do for some reasons:

RightToLeft is usually set on the parent (Form), and controls just “inherit” the setting from their parent.
If you do change parent's RightToLeft end-user will see the effect.

But you can always clone the object and change the behavior, right? But you can not do so with Visual Elements. There's no Copy / Clone method on Visual elements in WPF, so how do we “clone” the control, change the FlowDirection, and hand it to the reporting?

Fortunately, WPF comes with two neglected classes : “XamlWriter” and “XamlReader” each of which do as exactly as the name puts it. Using “XamlWriter” you can write a Visual object (UIElement) into a string, then use “XamlReader” ton construct it back. This is just about the UI, so you'll have to re-attach the “DataSource” and “DataContext” you might have. Here's the snippet to do the trick:

public XamDataGrid Clone(XamDataGrid printable)
{
    //Clone the grid control
    var o = XamlWriter.Save(printable);
    var sr = new StringReader(o);
    var reader = XmlReader.Create(sr, new XmlReaderSettings());
    var result = (XamDataGrid)XamlReader.Load(reader);

    //It's a clone, need to reassign data source
    result.DataSource = printable.DataSource;

    //Set flow direction to LTR
    result.FlowDirection = FlowDirection.LeftToRight;

    return result;
}

You can download the whole sample that shows the issue and the workaround. To compile and run it you need to have Infragistics 2009.1 installed. You can download Infragistics package here.

Additional CallContext information in WCF

2009-10-18T09:20:50.333

Yeah, this might be a little old, but someone asked me how to send context information from client to the service with WCF.

Note: In general, you should not rely on client provided information about security, authentication, licensing, etc. Use this code and sample as an idea on how to implement your custom security. If you're trying to send sensitive information over the network, use this at your own risk.

WCF client and services might be (and probably are) in two separate AppDomain or even on separate machines across the network, so how do we send extra information from the client to the service when the service call is made? Fortunately, WCF provides enough extensibility points for us to participate in the action and change the default behavior. It is pretty much easy to add context information to the message header on the client side, and the on the server side extract the custom data from the message header. Added data to the message header can be a DataContract / Serialized class.

[DataContract]
public class MessageInfo
{
   public MessageInfo(Guid sessionId, CultureInfo culture, DateTime requestDate)
   {
       this.sessionId = sessionId;
       this.culture = culture;
       this.requestDate = requestDate;
   }

   [DataMember]
   public DateTime RequestDate
   {
       get;
       set;
   }

   [DataMember]
   public Guid SessionId
   {
       get;
       set;
   }

   [DataMember]
   public CultureInfo Culture
   {
       get;
       set;
   }
}

Client uses IClientMessageInspector to add context data before the message is handed over to WCF for the delivery.

/// 
/// Flows the client's MessageInfo to the service.
/// 
public class ClientMessageInfoInspector : IClientMessageInspector
{
   public object BeforeSendRequest(ref Message request, IClientChannel channel)
   {
       request.Headers.Add(MessageHeader.CreateHeader(MessageHeaderKeys.MessageInfoKey, string.Empty, GetInfo()));
       return null;
   }

   public void AfterReceiveReply(ref Message reply, object correlationState)
   {
   }

   private MessageInfo GetInfo()
   {
       return new MessageInfo(Guid.NewGuid(), Thread.CurrentThread.CurrentUICulture, DateTime.Now);
   }
}

On the other hand, the service side uses IDispatchMessageInspector interface to extract the data from message header.

/// 
/// Reads the MessageInfo of client and updates the service.
/// 
public class ServiceMessageInfoInspector : IDispatchMessageInspector
{
   public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
   {
       int headerIndex = request.Headers.FindHeader(MessageHeaderKeys.MessageInfoKey, string.Empty);
       if (headerIndex != -1)
       {
           MessageInfo ui = request.Headers.GetHeader<MessageInfo>(headerIndex);
          
           Thread.CurrentThread.CurrentUICulture = ui.Culture;
           Thread.CurrentThread.CurrentCulture = ui.Culture;

            Console.WriteLine("Request recieved on {0}", ui.RequestDate);
       }

       return null;
   }

   public void BeforeSendReply(ref Message reply, object correlationState)
   {
   }
}

To wire things up, you also need to create a new behavior by implementing IEndpointBehavior and registering it with your endpoint, either by code, or configuration. Should you use a single behavior for both client and server, here's how to do it:

public class MessageInfoBehavior : IEndpointBehavior
{
   public void Validate(ServiceEndpoint endpoint)
   {
   }

   public void AddBindingParameters(ServiceEndpoint endpoint, BindingParameterCollection bindingParameters)
   {
   }

   public void ApplyDispatchBehavior(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher)
   {
       ServiceMessageInfoInspector inspector = new ServiceMessageInfoInspector();
       endpointDispatcher.DispatchRuntime.MessageInspectors.Add(inspector);
   }

   public void ApplyClientBehavior(ServiceEndpoint endpoint, ClientRuntime clientRuntime)
   {
       ClientMessageInfoInspector inspector = new ClientMessageInfoInspector();
       clientRuntime.MessageInspectors.Add(inspector);
   }
}

Hope this helps.

File Download with ASP.NET MVC

2009-10-18T09:33:58.077

One of the things that might be less obvious when doing applications with ASP.NET MVC, is the ability to download files without exposing your files directly and possibly applying other mechanisms such as authentication or registering emails before allowing someone download your files. This is pretty much easy. The "Controller" class has a File method which returns a "FilePathResult".

public class DownloadsController : Controller
{
    private readonly IProductService _productService;

    public DownloadsController(IProductService productService)
    {
        _productService = productService;
    }

    [SessionPerRequest]
    public ActionResult Index()
    {
        var products = _productService.GetDownloadableProducts();
        var model = new DownloadViewModel(products);

        return View(model);
    }

    [SessionPerRequest]
    public ActionResult File(int id)
    {
        var download = _productService.FindDownload(id);

        if (download != null)
        {
            var path = Server.MapPath(download.URL);
            var file = new FileInfo(path);
            if (file.Exists)
            {
                return File(download.URL, "application/binary", download.FileName);
            }
        }

        return RedirectToAction("Index");
    }
}

<table>
   
    <% foreach (var p in Model.Products) { %>
         <tr>
           <td>
             <strong><%= p.Title %></strong><br />
              
             <%foreach(var d in p.Downloads) { %>
               
                <a href="/Downloads/File/<%= d.Id %>">
                   Version: <%= d.Version %>- <%= d.DownloadSize %> KB
                </a>
                <br />
            <%} %>
               
           </td>
        </tr>
     <% } %>
</table>

NHibernate JetDriver : Another Issue

2009-10-19T13:56:11.3

There is yet another issue with NHibernate and JetDriver I encountered yesterday. It seems that a select query containing "Order By", will gets its "From" keyword cut off at some stage by the Jet Driver. It means simple object querying won't work:

public IList<Account> GetAllAccounts()
{
  using (UnitOfWork.Start())
  {
      var repository = new NHRepository<Account>();
      var orders = new[] { new Order("Firstname", true), new Order("Lastname", true) };

      return repository.FindAll(orders).ToList();
  }
}

To fix it, let's first pin point the problem by creating a failing test. It was a good thing I was already running everything from the trunk build, so I opened up the JetDriver project (from NHContrib) and luckily there is already a test project. Since I didn't want to actually change any method visibility, I used reflection to call the private methods that fails this test:

[TestFixture]
public class JetOrderByFixture
{
  [Test]
  public void Select_Statement_With_OrderBy_Should_Run()
  {
      SqlString sql = new SqlString("SELECT * FROM ACCOUNTS ORDER BY Firstname ASC, Lastname ASC");
      JetDriver driver = new JetDriver();

      SqlString processedSql = driver.GetType()
                                     .GetMethod("FinalizeJoins", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.InvokeMethod)
                                     .Invoke(driver, new object[] { sql }) as SqlString;

      Assert.That(processedSql, Is.Not.Null);
      Assert.That(processedSql.LastIndexOfCaseInsensitive("FROM"), Is.GreaterThan(0));
  }
}

The problem is the private FinalizeJoins method, so the test, to no surprise, fails. I have created a task in NHibernate's Jira and the patch to fix this is attached, if you need it.

Unit Testing with TypeMock

2009-10-19T13:57:10.24

Unit Testing ASP.NET? ASP.NET unit testing has never been this easy.

Typemock is launching a new product for ASP.NET developers : the ASP.NET Bundle - and for the launch will be giving out FREE licenses to bloggers and their readers.

The ASP.NET Bundle is the ultimate ASP.NET unit testing solution, and offers both Typemock Isolator, a unit test tool and Ivonna, the Isolator add-on for ASP.NET unit testing, for a bargain price.

Typemock Isolator is a leading .NET unit testing tool (C# and VB.NET) for many â€˜hard to testâ€™ technologies such as SharePoint, ASP.NET, MVC, WCF, WPF, Silverlight and more. Note that for unit testing Silverlight there is an open source Isolator add-on called SilverUnit.

The first 60 bloggers who will blog this text in their blog and tell us about it, will get a Free Isolator ASP.NET Bundle license (Typemock Isolator + Ivonna). If you post this in an ASP.NET dedicated blog, you'll get a license automatically (even if more than 60 submit) during the first week of this announcement.

Also 8 bloggers will get an additional 2 licenses (each) to give away to their readers / friends.

Go ahead, click the following link for more information on how to get your free license.

NHibernate and DateTime

2009-10-18T09:53:58.573

I've been working on a WPF application which is maybe another post. The work is done and I have started localizing the applications. Localization was mostly chanding the FlowDirection and lables / texts for other languages, but when testing the application, I came across an intresting problem with Nhibernate. The application worked correctly in default (en-us) culture, but not in fa-ir, as NHibernate reported problems when running the working query. This highlights the problem:

[Test]
public void Can_Run_Query_In_Persian_Culture()
{
  using(new CultureContext(new PersianCultureInfo()))
  {
      using (UnitOfWork.Start())
      {
          var todayStart = new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 0, 0, 0, CultureHelper.DefaultCalendar);
          var todayEnd = new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 23, 59, 59, CultureHelper.DefaultCalendar);

          var queryable = UnitOfWork.CurrentSession.Linq<Purchase>();
          var query = from sales in queryable
                      where sales.PurchaseDate >= todayStart && sales.PurchaseDate <= todayEnd
                      select sales;

          Assert.DoesNotThrow(() => query.ToList());
      }
  }
}

The test which is totally working on other cultures, fails miserably in fa-ir. The reason is somewhere in the criteria parameter being converted to string. The output of the query being run on the database is this:

[SELECT this_.PurchaseId as PurchaseId4_0_, this_.PaidValue as PaidValue4_0_, this_.PurchaseDate as Purchase3_4_0_, this_.Quantity as Quantity4_0_, this_.IsOwed as IsOwed4_0_, this_.Product_id as Product6_4_0_, this_.PurchaseRegisteredBy_id as Purchase7_4_0_, this_.Purchaser_id as Purchaser8_4_0_ from `Purchase` this_ WHERE (this_.PurchaseDate >= ? and this_.PurchaseDate <= ?) ]

Positional parameters: #0>1388/02/30 12:00:00 Ù‚.Ø¸ #1>1388/02/30 11:59:59 Ø¨.Ø¸

It is obvious that date values are converted to String using current Culture of the running thread, while the conversion should use invariant culture instead:

Invalid:

var dateValue = todayStart.ToString();

Valid:

var dateValue = todayStart.ToString(CultureInfo.InvariantCulture);

Any workaround for this? I haven't found any yet. In fact I still do not exactly know if this is NH core problem or the Linq extensions and since I'm running a build from the trunk, I'm not sure if this is reproducible on released versions.

Update : The problem was actually related to JET Driver of NHibernate Contrib project. A patch is created and sent to authorities.

MVVM Validation With NHibernate Validator

2009-10-18T11:40:33.907

Simplest way to do Validation in WPF is usually implementing IDataErrorInfo interface, and do the validation in the indexer's getter. It turns out to be ugly and gets out of hand when your model / viewmodel gets a little larger. Implementing the IDataErrorInfo is as simple as this:

public string this[string propertyName]
{
  get
  {
      //Validate property that is being set,
      //and return an error message if there's
      //any error.

      return null;
  }
}

public string Error
{
  get { return string.Empty; }
}

I intend to use NHibernate Validator attributes to add non-intrusive validation to my ViewModel classes. So you'd just decorate properties of your ViewModel and let WPF and NHibernate Validator do the rest for you. Before we do that, let's create a more elegant way to show the errors by restyling the TextBox control and add an Error Icon and tooltip to it in case of an error existing:

<Style TargetType="{x:Type TextBox}">
   <Setter Property="Validation.ErrorTemplate">
       <Setter.Value>
           <ControlTemplate>
               <DockPanel LastChildFill="True">
                   <Image x:Name="ErrorIcon" Source="Images/FieldError.png" DockPanel.Dock="Right" Width="16" Height="16" Margin="4,0,0,0" />
                   <Border BorderBrush="Red" BorderThickness="1">
                       <AdornedElementPlaceholder />
                   </Border>
               </DockPanel>
           </ControlTemplate>
       </Setter.Value>
   </Setter>
   <Style.Triggers>
       <Trigger Property="Validation.HasError" Value="true">
           <Setter Property="ToolTip" Value="{Binding RelativeSource={RelativeSource Self}, Path=(Validation.Errors)[0].ErrorContent}"/>
       </Trigger>
   </Style.Triggers>
</Style>

Now that styles are all set, let's configure NHibenrate Validator's engine on application startup. Nothing fancy, just a straightforeward configuration. We'll use a shared validation engine:

public void RegisterValidatorEngine()
{
  var config = new NHVConfigurationBase();

  config.Properties[Environment.ApplyToDDL] = "false";
  config.Properties[Environment.AutoregisterListeners] = "true";
  config.Properties[Environment.ValidatorMode] = "UseAttribute";
  config.Properties[Environment.SharedEngineClass] = typeof(ValidatorEngine).FullName;
  config.Mappings.Add(new MappingConfiguration(DomainAssemblyName, null));

  Environment.SharedEngineProvider = new NHibernateSharedEngineProvider();
  Environment.SharedEngineProvider.GetEngine().Configure(config);

  ValidatorInitializer.Initialize(NHibernateConfig);
}

And to make things reusable, why not create a base ViewModel:

public abstract class ValidatableViewModel : IDataErrorInfo
{
  private readonly ValidatorEngine validation;

  protected ValidatableViewModel()
  {
      validation = Environment.SharedEngineProvider.GetEngine();
  }

  public string this[string propertyName]
  {
      get
      {
          var rules = GetInvalidRules(propertyName);
          if (rules != null && rules.Count > 0)
          {
              return rules[0].Message;
          }

          return null;
      }
  }

  public string Error
  {
      get { return string.Empty; }
  }

  public IList GetInvalidRules(string propertyName)
  {
      var type = this.GetType();

      return validation.ValidatePropertyValue(type, propertyName, GetPropertyValue(type, propertyName));
  }

  public IList GetAllInvalidRules()
  {
      return validation.Validate(this);
  }

  private object GetPropertyValue(Type objectType, string properyName)
  {
      return objectType.GetProperty(properyName).GetValue(this, null);
  }
}

The rest is just to inherit the ValidatableViewModel and add necessary attributes to our binded properties. A sample ViewModel containing a Save command, which is invocable only when there's no error on the model and a couple of other business properties would look like this:

public class NewAccountViewModel : ValidatableViewModel, INotifyPropertyChanged
{
  private string _firstName;
  private string _lastName;
  private string _currentBalance;

  [NotNullNotEmpty]
  public string Firstname
  {
      get { return _firstName; }
      set
      {
          _firstName = value;
          this.Notify(this.PropertyChanged, o => o.Firstname);
      }
  }

  [NotNullNotEmpty]
  public string Lastname
  {
      get { return _lastName; }
      set
      {
          _lastName = value;
          this.Notify(this.PropertyChanged, o => o.Lastname);
      }
  }

  [IsNumeric]
  [NotNullNotEmpty]
  public string CurrentBalance
  {
      get { return _currentBalance; }
      set
      {
          _currentBalance = value;
          this.Notify(this.PropertyChanged, o => o.CurrentBalance);
      }
  }

  public event PropertyChangedEventHandler PropertyChanged = delegate { };

  private ICommand _cmdSave;
  public ICommand SaveCommand
  {
      get
      {
          if (_cmdSave == null)
              _cmdSave = new RelayCommand(Save, CanSave);

          return _cmdSave;
      }
  }

  public void Save()
  {
      MessageBox.Show("Save");
  }

  public bool CanSave()
  {
      return GetAllInvalidRules().Count == 0;
  }
}

<UserControl x:Class="Jimba.UI.View.NewAccountView"
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
  <StackPanel>
      <StackPanel Orientation="Horizontal">
          <Label Width="100">Firstname:</Label>
          <TextBox Text="{Binding Path=Firstname, UpdateSourceTrigger=PropertyChanged, ValidatesOnDataErrors=True}" />
      </StackPanel>

      <StackPanel Orientation="Horizontal">
          <Label Width="100">Lastname:</Label>
          <TextBox Text="{Binding Path=Lastname, UpdateSourceTrigger=PropertyChanged, ValidatesOnDataErrors=True}" />
      </StackPanel>

      <StackPanel Orientation="Horizontal">
          <Label Width="100">Current Balance:</Label>
          <TextBox Text="{Binding Path=CurrentBalance, UpdateSourceTrigger=PropertyChanged, ValidatesOnDataErrors=True}" />
      </StackPanel>
  </StackPanel>
</UserControl>

ASP.NET MVC Validation with Ajax and Json

2009-10-18T12:21:15.527

ASP.NET MVC has great ajax integration with no doubt. Simply by using ajax forms you can use partial page rendering and there are also controller callbacks. One thing that will break if you switch to Ajax / JsonResult is the built-in Validation result (ModelErrors) rendering of the MVC engine.

It won't work because of a simple fact: The built-in validation will take place when the page is being rendered on the server. When you use ajax and callbacks page will not re-render on the server-side, hence validation can not mark fields with error and add validation information to the already rendered page.

Let's see how you can do this, without using a client-side validation framework.

Creating a Contact Form

First, let's create a form using Ajax.BeginForm and provide a javascript action to process the results. You can get rid of the ValidationMessage and ValidationSummary, since we don't need it anymore:

<% using (Ajax.BeginForm(new AjaxOptions { OnComplete = "ProcessResult" })) { %>
    <p>
   <label for="Name" class="contactLabel">Your Name:</label>
   <%= Html.TextBox("SenderName", Model.SenderName)%>
    </p>
<p>
   <label for="Email" class="contactLabel">Your Email:</label>
   <%= Html.TextBox("Email", Model.Email)%>
    </p>
<p>
   <label for="Subject" class="contactLabel">Subject:</label>
   <%= Html.TextBox("Subject", Model.Subject)%>
    </p>
<p>
   <label for="Message" class="contactLabel">Message:</label>
   <%= Html.TextBox("Message", Model.Message)%>
    </p>
<p>
   <br />
   <input type="submit" value="Send" class="inputButton" />
   <br />
</p>
<div id="operationMessage"><ul></ul></div>
<% } %>

Notice that there is a div at the bottom which acts as an error placeholder and will be used to display validation information.

To actually bind these fields to data, we need to create an POCO class acting as a backing entity. In this example, I've used a poco class and decorate it with NHibernate Validator's attributes to do the validation. See here for more info on how to configure NHibernate Validator using ASP.NET MVC:

public class ContactMessage : IValidatable
{
  public ContactMessage()
  {
     MessageDate = DateTime.Today;
  }

  public virtual int Id
  {
     get; private set;
  }

  [NotNullNotEmpty]
  public virtual string SenderName
  {
     get; set;
  }

  [NotNullNotEmpty]
  [Email]
  public virtual string Email
  {
     get; set;
  }

  [NotNullNotEmpty]
  public virtual string Subject
  {
     get; set;
  }

  [NotNullNotEmpty]
  public virtual string Message
  {
     get; set;
  }

  public virtual DateTime MessageDate
  {
     get; private set;
  }
}

Controller Action

Two methods are needed to handle to Post / Get separately. Our Get method returns a new instance of our contact entity to the view, and Post method is where the operation results is returned to the client using Json. The OperationResultInfo class containing the elaborate error information is what returned as Json to the client:

public class OperationResultInfo
{
  public OperationResultInfo()
  {
     Errors = new List<ErrorReasonInfo>();
  }

  public bool Successfull { get; set; }

  public string Message { get; set; }

  public IList<ErrorReasonInfo> Errors { get; set; }
}

public class ErrorReasonInfo
{
  public string PropertyName { get; set; }

  public string Error { get; set; }
}

[AcceptVerbs(HttpVerbs.Get)]
public ActionResult Contact()
{
  return View(new ContactMessage());
}

[AcceptVerbs(HttpVerbs.Post)]
[AutoValidate]
public ActionResult Contact(ContactMessage msg)
{
  if (ModelState.IsValid)
  {
     try
     {
         this.messengerService.SendMail(msg);

         return Json(new OperationResultInfo
         {
             Successfull = true,
             Message = "Thank you. Your message was sent successfully."
         });
     }
     catch (Exception ex)
     {
         ModelState.AddUnhandledError(ex);
         return Json(new OperationResultInfo
         {
             Successfull = false,
             Message = "There was an error processing your request. Retry later."
         });
     }
  }

  return Json(new OperationResultInfo
  {
     Successfull = false,
     Message = "Could not send your information.",
     Errors = ModelState.GetAllErrors()
  });
}

public static class ModelStateExtensions
{
  public static IList<ErrorReasonInfo> GetAllErrors(this ModelStateDictionary modelState)
  {
     var errors = new List<ErrorReasonInfo>();

     foreach (var state in modelState)
     {
         if (state.Value.Errors.Count > 0)
         {
             var err = new ErrorReasonInfo { PropertyName = state.Key };
             state.Value.Errors.ForEach(x => err.Error += x.ErrorMessage);

             errors.Add(err);
         }
     }

     return errors;
  }
}

Displaying The Json Result

The Json result returned to the client contains all the fields having errors and the related error message. A typical result would look like this:

{
   "Successfull":false, "Message":"Could not send your information:",
   "Errors":
   [
      {"PropertyName":"SenderName", "Error":"may not be null or empty"},
      {"PropertyName":"Email", "Error":"may not be null or empty"},
      {"PropertyName":"Subject", "Error":"may not be null or empty"},
      {"PropertyName":"Message", "Error":"may not be null or empty"}
   ]
}

How do we format this data on the client and display it in a user-friendly fashion on our page? Let's process the Json object using javascript and add the result to the error place holder using jQuery:

<script type="text/javascript">
function ProcessResult(content) {

   var json = content.get_response().get_object();
   var result = eval(json);

   $("#operationMessage > span").empty();
   $("#operationMessage > ul").empty();
   $(':input').removeClass('input-validation-error');

   if (result.Successfull) {
       $('#operationMessage').append('<span>' + result.Message + '</span>')
                             .removeClass('error')
                             .addClass('success');
   }
   else {

       $('#operationMessage').append('<span><br>' + result.Message + '</span>')
                             .removeClass('success')
                             .addClass('error');

       for (var err in result.Errors) {
           var propertyName = result.Errors[err].PropertyName;
           var errorMessage = result.Errors[err].Error;
           var message = propertyName + ' ' + errorMessage;

           $('#' + propertyName).addClass('input-validation-error');
           $('#operationMessage > ul').append('<li># ' + message + '</li>');
       }
   }
}
</script>

Pretty neat, ha? Hope this helps.

Google Analytics in Silverlight

2009-10-18T12:32:53.203

I've been trying to setup Google Analytics Event Tracking in a Silverlight application for a while and despite all the how-tos and artilces on the web, I just couldn't get it running. I kept doing everything proposed, but when the application was run on IE, a javascript error was occurred. Firefox didn't even bother reporting the JS error. So, if you happen to have the same problem, here's how you should do it to get it working.

Event Tracking is when you want to track users accessing various parts of you RIA application, which works differently comparing to html based websites. The basic setup is almost the same: include ga.js javascript on your page hosting the Silverlight application. Include this snippet before </body> tag:

<script type="text/javascript">
   var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl." : "http://www.");
   document.write(unescape("%3Cscript src='" + gaJsHost + "google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E"));
</script>

Next step would be to create a helper javascript function which we'll call in our silverlight application. The script would help us track events on our Silverlight application. Add this just below the above script:

<script type="text/javascript">
   function trackPage(category, action, label) {
       try {
           var pageTracker = _gat._getTracker("xx-xxxxxxxx-x");
           pageTracker._trackPageview();
           pageTracker._trackEvent(category, action, label);
       }
       catch (err) {
       }
   }
</script>

Note: It is essential that calls to_trackPageview is made prior to calling _trackEvent.

Notice how the function is wrapped in a try-catch block so if there is any issues with ga.js loading, we silently ignore the tracking. Strangely, when there was any javascript error in IE 8, some parts of my silverlight application didn't work properly. This helped getting around it.

Usually, you'd call an existing javascript in your silverlight app by calling it this way:

HtmlPage.Window.Invoke("functionName", new[] { args });

But to make things easier, let's create an extension method to help us calling the tracking function:

public static class ViewExtension
{
   public static void Track(this UserControl view, string action, string page, string label)
   {
       HtmlPage.Window.Invoke("trackPage", new string[] { action, page, label });
   }
}

Just need to start tracking now!

NHibernate Automatic Validation

2009-10-18T12:53:42.513

NHibernate is for sure one of the prodigy childs of the .NET open-source movement, yet there are some other great libraries and frameworks. One of them is NHibernate Validator which belongs to NHibernate Contrib project. What it does is to validate your domain entities that supposedly are being persisted using NHibernate, but it provides so much flexibility that you can validate almost every POCO class using attributes.

I'm using it in an ASP.NET MVC project, so first let's see how to configure and make it work here.

Note: I'm using the trunk build of the Castle and NH Contrib Projects. Things may work differently on other versions.

First thing you need to do is to initialize Validator's engine. I'm using it on a web application so let's initialize and use a shared engine. I'm also using the attribute based validation, but you can write the validation logic in your .hbm mapping files.

public class MvcApplication : System.Web.HttpApplication, IMvcApplication
{
  protected void Application_Start()
  {
      RegisterRoutes(RouteTable.Routes);
      CreateDependencyInjectionContainer();
      RegisterControllerFactory();
      RegisterSessionFactory();
      RegisterValidatorEngine();
  }

  private void RegisterValidatorEngine()
  {
      var config = new NHVConfigurationBase();

      config.Properties[Environment.ApplyToDDL] = "false";
      config.Properties[Environment.AutoregisterListeners] = "true";
      config.Properties[Environment.ValidatorMode] = "UseAttribute";
      config.Properties[Environment.SharedEngineClass] = typeof (ValidatorEngine).FullName;
      config.Mappings.Add(new MappingConfiguration("MyApp.Domain", null));

      Environment.SharedEngineProvider = new NHibernateSharedEngineProvider();
      Environment.SharedEngineProvider.GetEngine().Configure(config);

      ValidatorInitializer.Initialize(NHibernateConfig);
  }
}

...and that's it. You can validate entities passed to your controller's action by creating an extension method which simplifies things and automatically adds all the errors to the ModelState:

public static class ControllerExtensions
{
  /// 
  /// Validates an entity
  /// 
  public static void Validate(this Controller controller, IValidatable entity)
  {
      var engine = Environment.SharedEngineProvider.GetEngine();
      var errors = engine.Validate(entity);

      foreach (var error in errors)
      {
          controller.ModelState.AddModelError(error.PropertyName, error.Message);
      }
  }
}

Note that IValidatable is just a marker interface. To call this method and do the actual validation, you need to call the validate method:

[AcceptVerbs(HttpVerbs.Post)]
public ActionResult Contact(ContactMessage msg)
{
  try
  {
      this.Validate(msg);

      if (ModelState.IsValid)
      {
          this.messengerService.SendMail(msg);
          return RedirectToAction("Index");
      }
  }
  catch (Exception ex)
  {
      ModelState.AddUnhandledError(ex);
  }

  return View(msg);
}

Easy, right? but it can even get easier! With the power of ASP.NET MVC ActionFilters we can automagically validate our parameters when the action is invoked:

/// 
/// Automatically validates all the action
/// parameters of type IValidatable.
/// 
public class AutoValidate : ActionFilterAttribute
{
  public override void OnActionExecuting(ActionExecutingContext filterContext)
  {
      var controller = filterContext.Controller as Controller;
      if(controller == null)
          return;

      foreach (var entity in GetEntitiesFromParameters(filterContext.ActionParameters))
      {
          controller.Validate(entity);
      }
  }

  private static IEnumerable<IValidatable> GetEntitiesFromParameters(IEnumerable<KeyValuePair<string, object>> dictionary)
  {
      var validatableParameters = new List<IValidatable>();

      foreach (var keyValue in dictionary)
      {
          if(keyValue.Value is IValidatable)
          {
              validatableParameters.Add((IValidatable)keyValue.Value);
          }
      }

      return validatableParameters;
  }
}

...and your action method looks as simple as this:

[AcceptVerbs(HttpVerbs.Post)]
[AutoValidate]
public ActionResult Contact(ContactMessage msg)
{
  if(ModelState.IsValid)
  {
      try
      {
          this.messengerService.SendMail(msg);
          return RedirectToAction("Index");
      }
      catch (Exception ex)
      {
          ModelState.AddUnhandledError(ex);
      }
  }

  return View(msg);
}

Have fun validating!

Code Review No. N, or Do chimps write code better than us?

2009-10-18T13:07:29.463

Well, this is not actually my first code review, but this is supposed to be a copycat of 'Code Review WTF, Number N' series by Ayende Rahien.

I was inspecting an open-source code base which is a medical business application. So why am I reviewing the code base? I had a request to add persian calendar support to this application and I was trying to figure out how much time does this take and if it is possible.

There are very serious issues here, I even don't know where to start! For a open-source project at its 6th version, I was hoping things to be pretty much solid. Apparently with all the bells and whistles on developer's website, it is not.

Using a strange naming conversion for your project like xCodeBase, xODR is BAD.
Having A LOT of commented code in your code base is a BAD practice.
Exposing class fields as public is a BAD practice. Try using properties.
Using IF statements to check for database types ALL OVER THE PLACE is VERY BAD.
Obfuscated class and method names are considered BAD (unless you've used an obfuscator) as in Lan class which does the string translation job with public methods named g, F and C!!
Wrapping remote method names in an ENUM. What were you thinking?!

After going through some of the classes, I think I'm going crazy! Okay, let's see how's the business logic being handled. That's the major part of the application, right?

Data is accessed by DataCore class in server AND client side (depending if remoting is used), which retrieves the data in an UnTyped dataset. To make things easier(?) there's one single method to invoke remote BusinessLayer implementation methods:

public static DataSet GetDsByMethod(MethodNameDS methodName, object[] parameters)
{
   switch (methodName)
   {
       default:
           throw new ApplicationException("MethodName not found");
       case MethodNameDS.AccountModule_GetAll:
           return AccountModules.GetAll((int)parameters[0], (bool)parameters[1], (DateTime)parameters[2], (DateTime)parameters[3], (bool)parameters[4]);
       case MethodNameDS.Appointment_GetApptEdit:
           return Appointments.GetApptEdit((int)parameters[0]);
       case MethodNameDS.Cache_Refresh:
           return Cache.Refresh((string)parameters[0]);
       case MethodNameDS.CovCats_RefreshCache:
           return CovCats.RefreshCache();
   }
}

public enum MethodNameDS
{
   AccountModule_GetAll,
   Appointment_GetApptEdit,
   Cache_Refresh,
   CovCats_RefreshCache,
}

Dude! WTF is that?! and then there's a similar method to work with DataTables!

On the server where client requests are processed, data is being serialized / deserialzed by a "WorkerClass". The code to perform the client's request is what makes me wonder!

public class WorkerClass
{
   private NetworkStream netStream;

   // The constructor obtains the state information.
   public WorkerClass(NetworkStream stream)
   {
       netStream = stream;
   }

   public void DoWork()
   {
   while(true) {//Each loop gets and returns one message pair.
       byte[] data =  null;
       // Retrieve data from client
       try {
           data = RemotingClient.ReadDataFromStream(netStream);
       }
       catch {//if connection was closed by client.
           break;
       }
       DataTransferObject dto=DataTransferObject.Deserialize(data);
       //Process and send response to client--------------------------------------
       XmlSerializer serializer;
       using (MemoryStream memStream = new MemoryStream()) {
           try {
               Type type = dto.GetType();
               if (type == typeof(DtoGetDS)) {
                   DataSet ds = DataCore.GetDsByMethod(((DtoGetDS)dto).MethodNameDS, ((DtoGetDS)dto).Parameters);
                   serializer = new XmlSerializer(typeof(DataSet));
                   serializer.Serialize(memStream, ds);
               }
               else if (type == typeof(DtoGetTable)) {
                   DataTable tb = DataCore.GetTableByMethod(((DtoGetTable)dto).MethodNameTable, ((DtoGetTable)dto).Parameters);
                   serializer = new XmlSerializer(typeof(DataTable));
                   serializer.Serialize(memStream, tb);
               }
               else if (type.BaseType == typeof(DtoCommandBase)) {
                   int result = BusinessLayer.ProcessCommand((DtoCommandBase)dto);
                   DtoServerAck ack = new DtoServerAck();
                   ack.IDorRows = result;
                   serializer = new XmlSerializer(typeof(DtoServerAck));
                   serializer.Serialize(memStream, ack);
               }
               else if (type.BaseType == typeof(DtoQueryBase)) {
                   DataSet ds = BusinessLayer.ProcessQuery((DtoQueryBase)dto);
                   serializer = new XmlSerializer(typeof(DataSet));
                   serializer.Serialize(memStream, ds);
               }
               else if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(FactoryTransferObject<>)) {
                   // Pass the DTO to the FactoryServer<T>
                   Type factoryServerType = typeof(FactoryServer<>);
                   factoryServerType = factoryServerType.MakeGenericType(type.GetGenericArguments());

                   MethodInfo processCommandMethod = factoryServerType.GetMethod("ProcessCommand", BindingFlags.Public | BindingFlags.Static);
                   processCommandMethod.Invoke(null, new object[] { memStream, dto });
               }
               else {
                   throw new NotSupportedException(string.Format(Resources.DtoNotSupportedException, type.FullName));
               }
           }
           catch (Exception e) {
               DtoException exception = new DtoException();
               exception.Message = e.Message;
               serializer = new XmlSerializer(typeof(DtoException));
               serializer.Serialize(memStream, exception);
           }
           data = memStream.ToArray();
           RemotingClient.WriteDataToStream(netStream, data);
       }
   }//wait for the next message
   //connection was lost.  Client probably closed program
   netStream.Close();
}

The code is so full of anti-patterns that I wonder how it even works. But wait...I just saw a Unit Test project! Something good, finally, eh? But nah...It is a WinForm application and the test code does not looks like a unit test:

private void FormUnitTests_Load(object sender, EventArgs e)
{
   BenefitComputeRenewDate();
   ToothFormatRanges();
   //LabDueDate();
   textResults.Text += "Done.";
   textResults.SelectionStart = textResults.Text.Length;
}

private void BenefitComputeRenewDate()
{
   DateTime asofDate = new DateTime(2006, 3, 19);
   bool isCalendarYear = true;
   DateTime insStartDate = new DateTime(2003, 3, 1);
   DateTime result = BenefitLogic.ComputeRenewDate(asofDate, isCalendarYear, insStartDate);
   if (result != new DateTime(2006, 1, 1))
   {
       textResults.Text += "BenefitComputeRenewDate 1 failed.\r\n";
   }
   isCalendarYear = false; //for the remaining tests
   //earlier in same month
   result = BenefitLogic.ComputeRenewDate(asofDate, isCalendarYear, insStartDate);
   if (result != new DateTime(2006, 3, 1))
   {
       textResults.Text += "BenefitComputeRenewDate 2 failed.\r\n";
   }
   //earlier month in year
   asofDate = new DateTime(2006, 5, 1);
   result = BenefitLogic.ComputeRenewDate(asofDate, isCalendarYear, insStartDate);
   if (result != new DateTime(2006, 3, 1))
   {
       textResults.Text += "BenefitComputeRenewDate 3 failed.\r\n";
   }
}

I think that's enough proof for one day. You probably have heard the saying: "Even a chimp can write code", but sometimes the saying goes like: "Even chimp writes code better than that".

Dynamically Generated Images with ASP.NET MVC

2009-10-18T13:39:47.257

For a site I'm working on using ASP.NET MVC, I intended to place a Date badge beside the blog and news posts I'm writing. Since in ASP.NET MVC there's no notion of custom controls (well, at least not like in WebForms) you'll have to do this manually, but as it turned out it was pretty easy to do.

What I needed to do was to convert a Date instance, e.g. 04.23.2009 to a user friendly calendar icon like this one:

I've seen blogs and site using different icon for each day of the month or a similar trick to do this, but why not actually render it using Graphics API and a picture?

The first step was to decide what should be returned in you Controller's action method, as the action result? Since there's nothing that returns an Image as the result, let's create one:

public class ImageResult : ActionResult
{
  public Image Image
  {
      get; set;
  }

  public ImageFormat ImageFormat
  {
      get; set;
  }

  private static Dictionary<ImageFormat, string> FormatMap
  {
      get; set;
  }

  static ImageResult()
  {
      CreateContentTypeMap();
  }

  public override void ExecuteResult(ControllerContext context)
  {
      if (Image == null) throw new ArgumentNullException("Image");
      if (ImageFormat == null) throw new ArgumentNullException("ImageFormat");

      context.HttpContext.Response.Clear();
      context.HttpContext.Response.ContentType = FormatMap[ImageFormat];

      Image.Save(context.HttpContext.Response.OutputStream, ImageFormat);
  }

  private static void CreateContentTypeMap()
  {
      FormatMap = new Dictionary<ImageFormat, string>
      {
          { ImageFormat.Bmp,  "image/bmp"                },
          { ImageFormat.Gif,  "image/gif"                },
          { ImageFormat.Icon, "image/vnd.microsoft.icon" },
          { ImageFormat.Jpeg, "image/Jpeg"               },
          { ImageFormat.Png,  "image/png"                },
          { ImageFormat.Tiff, "image/tiff"               },
          { ImageFormat.Wmf,  "image/wmf"                }
      };
  }
}

Pretty easy, ha? You just need to specify the image and the format and it is rendered to the HttpContext as an image. The controller action to render the text would something like this:

public ActionResult GetCalendarBadge(DateTime displayDate)
{
  Graphics graphics = ?;
  Bitmap bmp = ?;

  //Draw using graphics

  //Direct the output to the bitmap

  return new ImageResult { Image = bmp, ImageFormat = ImageFormat.Png };
}

...and on the view:

<% foreach(var item in this.Model.News) %>
     <%= Html.Image<NewsController>(o => o.GetCalendarBadge(item.DisplayDate), 100, 100) %>
<% } %>

Now, to make things easier, le's use an existing bitmap as our canvas and just draw the values on it. To do this, add an existing image to your project and load it. The rest is just GDI API that renders the date values according to user's Cultural setting.

public ActionResult GetCalendarBadge(DateTime displayDate)
{
  var bmp = Images.Calendar;
  var g = Graphics.FromImage(bmp);

  using (var genericFormat = GetStringFormat())
  {
      var yearRect = new Rectangle(24, 13, 40, 15);
      var dayOfMonthRect = new Rectangle(10, 29, 70, 44);
      var dayNameRect = new Rectangle(10, 30, 70, 10);
      var monthNameRect = new Rectangle(10, 61, 70, 10);

      using(var headerFont = new Font("Tahoma", 7.5f, FontStyle.Regular))
      using(var footerFont = new Font("Tahoma", 7.5f, FontStyle.Regular))
      using (var dayFont = new Font("Tahoma", 14, FontStyle.Bold))
      {
          var day = CurrentCulture.Calendar.GetDayOfMonth(displayDate).ToString();
          var month = CurrentCulture.Calendar.GetMonth(displayDate);
          var year = CurrentCulture.Calendar.GetYear(displayDate).ToString();
        
          var weekDay = CurrentCulture.Calendar.GetDayOfWeek(displayDate);
          var dayName = CurrentCulture.DateTimeFormat.GetDayName(weekDay);
          var monthName = CurrentCulture.DateTimeFormat.GetAbbreviatedMonthName(month);
        
          g.DrawString(year, headerFont, Brushes.White, yearRect, genericFormat);
          g.DrawString(day, dayFont, Brushes.Black, dayOfMonthRect, genericFormat);
          g.DrawString(dayName, footerFont, Brushes.Black, dayNameRect, genericFormat);
          g.DrawString(monthName, footerFont, Brushes.Black, monthNameRect, genericFormat);
      }
  }

  return new ImageResult { Image = bmp, ImageFormat = ImageFormat.Png };
}

Note that CurrentCulture property returns the running user's CultureInfo which will help 'Translating' the date value correctly for different Cultures. What we achieved is a nice calendar badge with render date values and it is not even constrained to our Canvas size. Hope this helps.

Using Windsor IoC in ASP.NET MVC

2009-10-18T13:44:47.043

With the power of an IoC engine, you can inject your repositories, services, etc. when building applications using ASP.NET MVC framework. Since one of the best IoC engines out there IMHO is Castle Windsor using it has become natural more than ever, but as soon as I did, strange problems occurred when testing very simple scenarios. Two major pains were:

Model Binders
ModelBinders automatically bind form values to your object properties. When using Windsor, I noticed that almost all the parameter values are null when passed to the controller action.

Parameter Values
When a controller action was called with a parameter for the first time, all subsequent calls somehow cached the parameter values. Type and Value of the parameter has no effect, and even disabling caching didn't work.

I've been pulling my hair for a couple of days (yeah, I kinda went bald because of this) before I figure this out, and when I thinking about it, the reason of this behavior is clearly obvious!

Windsor uses Singleton lifetime for registered services. All you need to do when registering controllers, is to use Transient lifetime!

Container.Register(AllTypes.FromAssemblyContaining<MvcApplication>()
                           .Where(o => o.Namespace == typeof(HomeController).Namespace)
                           .Configure(o => o.LifeStyle.Is(LifestyleType.Transient)));

Problem solved, Case closed!

ASP.NET MVC : Best way to go?

2009-10-18T13:48:02.437

With total control over html rendering in ASP.NET MVC there are a lot of things you can do, and this actually is correct the other way around, meaning you have to do a lot of things yourself: No fancy ASP.NET Custom Controls. It somehow reminds me of the old days, when you had to do everything to display a list of data. Back then, everything seemed manual. You had to emit html, control page state, etc. but with the rise of ASP.NET everything was amazingly done for you behind the scene. You no longer had to waste your time on the basics and you could focus on the problem at hand. Great, right?

Now with ASP.NET MVC, you might think we're back where we started, but I wouldn't go that far. While ASP.NET MVC offers control, maintainability and simplicity it also provides you Separation of Concerns which [ is one of the things that] was lacking in Classic ASP.

The question is, should you use it, instead of well established ASP.NET WebForms? That depends. Are you working on a greenfield project? Are you eager to learn the new stuff? Are you looking for more control and power on what the actual html outcome is? If you answer to these questions is positive, then you definitely need to use ASP.NET MVC for your project.

ASP.NET MVC and Testing FilterActions

2009-10-18T13:56:11.913

I'm preparing my website, which benefits NHibernate and ASP.NET MVC so I finally got a chance to actually do something with this nice pair. Since the pattern of SessionPerRequest and TransactionPerRequest is useful, I intended to automagically create a new session upon activating my Controller's action, where necessary, since this cross-cutting of concerns will make your session management code separate from your controller's code and you no longer need to worry about it. This part is very easy to do thanks to ActionFilterAttributes in ASP.NET MVC:

public class TransactionPerRequest : ActionFilterAttribute
{
   public override void OnActionExecuting(ActionExecutingContext filterContext)
   {
       NHibernateSessionHolder.Current.BeginTransaction();
   }

   public override void OnResultExecuted(ResultExecutedContext filterContext)
   {
       if(filterContext.Exception == null)
       {
           Commit();
       }
       else
       {
           Rollback();
       }
   }

   protected virtual void Commit()
   {
       if (NHibernateSessionHolder.Current.Transaction.IsActive)
       {
           NHibernateSessionHolder.Current.Transaction.Commit();
       }
   }

   protected virtual void Rollback()
   {
       if (NHibernateSessionHolder.Current.Transaction.IsActive)
       {
           NHibernateSessionHolder.Current.Transaction.Rollback();
       }           
   }
}

NHibernateSessionHolder is actually a static class and is initialized in Global.asax when application is started. Is stores the session in current HttpContext object.

So, how do we test this, you might ask? This leads to another question that how do you generally test ActionFilterAttributes? There are two ways to achieve this.

If you can test the filter attribute's behavior in your controller, the easiest way would be to directly call the action on the controller. You need to create the route values and use the ControllerActionInvoker to call the action of your controller. Also mocking HttpContext is preferred for obvious reasons. My test case would look like this:

[TestMethod]
public void Transaction_Is_Automatically_Opened_Using_Transaction_Per_Request()
{
   var httpContext = new Mock<HttpContextBase>().Object;
   var controller = new AccountController();
   var controllerContext = new ControllerContext(httpContext, controller.GetCreateActionRouteData(), controller);
   var controllerInvoker = new ControllerActionInvoker();
  
   controllerInvoker.InvokeAction(controllerContext, "Create");

   Assert.IsTrue(controller.TransactinWasCreated);
}

But sometimes, you need to test the internal behavior of your filter attribute and it would not be possible doing so in your Controller classes. Let's say, you want to check if the OnResultExecuted method handles exception properly by rolling back the transaction. To do it this way, you need to create or mock ActionExecutingContext and ResultExecutedContext:

[TestMethod]
public void Transaction_Is_Automatically_Rolled_Back_If_Exception_Thrown()
{
   var httpContext = new Mock<HttpContextBase>().Object;
   var actionDescriptor = new Mock<ActionDescriptor>().Object;
   var actionResult = new Mock<ActionResult>().Object;

   var controller = new AccountController();
   var controllerContext = new ControllerContext(httpContext, new RouteData(), controller);
   var filterContext = new ActionExecutingContext(controllerContext, actionDescriptor, new RouteValueDictionary());
   var resultContext = new ResultExecutedContext(controllerContext, actionResult, false, new Exception("an exception is thrown"));
   var transactionAttrib = new TestableTransactionAttribute();

   transactionAttrib.OnActionExecuting(filterContext);
   transactionAttrib.OnResultExecuted(resultContext);

   Assert.IsFalse(NHibernateSessionHolder.Current.Transaction.IsActive);
   Assert.IsFalse(transactionAttrib.IsCommitted);
   Assert.IsTrue(transactionAttrib.IsRolledback);
}

Key-Gen for .NET Apps!

2009-10-18T14:02:01.123

You all know that .NET generated application convert the high-level codes from source language (e.g. C#) and converts them to IL. Basically, if you could convert the IL code back to the high-level language, you'd have the original source code of the application, and to some extent, you can do this, but this is the story for another post. Today, I'd want to show you how your public licensing API would provide a very easy way to crack open your own application.

Note: I take no responsibility for how you use the piece of information. By reading these instructions you accept the sole responsibility of any illegal use. The names and information provided here are changed to save the innocent.

Suppose you've put a lot of energy and time and written your state-of-the-art application and you've released it to the market. After a while some junior software developer tries to inspect your assembly to see how you've managed to do a special tricks or two. (Mind you, that's not what I'd suggest you do, dear reader, because you might end-up facing copyright infringement lawsuits). Now when he's inspecting the API, he encounters your licensing API, and even worst, those API are public:

public class RSALicenseCodec : IEncoder, IDecoder
{
}

public class License
{
   public Guid LicenseId = Guid.NewGuid();
   public DateTime EndTime;   public string LicensedTo;
   public DateTime PurchaseDate;
   public LicenseType Type;
   public DateTime StartTime;
}

public static string LicenseToKey(IEncoder encoder, License license)
{
}

public static License KeyToLicense(IDecoder decoder, string key)
{
}

Note: Actual implementation was cut off!

Now with all these public API, only thing between a novice developer with bad intentions and a perfect key-gen to for application, is the copyright infringement lawsuit! Do you think that alone is enough?

I don't want to give you the idea that by only making these API private you're safe, no. There are a lot of things you should do before you're even close to being safe with hackers and crackers, but in my opinion taking all the care would no save you either. Almost nothing can stop a motivated cracker.

Resharper 4.5 Released

2009-10-18T14:24:05.85

Great guys at JetBrains have release next version of their productivity tool, Resharper. It seems this release fixes performance and memory usage issues and performance is tuned for big projects. According to JetBrains, following features are significantly faster now:

Renaming Symbols
Finding Usages
Creating Symbol from Usage
Analyzing large XAML files

I've been using their nightly builds for a while and there are a couple of nice new features added to version 4.5. Things like enforcing a naming convention, native support for MSTest unit testing, and copying XML comment from existing (base class / interfaces) sources are some of them. To give it a try, download a trial copy here.

Windows Seven and Sidebar Gadgets

2009-10-18T14:27:03.153

I've been using Windows 7 for a while now and my test experience is nearly great, with some exceptions like for occasional NVidia driver crashing the kernel and a few restarts because of it. The other day, I found something new : my sidebar gadget was missing completely! After searching for it and googling, it turns out disable UAC altogether (setting to "Never Notify") will make sidebar completely disappear and as soon as you bring it up only one notch (setting it to "Do not dim my desktop") will automagically bring it back after a restart.

Luckily for me, guys on My Digital Life forum have a hack to get this going :

1- Close all gadgets.

2- Take the ownership of the Gadget folder and grant permission to Administrators (folder is located on Windows Drive:\Program Files\Windows Sidebar)

3- There are a couple of file here, create a backup copy.

4- Download the patched files here.

5- Overwrite the existing files with the ones in the zip file.

6- Re-add all your gadgets to your desktop.

Note that this is a patch. It worked on my machine but use it at your own risk.

FarsiLibrary 2.1 Released

2009-10-18T14:28:31.693

Finally the 2.1 version of FarsiLibrary is released. Here are the changes made into this version:

- Fixed : Rendering of controls in non-official themes or when a 3rd party windows skinning (e.g. WindowsBlinds) is installed.
- Fixed : Problem when setting SelectedDateTime property of FXDatePicker control to null value.
- Fixed : Painting of FADatePicker in readonly mode when Readonly property is set fixed.
- Fixed : Problem of setting ForeColor and BackColor in FADatePicker
- Fixed : Certain usage of WinForms control resulted wrong display of Week Of Day in header part of the FAMonthView.
- Fixed : Certain usage of FAMonthView resulted in wrong displaying of date when culture is invariant.

- Added : Methods SetTodayDate and SetEmptyDate added to FXDatePicker and FXMonthView which lets you call the code that represents Today and Empty buttons clicks respectively.
- Added : PersianCultureInfo which is a FA-IR Culture with correct PersianCalendar and DateTimeFormatInfo.
- Added : PersianDateTimeFormatInfo that represents datetime formatting information for FA-IR culture.
- Added : DateTimeExtensions to help convert between PersianDate and DateTime instances via extension methods.
- Added : XmlnsDefinition is added to WPF namespaces. You can reference the controls assembly with http://schemas.hightech.ir/wpf/2008/FarsiLibrary namespace.
- Added : Methods to add / remove validation errors on BaseControl.
- Added : PersianDateValueConverter which can be used in WPF applications to convert strings representing DateTime to their PersianDate equivalant.
- Added : WPF Demo to show usage of custom date converters.
- Added : Ability to show and hide Today and Empty buttons on FAMonthView.
- Added : VisualStudio designer for WPF and actions for WinForm controls is added.

- Modified : Localization of WPF controls are using mechanism like WinForm controls (using StringIDs). Redundant .resx files are removed.
- Modified : Merged WinForm and WPF controls into one solution.
- Modified : ValueValidatingEventArgs now passes HasErrors property of the control when raising event.
- Modified : PersianWeekDayNames and PersianMonthNames have became internal. Use PersianDateTimeFormatInfo class instead.
- Modified : When parsing a string representation of PersianDate e.g. 1382/08/23 time part was initialized from system time, but now initialized to 00:00 to be consistent with DateTime behavior.
- Modified : PersianDateConverter is changed access modifier to Internal. You should not use this class, and instead either cast instances of DateTime / PersianDate or use newly provided extension methods.
- Modified : Strings representing DateTime is now parsed using InvariantCulture when parsed to DateTime instance.
- Modified : Static Parse and TryParse method accepting DateTime instance is removed. Use constructor overload instead.
- Modified : "Readonly" property in FAContainerComboBox is made obsolete. Use IsReadonly property.
- Modified : Border color of control in Office2000 and WindowsXP was near white color. Now uses SystemColors.ControlDarkDark value.
- Modified : Created a new base class for FAMonthView, which will be base of other upcoming controls.
- Modified : CurrentMonthName property from FAMonthView is made obsolete. You can use the GetMonthName method on BaseCulturedControl class instead.
- Modified : Arrows of the FAMonthView will gray-out if the control is in disabled state. Change of selected date is not available if the control is disabled.

Notice that "Modified" entries might be breaking your existing code base, but you are encouraged to use this latest version as there were some rather important bugs fixed and some useful features is added.

Like always, get the files from my web sky-drive here.

Unit Testing : Fact or Fantasy?

2009-10-18T14:32:56.24

I proposed a poll to CodeProject web site a while ago to see how community is embracing the TDD and agile. There are a lot of talks in .NET community regarding writing tests (Unit Tests, Acceptance Tests, etc.) and even Microsoft is taking this seriously by providing new frameworks and tools to support the idea and encourage the developers. I could argue that ASP.NET MVC, supporting TDD in VisualStudio 2010 and lots of other things coming from the "Bosses" is a sign of this, don't you agree? But how community in general and specifically developers are embracing this? That's what I intended to find out.

Here's the result:

Interesting, right? You can see that 18% not know what unit testing is! and this makes almost half of 1000 voted people (exactly 42%) not testing their code! What do you make of it? I'd say it is a disaster! How could the application developers have a night's sleep if they have absolutely ZERO testing code? I'm sure they say unit testing is not for us, we just write business applications. Well, writing a business application with 50,000 - 70,000 LoC should have SOME bugs in it, right? How do you make sure there's no bug at least in your core functionality!?

Thanks Chris for shedding some lights on this. What about you, dear reader? Do you find unit testing important? Do you test the code you've written?

Design-Time Properties

2009-10-19T07:18:38.377

Ever wanted to have a Designer-Only properties, whose only purpose is to do something in Visual Studio? I guess you already almost know how to do this. Simply create a property with Getters / Setters and assign an Editor to it, but there are a few things you can do to enhance it.

Let's say we want to create a property that will be shown on PropertyEditor and assign it an editor so that when the editor is activated we get an About dialog about our control / component. Fancy enough?

so let's create our basic property. After thinking about it, we don't need a setter at all and since this is a design time property the return value and return type are also unimportant. So we're down to this:

public object About
{
    get { return null; }
}

Assigning an property Editor is relatively easy. Create a new class and inherit from UITypeEditor override a couple of methods and you're all set:

[EditorBrowsable(EditorBrowsableState.Never)]
internal sealed class AboutDialogEditor : UITypeEditor
{
    public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context)
    {
        return UITypeEditorEditStyle.Modal;
    }

    public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
    {
        About about = new About();
        about.ShowDialog();
        about.Dispose();

        return null;
    }
}

What we're doing here is first to specify our editor should be opened in Modal mode, and second when the value is requested for that property (Editor is invoked), we just display our about dialog. So, by assigning this editor to our property, it should work:

[Editor(typeof(AboutDialogEditor), typeof(UITypeEditor))]
public object About
{
    get { return null; }
}

There are some other things to do. First, our property is displayed "somewhere" in the PropertyEditor. That's not what we want for an About dialog, is it? We need the property to appear always first and we need to somehow distinct it from other normal properties. What we can do about it is to use ParenthesizePropertyNameAttribute which simply signifies what our property should be treated specially, just like the standard Name property which is displayed above the others and is in parentheses. Also, to explicitly declare that our property is only a design-time property we'll add a DesignOnlyAttribute:

[DesignOnly(true)]
[ParenthesizePropertyName(true)]
[Editor(typeof(AboutDialogEditor), typeof(UITypeEditor))]
public object About
{
    get { return null; }
}

The only thing left here is that we don't want developers working with our controls see this property, because of the fact that it is a design-time property. To do this we add a EditorBrowsableAttribute and make our property Hidden in the texteditor of Visual Studio. So here's how our final property looks like:

[DesignOnly(true)]
[EditorBrowsable(EditorBrowsableState.Never)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
[ParenthesizePropertyName(true)]
[Editor(typeof(AboutDialogEditor), typeof(UITypeEditor))]
public object About
{
    get { return null; }
}

Gmail on IE8

2009-10-18T14:42:46.517

Looks like Gmail guys don't like my new browser. Sometimes (notice, just sometimes) things get broken in IE8 beta when using Gmail resulting strange layout problems. Even in turning compatibility mode to on has no effect on this.

VS.NET Designer Errors

2009-10-19T06:13:12.583

Maintaining old applications has always been something painful for me. Old application, for me, means Winform applications using DataSets for binding operations. When converting and opening an old application, the least thing you want on your hands is to open a form and see Designer screen of death. This is due to the fact that in the WinForm world when you open a form, all the extra codes in the constructor and Load events will get executed, and this where things can go wrong. Think about a pieced of code in constructor of a form doing something innocent in nature like saving / loading data from registry, connecting to a service. Almost always VS.NET shows a cryptic message. How would you know which code / form / usercontrol is causing this?

Debugging the Designer

There are just a few steps to catch the buggy piece of code ruining your day. Open up your visual studio solution containing your application's code and compile. Locate the form that is breaking the designer. Open another instance of VS.NET and Goto "Tools" > "Attach To Process" and locate the process named "Devenv.exe" which is Visual Studio's process name. There are two processes named "Devenv". Make sure you select the one with loaded solution. To catch all the thrown exceptions go to "Debug" > "Exceptions" and check the column "Thrown" in front of "Common Language Runtime Exceptions". This will tell the VS.NET to catch all the exception thrown by CLR. At this point you're good to go. Switch to your VS.NET containing the solution and open the Form / Usercontrol. The exception will be caught so you can have a very good idea what the problem is.

It is very easy to avoid this.

Make sure the codes written in Form and Usercontrol constructors / OnLoaded / Loaded event (except for InitializeComponents in constructors) will not get executed.
Use the DesignMode property

If you're extending functionality of a custom control you need to be aware of this problem. The constructors of custom controls will be called in InitializeComponent anyway, so if there's something wrong with the code in there, you'll end up with this problem.

There's also an issue with the DesignMode property in UserControls. The design mode only works when the user control is Sited so you may be in design mode and get "False" value when checking DesignMode property. The trick is to use a property on System.ComponentModel.LicenseManager which is more reliable.

MIX 10K

2009-10-19T06:27:08.077

There's been a new competition around for WPFers. You need to submit an application created with WPF technology (being a WPF app or Silverlight) which should not exceed 10 KB in size. Tricky, eh? What kind of an app can be 10 K? Check out the gallery to see for yourself. You can vote on your favorite app until 16th of February.

Windsor and Automatic Properties

2009-10-19T06:32:12.19

When maintaining an old application that uses Windsor as IoC container, a strange NullReferenceException throwed when trying to resolve an instance of a specific class. Our project has been recently upgraded to VS 2008 so it was natural to use C# 3.0 specific features. One thing I used in the failing class was Automated Properties. The implementation looked like this :

public class GridRepositoryFactory : IGridRepositoryFactory
{
   public GridRepositoryFactory()
   {
   }

   public IDynamicFormDataService Service
   {
       get;
       private set;
   }
}

as the stacktrace showed, Castle Windsor version 1.0.3.4333 does not work correctly with inject automated properties. I had to use properties with backing field to solve this, but updating to a more recent version may also get it fixed.

Error Messages in Silverlight

2009-10-19T06:37:23.467

Can you guess what's wrong with this Xaml code, without running it?

<Application xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             x:Class="Test.UI.App">
    <Application.Resources>

        <Color x:Key="HeaderRectangleStrokeColor">#FF777676</Color>
        <Color x:Key="AppInvertTitleForegroundColor">#16FFFFFF</Color>
        <Color x:Key="AppTitleForegroundColor">FFFFF8F8</Color>
        <Color x:Key="PageBackground">#FF000000</Color>

        <SolidColorBrush x:Key="HeaderRectangleStrokeBrush" Color="{StaticResource HeaderRectangleStrokeColor}" />
        <SolidColorBrush x:Key="AppInvertTitleForegroundBrush" Color="{StaticResource AppInvertTitleForegroundColor}" />
        <SolidColorBrush x:Key="AppTitleForegroundBrush" Color="{StaticResource AppTitleForegroundColor}" />

        <LinearGradientBrush x:Key="HeaderRectangleBrush" EndPoint="0.5,1.011" StartPoint="0.5,-0.011">
            <GradientStop Color="#FF343333" Offset="0"/>
            <GradientStop Color="#FF3E3E3E" Offset="1"/>
        </LinearGradientBrush>
         
    </Application.Resources>
</Application>

Application compiles just fine. Even Resharper can not detect a problem in it. But when you running it a hard error happens that fails the Silverlight plug-in! What's worse, is that the error message is cryptic as can be :

My Application resource had more Colors and Brushes than the example here, so it was much harder to find the needle in haystack. Luckily I found out what the problem was. The Color value for one of the resource has missing # mark. Shouldn't there be a more explicit error message?

Efficient Code

2009-10-19T06:43:23.793

Writing code may look easy to some and hard to others, but some programmers always tend to write messy, smelling, ugly-looking, inefficient code. Here's one :

protected override AppointmentForm CreateAppointmentForm(SchedulerControl control, Appointment apt, bool openRecurrenceForm)
{
  //return new CustomAppointmentForm(control, apt, openRecurrenceForm);
  if (Thread.CurrentThread.CurrentUICulture.Name == "fa-IR")
  {
      if (openRecurrenceForm)
          return new CustomAppointmentForm(control, apt,openRecurrenceForm);
      else
      return new CustomAppointmentForm(control, apt);
  }

  if (openRecurrenceForm)
      return new AppointmentForm(control, apt,openRecurrenceForm);
  else
      return new AppointmentForm(control, apt);
}

What's wrong with it you might say? Other than the logic implemented wrong (for specific culture instead of all RTL cultures), "A lot", I'd answer.

Commenting out code instead of deleting it will leave a lot of "Ghost" codes in your source. If you have a source-control in place why do you need to keep old code as commented out? it is always available in your source control, isn't it??
Embedding culture-specific code in not a good idea. What we want to achieve here can be easily achieved using factory patterns.
Control flow is very important for other programmers to understand what you wanted to achieve. Writing nested if / else and multiple returns in a method tend to make this harder.
Having braces in C style programmings is more a matter of style, but always be consistent.
Efficiently use constructor / method overloads. Know what are the default values for overloaded parameters.

The above code could be refactored into this :

protected override AppointmentForm CreateAppointmentForm(SchedulerControl control, Appointment apt, bool openRecurrenceForm)
{
  AppointmentForm form = null;

  if (CultureHelper.IsCultureRightToLeft)
  {
      form = new CustomAppointmentForm(control, apt, openRecurrenceForm);
  }
  else
  {
      form = new AppointmentForm(control, apt, openRecurrenceForm);
  }

  return form;
}

Silverlight + RESTful POX

2009-10-19T06:50:31.17

I'm working on a small project for a Swedish company. They need their application be available via web, so it's time to put that Silverlight knowledge at work. I decided to use Silverlight for UI technology and have a REST service layer to provide the required data. After all Silverlight and REST services should have no problem. Silverlight experience was great. You have LINQ at your disposal to process the REST results and although the set of available commands in Silverlight is less than WPF, but this makes it is easier to learn and work with at the same time. There was a couple of gatchas along the way, so I'm writing this as a note-to-self.

Service Contract vs. Object Model

The domain model is very simple and consist of a couple of entities, so what REST Services expose as data contracts are more or less the same as what I use in application layer. Silverlight's class library is not the same as a normal class library so I can not reuse the domain model available in my Silverlight library. This will lead to two set of object models. One for the domain model and the other for the service layer as data contracts. This separation or concern is a good idea, but for this small application it is overkill, but there's nothing I can do with it. With the help of LINQ2XML the best choice for exposing the contract model is POX (Plain old XML) so result of our services would be in XML parse by LINQ and converted to our domain model.

Unit Testing

Also because of different class library outputs, you can not use unit testing frameworks the way you usually do. This means you can not use xUnit, nUnit, etc. Hopefully there's a test harness to allow both UI and API level testing when developing Silverlight and it works just like MSTest does. Download the binary files here and read this to know how to add templates to your VS.NET to easily create a test application.

RESTful POX

To achieve this the service contract is decorated with REST attributes, That is a WebGetAttribute if you're exposing the operation via GET verb or a WebInvokeAttribute if you're exposing it via POST.

Note : The thing was that exposing IList<T> as a returned result of a service resulted a non functioning service with the following message : "Request Error : The server encountered an error processing the request. See server logs for more details." It turned out exposing the List<T> worked. The reason behind this is probably the same thing as exposing an objectâ€™s interface via normal (Soap) WCF service which also doesn't work due to interfaces not being serializable.

So here's the service contract :

[ServiceContract]
public interface IDataServices
{
    [OperationContract]
    [WebGet(ResponseFormat = WebMessageFormat.Xml, BodyStyle = WebMessageBodyStyle.Bare, UriTemplate = "/Advertisers")]
    List<Advertiser> GetAdvertisers();
}

and the implementation is self explanatory. What you get is a service exposed at a URL like http://localhost/Services/DataServices.svc/Advertisers. In order to get rid of the nasty .svc extension you either need to use IIS URL Rewriting Module which is only available on IIS 7 or use IIS Wildcard Mapping plus a HttpModule to make this happen. Read here for complete information.

Note : The .svc extension does not matter from operational perspective. It is computer applications that connect to these URLs after all, but from purists point of view it does matter.

The final part is the configuration which is standard WCF configuration like identifying service and contract, exposing EndPoints, etc. :

<system.serviceModel>
   <serviceHostingEnvironment aspNetCompatibilityEnabled="true" />
   <behaviors>
     <endpointBehaviors>
       <behavior name="WebBehavior">
         <webHttp/>
       </behavior>
     </endpointBehaviors>
   </behaviors>

   <services>
     <service name="Reklam.UI.Web.Services.DataServices">
       <endpoint behaviorConfiguration="WebBehavior"
                 binding="webHttpBinding"
                 contract="Reklam.UI.Web.Services.IDataServices" />
     </service>
   </services>
</system.serviceModel>

Using Windows Seven Beta

2009-10-19T13:55:24.867

It's been a few weeks since I've installed Windows 7 on my work development box. During the installation everything went fine and all the applications I had on my Windows Vista installed and worked fine under new windows 7, except for Skype for which I had to download and install their version 4.0 Beta. As a Vista user, I found myself immediately familiar with the environment but there are a lot of goodies here and there which made me say "Nice" loud and clear. Performance gain is totally noticeable compared to Vista and memory usage is as low as it can be. Fresh installation of Windows 7 occupies just 700 MB of memory which is obviously way lower than Vista.

I had very few problems using it. The disastrous one was two occasional system crashes when I was designing WPF apps in Visual Studio 2008. The design screen of my WPF UI was frozen and with just a mouse click system had a hard crash. The other issue is using Virtual PC. When windows overlap the VPC window, it goes black and I have to move the window a little bit to see the content (I'm using VPC in Windowed mode, not fullscreen). This too is very annoying because Windows are overlapping each other all the time and its giving me a hard time.

I know this is beta stuff and things may be broken and not working, but I see that guys at Windows 7 team have done a great job.

Update : If you have a Nvidia graphic card, upgrading the driver via Windows Update will solve the VPC going black.

Paint API on Vista

2009-10-19T06:56:11.197

I was testing bunch of custom controls using Managed paint API on Windows Vista. Basically, managed and unmanaged paint API use native resources of the OS to paint controls, so if you run your controls on Windows XP you'll get XP look and feel and if you run it on Vista, you get new vistaish look and feel, right? All control parts I've tested seems to work, but there is a catch! If you draw a disabled TextBox, it looks strange in Windows Vista, but looks right in XP :

VisualStyleRenderer renderer = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Disabled);
renderer.DrawBackground(e.Graphics, ClientRectangle);

While this code looks fine in XP, it produces a flat blue textbox on Vista :

As far as I could tell, this is an issue with textbox only and other controls like buttons, etc render correctly in both OSes.

I wonder why?! From end-user's perspective this does not look like disabled piece of UI and even worse it doesn't look like a native disabled texbox on Vista. I still don't know about any workarounds and I doubt it if native calls to UxTheme API would solve this.