Question

I was recently watching a webcast about how to create a fluent DSL and I have to admit, I don’t understand the reasons why one would use such an approach (at least for the given example).

The webcast presented an image resizing class, that allows you to specify an input-image, resize it and save it to an output-file using the following syntax (using C#):

Sizer sizer = new Sizer(); sizer.FromImage(inputImage)      .ToLocation(outputImage)      .ReduceByPercent(50)      .OutputImageFormat(ImageFormat.Jpeg)      .Save(); 

I don’t understand how this is better than a ‘conventional’ method that takes some parameters:

sizer.ResizeImage(inputImage, outputImage, 0.5, ImageFormat.Jpeg); 

From a usability point of view, this seems a lot easier to use, since it clearly tells you what the method expects as input. In contrast, with the fluent interface, nothing stops you from omitting/forgetting a parameter/method-call, for example:

sizer.ToLocation(outputImage).Save(); 

So on to my questions:

1 – Is there some way to improve the usability of a fluent interface (i.e. tell the user what he is expected to do)?

2 – Is this fluent interface approach just a replacement for the non existing named method parameters in C#? Would named parameters make fluent interfaces obsolete, e.g. something similar objective-C offers:

sizer.Resize(from:input, to:output, resizeBy:0.5, ..) 

3 – Are fluent interfaces over-used simply because they are currently popular?

4 – Or was it just a bad example that was chosen for the webcast? In that case, tell me what the advantages of such an approach are, where does it make sense to use it.

BTW: I know about jquery, and see how easy it makes things, so I’m not looking for comments about that or other existing examples.

I’m more looking for some (general) comments to help me understand (for example) when to implement a fluent interface (instead of a classical class-library), and what to watch out for when implementing one.

Answer 1

2 – Is this fluent interface approach just a replacement for the non existing named method parameters in C#? Would named parameters make fluent interfaces obsolete, e.g. something similar objective-C offers:

Well yes and no. The fluent interface gives you a larger amount of flexibility. Something that could not be achieved with named params is:

sizer.FromImage(i)  .ReduceByPercent(x)  .Pixalize()  .ReduceByPercent(x)  .OutputImageFormat(ImageFormat.Jpeg)  .ToLocation(o)  .Save(); 

The FromImage, ToLocation and OutputImageFormat in the fluid interface, smell a bit to me. Instead I would have done something along these lines, which I think is much clearer.

 new Sizer('bob.jpeg')   .ReduceByPercent(x)  .Pixalize()  .ReduceByPercent(x)  .Save('file.jpeg',ImageFormat.Jpeg); 

Fluent interfaces have the same problems many programming techniques have, they can be misused, overused or underused. I think that when this technique is used effectively it can create a richer and more concise programming model. Even StringBuilder supports it.

var sb = new StringBuilder();  sb.AppendLine('Hello')  .AppendLine('World');