create fluent interface for adding elements to a list

Question

this is what I'm trying to achieve:

config.Name("Foo")
      .Elements(() => {
                         Element.Name("element1").Height(23);
                         Element.Name("element2").Height(31);
                      })
     .Foo(23);

or like this:

  .Elements(e => {
                     e.Name("element1").Height(23);
                     e.Name("element2").Height(31);
                  })
  .Foo(3232);

this is what I have for the moment:

public class Config
{
   private string name;
   private int foo;
   private IList<Element> elements = new List<Element>();

   public Config Name(string name)
   {
      this.name = name;
      return this;
   }

   public Config Foo(int x)
   {
       this.foo = x;
   }

   ... //add method for adding elements 

   class Element
   {
      public string Name { get; set; }
      public int Height { get; set; }
   }
}

anybody knows how to do this ?

Answer 1

public class Config
{
   private string name;
   private IList<Element> elements = new List<Element>();
   public IList<Element> GetElements {get {return this.elements;}}
   public Config Name(string name)
   {
      this.name = name;
      return this;
   }

   public Config Elements(IEnumerable<Element> list)
   {
        foreach ( var element in list)
            elements.Add(element);
        return this;
   }

   public Config Elements(params Element[] list)
   {
        foreach ( var element in list)
            elements.Add(element);
        return this;
   }

   public Config Elements(params Expression<Func<Element>>[] funcs)
   {
        foreach (var func in funcs )
            elements.Add(func.Compile()());
        return this;
   }

   public Config Elements(params Expression<Func<IEnumerable<Element>>>[] funcs)
   {
        foreach (var func in funcs )
            foreach ( var element in func.Compile()())
                elements.Add(element);
        return this;
   }

   public class Element
   {
      public string Name { get; set; }
      public int Height { get; set; }     
      public Element() {}
      public Element(string name)
      {
         this.Name = name;
      }  
      public Element AddHeight(int height)
      {
          this.Height = height;
          return this;
      }
      public static Element AddName(string name)
      {
        return new Element(name);
      }
   }
}

usage

var cfg = new Config()
    .Name("X")
    .Elements(new [] { new Config.Element { Name = "", Height = 0} })
    .Elements(
            Config.Element.AddName("1").AddHeight(1), 
            Config.Element.AddName("2").AddHeight(2) 
            )
    .Elements(
        () => Config.Element.AddName("1").AddHeight(1)
    )
    .Elements(
        () => new[] {
                Config.Element.AddName("1").AddHeight(1),
                Config.Element.AddName("1").AddHeight(1)
               }
    )

Answer 2

Here's a version which works exactly as per your second code sample. It's really ugly though - I definitely wouldn't want to use it myself. Notes at the end.

using System;
using System.Collections.Generic;

public class Config
{
    private string name;
    private int foo;
    private IList<Element> elements = new List<Element>();

    public Config Name(string name)
    {
        this.name = name;
        return this;
    }

    public Config Foo(int x)
    {
        this.foo = x;
        return this;
    }

    public Config Elements(Action<ElementBuilder> builderAction)
    {
        ElementBuilder builder = new ElementBuilder(this);
        builderAction(builder);
        return this;
    }

    public class ElementBuilder
    {
        private readonly Config config;

        internal ElementBuilder(Config config)
        {
            this.config = config;
        }

        public ElementHeightBuilder Name(string name)
        {
            Element element = new Element { Name = name };
            config.elements.Add(element);
            return new ElementHeightBuilder(element);
        }
    }

    public class ElementHeightBuilder
    {
        private readonly Element element;

        internal ElementHeightBuilder(Element element)
        {
            this.element = element;
        }

        public void Height(int height)
        {
            element.Height = height;
        }
    }

    public class Element
    {
        public string Name { get; set; }
        public int Height { get; set; }
    }
}



class Test
{
    static void Main()
    {
        Config config = new Config();

        config.Name("Foo")
            .Elements(e => {
                e.Name("element1").Height(23);
                e.Name("element2").Height(31);
            })
            .Foo(3232);
    }
}

Notes:

With this code you have to call Name first, and then optionally call Height for each element - although nothing will complain if you fail to call Height. If you changed the Elements call to either this:

  .Elements(e => {
                     e.NewElement().Name("element1").Height(23);
                     e.NewElement().Name("element2").Height(31);
                 })

or this:

  .Elements(e => {
                     e.Name("element1").Height(23).AddToConfig();
                     e.Name("element2").Height(31).AddToConfig();
                 })

then you'd end up with a more flexible situation; you could have a single ElementBuilder class which would do the right thing. The first version of this is nicer IMO.

