Fluent Interfaces in C# – Extension Methods

1 comment

Monday, July 16, 2012

FOr those of you who haven't read the previous post. This post is the 2nd of many where I explain how to use C# and a bag of tricks to create fluent interfaces – easily.

In the previous post I’ve talked about what fluent interfaces is all about and gave a brief introduction to the subject – in this post we’ll actually get to see some code.

The introduction you might not need

Extension methods enable you to "add" methods to existing types without creating a new derived type, recompiling, or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called as if they were instance methods on the extended type. For client code written in C# and Visual Basic, there is no apparent difference between calling an extension method and the methods that are actually defined in a type.

from C# Programming Guide

First introduced in .NET 3 – extension methods have been widely used to “add” methods to existing class without changing the actual class implementation. Using extension methods is as simple as creating a static method – in fact that’s all it takes.

Using extension methods to create an API

The quick and simple way to create “poor man’s” fluent API is to use Extension methods.

All we need is to create a few static methods and we can transform the following code:

// Instead of using this:

// Using extension method we can write:

// Or even this:


The actual implementation is quite simple – but here it is just in case:

public static DateTime AddWeeks(this DateTime baseTime, int weeks)
    return baseTime.AddDays(7 * weeks);

public static DateTime DaysFromNow(this int days)
    return DateTime.Now.AddDays(days);


Thus by using simple method call we managed to transform “14” to “two weeks” – not much but it’s a good place to start.

When to use

Extension methods are best used when the API we’re trying to add is on top some 3rd party component or internal class we do not wish to use.

This method is very effective when using along with “method chaining” where using extension method is a good starting point for the whole API – but more on that in posts to come.

In the meantime keep in mind that one of the best fluent API out there (in my humble opinion) uses extension method extensively:

public static IEnumerable<TSource> Where<TSource>
                               (this IEnumerable<TSource> source,
                                Func<TSource, bool> predicate)

public static IEnumerable<TResult> Select<TSource, TResult>
                                (this IEnumerable<TSource> source,
                                 Func<TSource, TResult> selector)

Cons and pitfalls

There are some problems in “adding methods” to existing class – especially if this class is part of the CLR. In the example above I’ve used extension method on integer to create a new DateTime which has nothing to do with the previous type. I’ve added as method to every single integer in my system. Although I could filter the the use of the new method using namespace it’s still a lot of noise.


This is it – the first tool in your fluent interface belt. Experiment with it and use it wisely. And as always:


Happy Coding…

Fluent Interfaces in C#–Introduction


Monday, July 02, 2012

Not many developers are familiar with the concept of DSLs (Domain Specific Languages) even fewer use them in their day job. It seems that creating a new language is a hard job that should only be left for professors in the academia or certain employees that work in Microsoft, Sun or some other compiler vendor.

But not all languages are created equal in the world of DSLs, there is a branch of languages called “Internal DSLs” – that any developer worth his salt can leverage to create better, more readable code.

Internal DSLs and fluent interfaces

The basic idea of a domain specific language (DSL) is a computer language that's targeted to a particular kind of problem, rather than a general purpose language that's aimed at any kind of software problem. Domain specific languages have been talked about, and used for almost as long as computing has been done.

Martin Fowler – DomainSpecificLanguage

And so internal DSL (a.k.a “Embedded DSL) is a domain specific language created using an existing (host) language.

Within the group of internal DSLs there is sub group known as “fluent interfaces” – basically using the host language to create code that can be easily read – and look (after a fashion) just like plain English.


The term “Fluent Interfaces” was coined by Eric Evens and Martin Fowler and it refers to an implementation of object oriented API on top of existing functionality in order to provider more readable code.

Why should you care?

There are many benefits of using fluent interfaces – you can create a easy to use and understand API that does not require any additional libraries to implement.

That API provides directions on how the code should be used and can help your users use your software or you can use it internally in order to make a complicated process easy to code by your teammates.

There is one catch – creating a good API is always difficult and creating fluent interface requires understanding of certain tricks in the language that can be leveraged to create the desired code.

C# just like any other object oriented language has the capability to create fluent API in fact certain feature of C# makes it extremely easy to create such API.

What's next

In the upcoming posts I’m going to show a few tricks that I’ve used in the past to create fluent interfaces all of which you probably already know.


So until next time – happy coding…

Related Posts Plugin for WordPress, Blogger...