Um conceito que eu acabei entrando em contato mais próximo enquanto estudava interfaces fluentes foi operadores implícitos. Operadores implícitos são operadores chamados quando você quer fazer um cast automático de um tipo para outro tipo.

A classe de builder de itens (CatalogItemBuilder) que usei nas interfaces fluentes tinha um desses. Ele era assim:

    public class CatalogItemBuilder : DomainObjectBuilder<CatalogItem>, ICatalogItemBuilder
    {
        //uma função Build existe
        //resto do código oculto

        public static implicit operator CatalogItem(CatalogItemBuilder builder)
        {
            return builder.Build();
        }
    }

Isso permitia que eu fizesse isso:

CatalogItemBuilder builder = ObterBuilder();
CatalogItem item = buider;

Ou passasse ele para uma função, como a de adicionar um novo item:

Category category = new Category();
category.Items.Add(builder);

Nesse caso, “Items” é uma coleção de CatalogItems, não CatalogItemBuilders. Na chamada, a conversão é feita implicitamente.

Você só pode usar operadores implícitos quando não há perda de informação, a documentação deixa isso bem claro. Nesse caso, estamos convertendo para um objeto totalmente diferente e realmente não havia perda de informação, então o operador implícito caia muito bem. Muito interessante, porque abre o horizonte para seu uso em outras atividades de negócio no código. Muito diferente dos exemplos mais comuns, que geralmente envolvem converter um inteiro para um double.