Yesterday, I mentioned in my post about MonoRail that I would make the source of the framework available to the community. Today I found some time to build a sample application demonstrating the framework.

You can view the sample application by navigating to: http://breadcrumbs.premotion.nl and you can get the source by clicking here: Download here. The framework is by no means complete or stable and must not be used in any other application than test applications. Neither me nor Premotion can be held responsible for damage caused by the usage of the framework.

I know the framework contains a lot of bugs, but I am not going to fix them before I have a clear idea of what features the framework should contain. If you have any suggestions, ideas or comments, please let me know!

This post is not about some train riding one single track and a big fortified building but about the Monorail MVC (Model View Controller) framework of the Castle Project.

This is not going to be an introduction to Monorail but rather a story about my workflow for this particular project. Although I might write an article about Monorail in the future, for now I will point you to the Castle Project website for information about Monorail.

Last week I had to build a web application for the Van der Werff project, which allows users to view project information online and report malfunctions. The access to the information must be protected from anonymous users and only be accessible for authenticated users. The project information comes from the WCF web service, which also provides the security.

In the next paragraphs you can read how I implemented the application.

Functional Structure

The application has the following structure:

• Home
• Contact form
• Projects
  • Project information
  • Addresses
    • Address information
    • Product information
    • Checklist information
    • Report malfunction form
• Login

Logical Structure, Controllers & Actions

I started dividing the application functionality into logical groups which became the controllers and each bit of functionality became one or more actions.

The result is:

• Home Controller
  • Home
  • Contact form
  • Contact form ‘thank you’
• ProjectView Controller
  • List projects
  • View project
  • View address
  • View product
  • View checklist
  • Report malfunction form
  • Report malfunction form ‘thank you’
• Login Controller
  • Login form
  • Logout

Home Controller

The home controller was the simplest controller to implement, it contains only three actions. The first action ‘Home’ does nothing more than to render the homepage. The second action ‘Contact form’ renders the contact form. The third action is more interesting, it gathers the information from the ‘Contact form’ validates it and sends it as an e-mail to the configured address.

This was the first time I used the e-mail sender service of the Monorail framework but it was a joy to work with. You can store anything in the PropertyBag and then render an e-mail template like you would with a normal view. After rendering you get a Message object back which you can send.

Here is some sample code:

// set the properties
PropertyBag["from"]    = Settings.ApplicationMailAddress;
PropertyBag["to"]      = Settings.ContactMessageDeliverAddress;
PropertyBag["name"]    = name;
PropertyBag["phone"]   = phone;
PropertyBag["mail"]    = mail;
PropertyBag["subject"] = Settings.ContactMessageSubject;
PropertyBag["message"] = message;

// send the message
Message msg = this.RenderMailMessage(Settings.ContactMessageTemplate);
msg.From    = Settings.ApplicationMailAddress;
msg.To      = Settings.ContactMessageDeliverAddress;
msg.Subject = Settings.ContactMessageSubject;
this.DeliverEmail(msg);

The RenderMailMessage() function does all the magic of rendering an e-mail template and creating a Message object out of it.

After the message is send, the user is redirected to a nice ‘thank you’ view.

Login Controller

The login controller container, do not be surprised, the login functionality. The controller does nothing more than to render the login form, check if the user name and password are valid string (the real authentication is done by the WCF back-end web service), store them in the session and destroy the session when the user logs out.

Project View Controller

The project view controller was surpassingly easy to implement. It does nothing more than retrieving data, managing identifiers and to render the correct view. Actually it does a little more than that: It manages caching and also contains an e-mail form which allows the user to report a malfunction. The functionality is similar to the ‘Contact form’ functionality.

But it really surprised me how simple it is to create such an application. If I had used ASP.NET or PHP it would have cost me a lot more time.

Time

Speaking of time, it took about three 8 hour days to implement the application. That includes writing the style and html layout as well as deploying the application to the server. Some people might still think that 24 hours is too long, but remember: There was a learning curve, for example: I did not know how to use the mail sender service.

Another aspect that cost more time than it could have was: breadcrumbs. I could have hardcoded them, saving myself about 8 hours, but I choose to write a framework to handle them.

Breadcrumb Framework

The breadcrumb framework contains some classes to allow me to define breadcrumb paths easily. Each action can be decorated with a Breadcrumb attribute. An interceptor checks if an action is decorated with the attribute and adds it to a manager class if it does. Then on the view I can use a ViewComponent which renders the breadcrumb path. Simple, clean, nice!

Although the framework needs a lot of tuning, it something I am considering donating to the Castle framework. I just hope I can find the time to do it.

Conclusion

