Come take a walk with me

Google maps support for your asp.net site

noreply@blogger.com (Patrick) — Fri, 29 Aug 2008 19:20:00 +0000

I used the club starter kit as a base website template for my soccer team. It has a location feature where you can put the locations of certain important events (where our next game is, where do we meet up front, where are we having drinks afterwards, etc...). I though it would be nice to add support for Google maps so we can see where we'll have to play and give my teammates directions. This way I would already resolve the lame excuses that they usually have for being late.

At first I just looked at the Google website. Where else would you check how to integrate Google maps in your web app? I found an entire JavaScript api ready for use so I started hacking away. Now I must admit JavaScript is not my favorite language, I can manage but that's about it. Since I believe there will be other developers just like me, someone must have written server controls for it. And yes there is one available Googlemaps.subgurim (Free for non commercial use)

Just drag an drop the map control into your page, size it decently and put code to position the map in the page_load event handler. The website contains many useful and simple samples so I won't bore you with implementation details. You can see the map in action on my soccer's team (gilsboys) website (click the location list hyperlink for more locations). But I have to warn you if you decide to explore more of the site is in Dutch and my team is not famous for the way we play soccer but more for the drinks and parties afterwards. I guess it's my way of apologizing already for the pictures that are already available :-)

Check with you later !

Template your way into the hearts of your users !

noreply@blogger.com (Patrick) — Mon, 25 Aug 2008 22:46:00 +0000

This week we discussed our communication strategy at work. As already told previously we are writing a security service which involves creating users, adding and removing permissions and so on... Any of these actions can be performed by various actors (the user himself, an administrator, some batch job, ....) and thus the user must be notified about any change! Of course requirements are that the business should be able to change the emails, so hard coding them is out of the question (as always :-).

I had a look at a couple of template engines this weekend to solve the problem. Since I used Stringtemplate before I decided to go along with that one. The beauty of a template engine is that you can pass in an object graph and let the template figure out what to write and more importantly how to write it. First task was to make a simple email template that could be sent to the user:

 1 group TemplateEmail;
 2 
 3 Email(person, action) ::= <<
 4 
 5 \<html\>
 6 \<body\>
 7 Dear <person.name>,
 8 \<br\>
 9 \<br\>
10 
11 You receive this email because the following action \<b\> "<action.Name>" \</b\> has occurred.
12 \<br\>
13 \<br\>
14 
15 This leads to changes in the permissions you have on our applications.
16 \<br\>
17 
18 Please logon into our application to validate your permissions.
19 
20 \<br\>
21 \<br\>
22 \<br\>
23 Sincerly,
24 Patrick
25 \</html\>
26 \</body\>
27 >>

Done, this template creates a personal email with a header including the user's name and a subject containing the action that has occurred. Please not that the html syntax is entirely escaped because the < and > are used to refer to parameters and other templates. According to the documentation you should be able to use $ as well, but in my template these templates were never replaced. Is it because the dollar is that low? :-)).

The two templates that need replacing are <person.name> and <action.name>, the engine will try to find a property name on both of these objects (person and action), which need to be handed to the template engine. (If it cannot find this, the templates results in an empty string). Next we need to convert this template into a email with all values filled in, the following code does just about that:

1 var group = new StringTemplateGroup(new StreamReader("templates\\TemplateEmail.st"));
2 var template = group.GetInstanceOf("Email");            
3 
4 template .SetAttribute("person", person);
5 template .SetAttribute("action", action);
6 
7 var emailBody = query.ToString();

Again, piece of cake, if you put the result of the toString() into your email body you have nicely formatted email. How did this work? The first line reads the file from the disk in which the templates are stored. You get a group of templates as result, you then ask it for your named template. If you require attributes you can set them here by using the SetAttribute methods. Finally let the template engine do its work by calling the toString() on it.

All right, seems that basic templating is easy, let's switch to the next gear and divide our template into several little reusable templates. After all we will want to send different mails based on what action has been performed, the type of user who has performed the action, .... So let us create some templates for a mail header, mail subject and mail footer:

 1 WriteMailHeader(person) ::= <<
 2 
 3 \<html\>
 4 \<body\>
 5 \<div\>
 6 Dear <person.name>,
 7 \</div\>
 8 \<br\>
 9 \<br\>
10 >>
11 
12 WriteMailAction(action) ::= <<
13 
14 You receive this email because the following action \<b\> "<action.Name>" \</b\> has occurred.
15 \<br\>
16 \<br\>
17 >>
18 
19 WriteEmailFooter() ::= <<
20 \<br\>
21 \<br\>
22 \<br\>
23 Sincerly,
24 Patrick
25 \</html\>
26 \</body\>
27 >>

As you can see all multi line templates start with the template name followed by the argument list. The ::= << sign means the templates starts here and ends with the >> sign. Our mail template can now be rewritten as follows:

 1 group TemplateEmail;
 2 
 3 Email(person, action) ::= <<
 4 <WriteEmailHeader(person)>
 5 <WriteEmailAction(action)>
 6 
 7 This leads to changes in the permissions you have on our applications.
 8 \<br\>
 9 
10 Please logon into our application to validate your permissions.
11 <WriteEmailEnding()>
12 >>
13

The following step is to make our mail more useful by providing extra information. Lets assume that our Person has a property AuthorizationSet which holds two collections (one for the applications you are authorized to use and one for the functionalities you can execute). Our template can now read these properties and act upon these values. So let's add the applications and functionalities you are authorized for in the mail template.

 1 WriteApplicationInformation(person) ::= <<
 2 You have access to the following applications:
 3 \<ul\>
 4 <person.AuthorizationSet.Applications:{application|<WriteApplicationInformationLine(application)>}; separator="\n">
 5 \</ul\>
 6 >>
 7 
 8 WriteApplicationInformationLine(application) ::= <<
 9 \<li\> <application.Name> of type <application.Type> valid from <application.StartDate> till <application.EndDate>  \</li\>
