Interfaces fluidas: el número de objetos que se crean

Question

Estoy en el proceso de crear algunas interfaces fluidas para algunas cosas simples de validación con las que estoy jugando. Una cosa que noté es que tengo muchos objetos diferentes que se crean.

Por ejemplo, dadas las declaraciones siguientes: ''

Check.Assertion.ForValue.That(value, "value").IsNotNull() : void 

Check.Assertion.ForArgument.That(value, "value").IsNotNull() : void 

Validate.Assertion.ForDate.That("Test").IsNotNull() : bool 

Validate.Assertion.ForNumeric.That("Test").IsNotNull() : bool 

para cada (aceptar para el último) Estoy renovando un objeto. Si no estuviera usando una interfaz fluida, habría utilizado métodos estáticos.

Lo que me pregunto es si alguien sabe dónde se notaría una diferencia real en el rendimiento al usar este número de objetos de instancia (obsérvese que son objetos bastante pequeños) como para trabajar con métodos estáticos.

Saludos Anthony

Answer 1

en cuenta que no necesariamente tienen que construir nuevos objetos por todo el lugar. Puede resolver la mayor parte de la interfaz fluida a través de interfaces y simplemente implementar muchas interfaces en un objeto. En ese caso, puede devolver this, solo a través de una nueva interfaz.

Ejemplo:

public interface ICheckAssertionForValue 
{ 
    ICheckAssertionForValueThat That(Object value, String name); 
} 

public interface ICheckAssertion 
{ 
    ICheckAssertionForValue ForValue { get; } 
} 

public class Check : ICheckAssertion 
{ 
    public static ICheckAssertion Assertion 
    { 
     get { return new Check(); } 
    } 

    ICheckAssertionForValue ICheckAssertion.ForValue 
    { 
     get { return this; } // <-- no new object here 
    } 

    ICheckAssertionForValueThat ICheckAssertionForValue.That(Object value, String name) 
    { 
     return new SomeOtherObject(value, name); 
    } 
}