Castle Monorail is a powerful MVC framework which allows it users to develop web applications rapidly. It is very extensible as well: Most, if not all, components can be swapped out and be replaced by others.

The integration with Castle MicroKernel makes it even easier to develop complex applications. Combine it advantages with its ever growing user base/developers base and you have yourself a winner, well that is my opinion anyway .

That is it for this post. I hope you enjoyed the read, if you did, please let me know and if you did not, please let me know too. Bye

Sources

1. [1] Castle Monorail
2. [2] Castle Project
3. [3] Castle MicroKernel

What are interceptors you might think, well, interceptors are class which intercept method calls for other classes. The purpose is to implement a common action, like: logging or authorization, they basically act as proxies. Castle Windsor allows you to configure interceptors in the application configuration file which solved my problem of having to modify all the service code myself.

Writing an interceptor for the Castle Windsor container is actually a simple and straightforward process: Create a new class and implement the IInterceptor interface which defines one single method: Intercept(IInvocation). The only thing left to do is to configure the component on which you want to apply the interceptor. That is it.

I am not going to explain all the details now, however I might write an article in the near future. That is it for now, until next time.

However I decided to leverage the power of some components of the Castle project [1]: Castle MonoRail [2] and Castle ActiveRecord [3]. Castle Monorail is a MVC (Model View Controller) framework and Castle ActiveRecord is a framework based on the active record[4] pattern. The components integrate very nicely as you will see.

First I created the log entry active record class which is a simple POCO (Plain Old CLR Object), derived it from ActiveRecordBase and decorated its properties with the proper ActiveRecord attributes. That is it for the database logic, fast is it not?

Then I created the controller for the log entries. I simply created a class, derived it from Controller and added the Scaffolding attribute to it. That took me about a minute to implement.

Finally I needed to do some plumbing: configuration and initialization. That is all. I now have an working application which allows me to list (with pagination!), view, create, update and delete log entries. The design is awful but it good enough for its purpose.

Castle project supports this out of the box which is amazing in my opinion. You can download a sample application here.

Sources

In this post I will explain how you implement a message sender and receiver class. I tried to keep the framework as simple as possible and I think I did a pretty good job, however if you have any comments or ideas, please let me know.

Anyway, enough talk, lets get down to business.

Implementing a message sender

Implementing a sender is very easy, there are two things to do: The first step is to implement the IMessageSender interface or derive from the SenderBase class. Then you need to decorate the sender class with the MessageSenderAttribute. That is it.

Example:

[MessageSender()]
public class TestSender: SenderBase
{
	public void SendMessage()
	{
		TestMessage msg = new TestMessage();
		base.DoSend(msg);
	}
}

The TestMessage which is send in the example code does not contain any information, but you can define your own message class which contains any information you can imagine.

Implementing a message receiver

The implementation of a receiver class is not equal easy as the implementation of the sender class. There are two steps as well: The first step is to implement the IMessageReceiver interface and the second step is to decorate the class with the MessageReceiverAttribute.

Example:

[MessageReceiver()]
public class TestReceiver: IMessageReceiver
{
	public void Receive(IMessage message)
	{
		// do something with the message
	}
}

The receive function will be called when a message is received.

Currently I am working on the implementation of the message filters. The idea is that you can do pre-processing on messages using some clean C# constructs. When I got an implementation ready I will post it on this weblog. That is it for now. See you next time.

The messages can be sent from any component that is declared to be a message sender to any component that is declared to be a message receiver. The components, for the senders, do not know to which components receive the message or, for the receivers, where the message originated from.

The messages contain Meta information describing the payload of the message. Currently I am working on the messages themselves. Here is an example of how you can extract information from a message without knowing its explicit content.

Firs we will create a message and its payload:

// creating the message and it's payload
Person person1			= new Person("Bert");
IContentMetaInfo metaInfo1	= new ContentMetaInfoBase(typeof(Person));
IContent content1			= new ContentBase(person1, metaInfo1);
Person person2			= new Person("Trilobyte");
IContentMetaInfo metaInfo2	= new ContentMetaInfoBase(typeof(Person));
IContent content2			= new ContentBase(person2, metaInfo2);
MessageBase msg			= new MessageBase(new IContent[] {content1,content2});

Image the message is send to somewhere and then take a look at the receive code below:

// get the payload from the message
foreach (IContent personContent in msg.FindContentByMetaInfo(delegate (IContentMetaInfo inf) {return inf.ContentType == typeof(Person);}))
{
	// process the person content
	Person p	= (Person)personContent.Content;
	Console.WriteLine(p.Name);
}

As you can see, I only extracted the data I discovered, for all I know the message contains tons of other information, but I do not care about that.

Although my current implementation is not completed yet and there is a lot of stuff still to do, I really wanted to share this sample with you, because I think this method is a good way to decrease coupling between components in the system.