10 >>
11 
12 WriteFunctionalityInformation(person) ::= <<
13 You have access to the following functionalities:
14 \<ul\>
15 <person.AuthorizationSet.Functionalities:{functionality|<WriteFunctionalityInformationLine(functionality)>}; separator="\n">
16 \</ul\>
17 >>
18 
19 WriteFunctionalityInformationLine(functionality) ::= <<
20 \<li\> <functionality.Name> with code <functionality.Code> valid from <functionality.StartDate> till <functionality.EndDate> \</li\>
21 >>
22 
23

And you simply call these templates with the following 2 lines in your email template:

<WriteApplicationInformation(person)>
<WriteFunctionalityInformation(person)>

Let's go a little bit deeper in the previous templates we've seen, shall we! We have created 4 sub templates, two for application permissions (WriteApplicationInformation and WriteApplicationInformationLine) and two for functionality permissions (WriteFunctionalityInformation and WriteFunctionalityInformationLine). The main template calls the line template for each item. This is achieved by the following syntax: < property : { subtemplate }; separator = "\n">,. This means that for each property (if it is an array, otherwise it will be called only once) the subtemplate is called, the "\n" character will be used in the template between every iterated call. The subtemplate has the following pattern { parameter | <template(parameter)>}. First you name the value for each iterated object, then you specify what other named template to call (or use an inline template).

Finally I would like to add extra information on the items depending on the value we have in the permission sets. Every permission has a start date and an end date. These are shown as well, but now when a permission has an end date set to sometime far in the future, it doesn't really add any extra value. On top of that it looks unprofessional too, so let's us vary the template based on wether we have a permission that is open ended. First add an extra property in your permission class IsOpenEnded that returns true/false based on the EndDate == DateTime.MaxValue. Then make an if structure in your template depending on this property. If we have an open end, we simply make do not display the end date, but show a slightly different text.

 1 WriteApplicationInformationLine(application) ::= <<
 2 \<li\> 
 3     <application.Name> of type <application.Type> 
 4     <if(application.IsOpenEnded)>
 5         valid from <application.StartDate> till piggs can fly  
 6     <else>
 7         valid from <application.StartDate> till <application.EndDate>  
 8     <endif>    
 9 \</li\>
10 >>

So now we have a nice looking email that communicates everything we want with just providing an object tree to our template. But of course that doesn't suffice. We want to be able to differentiate templates between the action we have performed, that was one of the reasons why we created the small templates remember. So if we modify the code where we load our template, we can choose a different template based on the action we had.

1 var group = new StringTemplateGroup(new StreamReader("templates\\TemplateEmail.st"));
2 var template = group.GetInstanceOf("EmaiForl"+action.Type);            
3 
4 template .SetAttribute("person", person);
5 template .SetAttribute("action", action);
6 
7 var emailBody = query.ToString();

This means we need to have templates for the different actionTypes our application has, in our case these two templates would be required:

 1 EmailForChangeAuthorization(person, action) ::= <<
 2 <WriteEmailHeader(person)>
 3 <WriteEmailAction(action)>
 4 \<br\>
 5 This leads to changes in the permissions you have on our applications.
 6 \<br\>
 7 <WriteApplicationInformation(person)>
 8 <WriteFunctionalityInformation(person)>
 9 
10 <WriteEmailEnding()>
11 >>
12 
13 EmailForChangePassword(person, action) ::= <<
14 <WriteEmailHeader(person)>
15 <WriteEmailAction(action)>
16 
17 We are glad to inform you that your new password is <MakeBold(person.password)>, please 
18 logon and change your password to something more personal.
19 
20 <WriteEmailEnding()>
21 >>

That pretty much it. If you want to have a look at it yourself, you can download the code or go have a look at the he Stringtemplate website.

Simplify your life... decorate with aspects !

noreply@blogger.com (Patrick) — Sat, 02 Aug 2008 21:20:00 +0000

In the company that currently hired me tracing for instance (which is one of the areas you could benefit a lot from using aspects), is done my hand. Every method (at least most of them) follows the next format

public bool Method(params string[] inputValues) 
{
  Trace("Enter", "MethodName", inputValues); // trace all input parameters

  .....
  bool someValue;
  ......

  Trace("Exit", "MethodName", someValue); // trace parameters leaving the method
  return someValue
}

If you only have to write code once and then never touch it again, maybe this way of developing would be acceptable. But I rarely (read never) have been on a project where this was true. Code will be refactorred and not only once. Keeping the tracing parameters in sync with the constant refactorings is something that is often forgotten. Compare it with the method documentation you write, if you would generate your ndoc now does it truly reflect your code?? My thoughts exactly, so help is needed, aspect orientation to the rescue. If you Google aspect orientation (that's right I even saved you the time to do that) you will find many useful resources and implementations, today I will be taking a closer look into PostSharp.

PostSharp performs a post compilation step to inject IL code, which means it can 'adapt' your entire code base even private methods,fields... You can use PostSharp in two ways, the easiest is to download the msi file and install it on your machine. If you are anything like me you hate installing software on your machine, you might have a look at this blog post from Gael Fraiteur the lead developer for the project. He explains what happens under the hood and how the post compile step is called in msbuild.

If now you add the required assemblies (PostSharp.public and optionally PostSharp.Laos) to your project, the post compilation step will automatically gets called from msbuild. It will search your assembly for all required tasks to process and then updates the IL code.

First on my list is to improve my above tracing problem. This is easily solved by overriding the OnMethodBoundaryAspect (provided as one of the higher level aspects of the PostSharp.Laos library) , this provides the following methods:

OnEntry : called when entering the method
OnExit : always called when exiting a method
OnException: called when the method resulted in an exception
OnSuccess: called when the method executed successfully

and leads to the following code:

        public override void OnEntry(MethodExecutionEventArgs eventArgs)
        {
            Trace.WriteLine(
                string.Format("Enter {0}.{1}.", typename, methodname),
                this.category);
        }

        public override void OnExit(MethodExecutionEventArgs eventArgs)
        {
            Trace.WriteLine(
                string.Format("Leaving {0}.{1} with {2}",
                               typename,
                               methodname,
                               eventArgs.ReturnValue),
                this.category);            
        }

        public override void OnException(MethodExecutionEventArgs eventArgs)
        {
            Trace.WriteLine(
                string.Format("Exception {0}.{1}.",
                               eventArgs.Exception.Message,
                               eventArgs.Exception.StackTrace),
                this.category);
        }
        
        public override void OnSuccess(MethodExecutionEventArgs eventArgs)
        {
            // Usually you don't need this
        }

Another way to achieve this is to override the OnMethodInvocation. This provides you with different methods to work with but you have the same functionality at your disposal. The major difference is that this method does not modify your original method (as would happen with the above sample), but intercepts the call en invokes your OnInvocation method). Check reflector to see the differences here!!

        public override void OnInvocation(MethodInvocationEventArgs eventArgs)
        {
            // Perform tracing here
            Trace.WriteLine(
                string.Format("Enter {0}.{1}.", typename, methodname),
                this.category);

            try
            {
                base.OnInvocation(eventArgs); // Invoke your method here!
            } 
            catch(Exception ex)
            {
                Trace.WriteLine(
                string.Format("Exception {0}.{1}.",
                               ex.Message,
                               ex.StackTrace),
                this.category);
            }
            finally
            {
                Trace.WriteLine(
                           string.Format("Leaving {0}.{1} with {2}",
                                          typename,
                                          methodname,
                                          eventArgs.ReturnValue),
                           this.category);
            }            
        }