All of this is still vastly less pleasant than the simple and effective object/collection initializers shown in my other answer, which I would strongly urge you to use. I really so no benefit in this approach - if you hadn't seen in in the Telerik API, would you have naturally wanted this? It seems from other comments as if you're drawn to the "shininess" of using lambda expressions... don't be. They're great in the right setting, but it seems to me that there are far cleaner ways of achieving this without them.

I suggest you take a step back and work out whether you really gain anything from the syntax you originally wanted to use, and think about whether you'd rather maintain the kind of code in this answer, or the code in the object/collection initializer solution.

EDIT: Here's my interpretation of Zoltar's suggestion, which gets rid of the need for the extra class:

using System;
using System.Collections.Generic;

public class Config
{
    private string name;
    private int foo;
    private IList<Element> elements = new List<Element>();

    public Config Name(string name)
    {
        this.name = name;
        return this;
    }

    public Config Foo(int x)
    {
        this.foo = x;
        return this;
    }

    public Config Elements(Action<ElementBuilder> builderAction)
    {
        ElementBuilder builder = new ElementBuilder(this);
        builderAction(builder);
        return this;
    }

    public class ElementBuilder
    {
        private readonly Config config;
        private readonly Element element;

        // Constructor called from Elements...
        internal ElementBuilder(Config config)
        {
            this.config = config;
            this.element = null;
        }

        // Constructor called from each method below
        internal ElementBuilder(Element element)
        {
            this.config = null;
            this.element = element;
        }

        public ElementBuilder Name(string name)
        {
            return Mutate(e => e.Name = name);
        }

        public ElementBuilder Height(int height)
        {
            return Mutate(e => e.Height = height);
        }

        // Convenience method to avoid repeating the logic for each
        // property-setting method
        private ElementBuilder Mutate(Action<Element> mutation)
        {
            // First mutation call: create a new element, return
            // a new builder containing it.
            if (element == null)
            {
                Element newElement = new Element();
                config.elements.Add(newElement);
                mutation(newElement);
                return new ElementBuilder(newElement);
            }
            // Subsequent mutation: just mutate the element, return
            // the existing builder
            mutation(element);
            return this;
        }
    }

    public class Element
    {
        public string Name { get; set; }
        public int Height { get; set; }
    }
}

Answer 3

I'd rather go with following fluent interface:

Config config = new Config("Foo")
                        .WithElement("element1", 23)
                        .WithElement("element2");

I think it's more readable and compact. Implementation:

public class Config
{
    private string name;
    private IList<Element> elements = new List<Element>();

    public Config(string name)
    {
        this.name = name;
    }

    public Config WithElement(string name, int height = 0)
    {
        elements.Add(new Element() { Name = name, Height = height });
        return this;
    }

    class Element
    {
        public string Name { get; set; }
        public int Height { get; set; }
    }
}

If name is optional, then add Config constructor without parameters. Also consider optional parameters for WithElemnt method, if you don't need both height and name.

UPDATE: I changed height to be optional parameter to show how you can add elements with only name specified.

UPDATE (if you want to allow only one group of elements)

Config config = new List<Element>()
                    .AddElement(new Element {Name = "element1", Height = 23 })
                    .AddElement(new Element {Name = "element2" })
                    .WrapToConfig()
                    .Name("config1");

Implementation:

public static class ConfigurationHelper
{
    public static IList<Element> AddElement(this IList<Element> elements, Element element)
    {
        elements.Add(element);
        return elements;
    }

    public static Config WrapToConfig(this IList<Element> elements)
    {
        return Config(elements);
    }
}

But this is not very obvious for users, so I'd go with first simple fluent interface.

Answer 4

Any reason you don't want to use object and collection initializers?

public class Config
{
   public string Name { get; set; }
   public int Foo { get; set; }
   public IList<Element> Elements { get; private set; }

   public Config()
   {
       Elements = new List<Element>();
   }
}

// I'm assuming an element *always* needs a name and a height
class Element
{
   public string Name { get; private set; }
   public int Height { get; private set; }

   public Element(string name, int height)
   {
       this.Name = name;
       this.Height = height;
   }
}

Then:

var config = new Config
{
    Name = "Foo",
    Elements = { 
        new Element("element1", 23),
        new Element("element2", 31)
    },
    Foo = 23
};

If you don't want to expose the list of elements directly, you could always turn that into a builder, and copy it into a more private data structure on Build:

var config = new Config.Builder
{
    Name = "Foo",
    Elements = { 
        new Element("element1", 23),
        new Element("element2", 31)
    },
    Foo = 23
}.Build();

This has the additional advantage that you can make Config itself immutable.

If you always need Name to be present, just take that as a constructor parameter instead.