I will keep working on the framework as much as I can, so expect more information about it soon. In the mean time reactions about ideas, questions or comments are very welcome!

Om maar bij het begin te beginnen: Wat is Inversion of Control?
IoC wordt meestal gebruikt in een raamwerk om deze uitbreidbaar te maken voor ontwikkelaars. Het basis principe is dat het raamwerk weet van de uitbreidingen en deze zelf aanroept. Dit in tegenstelling tot de traditionele API waar de uitbreiding ontwikkelaar het raamwerk aanroept. Dat betekent concreet dat het raamwerk de baas is. Oftewel de rollen zijn omgedraaid.Voor andere definities, zie bronner: [1], [3] en [4].

Inversion of Control container?
Het IoC patroon wordt meestal geïmplementeerd met behulp van een IoC container. Deze container bevat een register van alle componenten in het hele systeem. Dit register is verantwoordelijk voor het creëren en opruimen van de componenten als ook het bijhouden van de configuratie en de afhankelijkheden van andere componenten. Dit reduceert de koppeling tussen de diverse component, met als gevolg dat ze makkelijker herbruikbaar, te onderhouden en te testen zijn.

Zoals je misschien hebt opgemerkt maakt de IoC container gebruik van het Dependency Injection patroon om de componenten zo los mogelijk van elkaar te houden.

Waarom is IoC zo geweldig?
IoC stelt je als ontwikkelaar in staat om gemakkelijk afhankelijkheden en configuratie te beheren Doordat koppelingen voorkomen kunnen worden, kan de ontwikkelaar zich richten op zijn eigen taak zonder zich druk hoeft te maken over allerlei afhankelijkheden. Het onderhouden en testen van code is eenvoudiger en ook kunnen componenten gemakkelijker opnieuw gebruikt worden.

Doordat afhankelijkheden in de configuratie geregeld worden, kun je als applicatie beheerder gemakkelijk onderdelen vervangen door andere onderdelen zonder dat er een programmeur aan te pas hoeft te komen.

Dit alles heeft tot gevolg dat softwareprojecten eenvoudiger worden en met grotere zekerheid uitgevoerd kunnen worden, iets waar iedereen voordeel van heeft.

Welke IoC container te gebruiken?
Er zijn verschillende implementaties van IoC containers voor verschillende platformen. Zelf gebruik ik WindsorContainer uit het Castle Project [2]. Deze container werkt op het .NET platform, mijn favoriete ontwikkelomgeving. Ik ben er pas een aantal weken mee aan het werk en ik ving het geweldig werken, nou zal ik niet beweren dat Windsor de beste is omdat het de enige IoC container is die ik tot nog toe gebruikt heb.

Mocht iemand ervaring hebben met een andere IoC containers, geef dan je mening in een reactie op deze post.

Op de wikipedia pagina over IoC [1] staat een overzicht van een aantal IoC containers gesorteerd op platform en taal.

Voorbeeld:
Het onderstaande voorbeeld maakt gebruik van de WindsorContainer van het Castle Project. Het is een eenvoudig voorbeeld puur gericht om het IoC principe te demostreren. De onderstaande code is ook niet compleet. Klik hier om de hele code te downloaden.

Klasse diagram van het model:

Configuratie:

De configuratie specificeert twee componenten: De MessageFactory en de SmtpSender. De SmtpSender wordt geinitialiseerd met de gespecificeerde host name en port (zie constructor van de SmtpSender klasse).

Code:

De code is, zoals je kunt zien, erg eenvoudig. De code bestaat uit een viertal delen: Het eerste deel creëert en configureert de IoC container. Het volgende code gedeelte bestaat uit twee stappen: Het ophalen van de IMessageFactory implementatie klasse uit de IoC container en het creëren van het bericht. Het derde deel haalt eerst de IMessageSender implementatie klasse op, om vervolgens daarmee het bericht te versturen. En tot slot het laatste deel dat niks anders doet dan opruimen. Dat is alles!

Inversion of Control is, naar mijn mening, een krachtig principe dat er voor zorgt dat je op een totaal andere manier software gaat ontwikkelen. Het ontwikkelen met behulp van het IoC principe even wennen is, het vergt namelijk een andere denkwijze, maar mijn ervaring is dat je na een paar kleine test applicaties, je het principe goed onder de knie hebt en de kracht optimaal kan benutten.

Dat is het wel weer voor deze post, en volgende posts over dit onderwerp zal ik wat meer op de details ingaan. Ik hoop dat je deze post leuk en nuttig vond om te lezen! Als je nog vragen of opmerkingen hebt dan hoor ik het graag!

Bronnen