So far so good. Applying these attributes is as simple as using other attributes in .NET, just decorate your method/class with them. If off course you wish to perform tracing on an entire assembly or part of it, You will be adding a lot of these attributes, so a better way has been provided: The following configuration intercepts all method calls from the Tracing.Model, Tracing.Repository and Tracing.Service namespace. You could tweak this further.

[assembly: Trace(AttributeTargetTypes = "Tracing.Model.*")]
[assembly: Trace(AttributeTargetTypes = "Tracing.Repository.*")]
[assembly: Trace(AttributeTargetTypes = "Tracing.Service.*")]

You could specify on which the aspects (or attributes) can be applied by specifying the AttributeUsage and MulticastAttributeUsage, see the official documentation about that here (UserGuide -> Using PostSharp LAOS -> Wildcards and multicasting).

Secondly my I wanted to simplify my validation code. One solution is to decorate my fields with the specification they have to obey. For instance

A String field should contains maximally 16 characters
A Number must be between 1-100 (see the following code sample)
A Date must be in the future

 [Serializable]
    public class RangeSpecification : OnFieldAccessAspect 
    {
        public Int32 _minimum = 0;
        public Int32 _maximum = 100;

        public RangeSpecification(Int32 minimum, Int32 maximum)
        {
            _minimum = minimum;
            _maximum = maximum;
        }

        public override bool CompileTimeValidate(System.Reflection.FieldInfo field)
        {
            Console.WriteLine("RangeSpecification"); // this comes in the output window when compiling

            if (field.FieldType.Name != typeof(Int32).Name)            
            {
                // "Why would you want to use this specification on a non number field?"
                return false;
            }
            return true;
        }

        public override void OnSetValue(FieldAccessEventArgs eventArgs)
        {
            Int32 exposedValue = Int32.Parse(eventArgs.ExposedFieldValue.ToString());
            if (exposedValue < _minimum || exposedValue > _maximum)
            {
                // keep the old value when an invalid value was passed in
                eventArgs.ExposedFieldValue = eventArgs.StoredFieldValue;                
            }            

            base.OnSetValue(eventArgs);
        }
    }

So far the first exploration of PostSharp, I realize this was only the top of the possibilities but I hope everybody can see how much code can be saved and might not clutter your production code by applying these aspects correctly in your code.

See you next time.

Ignore files in your subversion repository

noreply@blogger.com (Patrick) — Tue, 29 Jul 2008 21:45:00 +0000

After reading the pragmatic programmer in my holiday I decided it was time to put theory into practice. Whenever I perform an check-in in my subversion repository I usually deleted my bin and obj folders manually to make sure they didn't got checked-in. Of course tortoiseSVN and subversion provides ways to automatically exclude them when you check-in.

So in order to 'avoid my repetitive tasks' and win those crucial couple of seconds on every commit (have you ever count how much this could add-up to on a year basis?) I browsed the tortoise site and found the following documentation:

http://tortoisesvn.net/docs/nightly/TortoiseSVN_en/ch05s11.html#tsvn-DUG-ignore-glob

Here are the settings that I've applied on my projects : */bin */obj */_ReSharper* *.suo *.user *.resharper

Right where can I win some more time, maybe I can achieve my 4 hour work week!

Book Reviews: the holiday books

noreply@blogger.com (Patrick) — Mon, 07 Jul 2008 16:30:00 +0000

Just returned from my holiday where I had the time to catch up on my reading. I choose a couple of books from my shelf and went on my way to France.

The pragmatic programmer

This book is all about becoming a better and more productive developer. The book contains tips and tricks to let you focus on the job at hand instead of distracting you from it. It reads like a novel so it is perfect as holiday lecture (buy this book if you are leaving in the next couple of weeks).

I simply cannot believe that this book is written 10 years ago. It still is burning accurate and besides the referral to the "upcoming language of java" and "in the future there will be refactorings tools available" you simply cannot tell it is this 'old'.

I really liked the way the book compared the continuously studying everyone has to do with investing in your stock portfolio, it's all about diversification!

As a nice extra for one of my colleagues the books describes nicely the pussy way of development. :-)

Agile principles, patterns and practices in C#

A must read book for everyone doing agile development in C#. It starts of with a section explaining what agile development is all about and what are its cornerstones. The section ends with an hilarious 'role play story on pair programming'.

The second section is more interesting where all the basic principles of software development pas the revue. If you don't know what the Single Responsibility principle, what the open/closed principle has to do when there are no doors involved, when LSP, DIP and ISP are just meaningless acronyms then this book is for you. The section finishes of with an overview of UML and how to express design in various diagrams.

Section three and four covers the patterns part of the book and it does this by following a case study about a payroll system. If you have heard of NDepend you will probably be familiar with the principles (REP, CRP, ....) Robert explains when packaging our case study.

I would advice this book to everyone who wants to start with agile development!

