Consejos para escribir interfaces fluidas en C # 3

El mayor desafío que he experimentado como consumidor de interfaces fluidas es que la mayoría de ellas no son realmente intefaces fluidas instead en cambio, son realmente instancias de lo que tiendo a llamar 'interfaces legibles'.

Una interfaz fluida implica que su objetivo principal es hacer que sea fácil de HABLAR, mientras que una interfaz legible implica que su objetivo principal es ser fácil de LEER. Las interfaces más fluidas solo tienden a ser ridículamente difíciles de codificar, pero a la inversa increíblemente fácil de leer más tarde por otros.

Assert().That().This(actual).Is().Equal().To(expected).
    Except().If(x => x.GreaterThan(10));

Is es mucho más fácil de leer más tarde de lo que es realmente componer en código!

Te toparás con un ladrillo cuando uses herencia junto con interfaces fluidas porque el uso de métodos polimórficos rompe tus cadenas de llamadas y definitivamente no quieres hacer que tus interfaces no sean fluidas usando ugly casting y parantesis donde no son necesarias. He escrito un artículo sobre un patrón que le proporciona una solución utilizando constructores genéricos y métodos de extensión genéricos con genéricos limitación: http://liviutrifoi.wordpress.com/2009/02/16/fluent-interfaces-constraints-at-compile-time/

Moq oculta métodos no leated como equals, ToString y así sucesivamente para hacer su interfaz fluida aún más fácil de usar.

Ocultar Objeto del sistema es un artículo que explica el beneficio de hacer esto.

Y sobre su segunda y tercera pregunta;

Tres patrones fluidos que he notado

La primera usa la instrucción using (C # 2.0) para ejecutar código en un contexto determinado, por ejemplo:

using(var transaction = new Transaction())
{
  // ..
  // ..
}

Esto usa el constructor y el eliminador de Transaction para configurar una transacción y luego ejecuta el código en este contexto.

El segundo hace casi lo mismo, pero con lambda, esto se usa mucho en Rhino Mock, por ejemplo.

(new Transaction()).Run( () => mycode(); );

La interfaz fluida más conocida es utilizar devuelve tipos a llamadas a métodos de cadena. La mayoría de los métodos devuelven esto para que pueda encadenar llamadas en el mismo objeto. Pero también puede devolver diferentes objetos para cambiar el contexto dependiendo del método llamado. Si tiene un objeto que solo puede ejecutarse en una transacción (lo siento, no se le ocurre un ejemplo diferente), puede darle un método StartTransaction que devuelve una transacción inicializada donde puede ejecutar call run y stoptransaction, en pseudocódigo:

class Runner
{
  Transaction StartTransaction()
  {
    return new Transaction(this);
  }
}

class Transaction
{
  Transaction Run()
  Transaction StopTransaction()
}

Dónde se ve la llamada como

var runner = new Runner();
runner
  .StartTransaction()
  .Run()
  .StopTransaction();

Por supuesto, debe agregar todo tipo de manejo de errores, etc.

Yo también estoy aprendiendo a escribir una interfaz fluida para una pequeña aplicación en el trabajo. He preguntado e investigado un poco y encontré que un buen enfoque para escribir una interfaz fluida es usar el "patrón de constructor", lea más sobre él aquí.

En esencia, así es como empecé la mía:

public class Coffee
{
    private bool _cream;
    private int _ounces;

    public Coffee Make { get new Coffee(); }

    public Coffee WithCream()
    {
        _cream = true;
        return this;
    }

    public Coffee WithOuncesToServe(int ounces)
    {
        _ounces = ounces;
        return this;
    }
}

Aquí hay un mensaje cruzado a una pregunta similar Que tengo para implementar un cierre en una interfaz fluida.

Una cosa es que tiene que tener en cuenta la morfología de la sintaxis inglesa y asegurarse de que no ha introducido el acoplamiento secuencial indocumentado debajo.

// Snarky employees get a raise.
employees.WhereSnarky().GiveRaise();

Vs.

// Depending on implementation, everyone may get a raise.
employees.GiveRaise().WhereSnarky();

Hace algún tiempo tuve las mismas dudas que tú tienes ahora. He hecho algunas investigaciones y ahora estoy escribiendo algunas publicaciones para ayudar en esos temas.

Compruébalo en mi blog:

Directrices para el diseño fluido de la interfaz en C # parte 1

Y en los siguientes posts cubriré cada uno de los puntos que mencionaste.

Saludos cordiales André Vianna