sobrecarga de métodos: embudo de llamada a la clase derivada de sobrecarga argumento

Question

Ok, estoy tratando de hacer lo siguiente:

 protected bool ValidAdvert(Base item) 
     { 
      throw ThisIsAnAbstractClassException(); 
     } 

     protected bool ValidAdvert(Derived1 item) 
     { 
      return ADerived1SpecificPredicate; 
     } 

     protected bool ValidAdvert(Derived2 item) 
     { 
      return ADerived2SpecificPredicate; 
     }

Y tienen las versiones de clase derivada del método de ser llamado, cuando una clase base se pasa a el método. La clase base es abstracta, así que esto debería, en teoría, ser posible.

Antes de que alguien diga algo sobre sobrecargar el método en las clases, la lógica dentro de los métodos depende de un gran número de condiciones diferentes, ninguna de las cuales está relacionada, y ninguna relacionada directamente con la clase Base/Derivada (como el estado de inicio de sesión, etc.)

Answer 1

Si considera que el doble despacho es demasiado intrusivo, puede llamar al método por reflexión y resolver la sobrecarga adecuada de forma dinámica.

protected bool ValidAdvert(Base item) 
{ 
    if (item.GetType() == typeof(Base)) 
     throw new ThisIsAnAbstractClassException(); 

    Type type = typeof(CurrentClass); 

    MethodInfo method = type.GetMethod("ValidAdvert", 
             BindingFlags.Instance | BindingFlags.NonPublic, 
             null, 
             new Type[] { item.GetType() }, 
             null); 
    return (bool)method.Invoke(this, new object[] { item }); 
} 

protected bool ValidAdvert(Derived1 item) 
{ 
    return ADerived1SpecificPredicate; 
} 

protected bool ValidAdvert(Derived2 item) 
{ 
    return ADerived2SpecificPredicate; 
} 

Este patrón se llama MultipleDispatch, mientras que llamar a un método de reflexión es más lento que una llamada al método directamente (no va a ser una sobrecarga si el método se llama menos de unos pocos cientos de veces por segundo), que tiene el beneficio de no requerir modificar su jerarquía de clases como en el patrón de Despacho doble.

Esto será aún más fácil cuando C# 4.0 sale con la dinámica de palabras clave:

protected bool ValidAdvert(Base item) 
{ 
    if (item.GetType() == typeof(Base)) 
     throw new ThisIsAnAbstractClassException(); 

    dynamic dynamicThis = this; 

    return (bool)dynamicThis.ValidAdvert(item as dynamic); 
} 

Answer 2

un lugar perfecto para utilizar double dispatch:

class Base 
{ 
    public abstract bool IsValid(IAdvertValidator validator); 
} 

class Derived1 : Base 
{ 
    public bool IsValid(IAdvertValidator validator) 
    { 
     return validator.ValidAdvert(this); 
    } 
} 

class Derived2 : Base 
{ 
    public bool IsValid(IAdvertValidator validator) 
    { 
     return validator.ValidAdvert(this); 
    } 
} 

interface IAdvertValidator 
{ 
    bool ValidAdvert(Derived1 d1); 
    bool ValidAdvert(Derived2 d2); 
} 

Answer 3

no estoy seguro exactamente cómo va a tener cada vez una instancia de la clase base que no es realmente una instancia de una clase derivada. Como la clase base es abstracta, no se puede crear una instancia. Supongo que coincidiría con cualquier clase derivada que no tenga una firma específica, pero eso no parece ser lo que estás buscando.