Override get, But not set

Question

I have an abstract class that defines a get, but not set, because as far as that abstract class is concerned, it needs only a get.

Answer 1

It is not possible to do what you want. You have to define the setter in the abstract property, otherwise you won't be able to override it properly.

The only case I know where a getter is defined and a getter/setter are implemented is by using an interface:

public interface IBaseInterface
{
    double MyPop { get; }
}

public class DClass : IBaseInterface
{
    public double MyPop { get; set; }
}

Answer 2

You could do something like this:

abstract class TestBase { public abstract int Int { get; } }

class TestDerivedHelper : TestBase
{
    private int _Int;
    public override int Int
    {
        get
        {
            return _Int;
        }
    }

    protected void SetInt(int value)
    {
        this._Int = value;
    }
}

class TestDerived : TestDerivedHelper
{
    public new int Int
    {
        get { return base.Int; }
        set { base.SetInt(value); }
    }
}

Using TestDerived will have the functionality you're looking for. The only drawback I can see from this method is that you have to implement every abstract method in TestDerivedHelper, but it gives you more control later.

Hope this helps. ;)

Answer 3

New in C# 6.0:

If you are only calling the setter within your constructor, you can resolve this problem using read-only properties.

void Main()
{
    BaseClass demo = new DClass(3.6);
}

public abstract class BaseClass
{
    public abstract double MyPop{ get; }
}

public class DClass : BaseClass
{
    public override double MyPop { get; }
    public DClass(double myPop) { MyPop = myPop;}
}

Answer 4

Even though this thread is old I'm positing my solution, in case it helps someone. It is not my own but is based off answers in other SO topics.

public abstract BaseClass
{
  public double MyPoP { get { return GetMyPoP; } }

  protected abstract double GetMyPoP { get; }
}

public class DClass: BaseClass
{
  public new double MyPoP { get; set; }

  protected override double GetMyPop { get { return MyPoP; } }
}

This solution adds an extra line of code for each such property that needs accessor modified. However, there is no change to external visibility and provides needed functionality.

Answer 5

One possible answer would be to override the getter, and then to implement a separate setter method. If you don't want the property setter to be defined in the base, you don't have many other options.

public override double MyPop
{
    get { return _myPop; }
}

public void SetMyPop(double value)
{
    _myPop = value;
}

Answer 6

Why not just have a property in the base class that has a private setter, then in your subclass that needs the setter, override it and make it public.