Interfaces fluidas y herencia en C#

Question

Voy a mostrar un problema con el ejemplo. Hay una clase base con interfaz fluida:

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); 
    } 
} 

y una clase hija:

class FluentCustomer : FluentPerson 
{ 
    private long _Id; 

    private string _AccountNumber = String.Empty; 

    public FluentCustomer WithAccountNumber(string accountNumber) 
    { 
     _AccountNumber = accountNumber; 
     return this; 
    } 
    public FluentCustomer WithId(long id) 
    { 
     _Id = id; 
     return this; 
    } 

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

El problema es que cuando se llama a customer.WithAccountNumber("000").WithFirstName("John").WithLastName("Smith") no se puede agregar .WithId(123) al final porque el tipo de retorno de la El método WithLastName() es FluentPerson (no FluentCustomer).

¿Cómo se resuelve este problema habitualmente?

Answer 1

Puede usar genéricos para lograr eso.

public class FluentPerson<T> 
    where T : FluentPerson<T> 
{ 
    public T WithFirstName(string firstName) 
    { 
     // ... 
     return (T)this; 
    } 

    public T WithLastName(string lastName) 
    { 
     // ... 
     return (T)this; 
    } 
} 

public class FluentCustomer : FluentPerson<FluentCustomer> 
{ 
    public FluentCustomer WithAccountNumber(string accountNumber) 
    { 
     // ... 
     return this; 
    } 
} 

Y ahora:

var customer = new FluentCustomer() 
    .WithAccountNumber("123") 
    .WithFirstName("Abc") 
    .WithLastName("Def") 
    .ToString(); 

Answer 2

Lógicamente, debe configurar las cosas desde el más específico (cliente) al menos específico (persona) o de lo contrario es incluso difícil de leer a pesar de la fluida interfaz. Siguiendo esta regla en la mayoría de los casos no necesitarás meterse en problemas. Sin embargo, si por alguna razón usted todavía necesita mezclarlo puede utilizar declaraciones enfatizando intermedios como

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

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

Answer 3

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); 
     } 
    } 

Y invocarlo usando

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

Answer 4

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

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 hereda una propiedad, la persona que llama realmente no debería preocuparse de si FirstName se implementó por primera vez en Persona, Cliente u Objeto.

Encuentro esto más legible también, ya sea en una línea o múltiple, y, no tiene que tomarse la molestia de proporcionar funciones de auto-decoración fluidas que se correspondan con cada propiedad.

Answer 5

tratar de utilizar algunos métodos Extention.

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 puede utilizar como

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

Answer 6

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

De todos modos, como dije antes: este es el única opción si desea utilizar la herencia y acceder también a los 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); 
    } 
}