Looking for a better way to extend methods-CodePudding

I'm working on a hobby project in Unity. I have MonoBehaviour scripts for my characters that use component objects for each behavior the character has. When I create new characters, I inherit a new class from the base class for whichever component behaves differently.

When certain triggers occur, I send characters back to their initial state by calling a Reset() method exposed by the base class that sets fields back to their initial values. I'm wondering how to send that call down through the inheritance chain. Right now, the base class has a protected virtual ChildReset() that gets called in Reset() and does nothing by default. If child classes have fields to reset, they override this method. It feels like a really awkward way of doing it.

I like the idea of implementing something similar to the messaging system Unity uses. If a monobehavior doesn't use the Update() message, then the class just doesn't define an update. It eliminates unnecessary calls. I have no idea how I would do something like that.

Any thought invested in this is much appreciated! I've written out the way my project is structured below just in case these details are useful for answers.

public class Character : MonoBehaviour
{
    private Motion motionController;
    private Interaction characterInteractionController;
    //etc

    private void Update()
    {
        motionController.DoStuff();
        characterInteractionController.DoStuff();
    }

    private void Reset()
    {
        motionController.Reset();
        characterInteractionController.Reset();
    }

    private void OnEnable() => ResetTrigger.OnReset  = Reset;
    private void OnDisable() => ResetTrigger.OnReset -= Reset;
}

public class Motion : Component {}
public class Interaction : Component {}

public abstract class Component
{
    public void Reset() 
    { 
        /* set fields to default values */ 
        ChildReset();
    }
    
    protected virtual void ChildReset() { }
    public abstract void DoStuff();
}

CodePudding user response：

There is no need to send a call down through the inheritance chain. You do not have two different objects. An object of the child class contains everything declared in the base class. Why not directly make Reset() virtual?

public abstract class Character : MonoBehaviour
{
    public virtual void Reset()
    {
        ...
    }
}

public class ChildCharacter : Character
{
    // If ChildCharacter has stuff to reset, override this method, otherwise don't!
    public override void Reset()
    {
        base.Reset(); // Call this to reset stuff from the base class.

        //TODO: reset child stuff.
    }
}

If Reset is overridden in the child class, then calling Reset will call ChildCharacter.Reset() even if called on a variable statically typed as Character.

    Character c = new ChildCharacter();
    c.Reset(); // calls ChildCharacter.Reset() when overridden

If Reset is not overridden in the child class, then calling Reset will call Character.Reset() even if called on a ChildCharacter.

    ChildCharacter child = new ChildCharacter();
    c.Reset(); // calls Character.Reset() when not overridden.