tag4sree on SWiK

Generic pipeline for business objects using Castle Windsor

Sun, 20 Jul 2008 13:54:39 -0700

Currently I'm working with a system handling different operations when receiving business documents in object form. Its quite obvious that the code for handling this has evolved to have a lot more responsibilities than it was intended to.

So already having an Inversion of Control container in our stack I thought we could make the operations in the pipeline configurable using the container. To achieve this we need to specify an interface for the tasks in the pipeline, in our case its pretty simple:

public interface IPipelineTask<T>
{
    T Perform(T instance);
}

Secondly we need to define the pipeline itself, again using a generic interface:

public interface IPipeline<T>
{
    T Execute(T instance);
}

So basically what I want to accomplish is the ability to ask my Inversion of control container for a pipeline for a certain type and be able to call the Execute method on the instance and have all associated tasks performed on the instance I pass to the method. So the code for handling an incoming object of type Invoice would look like this:

Invoice incomingInvoice = ....;
ProjectContainer container = new ProjectContainer();
IPipeline<Invoice> pipeline = container.Resolve<IPipeline<Invoice>>();
Invoice processedInvoice = pipeline.Execute(incomingInvoice);
container.Release(pipeline);

So lets look at the implementation of the generic pipeline that handles executing of each task:

public class Pipeline<T> : IPipeline<T>
{
    private IPipelineTask<T>[] tasks;
    public Pipeline(IPipelineTask<T>[] pipelinetasks)
    {
        tasks = pipelinetasks;
    }

    public T Execute(T instance)
    {
        T processedInstance = instance;
        foreach (var task in tasks)
        {
            processedInstance = task.Perform(processedInstance);
        }
        return processedInstance;
    }
}

Note the constructor takes an array of IPipelineTasks<T> this is here our Inversion of Control container comes to play and does this for us using constructor dependency injection.

Each task needs to implement the IPipelineTask<T> with its specific business object type:

public class InvoiceNotifier : IPipelineTask<Invoice>
{
    private IUserNotifier usernotifier;
    public InvoiceNotifier(IUserNotifier notifier)
    {
        usernotifier = notifier;
    }

    public Invoice Perform(Invoice instance)
    {
        usernotifier.Notify(Notification.IncomingInvoice,
                            "The invoice with identifier " + instance.ID + " changed state to " + instance.State);
        return instance;
    }
}

Normally when working with arrays in Castle Windsor we have to specify each service to be part of the array in the configuration, however in our case we want all registered implementations of the specific interface to be passed to the pipeline. To do this we can add a custom sub dependency resolver to castle, in fact we can use the ArraySubDependencyResolver already written by Castle projects founder (and soon to be Microsoftee) Hammett. With this in place we can make the following configuration and our mission is accomplished and all tasks registered in the configuration will be injected when we request the generic Pipeline of this type.

<components>
   <!--Register the generic pipeline--> 
  <component
    id="bussiness.document.pipeline"
    service="Services.IPipeline`1, Services"
    type="Services.Pipeline`1, Services"
    lifetype="Thread"
    />
   <!--Register our pipeline tasks-->
  <component
    id="invoice.notification"
    service="Services.IPipelineTask`1[[Domain.Invoice, Domain]], Services"
    type="Services.InvoiceNotifier, Services"
    lifetype="Thread"
    />
  <component
    id="invoice.reciever"
    service="Services.IPipelineTask`1[[Domain.Invoice, Domain]], Services"
    type="Services.InvoiceReciever, Services"
    lifetype="Thread"
    />
  
   <!--Registration of services and repositories which our pipeline tasks uses-->
   ....
</components>

Using this infrastructure custom tasks can be specified easily in the configuration even from other namespaces and assemblies. And the pipeline doesn't need to worry about the dependencies of each Pipeline task, the container handles this

Generic pipeline for business objects using Castle Windsor

Sun, 20 Jul 2008 13:54:38 -0700

public interface IPipelineTask<T>
{
    T Perform(T instance);
}

Secondly we need to define the pipeline itself, again using a generic interface:

public interface IPipeline<T>
{
    T Execute(T instance);
}

Invoice incomingInvoice = ....;
ProjectContainer container = new ProjectContainer();
IPipeline<Invoice> pipeline = container.Resolve<IPipeline<Invoice>>();
Invoice processedInvoice = pipeline.Execute(incomingInvoice);
container.Release(pipeline);

So lets look at the implementation of the generic pipeline that handles executing of each task:

public class Pipeline<T> : IPipeline<T>
{
    private IPipelineTask<T>[] tasks;
    public Pipeline(IPipelineTask<T>[] pipelinetasks)
    {
        tasks = pipelinetasks;
    }

    public T Execute(T instance)
    {
        T processedInstance = instance;
        foreach (var task in tasks)
        {
            processedInstance = task.Perform(processedInstance);
        }
        return processedInstance;
    }
}

Note the constructor takes an array of IPipelineTasks<T> this is here our Inversion of Control container comes to play and does this for us using constructor dependency injection.

Each task needs to implement the IPipelineTask<T> with its specific business object type:

public class InvoiceNotifier : IPipelineTask<Invoice>
{
    private IUserNotifier usernotifier;
    public InvoiceNotifier(IUserNotifier notifier)
    {
        usernotifier = notifier;
    }

    public Invoice Perform(Invoice instance)
    {
        usernotifier.Notify(Notification.IncomingInvoice,
                            "The invoice with identifier " + instance.ID + " changed state to " + instance.State);
        return instance;
    }
}

