Interfaces fluidas y herencia en C#

Trate de usar algunos métodos de extensión.

static class FluentManager
{
    public static T WithFirstName<T>(this T person, string firstName) where T : FluentPerson
    {
        person.FirstName = firstName;
        return person;
    }

    public static T WithId<T>(this T customer, long id) where T : FluentCustomer
    {
        customer.ID = id;
        return customer;
    }
}

class FluentPerson
{
    public string FirstName { private get; set; }
    public string LastName { private get; set; }

    public override string ToString()
    {
        return string.Format("First name: {0} last name: {1}", FirstName, LastName);
    }
}

class FluentCustomer : FluentPerson
{
    public long ID { private get; set; }
    public long AccountNumber { private get; set; }

    public override string ToString()
    {
        return base.ToString() + string.Format(" account number: {0} id: {1}", AccountNumber, ID);
    }
}

Después puedes usar como

new FluentCustomer().WithId(22).WithFirstName("dfd").WithId(32);

Lógicamente necesitas configurar cosas de la más específica (cliente) a la menos específica (persona) o de lo contrario es incluso difícil de leer a pesar de la interfaz fluida. Siguiendo esta regla en la mayoría de los casos no tendrás que meterte en problemas. Sin embargo, si por alguna razón todavía necesita mezclarlo, puede usar declaraciones de énfasis intermedias como

static class Customers
{
   public static Customer AsCustomer(this Person person)
   {
       return (Customer)person;
   }
}

customer.WIthLastName("Bob").AsCustomer().WithId(10);

Una solución donde necesita una interfaz fluida, herencia y también algunos genéricos...

De todos modos, como he dicho antes: esta es la única opción si desea usar herencia y acceder también a miembros protegidos...

public class GridEx<TC, T> where TC : GridEx<TC, T>
{
    public TC Build(T type)
    {
        return (TC) this;
    }
}

public class GridExEx : GridEx<GridExEx, int>
{

}

class Program
{
    static void Main(string[] args)
    {
        new GridExEx().Build(1);
    }
}

 public class FluentPerson
 {
    private string _FirstName = String.Empty;
    private string _LastName = String.Empty;

    public FluentPerson WithFirstName(string firstName)
    {
        _FirstName = firstName;
        return this;
    }

    public FluentPerson WithLastName(string lastName)
    {
        _LastName = lastName;
        return this;
    }

    public override string ToString()
    {
        return String.Format("First name: {0} last name: {1}", _FirstName, _LastName);
    }
}


   public class FluentCustomer 
   {
       private string _AccountNumber = String.Empty;
       private string _id = String.Empty;
       FluentPerson objPers=new FluentPerson();



       public FluentCustomer WithAccountNumber(string accountNumber)
       {
           _AccountNumber = accountNumber;
           return this;
       }

       public FluentCustomer WithId(string id)
       {
           _id = id;
           return this;
       }

       public FluentCustomer WithFirstName(string firstName)
       {
           objPers.WithFirstName(firstName);
           return this;
       }

       public FluentCustomer WithLastName(string lastName)
       {
           objPers.WithLastName(lastName);
           return this;
       }


       public override string ToString()
       {
           return objPers.ToString() + String.Format(" account number: {0}",  _AccountNumber);
       }
   }

E invocarlo usando

  var ss = new FluentCustomer().WithAccountNumber("111").WithFirstName("ram").WithLastName("v").WithId("444").ToString();

¿Es una interfaz fluida realmente la mejor llamada aquí, o sería mejor un inicializador?

 var p = new Person{
      LastName = "Smith",
      FirstName = "John"
      };

 var c = new Customer{
      LastName = "Smith",
      FirstName = "John",
      AccountNumber = "000",
      ID = "123"
      };

A diferencia de una interfaz fluida, esto funciona bien sin métodos heredados que devuelvan la clase base y arruinen la cadena. Cuando se hereda una propiedad, a la persona que llama realmente no le debería importar si FirstName se implementó primero en Persona o Cliente u Objeto.

Encuentro esto más legible también, ya sea en una línea o múltiple, y no tienes que pasar por la molestia de proporcionando funciones de auto-decoración fluidas que corresponden con cada propiedad.