While there are times where it's good to have a fluent interface with mutating (or copy-and-change) method calls, in this case I think collection/object initializers are more idiomatic C#.

Note that if you're using C# 4 and you want to make your Element constructor calls, you can always use named arguments:

new Element(name: "element2", height: 31)

Answer 5

Use data builder pattern. Nice thing about that is that it separates the fluent build api from the data objects. Of course you can omit "with" in your convention.

Usage:

var aConfig = new ConfigBuilder();

// create config fluently with lambdas
Config config = aConfig.WithName("Foo")
        .WithElement(e => e.WithName("element1").WithHeight(23))
        .WithElement(e => e.WithName("element2").WithHeight(31))
    .WithFoo(3232)
    .Build();

// create elements in one go
config = aConfig.WithName("Foo")
         .WithElements(
             e => e.WithName("element1").WithHeight(23), 
             e => e.WithName("element2").WithHeight(31))
     .WithFoo(3232)
     .Build();


var anElement = new ElementBuilder();

// or with builders 
config = aConfig.WithName("Foo")
        .WithElement(anElement.WithName("element1").WithHeight(23))
        .WithElement(anElement.WithName("element2").WithHeight(31))
    .WithFoo(3232)
    .Build();

// use builders to reuse configuration code
anElement.WithHeigh(100);

config = aConfig.WithName("Bar")
        .WithElement(anElement.WithName("sameheight1"))
        .WithElement(anElement.WithName("sameheight2"))
    .WithFoo(5544)
    .Build();

Implementation:

public class ConfigBuilder
{
    private string name;
    private int foo;
    private List<Element> elements = new List<Element>();

    public ConfigBuilder WithName(string name)
    {
         this.name = name;
         return this;
    }

    public ConfigBuilder WithFoo(int foo)
    {
        this.foo = foo;
        return this;
    }

    public ConfigBuilder WithElement(Element element)
    {
        elements.Add(element);
        return this;
    }

    public ConfigBuilder WithElement(ElementBuilder element)
    {
        return WithElement(element.Build());
    }

    public ConfigBuilder WithElement(Action<ElementBuilder> builderConfig)
    {
         var elementBuilder = new ElementBuilder();
         builderConfig(elementBuilder);
         return this.WithElement(elementBuilder);
    }

    public ConfigBuilder WithElements(params Action<ElementBuilder>[] builderConfigs)
    {
         foreach(var config in builderConfigs)
         {
              this.WithElement(config);
         }

         return this;
    }

    public Config Build()
    {
         return new Config() 
         { 
             Name = this.name,
             Foo = this.foo,
             Elements = this.elements
         };
    }
}

public class ElementBuilder
{
    private string name;
    private int height;

    public ElementBuilder WithName(string name)
    {
        this.name = name;
        return this;
    }

    public ElementBuilder WithHeight(int height)
    {
        this.height = height;
        return this;
    }

    public Element Build()
    {
        return new Element() 
        { 
            Name = this.name,
            Height = this.height
        };
    }
}

public class Config
{
    public string Name { get; set; }
    public int Foo { get; set; }
    public IList<Element> Elements { get; set; }
}

public class Element
{
    public string Name { get; set; }
    public int Height { get; set; }
}

Answer 6

Here's method 1 to place inside Config -- "one at a time":

public Config Element(Action<Element> a) {
    Element e = new Element();
    a(e);
    this.elements.Add(e);
    return this;
}

And here's how to use it:

config.Name("Foo")
    .Element(e => e.Name("element1").Height(23))
    .Element(e => e.Name("element2").Height(31))
    .Foo(3232);

Here's method 2 -- "the list":

public Config Elements(Func<List<Element>> a) {
    List<Element> elements = a();
    foreach (Element e in elements) {
        this.elements.Add(e);
    }
    return this;
}

And here's how to use it:

config.Name("Foo")
    .Elements(() => new List<Element>() {
            new Element().Name("element1").Height(23),
            new Element().Name("element2").Height(31)
        })
    .Foo(3232);

Note that it presumes Element is not nested inside Config (or you'd need new Config.Element() in example 2).

Note that in your "the list" example, you've passed in a single Element object, but you're trying to set it twice. The second line will alter the Element, not create a new one.:

.Elements(e => {
                 e.Name("element1").Height(23); // <-- You set it
                 e.Name("element2").Height(31); // <-- You change it
              })
.Foo(3232);

Thus this syntax can't work.

How it works:

Func<T,U,...> is an anonymous function delegate that takes in all the parameters but one, and returns the last one. Action<T,U,...> is an anonymous function delegate that takes in all parameters. For example:

Func<int,string> f = i => i.ToString(); says "take in an int, return a string".

Action<int> f = i => string c = i.ToString(); says "take in an int, return nothing".