Forcing a derived class to have a constructor with a signature

Question

How do I force all derived classes of an interface to have a constructor with a signature? This doesn't work:

public interface Constructor<T> where T : Constructor<T>, new()
{
    Constructor(T);
}

public interface IParameters
{
}

public interface IRule : Constructor<IParameters>
{
    //IRule (IParameters); must exist
}

You can't force a specific constructor on derived classes. constructors are not inherited nor can they be specified in interfaces. (I'm not sure about c#8 interface default implementation, though.) — Zohar Peled, Jul 16 '19 at 05:33

Mark Z. · Answer 1 · 2019-07-16T05:59:55.903

1

You can't, not via an interface. But you can sort of get at it with an abstract class. Similar to what the accepted answer here describes, try:

public abstract class MustInitialize<T>
{
    public MustInitialize(T parameters)
    {

    }
}

public class Rule : MustInitialize<IParameters>, IRule
{
    IParameters _parameters;

    public Rule(IParameters parameters)
        : base (parameters)
    {
        _parameters= parameters;
    }
}

edited Jul 16 '19 at 05:59

answered Jul 16 '19 at 05:36

Mark Z.

2,127
16
33

This still doesn't enforce the constructor on the derived class to take in parameters. Whatever implementation of `IParameters` can be initialized in the call to the base constructor. – Zohar Peled Jul 16 '19 at 05:49
"sort of get at it" @ZoharPeled , and better than nothing! – Mark Z. Jul 16 '19 at 05:55
I started to write a comment but it got too long. See my answer - it explains exactly what I mean. – Zohar Peled Jul 16 '19 at 06:20

Zohar Peled · Answer 2 · 2019-07-16T06:35:28.487

You can't force a specific constructor signature.
Even with an abstract class as demonstrated in Mark's answer, you can only force the constructor of the abstract class, but nothing is stopping the author of the derived class to do something like this:

public class Rule : MustInitialize<IParameters>, IRule
{
    public Rule()
        : base (new Parameters())
    {
        // Assuming Parameters is a class that implements the IParameters interface
    }
}

However, you can force dependency injection by using method (setter) injection:

public interface IMethodInjection<T>
{
    void Method(T injected);
}

score 0 · Answer 3 · answered Jul 16 '19 at 06:13

I think you can design your base class like the following example:

public abstract class MyBase
{
    private MyBase()
    {
    }

    public MyBase(string a)
    {
    }
}

public class MyDerived : MyBase
{
    public MyDerived(string a) : base(a)
    {
    }
}

You can even delete the private constructor if its not needed

Forcing a derived class to have a constructor with a signature

3 Answers3