<components>
   <!--Register the generic pipeline--> 
  <component
    id="bussiness.document.pipeline"
    service="Services.IPipeline`1, Services"
    type="Services.Pipeline`1, Services"
    lifetype="Thread"
    />
   <!--Register our pipeline tasks-->
  <component
    id="invoice.notification"
    service="Services.IPipelineTask`1[[Domain.Invoice, Domain]], Services"
    type="Services.InvoiceNotifier, Services"
    lifetype="Thread"
    />
  <component
    id="invoice.reciever"
    service="Services.IPipelineTask`1[[Domain.Invoice, Domain]], Services"
    type="Services.InvoiceReciever, Services"
    lifetype="Thread"
    />
  
   <!--Registration of services and repositories which our pipeline tasks uses-->
   ....
</components>

Generic pipeline for business objects using Castle Windsor

Sun, 20 Jul 2008 13:54:36 -0700

public interface IPipelineTask<T>
{
    T Perform(T instance);
}

Secondly we need to define the pipeline itself, again using a generic interface:

public interface IPipeline<T>
{
    T Execute(T instance);
}

Invoice incomingInvoice = ....;
ProjectContainer container = new ProjectContainer();
IPipeline<Invoice> pipeline = container.Resolve<IPipeline<Invoice>>();
Invoice processedInvoice = pipeline.Execute(incomingInvoice);
container.Release(pipeline);

So lets look at the implementation of the generic pipeline that handles executing of each task:

public class Pipeline<T> : IPipeline<T>
{
    private IPipelineTask<T>[] tasks;
    public Pipeline(IPipelineTask<T>[] pipelinetasks)
    {
        tasks = pipelinetasks;
    }

    public T Execute(T instance)
    {
        T processedInstance = instance;
        foreach (var task in tasks)
        {
            processedInstance = task.Perform(processedInstance);
        }
        return processedInstance;
    }
}

Note the constructor takes an array of IPipelineTasks<T> this is here our Inversion of Control container comes to play and does this for us using constructor dependency injection.

Each task needs to implement the IPipelineTask<T> with its specific business object type:

public class InvoiceNotifier : IPipelineTask<Invoice>
{
    private IUserNotifier usernotifier;
    public InvoiceNotifier(IUserNotifier notifier)
    {
        usernotifier = notifier;
    }

    public Invoice Perform(Invoice instance)
    {
        usernotifier.Notify(Notification.IncomingInvoice,
                            "The invoice with identifier " + instance.ID + " changed state to " + instance.State);
        return instance;
    }
}

<components>
   <!--Register the generic pipeline--> 
  <component
    id="bussiness.document.pipeline"
    service="Services.IPipeline`1, Services"
    type="Services.Pipeline`1, Services"
    lifetype="Thread"
    />
   <!--Register our pipeline tasks-->
  <component
    id="invoice.notification"
    service="Services.IPipelineTask`1[[Domain.Invoice, Domain]], Services"
    type="Services.InvoiceNotifier, Services"
    lifetype="Thread"
    />
  <component
    id="invoice.reciever"
    service="Services.IPipelineTask`1[[Domain.Invoice, Domain]], Services"
    type="Services.InvoiceReciever, Services"
    lifetype="Thread"
    />
  
   <!--Registration of services and repositories which our pipeline tasks uses-->
   ....
</components>

Generating DTO's from your fully populated domain classes

Thu, 19 Jun 2008 15:22:13 -0700

