如何覆盖方法保存模板方法模式

Question

I do have an abstract class where on the constructor I'm calling an abstract method declared on the very same class, and Im doing this because I do want to force all the derivated class to not just implement my abstract method but also call it (I think here is where the Template Method pattern comes in).

BTW: I know it is not the best approach to make sure all things will be correctly writen but due external problems I would like to minimize my future problems with bad implementation. The snippet is below:

public abstract class Generic
{
    public Generic()
    {
        Console.WriteLine("This is the generic");

        this.SetRules();
    }

    protected abstract void SetRules();
}

Well, on one of my derivated class need to set up a private variable on the declaration, and I would like to use this variable inside the overriden method. As I don't know how many possibilities I would need to each one of my derivated classes, I would like to declare it inside each one of my derivated class as necessary. An example below:

public class Derivated2 : Generic
{
    private int _parameter;

    public Derivated2(int parameter)
    {
        this._parameter = parameter;
    }

    protected override void SetRules()
    {
        int x = 0;
        x = 1 + 3;

        Console.WriteLine(String.Concat("This is the derivated2 with x: ", x, "; _parameter: ", _parameter));
    }
}

Now to the problem;

When I'm calling my derivated2 class, I can't use/see my variable value specified on declaraion:

public static void Main()
{
    Derivated2 _class1 = new Derivated2(2);
}

My output is:

This is the generic
This is the derivated2 one with x: 4; _parameter: 0

How can I see/use my variable on my overriden asbtract method? If I can't, What would be the best approach to reach my goal securing the SetRules method is going to be called no matter what the developer does and also can use private variables inside his derivated class?

Here is the full code I have done:

Calling SetRules on Abstract Generic Class

Calling SetRules on Derivated Class

Answer 1

The problem is you are calling the Generic constructor which will call SetRules before your Derivated2 constructor is called meaning your parameter has not been set yet. You could try this.

public abstract class Generic
{
    public Generic(int parameter)
    {
        Console.WriteLine("This is the generic");

        this.SetRules(parameter);
    }

    protected abstract void SetRules(int paramter);
}

public class Derivated2 : Generic
{

    public Derivated2(int parameter) : base(parameter){ }

    protected override void SetRules(int parameter)
    {
        int x = 0;
        x = 1 + 3;

        Console.WriteLine(String.Concat("This is the derivated2 with x: ", x, "; _parameter: ", parameter));
    }
}
public static void Main()
{
    Derivated2 _class1 = new Derivated2(2);
}

As you said it wouldn't be nice to have to call SetRules every time you want to create a new class so this would mean you wouldn't have to (quickly threw this together so you will need to fix it up)

public abstract class Generic
{
    public Generic()
    {
        Console.WriteLine("This is the generic");
    }

    public abstract void SetRules();
}

public sealed class Derivated2 : Generic
{
    int _param;

    public Derivated2(RulesWithParameters rules) {
        _param = rules.Parameter;
    }

    public override void SetRules()
    {
        int x = 0;
        x = 1 + 3;

        Console.WriteLine(String.Concat("This is the derivated2 with x: ", x, "; _parameter: ", _param));
    }
}
public void Main()
{
    var rules = new RulesWithParameters{
        Parameter = 5
    };
    var _class1 = FactoryMethod<Derivated2>(rules);

    var _class2 = FactoryMethod<Derivated1>(null);
}

public class Derivated1 : Generic
{
    public Derivated1(Rules rules)
    {

    }
    public override void SetRules()
    {
        Console.WriteLine("This is the derivated1");
    }
}
public class Rules
{
    public string RuleName {get; set;}
}

public class RulesWithParameters : Rules{
    public int Parameter { get; set;}
}

public Generic FactoryMethod<T>(Rules rules) where T : Generic
{
    T instance = (T)Activator.CreateInstance(typeof(T), rules);;
    instance.SetRules();
    return instance;
}

Answer 2

I guess constructors in C# are not polymorphic, so you cannot call an overridable method from your constructor. You can read this piece of documentation: MSDN article .

Also it seems as a bad practice to me to use such approach in general. The abstract class's constructor is not aware of your descendant class's details of implementation, and should not be, so it is not correct to put there initialization of Derivated2. Try to place initialization code somewhere else.

Answer 3

If the SetRules method could be static instead of instance maybe you can add a static constructor and inside that constructor you can call the SetRules method. If not the Factory idea seems to be the best clean approach.