einen Setter auf ein virtuelles Objekt in C#

Question

Ich habe Hinzufügen einer Situation wie folgt aus:

public abstract class BaseClass 
{ 
    public abstract string MyProp { get; } 
} 

Jetzt für einige der abgeleiteten Klassen, ist die Eigenschaften Wert ein synthetisiertes Werte, so gibt es keine Setzer:

public class Derived1 : BaseClass 
{ 
    public override string MyProp { get { return "no backing store"; } } 
} 

Dies funktioniert gut. Einige der abgeleiteten Klassen erforderten jedoch einen traditionelleren Hintergrundspeicher. Aber egal, wie ich es schreiben, wie die automatischen Eigenschaft oder mit einem expliziten Zusatzspeicher, erhalte ich eine Fehlermeldung:

public class Derived2 : BaseClass 
{ 
    public override string MyProp { get; private set;} 
} 

public class Derived3 : BaseClass 
{ 
    private string myProp; 
    public override string MyProp 
    { 
     get { return myProp;} 
     private set { myProp = value;} 
    } 
} 

Derived2.MyProp.set ': kann nicht außer Kraft setzen, weil ‚BaseClass.MyProp‘ tut hat einen überwindbaren set-Accessor nicht

Wie bekomme ich diese Arbeit ??

Answer 1

Das Beste, was Sie tun können, ist die Implementierung der Eigenschaft als virtual anstelle von abstract. Nehmen Sie die get und set Blöcke für jeden Wurf NotSupportedException in der Basisklasse und außer Kraft setzen entsprechend das Verhalten in abgeleiteten Klassen:

public virtual string MyProp { 
    get { 
     throw new NotSupportedException(); 
    } 
    set { 
     throw new NotSupportedException(); 
    } 
} 

Answer 2

Grundsätzlich können Sie nicht. Wenn Sie einen Setter hinzufügen, ändern Sie die Definition der Eigenschaft, sodass die Basiseigenschaft nicht wirklich überschrieben wird. Es ist dasselbe, als ob Sie versucht hätten, eine Methode zu überschreiben und einen weiteren Parameter hinzuzufügen - sie würden als unterschiedliche Methoden (überladen) behandelt werden. Da Eigenschaften nicht überladen werden können, funktioniert dies nicht.

Sie müssen nur eine andere Methode hinzufügen, um den Wert zu setzen (vielleicht mit protected Zugänglichkeit).

Answer 3

Bradley Vorschlag ist gut, aber eine Sache, die ich habe in Fällen geschehen, wo nur sollte der Setter sein virtuell ist dies etwas, dies zu tun:

public class Root 
{ 
    private string _MyProp; 
    public string MyProp 
    { 
     get { return _MyProp;} 
     set { _MyProp = SetMyProp(value); } 
    } 
    protected virtual string SetMyProp(string suggestedValue) 
    { 
     return suggestedValue; 
    } 
} 
public class Child 
    : Root 
{ 
    protected override string SetMyProp(string suggestedValue) 
    { 
     string oReturn = base.SetMyProp(suggestedValue); 
     // Do some sort of cleanup here? 
     return oReturn; 
    } 
} 

es erfordert ein wenig zusätzliche Arbeit nach vorne, aber es scheint, einen höheren Grad der Verkapselung zu erhalten (zB Sie Subklassen von Überschreiben der Getter Verhalten verhindern können, und Ihre Unterklasse doesn Sie müssen sich des dahinter liegenden Mitglieds bewusst sein das Eigentum).

Answer 4

Ich würde vorschlagen, virtuelle oder abstrakte Eigenschaften zu vermeiden. Verwenden Sie stattdessen eine nicht virtuelle Eigenschaft, die zu geschützten virtuellen oder abstrakten get/set-Methoden kettet. Dadurch können abgeleitete Klassen die Methoden überschreiben und die Eigenschaft auch mit einer Eigenschaft überschreiben, die über andere Zugriffsmodifizierer verfügt. Da die Basiseigenschaft selbst nicht virtuell ist, wird sie nie überschrieben werden müssen, so dass der Namenskonflikt mit der neuen Version keine Rolle spielt.