When working with object relational mapping(or even handrolled DAL's) you most often work on fully populated objects. When working in an environment utilizing Data Transfer Object either for transport over the wire or screen bound DTO's you have to slice or merge your fully populated objects. With LINQ for nHibernate, LINQ for SQL the solution for this is pretty obvious you populate the object using its constructor or object initialisers in a LINQ query either directly on your data source or on one or more already populated instances.

A quick example using LINQ for nHibernate could be:

var result = from p in db.Products select new ProductDTO {p.ID, p.Name} ;

(Of course we need to make instances not anonymous types because we need to pass them out of the current scope)

If we are stuck using traditional querying in nHibernate we can accomplish the same using HQL:

select new ProductDTO(p.ID, p.Name) from Product p

When using this HQL query its important to remember to import your DTO class in the mapping or else you will end up with an error like:

NHibernate.QueryException : class not found: ProductDTO

To import it just add <import class="Name.Space.ProductDTO, Assembly"> right after your hibernate-mapping element. Of course the generating of the DTO's can get much more complex than the samples i have shown. They could span multiple business object requiring complex queries but the concept remains the same.

Okay, so these options are valid only for folks using an LINQ empowered ORM's or frameworks with equivalent functionality to the nHibernate sample above. One thing we could do is to create the DTO's from the fully populated objects. Of course this could be a dangerous decision if you don't already have the objects in the current context and the DTO's require a very little subset of the data, so that's definitely worth noting. That beeing said we could do this in a number of ways all which i can thing of writing myself involves plumbing code. So a couple of days ago I stumbled upon a project called otis a object transformer or Object-to-Object mapper if you prefer that term.

The concept is pretty simple, we can define how one object map to another so if we take our very simple case we can specify a mapping on this form:

<?xml version="1.0" encoding="utf-8" ?>
<otis-mapping xmlns="urn:otis-mapping-1.0">
  <class name="Name.Space.ProductDTO, Assembly" source="Name.Space.Product, Assembly" >
    <member name="ID" />
    <member name="Name" />
  </class>
</otis-mapping>

In the above case we have the same names on properties in both classes so its pretty simple, but the possibilities in the mapping is many. You can use expression to combine multiple values to one, projections, exchanging certain values etc. I will certainly have to look into the source code of otis and have a look of its capabilities as the documentation is a bit sparse.

To utilize the above mapping we configure the framework and use a generic class to get Assembler classes that can convert our types, its pretty simple:

Product product = ...; //Our fully populated product instance
Otis.Configuration conf = new Otis.Configuration();
//Looks for embedded ressource with *.otis.xml ending
conf.AddAssemblyResources(Assembly.GetExecutingAssembly(), "otis.xml"); 
//Declare our assembler
var asm = conf.GetAssembler<ProductDTO, Product>();
//Use the assembler to get the DTO
ProductDTO dto = asm.AssembleFrom(product);

As I said I will definitely dive into the source to explore which features are available and how the transformation is done and what the costs of it is. The main issue I have with the approach is that we could do the same using code and to make it more flexible lambda expressions and have it strongly typed and avoid the verbosity of XML, but lets see how feature rich Otis is before dismissing it.

Generating DTO's from your fully populated domain classes

Thu, 19 Jun 2008 15:22:13 -0700

A quick example using LINQ for nHibernate could be:

var result = from p in db.Products select new ProductDTO {p.ID, p.Name} ;

(Of course we need to make instances not anonymous types because we need to pass them out of the current scope)

If we are stuck using traditional querying in nHibernate we can accomplish the same using HQL:

select new ProductDTO(p.ID, p.Name) from Product p

When using this HQL query its important to remember to import your DTO class in the mapping or else you will end up with an error like:

NHibernate.QueryException : class not found: ProductDTO

The concept is pretty simple, we can define how one object map to another so if we take our very simple case we can specify a mapping on this form:

<?xml version="1.0" encoding="utf-8" ?>
<otis-mapping xmlns="urn:otis-mapping-1.0">
  <class name="Name.Space.ProductDTO, Assembly" source="Name.Space.Product, Assembly" >
    <member name="ID" />
    <member name="Name" />
  </class>
</otis-mapping>

To utilize the above mapping we configure the framework and use a generic class to get Assembler classes that can convert our types, its pretty simple:

Product product = ...; //Our fully populated product instance
Otis.Configuration conf = new Otis.Configuration();
//Looks for embedded ressource with *.otis.xml ending
conf.AddAssemblyResources(Assembly.GetExecutingAssembly(), "otis.xml"); 
//Declare our assembler
var asm = conf.GetAssembler<ProductDTO, Product>();
//Use the assembler to get the DTO
ProductDTO dto = asm.AssembleFrom(product);

Generating DTO's from your fully populated domain classes

Thu, 19 Jun 2008 15:22:12 -0700

A quick example using LINQ for nHibernate could be:

var result = from p in db.Products select new ProductDTO {p.ID, p.Name} ;

(Of course we need to make instances not anonymous types because we need to pass them out of the current scope)

If we are stuck using traditional querying in nHibernate we can accomplish the same using HQL:

select new ProductDTO(p.ID, p.Name) from Product p

When using this HQL query its important to remember to import your DTO class in the mapping or else you will end up with an error like:

NHibernate.QueryException : class not found: ProductDTO

The concept is pretty simple, we can define how one object map to another so if we take our very simple case we can specify a mapping on this form:

<?xml version="1.0" encoding="utf-8" ?>
<otis-mapping xmlns="urn:otis-mapping-1.0">
  <class name="Name.Space.ProductDTO, Assembly" source="Name.Space.Product, Assembly" >
    <member name="ID" />
    <member name="Name" />
  </class>
</otis-mapping>

To utilize the above mapping we configure the framework and use a generic class to get Assembler classes that can convert our types, its pretty simple:

Product product = ...; //Our fully populated product instance
Otis.Configuration conf = new Otis.Configuration();
//Looks for embedded ressource with *.otis.xml ending
conf.AddAssemblyResources(Assembly.GetExecutingAssembly(), "otis.xml"); 
//Declare our assembler
var asm = conf.GetAssembler<ProductDTO, Product>();
//Use the assembler to get the DTO
ProductDTO dto = asm.AssembleFrom(product);

Copenhagen .NET User Group - Startup

Fri, 13 Jun 2008 05:22:20 -0700

A .NET User Group is starting up in Copenhagen for more information check http://cnug.dk/ (in Danish). I Hope to see many of the Danish developers on the 19th of June in Ballerup. Its gonna be a talk about expectations for the User Group and a presentation of some concepts from object relational mapping.

Copenhagen .NET User Group - Startup

Fri, 13 Jun 2008 05:22:19 -0700

Copenhagen .NET User Group - Startup

Fri, 13 Jun 2008 05:22:19 -0700

Why the database should handle paging

Thu, 05 Jun 2008 17:01:38 -0700

Notice that the scrollbar isn't at the bottom. That's a lot of data to fetch if you only show a single page of them

(click for larger image)

Why the database should handle paging

Thu, 05 Jun 2008 17:01:37 -0700

Notice that the scrollbar isn't at the bottom. That's a lot of data to fetch if you only show a single page of them

(click for larger image)

Why the database should handle paging

Thu, 05 Jun 2008 17:01:36 -0700

Notice that the scrollbar isn't at the bottom. That's a lot of data to fetch if you only show a single page of them

(click for larger image)

Generating passwords

Tue, 03 Jun 2008 14:41:53 -0700

So if you need to generate passwords easy you don't have to reinvent the wheel, you can use functionality that the Mempership functionality from ASP.NET already has. On the Membership class in System.Web.Security namespace is a static method for generating passwords. You can specify a length and how many non alphanumeric characters it should contain.

Of course its not exotic in anyway and you can not control the set of characters used (apart from how many should be non alphanumeric) and it does not generate pronounceable passwords.

string password = Membership.GeneratePassword(7, 1);

The above code will generate a string with seven random characters. Its worth taking note of the second parameter. It specifies the minimum number of non-alphanumerical characters so the generated password can contain more than one in the above case.

If you need to generate pronounceable passwords I would recommend you take a look at the C implementation available here: http://www.multicians.org/thvv/tvvtools.html#gpw it covers the theory behind using trigraphs and furthermore shows implementation of how to extract trigraphs from a dictionary and how to use this to generate the actual passwords.

But to keep it short, if you just need a random set of chars. Use the features already in the framework instead of rolling your own! The lines saved makes fewer lines that could contain that tricky bug you are hunting a few months from now.

Generating passwords

Tue, 03 Jun 2008 14:41:52 -0700

Of course its not exotic in anyway and you can not control the set of characters used (apart from how many should be non alphanumeric) and it does not generate pronounceable passwords.

string password = Membership.GeneratePassword(7, 1);

Generating passwords

Tue, 03 Jun 2008 14:41:51 -0700

Of course its not exotic in anyway and you can not control the set of characters used (apart from how many should be non alphanumeric) and it does not generate pronounceable passwords.

string password = Membership.GeneratePassword(7, 1);

Common nHibernate exceptions and a question

Tue, 13 May 2008 08:23:27 -0700

I often get asked question about nHibernate issues the question discussed last in this post is often brought up. But lets start out with a few simple exceptions that can sometimes take up more of your time than you would like.

"NHibernate.MappingException : Unknown entity class: MyNamespace.With.Persistent.Class"

You are trying to use a class as persistent that nHibernate wouldn't know how to handle. The number one reason for this error is that you have mapping files as embedded resources and that you forgot to actually embed the mapping file.

"NHibernate.MappingException : persistent class ClassName not found" or "NHibernate.MappingException : associated class not found: ClassName"

This is usually an error in your mapping, nHibernate can't find the class you reference in your mapping. This is often caused by typos or missing to specify in which assembly or namespace your persistent class is to be found. You can specify a default assembly and namespace in the <hibernate-mapping> element or you can write the name of your classes with the assembly and namespace specified on the form "Namespace.ClassName, Assembly".

"NHibernate.InvalidProxyTypeException : The following types may not be used as proxies"

This is a classic, if you want to use nHibernates lazyloading features you need to specify your classes properties as virtual so nHibernate can create proxies for you. If you don't need to use lazyloading on specific type mark these types with lazy="false" in the class element, and you won't have to mark its properties as virtual.

So that's a handful of the most common exceptions when starting out with nHibernate. Lets move on to a question I have answered quite a few times. People often want to minimize the number of roundtrip's to the database by joining and retrieving larger resultsets and have nHibernate transform this larger set of results into the correct object graph. Whether this is a good optimization depends heavily on the expected data since it could result in a huge amount of redundant data transferred between database and application. But nonetheless the thing that often tricks people is illustrated by the following test:

//Assumme we have 2 invoices with 3 invoicelines each
IList<Invoice> invoices = s.CreateCriteria(typeof (Invoice)).SetFetchMode("InvoiceLines", FetchMode.Join).List<Invoice>();
Assert.AreEqual(2, invoices.Count);

This test will fail, because you actually get 6 invoice entities back. That's because the resultset contains duplicate invoices (one for each InvoiceLine) and nHibernate transforms these into invoice instances. One way to fix this is to specify that you want distinct root entities back. This is done by specifying a result-transformer like this:

IList<Invoice> invoices =
                s.CreateCriteria(typeof (Invoice)).
                SetFetchMode("InvoiceLines", FetchMode.Join).
                SetResultTransformer(CriteriaUtil.DistinctRootEntity).
                List<Invoice>();

So what if your data isn't suitable for joining, you might end up with the large resultset I mentioned earlier? And we don't want to hit the N+1 Select problem by selecting the InvoiceLines for each of the fetched Invoice's. That's were nHibernates batch fetching can be used. We have retrieved all the Invoices we want to use and afterwards we want to select the invoicelines for those. We can specify that our InvoiceLines should be retrieved in batches by specifying a batch-size on the collection in our mapping file.

<set name="InvoiceLines" batch-size="20">
	<key column="InvoiceID" />
	<one-to-many class="InvoiceLine" />
</set>

I just used 20 as an example, this means that nHibernate will fetch the InvoiceLines for 20 Invoices at a time. So this will result in two roundtrip's(in our example case), and this without fetching duplicate data in the resultsets. You could optimize some scenarios like the one above using MultiQuery or MultiCriteria, that is sending multiple queries in one roundtrip, but that's another story.

Common nHibernate exceptions and a question

Tue, 13 May 2008 08:23:21 -0700

"NHibernate.MappingException : Unknown entity class: MyNamespace.With.Persistent.Class"

"NHibernate.MappingException : persistent class ClassName not found" or "NHibernate.MappingException : associated class not found: ClassName"

"NHibernate.InvalidProxyTypeException : The following types may not be used as proxies"

//Assumme we have 2 invoices with 3 invoicelines each
IList<Invoice> invoices = s.CreateCriteria(typeof (Invoice)).SetFetchMode("InvoiceLines", FetchMode.Join).List<Invoice>();
Assert.AreEqual(2, invoices.Count);

IList<Invoice> invoices =
                s.CreateCriteria(typeof (Invoice)).
                SetFetchMode("InvoiceLines", FetchMode.Join).
                SetResultTransformer(CriteriaUtil.DistinctRootEntity).
                List<Invoice>();

<set name="InvoiceLines" batch-size="20">
	<key column="InvoiceID" />
	<one-to-many class="InvoiceLine" />
</set>

Common nHibernate exceptions and a question

Tue, 13 May 2008 08:23:18 -0700

"NHibernate.MappingException : Unknown entity class: MyNamespace.With.Persistent.Class"

"NHibernate.MappingException : persistent class ClassName not found" or "NHibernate.MappingException : associated class not found: ClassName"

"NHibernate.InvalidProxyTypeException : The following types may not be used as proxies"

//Assumme we have 2 invoices with 3 invoicelines each
IList<Invoice> invoices = s.CreateCriteria(typeof (Invoice)).SetFetchMode("InvoiceLines", FetchMode.Join).List<Invoice>();
Assert.AreEqual(2, invoices.Count);

IList<Invoice> invoices =
                s.CreateCriteria(typeof (Invoice)).
                SetFetchMode("InvoiceLines", FetchMode.Join).
                SetResultTransformer(CriteriaUtil.DistinctRootEntity).
                List<Invoice>();

<set name="InvoiceLines" batch-size="20">
	<key column="InvoiceID" />
	<one-to-many class="InvoiceLine" />
</set>

BlogEngine.NET - Urlrewriting

Fri, 09 May 2008 02:18:55 -0700

So the first thing I usually do when reviewing web projects is to find the default entry page that the user would see. When doing this with BlogEngine.NET you find the default.aspx (obviously in most cases). The first thing in the Page_Load of this is the following code:

if (Request.RawUrl.ToLowerInvariant().Contains("/category/")){...}
else if (Request.RawUrl.ToLowerInvariant().Contains("/author/")){...}
else if (Request.RawUrl.ToLowerInvariant().Contains("?tag=")){...}
//a couple of else if's more

So this makes it clear that the default.aspx page handles all listing of posts whether it is all in a category, all by an author or all having a specific tag. All these listings are requested using different URI's, to handle this an UrlRewrite HttpModule is implemented. If we look at some code in this UrlRewriter we will find:

if (context.Request.Path.Contains("/blog.aspx")){...}
else if (url.Contains("/POST/")){...}
else if (url.Contains("/CATEGORY/")){...}
else if (url.Contains("/AUTHOR/")){...}
//a couple of else if's more

So what happens here is we delegate the responsibility for different URL's to be handled on different pages, the responsibilities redirected to the default page is afterwards on the default page once again delegated to different methods handling databinding because presentation is alike. This results in some parsing of the URL's is duplicated in the UrlRewriter and in the default.aspx.cs file. And furthermore the collection of all posts is iterated both in the UrlRewriter and on the pages, that seems silly. Why not let UrlRewriting do what its intended for: to forward information and then keep the processing on simple pages for specific requests to avoid the redundant parsing and iteration?

I read an interview with the BlogEngine.NET founder on InfoQ a while back, and it seems he has some issues with third party dependencies. I don't see the reason for this, if you can use a third party dependency too do a task it does well and have been doing in many projects already, why roll your own. So allow me to introduce UrlRewritingNet.UrlRewrite

UrlRewritingNet basically consists of a generic HttpHandler that rewrites based on rules you set up in a configuration section in your web.config file, so instead of having to change code to change rewrites, we change simple regular expressions in our configuration of UrlRewritingNet. So lets see the rules I set up for BlogEngine.NET:

<configSections>
	<section name="urlrewritingnet"
		restartOnExternalChanges="true"
		requirePermission="false"
		type="UrlRewritingNet.Configuration.UrlRewriteSection, UrlRewritingNet.UrlRewriter"
	/>
</configSections>
<urlrewritingnet xmlns="http://www.urlrewriting.net/schemas/config/2006/07">
	<rewrites>
		<add name="categoryRule" virtualUrl="^~/category/(.*).aspx" destinationUrl="~/category.aspx?name=$1"/>
		<add name="blogRule" virtualUrl="^~/blog.aspx" destinationUrl="~/default.aspx?blog=true"/>
		<add name="authorRule" virtualUrl="^~/author/(.*).aspx" destinationUrl="~/author.aspx?name?=$1"/>
		<add name="postRuleDate" virtualUrl="^~/post/(\d{4})/([0-1]?\d)/([0-3]?\d)/(.*).aspx"
			destinationUrl="~/post.aspx?year=$1&amp;month=$2&amp;day=$3&amp;name=$4"/>
		<add name="postRuleMonth" virtualUrl="~/post/(\d{4})/([0-1]?\d)/(.*).aspx"
			destinationUrl="~/post.aspx?year=$1&amp;month=$2&amp;name=$3"/>
		<add name="postRuleTitle" virtualUrl="~/post/(.*).aspx" destinationUrl="~/post.aspx?name=$1"/>
		<add name="pageRule" virtualUrl="~/page/(.*).aspx" destinationUrl="~/page.aspx?name=$1"/>
		<add name="calendarRule" virtualUrl="~/calendar/.*" destinationUrl="~/calendar.aspx"/>
	</rewrites>
</urlrewritingnet>
<system.web>
	<httpModules>
		<add name="UrlRewriteModule" type="UrlRewritingNet.Web.UrlRewriteModule, UrlRewritingNet.UrlRewriter"/>
	</httpModules>
</system.web>

The above handles rewriting of Url's nothing more, nothing less. The existing BlogEngine.NET UrlRewrite have some business logic built in, for instance to retrieve the identifier of posts and sending them to the page that shows the post. I feel this doesn't belong in an UrlRewriter so I will implement this logic on the pages that actually handles the requests instead of on the UrlRewriter.

So this was the first step, now we can move the if statement out of our default.aspx and let it concentrate on showing the default content which is the frontpage of the blog and the other pages concentrate on their tasks. How to implement the pages referred to in the mapping above will follow in the next post.

BlogEngine.NET - Urlrewriting

Fri, 09 May 2008 02:18:54 -0700

if (Request.RawUrl.ToLowerInvariant().Contains("/category/")){...}
else if (Request.RawUrl.ToLowerInvariant().Contains("/author/")){...}
else if (Request.RawUrl.ToLowerInvariant().Contains("?tag=")){...}
//a couple of else if's more

if (context.Request.Path.Contains("/blog.aspx")){...}
else if (url.Contains("/POST/")){...}
else if (url.Contains("/CATEGORY/")){...}
else if (url.Contains("/AUTHOR/")){...}
//a couple of else if's more

<configSections>
	<section name="urlrewritingnet"
		restartOnExternalChanges="true"
		requirePermission="false"
		type="UrlRewritingNet.Configuration.UrlRewriteSection, UrlRewritingNet.UrlRewriter"
	/>
</configSections>
<urlrewritingnet xmlns="http://www.urlrewriting.net/schemas/config/2006/07">
	<rewrites>
		<add name="categoryRule" virtualUrl="^~/category/(.*).aspx" destinationUrl="~/category.aspx?name=$1"/>
		<add name="blogRule" virtualUrl="^~/blog.aspx" destinationUrl="~/default.aspx?blog=true"/>
		<add name="authorRule" virtualUrl="^~/author/(.*).aspx" destinationUrl="~/author.aspx?name?=$1"/>
		<add name="postRuleDate" virtualUrl="^~/post/(\d{4})/([0-1]?\d)/([0-3]?\d)/(.*).aspx"
			destinationUrl="~/post.aspx?year=$1&amp;month=$2&amp;day=$3&amp;name=$4"/>
		<add name="postRuleMonth" virtualUrl="~/post/(\d{4})/([0-1]?\d)/(.*).aspx"
			destinationUrl="~/post.aspx?year=$1&amp;month=$2&amp;name=$3"/>
		<add name="postRuleTitle" virtualUrl="~/post/(.*).aspx" destinationUrl="~/post.aspx?name=$1"/>
		<add name="pageRule" virtualUrl="~/page/(.*).aspx" destinationUrl="~/page.aspx?name=$1"/>
		<add name="calendarRule" virtualUrl="~/calendar/.*" destinationUrl="~/calendar.aspx"/>
	</rewrites>
</urlrewritingnet>
<system.web>
	<httpModules>
		<add name="UrlRewriteModule" type="UrlRewritingNet.Web.UrlRewriteModule, UrlRewritingNet.UrlRewriter"/>
	</httpModules>
</system.web>

BlogEngine.NET - Urlrewriting

Fri, 09 May 2008 02:18:53 -0700

if (Request.RawUrl.ToLowerInvariant().Contains("/category/")){...}
else if (Request.RawUrl.ToLowerInvariant().Contains("/author/")){...}
else if (Request.RawUrl.ToLowerInvariant().Contains("?tag=")){...}
//a couple of else if's more

if (context.Request.Path.Contains("/blog.aspx")){...}
else if (url.Contains("/POST/")){...}
else if (url.Contains("/CATEGORY/")){...}
else if (url.Contains("/AUTHOR/")){...}
//a couple of else if's more

<configSections>
	<section name="urlrewritingnet"
		restartOnExternalChanges="true"
		requirePermission="false"
		type="UrlRewritingNet.Configuration.UrlRewriteSection, UrlRewritingNet.UrlRewriter"
	/>
</configSections>
<urlrewritingnet xmlns="http://www.urlrewriting.net/schemas/config/2006/07">
	<rewrites>
		<add name="categoryRule" virtualUrl="^~/category/(.*).aspx" destinationUrl="~/category.aspx?name=$1"/>
		<add name="blogRule" virtualUrl="^~/blog.aspx" destinationUrl="~/default.aspx?blog=true"/>
		<add name="authorRule" virtualUrl="^~/author/(.*).aspx" destinationUrl="~/author.aspx?name?=$1"/>
		<add name="postRuleDate" virtualUrl="^~/post/(\d{4})/([0-1]?\d)/([0-3]?\d)/(.*).aspx"
			destinationUrl="~/post.aspx?year=$1&amp;month=$2&amp;day=$3&amp;name=$4"/>
		<add name="postRuleMonth" virtualUrl="~/post/(\d{4})/([0-1]?\d)/(.*).aspx"
			destinationUrl="~/post.aspx?year=$1&amp;month=$2&amp;name=$3"/>
		<add name="postRuleTitle" virtualUrl="~/post/(.*).aspx" destinationUrl="~/post.aspx?name=$1"/>
		<add name="pageRule" virtualUrl="~/page/(.*).aspx" destinationUrl="~/page.aspx?name=$1"/>
		<add name="calendarRule" virtualUrl="~/calendar/.*" destinationUrl="~/calendar.aspx"/>
	</rewrites>
</urlrewritingnet>
<system.web>
	<httpModules>
		<add name="UrlRewriteModule" type="UrlRewritingNet.Web.UrlRewriteModule, UrlRewritingNet.UrlRewriter"/>
	</httpModules>
</system.web>

BlogEngine.NET - DAL Architecture

Thu, 08 May 2008 05:20:26 -0700

So as I wrote a few days ago I have been looking at BlogEngine.NET and considered how I would have designed its lower layers. So lets kick off with the provider that's currently used in BlogEngine.NET for accessing the various storages (XML and RDBMS). The provider is responsible for accessing all data, that is Pages, Categories, Posts etc. Furthermore for each of these types of data it is responsible for the structure of the storage location, transforming the data from storage to objects including loading of related data. In my book this isn't good for extensibility, and as BlogEngine.NET provides multiple point for extending its functionality I would argue that it should be possible to extend its storage mechanism to handle new types of data just as easily. Currently extending the data access would involve adding new members to the provider and its implementations.

So to solve this problem (and a few others I will address shortly) my suggestion would be to make data access classes responsible for a single type only, these can share some common functionality that deals with the structure of the storage when we talk about the XML provider. So basically we want to specify how these classes should look, the most generic approach is represented by this interface.

public interface IRepository<T>
{
    //Retrieval
    T Load(Guid identifier);
    IList<T> LoadAll();

    //Modification
    void Save(T instance);
    void Delete(T instance);
    void Delete(Guid identifier);
}

I have made the assumption here that all data has a Guid identifier, of course this could be handled so that we are free to choose the type of our identifier. But for know im satisfied with the Guid-identifier

Instead of implementing our repositories right away we can abstract common details for storage types away in abstract classes. This way the implementation of our actual repositories are as slim as possible. I have (based on the way XML is stored in BlogEngine.NET) chosen two different storage types for XML and implemented the abstract classes SingleFileRepository<T> and SingleFolderRepository<T>. The first one handles storage of data types where all instances are in a single XML file, the second one handles storage of data types where each instance has its own XML file all contained in a folder. So the basic responsibility of these two classes is to handle details of the storage, that is the structure on disk and the structure in the files. Let me remind you that these abstract classes are only for simplifying the implementation of the actual repositories, if development later requires changing minor details we can override or even change the implementations on these, and if we want to start from scratch without the assumptions build into these abstract classes we can implement IRepository<T> any way we would like. This gives great flexibility in how different data is stored and the opportunity for code reusability is very much still there.

Lets take a look at the code for SingleFolderRepository:

public abstract class SingleFolderRepository<T> : IRepository<T> where T : class, IEntity
{
    protected readonly IBlogSettings settings;
    protected readonly IObjectXmlConverter<T> converter;
    protected readonly string storagelocation;

    public SingleFolderRepository(IBlogSettings settings, IObjectXmlConverter<T> converter)
    {
        this.settings = settings;
        this.converter = converter;
        this.storagelocation = settings.StorageLocationFor(typeof (T));
    }

    public T Load(Guid identifier)
    {
        string path = Path.Combine(storagelocation, identifier + ".xml");
        FileInfo datafile = new FileInfo(path);
        if (datafile.Exists)
        {
            return converter.Build(GetXml(datafile));
        }
        return null;
    }

    private string GetXml(FileInfo datafile)
    {
        string xml = string.Empty;
        using (StreamReader sr = new StreamReader(datafile.Open(FileMode.Open, FileAccess.Read, FileShare.Read)))
        {
            xml = sr.ReadToEnd();
        }
        return xml;
    }

    public IList<T> LoadAll()
    {
        List<T> instances = new List<T>();
        DirectoryInfo datadirectory = new DirectoryInfo(storagelocation);
        if (datadirectory.Exists)
        {
            foreach (FileInfo datafile in datadirectory.GetFiles("*.xml"))
            {
                instances.Add(converter.Build(GetXml(datafile)));
            }
        }
        return instances;
    }

    public void Save(T instance)
    {
        if (converter.IsNew(instance))
        {
            instance.Identifier = Guid.NewGuid();
        }

        string path = Path.Combine(storagelocation, instance.Identifier + ".xml");
        using (FileStream fs = File.Open(path, FileMode.Create, FileAccess.Write, FileShare.None))
        {
            using (StreamWriter writer = new StreamWriter(fs))
            {
                writer.Write(converter.Flatten(instance));
                writer.Flush();
            }
        }
    }

    public void Delete(T instance)
    {
        Delete(instance.Identifier);
    }

    public void Delete(Guid identifier)
    {
        string path = Path.Combine(storagelocation, identifier + ".xml");
        File.Delete(path);
    }
}

So notice the constructor. The dependencies that this class has is passed into the contructor so before we can use the repository we need settings for the blog and an IObjectXmlConverter for the type that the repository handles. The IObjectXmlConverter handles flattening of objects to XML and building objects from XML. Below is an example an implementation of this.

public class CategoryConverter : IObjectXmlConverter<Category>
{
    public Category Build(string xml)
    {
        XmlDocument doc = new XmlDocument();
        doc.LoadXml(xml);
        Category c = new Category();
        c.Identifier = new Guid(doc.SelectSingleNode("/category/").Attributes["id"].InnerText);
        c.Name = doc.SelectSingleNode("/category/").InnerText;
        return c;
    }

    public string Flatten(Category instance)
    {
        return
            XmlOutput.Create().XmlDeclaration()
                .Node("category")
                .Attribute("id", instance.Identifier.ToString())
                .InnerText(instance.Name).GetOuterXml();
    }
}

So this is where the mapping between the datastore and the objects happen, of course error handling should be in place here if we expect missing values in the data we load.

With this change in structure presented above we have seperated concerns of the data access into smaller reusable components, furthermore in my book this makes the code easier to extend and understand but thats a subjective matter.

So now its time to specify the actual repositories, we could settle for the functionality present on our generic IRepository but often we want more specific functionality for each datatype for instance fetching all posts in a specific category, paging of posts and so forth. So for each data type we define an interface with its actions. Currently in BlogEngine.NET much of this functionality is done in various places for instance sorting, filtering and paging. I would like to have our repositories responsible for this because the most efficient way to do these things depends on the type of storage. That is paging would for instance be done different for XML storage and RDBMS storage.

So as an example we could make our repository for posts have an interface like this:

public interface IPostRepository : IRepository<Post>
{
    PageableList<Post> GetPage(int pagesize, int pagenum);
    PageableList<Post> GetPageInCategory(int category, int pagesize, int pagenum);
    PageableList<Post> GetPageWithTag(int tag, int pagesize, int pagenum);
    PageableList<Post> GetPageFromMonth(int month, int year, int pagesize, int pagenum);
}

Notice that we might need more methods, but this illustrates some examples on how we let the repository handle paging so it can optimize it based on the data storage.

The actual implementation in the XML storage can be optimized but for now we load all data and do it in memory like BlogEngine.NET currently does. (I will discuss caching in a later post)

The form and responsibility of our repositories is now pretty clear. You might have noticed that I have passed classes dependencies through their constructor. To avoid having to construct these dependencies myself I will use an Inversion of Control container that manages these dependencies for me. Furthermore configuration of the IoC container is what helps use interchange the repositiores for XML and RDBMS.

Small challenge: call method on null

Thu, 08 May 2008 05:20:26 -0700

Inspired by some talk I "overheard" on twitter I thought it would be interesting to post a small challenge. Is it possible to implement the missing parts of the following code so it compiles and runs without exceptions, if yes how would you do it? You are not allowed to modify the body of the Main method but the rest is up to you.

static void Main(string[] args)
{
    Foo f = null;
    f.Bar();
}

And yes its a pretty useless exercise :-)

BlogEngine.NET - Urlrewriting

Thu, 08 May 2008 05:20:26 -0700

if (Request.RawUrl.ToLowerInvariant().Contains("/category/")){...}
else if (Request.RawUrl.ToLowerInvariant().Contains("/author/")){...}
else if (Request.RawUrl.ToLowerInvariant().Contains("?tag=")){...}
//a couple of else if's more

if (context.Request.Path.Contains("/blog.aspx")){...}
else if (url.Contains("/POST/")){...}
else if (url.Contains("/CATEGORY/")){...}
else if (url.Contains("/AUTHOR/")){...}
//a couple of else if's more

<configSections>
	<section name="urlrewritingnet"
		restartOnExternalChanges="true"
		requirePermission="false"
		type="UrlRewritingNet.Configuration.UrlRewriteSection, UrlRewritingNet.UrlRewriter"
	/>
</configSections>
<urlrewritingnet xmlns="http://www.urlrewriting.net/schemas/config/2006/07">
	<rewrites>
		<add name="categoryRule" virtualUrl="^~/category/(.*).aspx" destinationUrl="~/category.aspx?name=$1"/>
		<add name="blogRule" virtualUrl="^~/blog.aspx" destinationUrl="~/default.aspx?blog=true"/>
		<add name="authorRule" virtualUrl="^~/author/(.*).aspx" destinationUrl="~/author.aspx?name?=$1"/>
		<add name="postRuleDate" virtualUrl="^~/post/(\d{4})/([0-1]?\d)/([0-3]?\d)/(.*).aspx"
			destinationUrl="~/post.aspx?year=$1&amp;month=$2&amp;day=$3&amp;name=$4"/>
		<add name="postRuleMonth" virtualUrl="~/post/(\d{4})/([0-1]?\d)/(.*).aspx"
			destinationUrl="~/post.aspx?year=$1&amp;month=$2&amp;name=$3"/>
		<add name="postRuleTitle" virtualUrl="~/post/(.*).aspx" destinationUrl="~/post.aspx?name=$1"/>
		<add name="pageRule" virtualUrl="~/page/(.*).aspx" destinationUrl="~/page.aspx?name=$1"/>
		<add name="calendarRule" virtualUrl="~/calendar/.*" destinationUrl="~/calendar.aspx"/>
	</rewrites>
</urlrewritingnet>
<system.web>
	<httpModules>
		<add name="UrlRewriteModule" type="UrlRewritingNet.Web.UrlRewriteModule, UrlRewritingNet.UrlRewriter"/>
	</httpModules>
</system.web>