I then started to read Implementation patterns from Kent Beck, but the didn't finish it yet. The swimming pool looked more appealing...

The pain of development in Vista

noreply@blogger.com (Patrick) — Thu, 12 Jun 2008 20:09:00 +0000

I recently bought a new laptop with Windows Vista already pre-installed. Until that time my development machine was running on XP, but now I had the joy of meeting the latest invention (??) of Microsoft called User Access Control (UAC)! I am still figuring out if this is supposed to be feature or a bug that the programmers could not fix.

My problem is the following: Whenever I open a perfectly working solution on my new machine I got an annoying "System.Runtime.InteropServices.COMException" exception hitting me. I quickly realized it happened only when accessing a Web or Service through IIS. Whenever you want to access local IIS Website your Visual Studio needs to fired up in the context of an administrator, by default Vista starts applications in a limited-privilege user account. The solution to this problems is relatively easy, always start your studio in administrator mode. I created a new shortcut that runs in administrator mode and associated my sln-files to use this shortcut by default. If you right-click on a shortcut, in the advanced tab you can select the 'run in administrator' option.

Problem solved if you can live with a UAC popup every time you open Visual Studio. If you anything like me you want to avoid this popup as well :-), my first thought was simply disable the UAC Altogether, but then other features might stop working because windows believes your system is not trustworthy. Since I usually select proceed in those useless popups I decided to accept this silently without prompting, you can read here how this can be achieved. I took the liberty of giving you summary here:

Click Start and Control Panel. Switch to Classic View (if you haven't already) and click on the Administration Tools icon. In the list that opens click on Local Security Policy, and in the next window, Local Policies (a tiny bit redundant, but all UIs can't be perfect -- If UAC is running you'll get a UAC pop-up somewhere in here). In the Local Policies list click Security Options, and scroll down to "User Account Control: Behavior" (the full title of the policy is "User Account Control: Behavior of the elevation prompt for administrators in Admin Approval Mode" but the window barely opens that far). Double-click the title and in the dialog box change its setting from "Prompt for Consent" to "Elevate without prompting." Click OK and the urge to tear your hair and scream at your PC will be greatly diminished in the future.

I hope this post will save you time and headache, till next time.

NHibernate in Action: Book Review

noreply@blogger.com (Patrick) — Thu, 05 Jun 2008 19:01:00 +0000

I finished this 'beta' book today, it took me a while because I have the bad habit of reading multiple books at the same time. For an NHibernate virgin like myself the book was a very good introduction. It covers everything you need to know to get started with release 1.2.1 version, although nothing is inserted (yet ?? ) for the upcoming 2.0 release. I hope the final version will include some chapters covering the new features, especially the event/listener model seems to be interesting. If it doesn't the book might already be outdated upon its release in August.

The thing I was missing was more in depth information about extending the functionality of NHibernate. We had an issue for instance with the interceptors which you can read all about here, but the book did not provide a lot of information about.

My overall conclusion is positive because it was a nice intro, but if you already have some experience with NHibernate the book might be too 'easy' for you.

Big twitter is watching you.... or me

noreply@blogger.com (Patrick) — Wed, 04 Jun 2008 14:58:00 +0000

I finally got the 'stalking decease' as well and subscribed to twitter. You can follow me here.

DDAD: Domain Driven "Allors" Design

noreply@blogger.com (Patrick) — Sat, 31 May 2008 21:32:00 +0000

As explained in my previous post I am going to build an application to demonstrate what Allors is and how to use it. I will hopefully have to time to build the same application later on using NHibernate to show both frameworks differences.

The application I'll be building will take care of the invoicing for a contractor. It is built using the YAGNI principle (this basically states if you think you need to add complexity to your domain model, you should defer it until the moment you actually need it. Probably you ain't gonna). Lets discuss the domain shall we. The most important class obviously is the Contract signed between a Customer and a contractors's Company. Both the customer and the company are subclasses of the corporation class, which gives them some common attributes (like Name, Address, Account, .... ). On the Contract you can then register the hours you worked for them and eventually generate an Invoice for a specific period.

All relations and classes are shown in the following model:

I deliberately kept everything as simple as possible so I can make future improvements to demonstrate what this means in terms of database upgrades, refactorings possibilities, etc.... If you want to follow everything that is explained here below, you can download the complete solution here or built everything yourself of course.

Building the domain (Allors)

