I have a base class that implements some logic and eventually calls an Action which was passed to the contructor.

public class BaseClass
{
    private Action action;

    public BaseClass(Action someAction)
    {
        action  = someAction;
    }

    private void doStuff()
    {
        action();
    }
}

Now I want to derive some child classes that implement some specific logic. In these child classes I have a method for that logic and my attempt was to pass this method to the base constructor. But this result in a compiler error CS0120: An object reference is required for the nonstatic field, method, or property 'member'.

public class SpecificClass : BaseClass
{
    private int b;

    public SpecificClass(int i)
        : base(doSpecificStuff)  // <-- compiler error CS0120 here
    {
        b = i;
    }

    private void doSpecificStuff()
    {
        // do something depending on b
    }
}

I don't quite get why it fails at that point. Is it because the base constructor gets called first which means when calling it I do not have an instance of the child class (including the child's method)?

But why does the compiler asks for a reference to a nonstatic field? Actually I don't see anything static here. Is there a way to get a reference to doSpecificStuff at that point? this.doSpecificStuff does not work, resulting in CS0027: Keyword 'this' is not available in the current context.

Any suggestions for a better design?

CodePudding user response：

This is exactly where object-oriented-design (OOP) and one of its principles, Polymorphism, comes in place, and what it was designed for.

By making doStuff virtual in the base class, we can override the method in the specific class and customize its behavior.

public class BaseClass
{
    private Action? action;

    public BaseClass(Action someAction)
    {
        action  = someAction;
    }

    protected BaseClass()
    {
    }

    protected virtual void doStuff()
    {
        action?.Invoke();
    }
}

public class SpecificClass : BaseClass
{
    private int b;

    public SpecificClass(int i)
    {
        b = i;
    }

    protected override void doStuff()
    {
        // do something depending on b
    }
}

CodePudding user response：

I don't quite get why it fails at that point. Is it because the base constructor gets called first which means when calling it I do not have an instance of the child class (including the child's method)?

Sort of. There is actually an instance of the child class (the object is created immediately of the "right" type) but you can't refer to anything specific to the instance in the constructor initializer.

From section 15.11.2 of the draft C# 6 spec:

An instance constructor initializer cannot access the instance being created.

The best way of handling this really depends on the broader context. For example, you could accept a Func<BaseClass, Action> instead and cast:

public class BaseClass
{
    private Action action;

    public BaseClass(Func<BaseClass, Action> actionProvider)
    {
        action  = actionProvider(this);
    }

    private void doStuff()
    {
        action();
    }
}

... then:

public class SpecificClass : BaseClass
{
    private int b;

    public SpecificClass(int i)
        : base(x => ((SpecificClass) x).doSpecificStuff)
    {
        b = i;
    }

    private void doSpecificStuff()
    {
        // do something depending on b
    }
}

That's a bit tortuous though. If the action is always expected to be a method in the derived class, an option would be to create an abstract method in the base class and just override it in the derived class instead.

CodePudding user response：

The error message means that the compiler is expecting this:

private static void doSpecificStuff()
{
    // do something depending on b
}

Why? because when you call your action in doStuff, C# has no way to now that doSpecificStuff has to be called on the current (this) instance.

To compile, you would have to do something like this :

public class BaseClass
{
    private Action action;

    public BaseClass(Action<BaseClass> someAction)
    {
        action  = () => someAction(this);
    }

    private void doStuff()
    {
        action();
    }
}

public class SpecificClass : BaseClass
{
    private int b;

    public SpecificClass(int i): base(x => ((SpecificClass)x).doSpecificStuff())  // <-- compiler error CS0210 here
    {
        b = i;
    }

    private void doSpecificStuff()
    {
        // do something depending on b
    }
}

I do not know exactly why you came up with this approach but why not just us inheritance? (Again, there might be some specific need I'm not aware of here, I'm just mentioning this for the record to post an answer as complete as possible) For instance:

public class BaseClass
{
    public BaseClass()
    {

    }

    protected virtual void doStuff()
    {
        // Doing stuff...
    }
}
public class SpecificClass : BaseClass
{
    private int b;

    public SpecificClass(int i): base() 
    {
        b = i;
    }

    protected override void doStuff()
    {
        // do something depending on b

        base.doStuff()// if needed...
    }
}