在不知道该类存在的情况下调用每个继承基类的类c#

Question

我正在尝试在 websocket 服务器中实现一个类似于 unity3d 所做的系统。他们有一个名为 MonoBehavior 的基类，所有类都从该基类继承。

这些类具有特定的函数（start、ongui、update），它们会在特定的时间间隔内被调用。

从该类继承的每个类都调用其函数（每帧调用更新）

我想创建一个基类，然后调用它，并让每个包含其中一个函数的类都像 unity3d 一样自动调用。我试过谷歌搜索，但不知道这种类型的类行为被称为什么来获得有用的结果

Answer 1

为什么不直接实现一个静态管理器类，如下所示：

public static class CallManager
{
    public static HashSet<Callable> callables = new HashSet<Callable>();

    // Other management code...
}

使用一个基类，所有可调用类的子类，它会自动将每个新实例添加到由您的CallManager 管理的可调用对象集：

public abstract class Callable
{
    public Callable()
    {
        OnCreate();
    }

    protected void OnCreate()
    {
        CallManager.callables.Add(this);
    }

    public abstract void Start();
    public abstract void OnGUI();
    public abstract void Update();
}

现在，每当有人创建新的Callable 时，基本的Callable 构造函数将使用新的Callable 更新CallManager。完整的示例程序如下：

class Caller
{
    public static void Main(string[] args)
    {
        Callee1 c1 = new Callee1();
        Callee2 c2 = new Callee2();
        foreach (Callable c in CallManager.callables)
        {
            c.Start();
            c.OnGUI();
            c.Update();
        }
    }
}

public abstract class Callable
{
    public Callable()
    {
        OnCreate();
    }
    protected void OnCreate()
    {
        CallManager.callables.Add(this);
    }
    public abstract void Start();
    public abstract void OnGUI();
    public abstract void Update();
}

public static class CallManager
{
    public static HashSet<Callable> callables = new HashSet<Callable>();
}

public class Callee1 : Callable
{
    public Callee1()
    {

    }
    public override void Start()
    {
        Console.WriteLine("Callee1::Start");
    }
    public override void OnGUI()
    {
        Console.WriteLine("Callee1::OnGUI");
    }
    public override void Update()
    {
        Console.WriteLine("Callee1::Update");
    }
}

public class Callee2 : Callable
{
    public Callee2()
    {

    }
    public override void Start()
    {
        Console.WriteLine("Callee2::Start");
    }
    public override void OnGUI()
    {
        Console.WriteLine("Callee2::OnGUI");
    }
    public override void Update()
    {
        Console.WriteLine("Callee2::Update");
    }
}

Answer 2

可能是这样的：

public static class Caller {
    public static event EventHandler Updating;
    public static Update() {
        var handler = Updating;
        if (handler ¡= null) handler(null, EventArgs.Empty);
    }
 }

public abstract class Base {
    protected Base() {
        Caller.Updating += Caller_Updating;
    }
    void Caller_Updating(object sender, EventArgs e) {
        Update();
    }
    protected abstract Update();
 }

据我了解，您希望所有派生类都调用该方法。这样，当您调用 Caller.Update 时，Base 的所有派生类都会执行它们的 Update 方法。

Answer 3

我相信您指的是Template Method 设计模式，通常也称为钩子。它是许多许多框架的构建块。它的工作原理是这样的：

public abstract class BaseClass
{
    public void Start()
    {
        //execute start logic
        DoThis();
        DoThat();

        //call base class's hook
        OnStart();
    }

    protected abstract void OnStart();
}

您声明了派生类必须实现的抽象方法OnStart。当基类的Start方法被调用时，基类调用hook，然后由派生类执行。

如果你想重写钩子可选，那么你用一个空实现声明方法 virtual，即protected virtual void OnStart() { }。

可能还值得一提的是，这是Hollywood Principle 的核心：“不要打电话给我们，我们会打电话给你！”（即，你不打电话给框架的类 - 框架会调用你！）