Question

这就是我想要实现的目标：

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

或者像这样：

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

这就是我现在所拥有的：

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; }
   }
}

有谁知道怎么做？

Answer 1

根据您的第二个代码示例，这是一个完全的版本。它真的很难看 - 我绝对不想自己使用它。最后的注释。

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);
    }
}

注意：

使用此代码，首先调用Name，然后可选择为每个元素调用Height - 但如果您未能调用{{1}，则不会抱怨}。如果您将Height调用更改为：

Elements

或者这个：

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

那么你最终会有一个更灵活的情况;你可以有一个

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

课程来做正确的事。第一个版本是更好的IMO。

所有这些仍然非常比我在其他答案中显示的简单有效的对象/集合初始化程序更令人愉快，我强烈建议您使用它。我真的没有这种方法的好处 - 如果你没有在Telerik API中看到过，你自然会想要这个吗？从其他评论看来，似乎你被吸引到使用lambda表达式的“光泽”......不要。他们在正确的环境中表现出色，但在我看来，如果没有它们，远更清洁的方法可以实现这一目标。

我建议您退后一步，确定您是否真正从您最初想要使用的语法中获取任何内容，并考虑是否要在此答案中维护代码类型，或对象/集合初始化器解决方案中的代码。

编辑：这是我对Zoltar的建议的解释，它摆脱了额外课程的需要：

ElementBuilder

Answer 2

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);
      }
   }
}

使用

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 3

我宁愿选择流畅的界面：

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

我认为它更具可读性和紧凑性。实现：

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; }
    }
}

如果name是可选的，则添加不带参数的Config构造函数。如果您不需要高度和名称，还要考虑WithElemnt方法的可选参数。

更新：我将高度更改为可选参数，以显示如何添加仅指定名称的元素。

更新（如果您只想允许一组元素）

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

实现：

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);
    }
}

但这对用户来说并不是很明显，所以我会选择第一个简单流畅的界面。

Answer 4

您是否不想使用对象和集合初始值设定项？

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;
   }
}

然后：

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

如果您不想直接公开元素列表，可以随时将其转换为构建器，并将其复制到Build上的更私密的数据结构中：

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

这具有额外的优势，您可以使Config本身不可变。

如果您总是需要Name，请将其作为构造函数参数。

虽然有时候通过变异（或复制和更改）方法调用建立一个流畅的界面是很好的，但在这种情况下，我认为集合/对象初始化器更像是惯用的C＃。

请注意，如果您正在使用C＃4并且想要进行Element构造函数调用，则可以始终使用命名参数：

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

Answer 5

使用数据构建器模式。关于这一点的好处是它将流畅的构建api与数据对象分开。当然，你可以在你的约定中省略“with”。

用法：

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();

实现：

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

这是方法1 放置在配置中 - “一次一个”：

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

以下是如何使用它：

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

这是方法2 - “列表”：

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

以下是如何使用它：

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

请注意，它假定Element未嵌套在Config中（或者您在示例2中需要new Config.Element()）。

注意在“列表”示例中，您传入了一个Element对象，但是您尝试将其设置两次。第二行将改变元素，而不是创建一个新元素。：

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

因此这种语法不起作用。

工作原理：

Func<T,U,...>是一个匿名函数委托，它接受除一个参数之外的所有参数，并返回最后一个参数。 Action<T,U,...>是一个匿名函数委托，它接受所有参数。例如：

Func<int,string> f = i => i.ToString();说“接受一个int，返回一个字符串”。

Action<int> f = i => string c = i.ToString();说“接受一个int，什么都不返回”。

创建流畅的界面，以便将元素添加到列表中

6 个答案: