强制子类初始化字段

Question

I have abstract base class that contains some fields and some methods that act on these fields. For example:

public abstract class A
{
    protected double _field;

    public double SquaredField { get { return _field * _field; } }

    ... some other abstract methods
}

I want to impose that all children of A initialize _field in their constructors

public class B : A
{
    public B(double field)
    {
         _field = Math.Sqrt(field);
    }

    ... some other method implementations
}

What's the correct pattern to achieve this?

-- EDIT

What I ended up doing is:

public abstract class A
{
    protected readonly double _field;

    public A(double field)
    {
         _field = field;
    }

    public double SquaredField { get { return _field * _field; } }

    ... some other abstract methods
}


public class B : A
{
    public B(double field) : base(field)
    {
    }

    public static B CreateNew(double val)
    {
         return new B(Math.Sqrt(field));
    }

    ... some other method implementations
}

Answer 1

Don't expose a field to the derived classes at all. Instead, create a protected abstract property :

public abstract class A
{
    protected double Field { get; }

    public double SquaredField { get { return Field * Field; } }
}

Or, if the field should always be constant for a particular instance, make it a constructor parameter and keep it private:

public abstract class A
{
    private readonly double _field;

    public double SquaredField { get { return _field * _field; } }

    protected A(double field)
    {
        _field = field;
    }
}

Answer 2

Don't let class A have a parameterless constructor:

public abstract class A
{
    protected double _field;

    public double SquaredField { get { return _field * _field; } }

    // Require any fields that must be initialized in the base class's
    // constructor. If there are a lot of such fields, consider encapsulating
    // them all in their own class, e.g. AArgs.
    protected A(double field)
    {
        _field = field;
    }
}

public class B : A
{
    // You must call a base class constructor as below, because class A
    // no longer has a parameterless constructor to use by default.
    public B(double field)
        : base(field)
    {
    }
}

Addendum

If you can't do the initialization in the constructor, you could make the field into an abstract property:

public abstract class A
{
    protected abstract double Field { get; }

    public double SquaredField { get { return Field * Field; } }
}

Now, the derived class has to implement the property, so you'll have it ready for the dependent SquaredField property. I would change the name though, since they're not fields anymore.

Answer 3

That's likely a signal that group of fields is more tightly coupled than A itself, and so should be moved to a class, say, AParams .

Then in A you can declare an abstract protected AParams createParams() method.

Answer 4

You could use a separate abstract function to accomplish this. The subclasses would be forced to implement it.

public abstract class A
{
    protected double _field;

    protected A()
    {
        InitializeField();
    }

    protected abstract void InitializeField();

    public double SquaredField { get { return _field * _field; } }
}

public class B : A
{
    protected override void InitializeField()
    {
        // Initialize...
    }
}