Fluent API:引用类型从彼此获取值

方法1

public class ColumnBuilderFactory<TModel> : IColumnBuilderFactory<TModel>
{
    #region Constructors
    public ColumnBuilderFactory(IGridBuilder<TModel> gridBuilder)
    {
        gridBuilderReference = gridBuilder;
    }
    #endregion
    #region IColumnBuilderFactory Members
    private IGridBuilder<TModel> gridBuilderReference { get; private set; }
    internal IList<IColumnBuilder<TModel>> Columns {get; private set; }
    public IColumnBuilder<TModel> New()
    {
        var column = new ColumnBuilder(gridBuilderReference);
        Columns.Add(column);
        return column;
    }
    #endregion
}

和GridBuilder WithColumns变成

public IGridBuilder<TModel> WithColumns(Action<IColumnBuilderFactory<TModel>> bindAllColumns)
{
    var factory = new ColumnBuilderFactory<TModel>(this);
    bindAllColumns(factory);
    foreach(var column in factory)
    {
        this.ColumnBuilders.Add(column );
    }        
    return this;
}

它的用法是

RenderedOutput = HtmlHelper.GridFor(Model)
.WithColumns(columnFactory =>
{
    columnFactory.New().Bind(x => x.Name)
        .WithCss("inline");
    columnFactory.New().Bind(x => x.Age)
        .WithCss("inline fixed right");
})
.Render();

方法2

的替代方法是通过欺骗和忽略它(使用FluentAPI来替换它)，基本上它和你现在的用法一样，但是Bind变成了

public IColumnBuilder<TModel> Bind<TItem>(Expression<Func<TModel, TItem>> propertySelector)
{
    var builder = new ColumnBuilder<TModel>(GridBuilderReference);
    GridBuilderReference.ColumnBuilders.Add(builder);
    return builder;
}

它依赖于GC整理第一个(无用的)实例

所以…

RenderedOutput = HtmlHelper.GridFor(Model)
.WithColumns(column =>
{
//column at this point isn't used, it's only there to avoid a NullReferenceException on the first call to Bind
    column
.Bind(x => x.Name)
//Bind has returned a new ColumnBuilder to play with so the next call will be on the new instance
        .WithCss("inline");
//Again this is just so we can make the next bind call
    column
//Again bind replaces the previous instance with a new one so we won't overwrite Name with this call
.Bind(x => x.Age)
//This now sets the css on the new ColumnBuilder we just created for Age
        .WithCss("inline fixed right");
})
.Render();

示例控制台应用程序显示方法2

using System;
using System.Collections.Generic;
using System.Linq.Expressions;
namespace ConsoleApplication3
{
    class Program
    {
        static void Main(string[] args)
        {
            var master = FluentHelper.GridFor(new Model())
            .WithColumns(column =>
                {
                    column.Bind(x => x.Name)
                        .WithCSS("inline");
                    column.Bind(x => x.Age)
                        .WithCSS("inline fixed right");
                });
            foreach(var c in master.children)
            {
                Console.WriteLine(c.Binding.ToString());
                Console.WriteLine(c.CSS);
            }
            Console.ReadKey(true);
        }
    }
    class Model
    {
        public string Name { get; set; }
        public string Age { get; set; }
    }
    class GridBuilder<T>
    {
        public GridBuilder<T> WithColumns(Action<ColumnBuilder<T>> bindAllColumns)
        {
            bindAllColumns(new ColumnBuilder<T>(this));
            return this;
        }
        public List<ColumnBuilder<T>> children = new List<ColumnBuilder<T>>();
    }
    class ColumnBuilder<T>
    {
        private GridBuilder<T> grid;
        public string Binding;
        public string CSS;
        public ColumnBuilder(GridBuilder<T> grid)
        {
            // TODO: Complete member initialization
            this.grid = grid;
        }
        public void WithCSS(string css)
        {
            this.CSS = css;
        }
        public ColumnBuilder<T> Bind<TItem>(Expression<Func<T, TItem>> propertySelector)
        {
            var builder = new ColumnBuilder<T>(grid);
            builder.Binding = (propertySelector.Body as MemberExpression).Member.Name;
            grid.children.Add(builder);
            return builder;
        }
    }
    static class FluentHelper
    {
        internal static GridBuilder<T> GridFor<T>(T model)
        {
            return new GridBuilder<T>();
        }
    }
}