Question

I have 2 classes that have the exact same logic/workflow, except in one method.

So, I created a abstract base class where the method that differs is declared as abstract.

Below is some sample code to demonstrate my design; can anyone offer suggestions on a better approach or am I heading in the right direction.
I didn’t use an interface because both derived classes B and C literally share most of the logic. Is there a better way to do what I am doing below via dependency injection?

public abstract class A
{
    public void StageData()
    {
        // some logic
        DoSomething();
    }
    public void TransformData();
    public abstract DoSomething();
}

public class B : A
{
    public override void DoSomething()
    {
        // Do Something!
    }
}

public class C : A
{
    public override void DoSomething()
    {
        // Do Something!
    }
}

Answer 1

There is nothing wrong with what you have done. To introduce dependency injection into this design would be messy and overkill – you would have to pass in a delegate:

public class ABC
{
    public ABC(Action z)
    {
        _doSomethingAction = z;
    }

    public void DoSomething()
    {
        _doSomthingAction.Invoke();
    }


    private Action _doSomthingAction;
}

There would be few reasons why you want to use this approach – one would be if you needed to execute a callback. So stick with the pattern you have, don’t try to overcomplicate things.