Metodo sovraccarico: imbuto chiamata a sovraccarico argomento classe derivata

Question

Ok, sto cercando di fare quanto segue:

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

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

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

e hanno le versioni classe derivata del metodo chiamato, quando una classe base viene passata al il metodo. La classe base è astratta quindi dovrebbe essere teoricamente possibile?

Prima che qualcuno dica qualcosa sull'overloading del metodo sulle classi stesse, la logica all'interno dei metodi si basa su un gran numero di condizioni diverse, nessuna delle quali è correlata, e nessuna delle quali correlata direttamente alla classe Base/Derivata (come ad esempio lo stato di accesso, etc.)

Answer 1

Se il doppio invio è troppo invadente, è possibile richiamare il metodo mediante la riflessione e risolvere il sovraccarico corretto in modo dinamico.

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

Questo modello è chiamato MultipleDispatch, mentre chiamando un metodo per riflessione è più lenta di chiamare il metodo direttamente (non sarà un overhead se il metodo viene chiamato a meno di qualche centinaio di volte al secondo), ha il vantaggio di non richiedere di modificare la gerarchia di classi come nel modello di Double Dispatch.

Questo sarà ancora più facile quando C# 4.0 se ne esce con la parola chiave dinamica:

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 luogo perfetto per utilizzare 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

io non sono sicuro esattamente come si potrà mai avere un'istanza della classe base che non è in realtà un'istanza di una classe derivata. Poiché la classe base è astratta, non può essere istanziata. Suppongo che potrebbe corrispondere a qualsiasi classe derivata che non ha una firma specifica, ma non sembra essere quello che stai cercando.