To start building an Allors domain you first need to download the binaries and the Allors Repository. You can either checkout the sources from the subversion (https://www.allors.com/svn/platform) or you can download the Quick Start file I've put together. The zip contains two directories & a command file

lib: Directory containing the Allors binaries and the Allors Repository, you should extract these in your solution folder.
Allors: Directory for the Allors Domain Files, you should extract these in your domain project folder.
AllorsRepository.cmd: file that will startup the AllorsRepository Tool for you domain, this should be extracted in your solution folder.

Step 1: Setting up the solution hierarchy

The solution structure I have applied consists of 4 projects.

Diagrams: containing the diagrams of my domain. This project will contain only generated code with getters/setter that reflect your domain. You can then use these to generate your class diagrams.
Domain: the heart and soul of our accounting application, you should refer to the Allors.Framework.dll here.
Population: Helper classes to build your domain objects and setup an initial population for unit/integration testing.
Unittests: proving our design and domain is correct and well thought.

Step 2: Creating the Allorized domain

The Allors folder from the zip file needs to be copied into your domain folder. This folder will contain the meta information (allors.repository) about your domain classes, which is built up using the AllorsRepository-Application (included in the zip file). if you modify the command file that was included in the zip file so that the parameter passed in to start up the "Allors.Repository.Application.exe" refers to the allors.repository in your domain folder, this file will now fire up the AllorsRepository-Application for your domain. You should see the following (if you are building from scratch, otherwise your domain will be completely filled in).

This screen has three main parts.

The top left has a tree containing all your types and relations in your domain
The top right is the property window of the selected treeNode
The bottom gives information about errors in your domain

All actions are available by rightclicking the treeNode and then select the action in the context menu or change the node's corresponding properties. If you need to know how things are getting done, you can checkout the getting started page of the Allors website. On the bottom you can see that the repository already has one error. It has no name, so you need to select the domain node and fill in the name in the properties window.

Step 3: Namespaces & Types

Our solution will have two namespaces to start with. You can see here how you can add namespaces in the repository. The types we are building are shown in the diagram above, you can easily add them yourself in the allors repository. It is written out here how you can achieve that. All objects belong to the Accounting namespace, only the DatePeriod type is more generic and is placed into its own General namespaces

Step 4: Attributes & Relations

We now have domain containing single classes without any attributes or relationships between them. You cannot call this a domain of course so the logical next step to give our objects data and connect them through the use of relations. As always you can checkout here how everything can be done. The above diagram gives you all the information you need to create all the relations.

Step 5: Adding Domain Logic

The Allors domain has been built (you can download the zip file here). The next step is to generate (right click the domain and select generate) our allors classes, these will be our base classes for our domain objects. You don't have to remember to inherit any classes or interfaces because we generate a partial class for you as well. Include these files (located inside the Allors/output/folder by default, but this can be tweaked of course) in your domain project and you can start using them. Every object you instantiate now is inside a Session, the creation is performed through the Session as you can see in the next code block:

 1 public static Account Create(AllorsSession session, 
 2                               string bank, 
 3                               string number)
 4 {
 5       Check.Argument(number, "number").IsNotNullAndNotEmptyAndNotWhiteSpace();
 6       Check.Argument(bank, "bank").IsNotNullAndNotEmptyAndNotWhiteSpace();
 7 
 8       var account = session.Create<Account>();
 9       account.Bank = bank;
10       account.Number = number;
11 
12       return account;
13 }

Adding the actual business logic is done simply by adding the methods into your class (as you normally would)

 1 public TimeRegistration RegisterWorkingTime(DateTime date, Double hours)
 2 {            
 3       return TimeRegistration.Create(AllorsSession, date, this, hours);
 4 }
 5 
 6 public Invoice BuildInvoice(DatePeriod period, 
 7                                     String reference, 
 8                                     DateTime invoiceDate,
 9                                     IInvoiceCalculator invoiceCalculator)
10 {
11       VerifyThatInvoiceReferenceIsUnique(reference);
12 
13       var timeRegistrations = new TimeRegistrationFinder(AllorsSession)
14                                                                 .GetNotInvoicedTimeRegistrationsFor(this,period);
15        if (timeRegistrations.Length == 0)
16        {
17            throw new ArgumentException("Invoice must contain TimeRegistrations");
18        }
19 
20        var invoice = Invoice.Create(AllorsSession, reference, invoiceDate);
21        AddInvoice(invoice);
22 
23       foreach (var timeRegistration in timeRegistrations)
24       {
25            invoice.InvoiceTimeRegistration(timeRegistration, invoiceCalculator);
26       }
27 
28       return invoice;
29 }

Step 6: Unit Testing

Since all objects are Session aware we need to have a Session in our UnitTests. For performance reasons we will not use a real database, but rather work completely in memory. The following code creates an in-memory session for our domain.

var population = new Allors.Adapters.Memory.AllorsConnectedMemoryPopulation(new AccountingDomainConfiguration());
population.Init();
_session = population.CreateSession();

You can then create your objects with this sessions and perform the regular tests you would normally write.

 1 [TestFixture]
 2 public class When_creating_an_account : AllorsBaseTest
 3 {
 4     private AccountBuilder _builder;
 5 
 6     [Test]
 7     [ExpectedException(typeof(ArgumentNullException))]
 8     public void Then_expect_an_error_when_the_number_is_null()
 9     {
10         _builder = new AccountBuilder(Session);
11         _builder.WithBank(null).Build();
12     }
13 }

The final step is to make our domain persistent.

For this I created a new project (IntegrationTests). You do not need to supply mapping files because Allors will make and initialize the database scheme for you based on the meta information you supplied. This is achieved by simply instantiating the correct population and Session, here we will use the SQL Server Express Edition. For unittesting we created the population in code (and for memory), you could as well set everything in the config file:

First of all you need to declare the allors section in the config
You need to configure your populations(or multiple of them) + connectionstrings
Finally you need to create the population from based on the name in the config

 1 <configSections>
 2     <section name="allors" type="Allors.AllorsConfigurationSection, Allors.Framework"/>
 3 </configSections>
 4 
 5 <allors>
 6     <populations>
 7       <add name="AccountingPopulation"
 8            type="Allors.Adapters.SqlClient.AllorsSqlClientPopulation, Allors.Adapters.SqlClient"
 9            domainConfiguration="AllorsDomains.AccountingDomainConfiguration, Pdbc.Accounting.Domain"
10            connectionStringName="accounting">
11       </add>      
12     </populations>
13 </allors>
14   
15 <connectionStrings>
16     <add name="accounting" connectionString="Data Source=Pdbc-Laptop\SqlExpress;Initial Catalog=accounting;Integrated Security=True"/>
17 </connectionStrings>

Then in code we can retrieve the population and instantiate the session. The Init method by the way drops the database and recreates it which makes sure that our integration tests always have the latest version of the database scheme available.

1 var population = AllorsConfiguration.GetPopulation("AccountingPopulation"); 
2 population.Init();
3 _session = population.CreateSession();

Check the complete sample along with the unittests for a complete overview. As you notice, the major difference with traditional POCO domain objects is that we need to inherit from an Allors Class. This Class encapsulates the access to a strategy object which contains all your class attributes and object relations. This way we can keep all objects managed by Allors which has a lot of benefits (lazy loading, managed relations, ...) , but that is for a next post.

Let me know what you think about it and have a spin with the sample.

Filtering your Nhibernate SQL Log: The good way

noreply@blogger.com (Patrick) — Tue, 27 May 2008 21:24:00 +0000

Apparently my previous post about filtering out the unique sql statements NHibernate fires at your database is a quick and dirty hack. Sure it works but why create a complete new appender if all you want to do is decorate the existing ones with filtering. If I would have read the documentation that the good people of log4net have prepared for the world, I would have noticed the concept of Filters. These form a chain that the logging event has to pass through in order to actually get logged.

Here is the same code that should do the trick using the filters, remember to add this filter in your appender declaration in the configuration file

public class NHibernateUniqueQueryFilter : FilterSkeleton
{
    private static readonly List<String> statements = new List<string>();

    public override FilterDecision Decide(LoggingEvent loggingEvent)
    {
         var message = loggingEvent.RenderedMessage;
         var index = loggingEvent.RenderedMessage.IndexOf(";");
         if (index != -1)
         {
             message = loggingEvent.RenderedMessage.Substring(0, index);
         }

         if (statements.Contains(message))
         {
             return FilterDecision.Deny;
         }

         statements.Add(message);
            
          return FilterDecision.Accept;
    }
}

It's Peter Time

noreply@blogger.com (Patrick) — Tue, 27 May 2008 21:01:00 +0000

Today (actually yesterday) Peter Eysermans started his blog. Peter is one of my colleagues and a really funny guy, he is an authority (or will be :-)) on Web Development. So if you want to follow his quest for world web domination then check out his blog or subscribe to it). I for one am looking forward to his next post : The pussy way of development'!

