自动实现属性的继承，派生类中仅需要getter

Question

I have next code

class Base
{
    public virtual int Prop { get; set; }
}

class Derived : Base
{
    public override int Prop { get { return 1; } }
}

//...
Derived obj = new Derived();
int some = obj.Prop; //expected
obj.Prop = 10; //oops it works

The fact that the last line should complile seems not to be so obvious at first sight. In my program I have a situation when overriding some auto-implemented property in a such way would be a solution. I understand that it's not a good approach. What kind of refactoring can I do to avoid such inheritance and to clean my code? Thanks

Answer 1

class Base
{
    public virtual int Prop { get; set; }
}

class Derived : Base
{
    public new int Prop { get { return 1; } private set {}  }
}

The problem is that if you cast your Derived to Base, you can set the property anyway. If the Property relay on a field, it will be overwriten.

Ex.:

class Base
{
    protected int fProp;
    public virtual int Prop { get { return fProp; } set { fProp = value; } }
}

class Derived : Base
{
    public Derived()
    {
        fProp = 1;
    }
    public new int Prop { get { return fProp; } private set {}  }
}



namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            //...
            Derived obj = new Derived();
            int some = obj.Prop; //expected
            Base b = (Base)obj;
            b.Prop = 10; //oops it works
            Console.WriteLine(obj.Prop); =>it will show 10, not 1
            Console.ReadKey();
        }
    }
}

A "better" approach to avoid this kind of problem is to avoid the use of a base class if you want to "change" something on a derived class. Or, put only the minimal content that must be implemente by ALL derived classes and let the derived classes implement any extra code that only they want.

Ex:

class Base
{
    protected int fProp;
}

class Derived : Base
{
    public Derived()
    {
        fProp = 1;
    }
    public int Prop { get { return fProp; } }
}

class Derived2 : Base
{
    public int Prop { get { return fProp; }  set { fProp = value; } }
}



namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            //...
            Derived obj = new Derived();
            int some = obj.Prop; //expected
            Base b = (Base)obj;
            //obj.Prop = 10; Compilation error
            Console.WriteLine(obj.Prop);
            Derived2 obj2 = new Derived2();
            obj2.Prop = 10;
            Console.WriteLine(obj2.Prop);
            Console.ReadKey();
        }
    }
}

Also, you could "encapsulate" your base class:

class Derived
{
    protected Base fBase;

    public Derived()
    {
        fBase = new Base;
    }

    //implement enything that you need to access from Base class

    public int Prop { get { return 1; } }
}

But I find this last one too "expensive"... :)

Answer 2

A derived class has to implement the same interface as its base class - having a public setter be inaccessible from a derived class would break polymorphism.

If Prop needs to be inaccessible to clients, but you need to be able to set its value from within the class itself, you could declare it as:

public virtual int Prop { get; protected set; }

There probably isn't a single answer to this question, as it depends on the model for your specific application. If some derived classes need to allow writes to this property, but others don't, you could either throw an exception on an invalid write and handle it at run time, or perhaps implement the property using a protected backing field and only a getter, and then add a derived class that provides a SetProp() method for those classes that need it.

public class Base
{
    protected int prop;
    public virtual int Prop { get { return prop; } }
}

public class WriteableBase : Base
{
    public virtual void SetProp(int prop) { this.prop = prop; }
}

Answer 3

I think it´s not possible to get compiler-error in this case. Imagine further you´d declare obj not as Derived but as Base = new Derived() , how should compiler know which property to infer. So all you can do is to throw an exception during runtime within the derived setter telling that setting this property isn´t allowed fir this type.

class Base
{
    public virtual int Prop { get; protected set; }
}

class Derived : Base
{
    public override int Prop { 
        get { return 1; } 
        protected set {throw NotSupportedException();}  
    }
}

Answer 4

When compiling, C# transforms the getter and setter to individual methods (get_Prop and set_Prop). Your code only implements the get in the Derived class, and the set remains that of the base class.

If this is your desired behavior, I don't find it to be wrong.

If you are trying to hide the setter in the Derived class, there is no elegant way to do it, so throwing an NotSupportedException is a solution.

    class Base
    {
        public virtual int Prop { get; set; }
    }

    class Derived : Base
    {
        public override int Prop { get { return 1; } set { throw new NotSupportedException();}}
    }