metodi virtuali Quando si esegue il un'istanza di una classe

Question

Ho una classe con alcune funzioni virtuali, facciamo finta questo è uno di loro:

public class AClassWhatever 
{ 
    protected virtual string DoAThingToAString(string inputString) 
    { 
     return inputString + "blah"; 
    } 
} 

voglio creare un'istanza di questa classe, mentre l'override "DoAThingToAString" in linea, proprio come ho possono dichiarare le proprietà inline in una dichiarazione, come segue:

... 

AClassWhatever instance = new AClassWhatever 
{ 
    DoAThingToAString = new function(string inputString) 
    { 
     return inputString + inputString + " fill my eyes." 
    } 
} 

... 

E ora per "istanza", DoAThingToAString viene sostituito con tale definizione. Devo essere in grado di definire il comportamento predefinito nella definizione della classe e solo sovrascriverlo in base alle esigenze, in momenti diversi e non voglio proliferare un gruppo di sottoclassi per farlo.

So che ho bisogno di usare delegati o qualcosa di simile, ma sono stato fuori dal gioco della sintassi per troppo tempo e Google mi stava dando troppe informazioni irrilevanti.

Answer 1

È possibile utilizzare i delegati o Func s per eseguire questa operazione.

In primo luogo, aggiungere questo alla classe AClassWhatever:

public Func<string, string> DoAThingToAString = (x) => x + "blah"; 

Ora è possibile utilizzare la stessa sintassi per ignorare l'azione.

AClassWhatever instance = new AClassWhatever() 
{ 
    DoAThingToAString = (x) => x + x + " fill my eyes." 
}; 

Answer 2

Non si può farlo con i metodi, ma si poteva fare l'equivalente con i delegati/metodi anonimi:

public class AClassWhatever 
{ 
    public AClassWhatever() 
    { 
     this.DoAThingToAString = this.DoAThingToAStringImpl; 
    } 

    public Func<string, string> DoAThingToAString { get; set; } 

    protected virtual string DoAThingToAStringImpl(string input) 
    { 
     return input + input + " fill my eyes."; 
    } 
} 

Usage:

var instance = new AClassWhatever 
{ 
    DoAThingToAString = inputString => inputString + inputString + 
     " fill my eyes something other than the default behavior." 
} 

var result = instance.DoAThingToAString("input"); 

Nota che inputString => inputString + inputString + "..." è lo stesso come x => x + x + "..."

Answer 3

Perché non definire una proprietà delegata e usa quella definizione se esiste quando viene chiamato il metodo? Nella tua istanziazione dell'oggetto, puoi fornire una definizione alternativa usando la proprietà.

Ad esempio:

public MyDelegateTypeThatMatchesMyFunctionCall DoAThingToAStringProperty { get; set; } 

public class AClassWhatever 
{ 
    protected virtual string DoAThingToAString(string inputString) 
    { 
     var handler = this.DoAThingToAStringProperty; 
     if (handler) 
     { 
      return handler(inputString); 
     } 

     // do default behavior 
     return inputString + "blah"; 
    } 
} 

Se si vuole garantire che la vostra proprietà delegato sostituisce qualsiasi definizione override del metodo virtuale che si possa fare in questo modo:

public MyDelegateTypeThatMatchesMyFunctionCall DoAThingToAStringProperty { get; set; } 

public class AClassWhatever 
{ 
    protected string DoAThingToAString(string inputString) 
    { 
     var handler = this.DoAThingToAStringProperty; 
     if (handler) 
     { 
      return handler(inputString); 
     } 

     // do default behavior 
     return DoAThingToAStringInternal(inputString); 
    } 

    protected virtual string DoAThingToAStringInternal(string inputString) 
    { 
     // do default behavior 
     return inputString + "blah"; 
    } 
}