Resharper 4.0 Stable release

noreply@blogger.com (Patrick) — Fri, 23 May 2008 12:45:00 +0000

I am using Resharper since version 2.0 and VS2003. In those days there were major problems with the memory consumption of the tool, resulting in a slow IDE and multiple crashes. Just when I was going to remove it from my system, I made the shift to VS2005 and Resharper 2.5 (and 3.0). It couldn't have come at a better time because I never doubted the guys from Jetbrains ever again.

A while ago I installed one of the 4.0 EAP Releases (4.0.775.22). Some of my solutions not even the big ones took ages to start up and occasionally my studio froze! I quickly reverted to my old version no harm done. But a couple of days ago a Stable version was released and I decided to give it another try. My problem solution now still take a little longer to load, but I didn't suffer any freezes anymore. The support for the .NET 3.5 framework makes the loading time a necessary evil, besides you need this version if you really want to develop in VS2008 (and not be annoyed by non-compilation warnings from Resharper about the new language stuff)

You can buy a license for the currently released 3.5 and are allowed to upgrade to 4.0 once this version becomes available. So what is stopping ya?

By the way, thanks to Ilya Ryzhenkov for providing a list of nice plug-ins for Resharper, these have proven to be quite helpful.

Know what happens on your database

noreply@blogger.com (Patrick) — Wed, 21 May 2008 20:51:00 +0000

