Seguindo na idéia de interfaces fluentes (expliquei o que elas são aqui), vou fecjar o assunto de builder. Se você não leu o outro post sobre o assunto, veja-o aqui.

Já sabemos como utilizar um builder assim:

            var item3 = new CatalogItemBuilder()
                 .Named("iPhone")
                 .ManufacturedBy(m => m.Named("Apple"))
                 .ForProduct(p => p.Number = "AA1687")
                 .Build();
            category.Categorize(item3);

Como fazer para chegar na construção baseada em lambas? Afinal, esse é o objetivo final. Queremos isso:

            var category = new Category();
            category.Categorize(item =>item.Named("iPhone")
                .ManufacturedBy(manufacturer =>
                    manufacturer.Named("Apple"))
                    .ForProduct(product =>
                        product.Numbered("AA1687")));

Fácil. Note que nesta segunda construção o método Categorize recebe uma lambda, que na verdade é um delegate, mais precisamente um Action<CatalogItemBuilder>. Basta criar então este método:

        public void Categorize(Action<CatalogItemBuilder> buildUsing)
        {
            var catalogItemBuilder = new CatalogItemBuilder();
            buildUsing(catalogItemBuilder);
            var item = catalogItemBuilder.Build();
            Categorize(item);
        }

E então a construção com Lambdas, a partir da categoria, já fica possível. Tudo baseado em inferência de tipos.

Note que o método utiliza o Action<CatalogItemBuilder>, passando para ele a ação que recebeu (as lambdas do segundo exemplo de código). Com isso, o builder é “populado” com valores. Aí ele utiliza o método Build para construir o item, e retorna-o. Simples assim.

Eu havia falado recentemente que o F# influenciou muito o C#. Está muito claro que esse tipo de construção usadas em interfaces fluentes está agarrada nos conceitos de programação funcional. É descarado (no bom sentido) o uso das funções como conceitos de primeiro nível. Notem que em todos estes casos, estamos passando funções, em forma de delegates, como argumentos aos métodos. Um delegate nada mais é que uma função em forma de objeto.

O projeto todo, com outros exemplos de chamada, pode ser baixado aqui. São 2 arquivos úteis em 5kb.

(E o Java Community Process (JCP) está a séculos decidindo se aprova ou não o uso de delegates no Java. Enquanto eles não aprovarem, isso não vai ser possível, ou, no mínimo, não será tão simples.)