When I was first exposed to the idea of fluent interfaces my response was… big flipping deal.

It wasn’t until I actively started using fluent interfaces in my code did I begin to see their power and elegance.

What is a fluent interface? Here is the obligatory link to wikipedia ;)

In simple terms, its returning a type instead of void in order to achieve method chaining.

The end goal of the method chaining is to provide a more readable interface and code.

First, does it break the Law of Demeter?

Law of Demeter doesn’t equal the number of periods. I am of the opinion fluent interfaces do not violate the Law of Demeter.

What is LoD? Another link to wiki and here is a link to a stack overflow on this very subject! :)

To me, Law of Demeter is about restricting communication between objects.

A common violation of LoD (imho) is the exposure of a list property on an object. I believe this serves as a good example of LoD as well as being an example on how to make a fluent interface. :)

A Person object has a name and a list of friends.

1
2
3
4
5
6
7
8
9
10

public class Person
{
  public string Name { get; set; }
  public List<Person> Friends { get; set; }

  public Person()
  {
    Friends = new List<Person>();
  }
}

I could then add friends by…

1
2
3
4

var roger = new Person{ Name="Roger" };
roger.Friends.Add(new Person { Name = "Eddie" });
roger.Friends.Add(new Person { Name = "Freddie" });
roger.Friends.Add(new Person { Name = "Gordie" });

Now this is pretty typical, so what’s the problem?

Well my code knows WAY too much about Person. I know it has a list of friends and if they change that list to say a dictionary, I am hosed.

Not only that, but poor Person class… people can add friends to his collection without him every knowing. What if some additional logic needs to be done when adding a friend?

What if the person wants to record the birth date of every friend so they can send out birthday cards? Person is SOL.

As for Law of Demeter, my code is using the Person object to communicate through to the List. I am exposing my code to changes in Person.

Let’s change Person to eliminate this problem.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

public class Person2
{
  public string Name { get; set; }
  private readonly List<Person2> _friends;

  public Person2()
  {
    _friends = new List<Person2>();
  }

  public void AddFriend(Person2 friend)
  {
    _friends.Add(friend);
  }
}

Now the only way to add a friend is through Person. Yippie!

1
2
3
4

var roger2 = new Person2 {Name = "Roger"};
roger2.AddFriend(new Person2 { Name = "Eddie" });
roger2.AddFriend(new Person2 { Name = "Freddie" });
roger2.AddFriend(new Person2 { Name = "Gordie" });

If I wanted to make this a fluent interface all I would need to do is instead of returning void, return the Person class.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class Person3
{
  public string Name { get; set; }
  private readonly List<Person3> _friends;

  public Person3()
  {
    _friends = new List<Person3>();
  }

  public Person3 AddFriend(Person3 friend)
  {
    _friends.Add(friend);
   return this;
 }
}

Now I can do the same logic like…

1
2
3
4

var roger3 = new Person3 { Name = "Roger" }
              .AddFriend(new Person3 { Name = "Eddie" })
              .AddFriend(new Person3 { Name = "Freddie" })
              .AddFriend(new Person3 { Name = "Gordie" });

That is pretty cool, but fluent interfaces really shine with the builder pattern.

This time around I want to force construction of a person through a builder and have the builder use a fluent interface. Notice my Person’s constructor and fields are private. I embed the builder class within the Person class so the builder has access to the constructor and fields. In this manner only my builder class has access to constructing a person. My builder can now act as an anti-corruption layer for Person.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

public class Person4
{
  private string _name;
  private List<Person4> _friends;

  private Person4()
  {
    _friends = new List<Person4>();
  }

  public Person4 AddFriend(Person4 friend)
  {
    _friends.Add(friend);
    return this;
  }

  public static PersonBuilder createAPerson()
  {
    return new PersonBuilder();
  }

  public class PersonBuilder
  {
    private Person4 _person;
    public PersonBuilder()
    {
      _person = new Person4();
    }

    public PersonBuilder named(string name)
    {
      _person._name = name;
      return this;
    }

    public PersonBuilder withFriend(Person4 friend)
    {
      _person.AddFriend(friend);
      return this;
    }

    public PersonBuilder withaFriendNamed(string name)
    {
      var friend = createAPerson().named(name).finish();
      _person.AddFriend(friend);
      return this;
    }

    public Person4 finish()
    {
      return _person;
    }
  }
}

Now to create Roger and his friends I do..

1
2
3
4
5
6

var roger4 = Person4.createAPerson()
                     .named("Roger")
                     .withaFriendNamed("Eddie")
                     .withaFriendNamed("Freddie")
                     .withaFriendNamed("Gordie")
                     .finish();

It’s a simple example but maybe it sparked some ideas on how to use fluent interfaces to chain methods and make your code more approachable to people without Computer Science degrees. :D