Although I believe that an ORM should take care of the persistence, you as a developer NEED to know what happens on your database. You need to know what SQL - statements get fired. NHibernate uses Log4Net for this, with a simple configuration setting you make NHibernate log all statements that make the trip to the database. In the hibernate-configuration you can set the "show_sql" property to true. You then need to specify the Nhibernate logger (be sure to name this "NHibernate.SQL" and link it to an appender. The following config section simply does that:

 1 <log4net>
 2     <appender name="NHibernateSQLLog" type="log4net.Appender.RollingFileAppender">
 3         <file value="nhibernate_sql_statements.txt"/>
 4         <appendToFile value="true"/>
 5         <rollingStyle value="Size"/>
 6         <maxSizeRollBackups value="10"/>
 7         <maximumFileSize value="1000KB"/>
 8         <staticLogFileName value="true"/>
 9         <layout type="log4net.Layout.PatternLayout">
10             <conversionPattern value="%d{HH:mm:ss.fff} [%t] %-5p %c - %m%n"/>
11         </layout>
12     </appender>
13     <logger name="NHibernate.SQL" additivity="false">
14         <level value="DEBUG"/>
15         <appender-ref ref="NHibernateSQLLog"/>
16     </logger>
17 </log4net>

As already mentioned in a previous post we had to be very persuasive in order to use NHibernate. One of the questions our DBA guys had was "what was going on on their database, can we see what queries and statements get executed?". The above gives us all information, however it is not very useful for them as they have to go through tons of duplicate statements. Fortunately Log4Net is very extensible, you can easily build your Appender and filter out the information you do not want to log. The easiest solution is to extend the appender you would normally use, (for example the RollingFileAppender) and override FilterEvent method. You can then return false for every loggingEvent that you do not want written out.

 1 private static List<String> statements = new List<string();
 2 
 3 
 4 protected override bool FilterEvent(log4net.Core.LoggingEvent loggingEvent)
 5 {
 6     string message = loggingEvent.RenderedMessage;
 7     int index = loggingEvent.RenderedMessage.IndexOf(";");
 8     if (index != -1) 
 9     {
10          message = loggingEvent.RenderedMessage.Substring(0, index);
11     }
12             
13     if (statements.Contains(message))
14     {
15          return false;
16     }
17 
18     statements.Add(message);
19 
20     return base.FilterEvent(loggingEvent);
21 }

In this example I build a list of all statements that have already been logged. First we need to filter out the parameters, because otherwise no statement would be unique. The loggingEvent contains a RenderedMessage that consist of two parts. First the actual statement containing wildcards or named parameters. Then the character ';' and lastly the mapping of the parameters. We only need the part before the ';' because any statement can be called multiple times with different parameters. Once we have the actual query statement we try to find this in our list and return false if it has already been logged. The result is that our logfile now only contain unique statements. The parameters included are those from the first time this statement was logged (Since the RenderedMessage is read-only we cannot remove these).

NHibernate's Optimistic Locking: Where did we go wrong?

noreply@blogger.com (Patrick) — Tue, 20 May 2008 20:19:00 +0000

I was trying to get optimistic locking to work properly by applying the following articles (this and this) from Ray Houston. I got it up and running in a couple of minutes and my audit information was automatically saved whenever I inserted or updated an object. If you think you can let NHibernate handle the version in this case you are wrong. The version (or timestamp) attribute needs to map to a single database column if you want to use it for optimistic locking.

So in order to have a working locking strategy I removed the LastModified Timestamp from my CompositeUserType and added a specific timestamp property in my mapping file.

Piece of cake, .... however ..... what happens when you start working disconnected? You have two possible solutions. Keeping your Session open (which will kill your application's scalability) or you can re-attach the objects into a new session (prefer this solution if you can).

Now consider my business use case where I am loading an entire object graph in my server session, these objects are transformed to DTO's and send to the client. The client then makes some changes and sends me only the updated values. In other words I cannot attach my objects into a new session because I simply do not have all the information at my disposal. There is simple solution for this problem, do it yourself (check 10.4.4 application version checking of the Nhibernate online documentation).

I decided to load the entire object graph again and set the LastModified whenever I apply the changes from the client. My version check will happen in the interceptor in the OnFlushDirty method, there I will check the original value of the date with the version I got back from the client (and applied in the object).

Int32 lastModificationPropertyIndex = Array.IndexOf(propertyNames, lastModificationProperty);            
if (-1 != lastModificationPropertyIndex)
{
       DateTime originalDateTime = (DateTime)(previousState[lastModificationPropertyIndex]);
       DateTime currentDateTime = domainObject.LastModification;

       if (originalDateTime.Ticks != currentDateTime.Ticks)
       {
            if(originalDateTime != DateTime.MinValue)
            {
                 throw new StaleObjectException(id);
            }
       }
}

The OnFlushDirty method is called only for dirty objects, the OnSave is called for new objects (although I added the check that the originalDateTime must be different than the MinValue if it should happen that this method gets called for new objects). 75% of the time this seems to work but sometimes the StaleObjectException is thrown when and object is not out-of-date. The LastModified date is updated whenever the data is flushed to the database. This flushing can be set on the session using the enumeration type FlushMode. Default is set to Automatic meaning that it can happen that the session is flushed before a query. The session now gets flushed before the interceptor gets called (strange, but this seems to be the reason). Setting the FlushMode to Commit or Never seems to resolve the above issue because then the flush has to be called manually or by committing a transaction.

Till next time

Allors vs NHibernate

noreply@blogger.com (Patrick) — Sat, 10 May 2008 10:40:00 +0000

Since we are now able to use NHibernate at my current job, I decided I needed to alter my blogging strategy a little bit. It was my intention to demonstrate Allors in a couple of posts during which I would build up an invoicing application. Since I will have to do some learning of Nhibernate (reading the book 'Nhibernate in Action'), I decided to build the same application in NHibernate as home practice. This way I can see what the strong and weak points of both the frameworks are create a good comparison between them.

Let's go high level and write down the differences I can spot immediately without an in depth knowledge of NHibernate.

What is Allors

Allors is not a pure mapper tool, it is a 'Domain Driven Enabler'. Your domain will be modeled (by using a "repository explorer") into a meta domain. This results in having full control of all your complete domain information both at runtime and design time. This meta information will be used to generate a database scheme for you (if you decide to deploy to a database, you can work completely in memory as well).

All access to class variables goes through strategy objects. These strategy objects are shielded from your domain class by means of Allors base classes (generated for you from the "repository explorer"). Your domain is thus heavily tied to the Allors platform. All objects are completely managed, they are created within a session which acts as a unit of work/Identity Map that can be committed/rollback entirely.

Allors tries to make relationships first class citizens into the development process. A relation should be considered as important as an object because a lot of what your object can or can't do depends on having such a relationship. (For example consider a relation between a person and a email. If that relation does not exists then the person cannot be emailed and a 'SendEmail' method on the object would make no sense). Every relation between objects is completely managed, all relations are by default bi-directional and both ends of it are maintained by the platform (see later 'what I like about Allors).

Allors chooses to not give the developer all the options. All the objects are loading with their value objects in them, in their strategy object that is. Once you need a relation to another object that object (or many objects depending on your relation cardinality) is lazy loaded. All access to variables is delegated to the strategy objects. There the lazy loading can be initiated if possible (lazy loading is possible if your strategy is based on a database, if the strategy is disconnected you might nog be able to load it afterwards), nothing happens through code manipulation or reflection.

What is NHibernate

NHibernate's domain model has no links with other assemblies what so ever. This is keeps your domain model lean and mean and involves no learning curve to build up your domain. However persistence is handled through mapping files/attributes. You can specify a ton of properties in here so it will take time to get this tweaked and completely learned. The major benefit of this NHibernate is that it can work with both existing databases as newly created (your ddl can be generation from Nhibernate).

Focus with Nhibernate lies towards mapping your domain objects into your database. It is focused on the object themselves and how to get them persisted into a database. All the rest is just standard behavior of .Net, meaning that a bi-directional relation is considered as two separate ones. You have to keep your domain in sync yourself.

As already mentioned NHibernate lets you specify the mapping between your object and your tables. While doing so you have a ton of options you can set. Different fetching strategies, Caching, setting variables through reflection (not exposing anything you don't want)... All is possible. It uses interceptors and code emitting to get all these things done without letting the persistence code into the domain. To do this you have to take some things under consideration (always create default constructor, make properties virtual in order to have them lazy loaded, ...). What ever happens with a sealed class??

High level Comparison Table

NHibernate	Allors
Persistence Ignorant	Managed Object
Object Driven	Relation Driven
Lots of configuration and fine tuning possible	Defaults by Allors
Both New and Existing database schemes	Only Managed by Allors

What I like about Allors (compared to NHibernate with my current knowledge)

Check the following code: Your domain model has two objects. A Person and an Address, the relationship between these two is a one-to-one, meaning that any address can be used for one person and one person can have only one address. Some code:

 1 Person person1 = new Person();
 2 Person person2 = new Person();
 3 Address address1 = new Address();
 4 Address address2 = new Address();
 5 
 6 person1.Addresss= address1;
 7 person2.Addresss= address2;
 8 
 9 // Switch one-to-one relation
10 person2.Address = address1;
11 
12 // Check that managed objects are correctly relinked
13 Assert.IsFalse(person1.ExistAddress);
14 Assert.IsFalse(address2.ExistPersoon);

The above test would go green with Allors, but with I don't know what happens with NHibernate. It will mostly depends on the mapping configuration you have specified. If you make the FK index unique I think you will get a FK Constraint violation?? If you don't make it unique your domain model will go out of synch with what you are trying to do/or you would have to get the objects in memory en remove the associations from them. I'll be doing a little spike in order of how these situations reaction (Still have to look into all the configurations possible before I can do that).

Where do we go from here

The next blog post will handle about the domain I will be building in order to make an adequate and more in depth comparison between both frameworks. The domain model will be about an invoicing application build in the simplest of way. That way I can as well check how future proof both frameworks are when you want to extend/update your database schemes and do some refactorings.

See you next time.

NHibernate here we come !

noreply@blogger.com (Patrick) — Wed, 30 Apr 2008 20:24:00 +0000

Currently we are starting up a project to rewrite the security service. The previous version was build using data sets (argh it even gives me the creeps just writing this word), relying heavily on the database. For every change (big or small) on the user profile the entire thing was deleted out of the database and the new version was inserted. It even came this far that with large profiles, the timeout of the web service was hit and the application refused to work altogether. Lessons learned from this debacle, we decided to build a clean domain model and use a UnitOfWork to decide what needs to be saved into the database. We added features like lazy loading and caching as well to avoid database payloads. Then we decided, based on the patterns already examined, we would need an ORM. We looked at some possibilities (Allors, NHibernate, ...) , did some spikes and decided that when building a Persistence Ignorant domain model, Nhibernate was the best choice.

We presented our findings and spike results along with our proposed solution to the enterprise architects. It was turned down for no apparent reason. Their solution was to align with the rest of the organization and go for a data-driven approach (they even mentioned data sets) and thus avoid complex domains that need mapping through a tool. In case of caching, we were told to write it in stored procedures (because that is why they are there for :-)). "Why on earth did we even have a complex domain model" was the last question of the meeting. This coming from a team that believes that writing unit tests is more time consuming than it is beneficial. Wait until they have to maintain one of these data-driven applications :-).

We lost this battle, but we didn't surrender our fight. We already assembled some followers:

The DBA team loved the caching and the reduced database hits.
Other development teams were experiencing the same problems so were asking for similar solutions.

Long story short, the decision to use it or not was postponed until a meeting were both us and the A-Team would present our cases. The meeting was last Monday and given this blog posts title our arguments have won it.

Thank God because we already started on the ground work of our own ORM and it would take a lot of work to build the features we are now getting for free! We've worked about two weeks on it and I think we could cover about 75% percent of our basic CRUD operations. We didn't yet added support for collections the UnitOfWork, but we already had ideas about how to do it (build a custom persistent collection for it). Our implementation depended heavily on the dynamic proxy of castle project and was inspired by the NHibernate source code. Writing it ourselves made me think about this scene from the matrix were Morpheus asked Neo to take the blue pill and stay ignorant (about persistence issues) or take the red pill and see what really going on. We were forced to take the red pill or doom the project before it even began. It was fun to experiment with it, but when your problem domain is security, that should be the focus of your development all time you spent on infrastructure code is time wasted!

Anyway we are going to test NHibernate in our project, then it will be evaluated and eventually rolled out to the rest of the development teams. Lets start reading about it!

See ya next time.

Tags van Technorati: NHibernate,ORM

Methodology

noreply@blogger.com (Patrick) — Sun, 27 Apr 2008 12:13:00 +0000

I am a big fan of agile methodologies. In my opinion they are the only way one can guarantee (can you ever??) the delivery of the project.

Benefits of agile development are already widely known by the developers. But the persons who control the budget usually are not aware about these. So here is a short list in case you have to convince them :-)

Improved return on investment (RIO)
Early detection and cancellation of failing products
Higher quality software
Improved control of a project
Reduced dependence on individuals and increased flexibility

One of the cornerstones of my development process is automatic testing. Writing your tests in advance (Test Driven Development) is better because then every feature you put into production code is checked by automatic tests. I must say I violate the principle of writing tests first occasionally, but all my code must be covered before I can ship it.

At my current job we are working according to the Scrum methodology. The organization has a more 'analysis first' belief therefor we cannot completely follow the Scrum principles. But time is changing.... hopefully!!

Tags van Technorati: methodology,agile,TDD

My open source project

noreply@blogger.com (Patrick) — Sat, 26 Apr 2008 10:42:00 +0000

As outlined in my previous post, I am working on Allors in my spare time. This project enables you to focus on your problem domain instead of most infrastructure code. It is not exactly an ORM mapper because is does not do mapping for you. If you decide the persistence layer should be a database, that database scheme is created for. It uses different strategies to 'save' your object with the active record principle.

In the following series of posts I will be building an Accounting program to track my customers and my contracts with them. I could then enter my timesheets and generate my invoices directly from them.

The main idea about the series is to show how easy you can model your domain and demonstrate the strong points of our framework.

Stick with me or subscribe to my feed at: http://feeds.feedburner.com/ComeTalkAWalkWithMe

Tags van Technorati: Open Source,Allors

Getting Started

noreply@blogger.com (Patrick) — Fri, 25 Apr 2008 22:33:00 +0000

A couple of weeks ago I decided that I should get a blog. Why one might ask, why do we need another blog in this world? The answer is fairly simple, I need a blog as a reference for myself. I need a blog to improve my writing skills and I need a blog because Jan told me (just kidding of course).

If you care to know me more personally I invite you to read my profile. professionally I am developing software ever since the millennium bug. I started out at Capco, doing consultancy work in Java across Europe (Antwerp, London, Frankfurt, Luxemburg). I then switched to MSP and .Net. For them I became the lead developer/architect on a major insurance project in Eindhoven. In 2004 I decided to take a leap into the dark. I quit my job and started my own company (PDBC-Systems).

Currently I have a contract at SD WORX (signed thank to Inxin) where I am working on the new security component. It is built using .NET 3.0 exposing a WCF service on the back-end and a WPF application on the client-side. My blog will probably be filled with anecdotes about this project.

In my spare time I participate on an Open-Source project called Allors. Allors is a domain driven enabler! You create a meta domain by using the repository browser, afterwards Stringtemplate takes care of the code generation to build your domain objects. By using different strategies (memory, SQL, oracle, ...) you can map your domain to different persistence methods. A fair amount of blog posts will probably be Allors inspired.