Question

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

这些类具有以特定间隔调用的某些函数（start，ongui，update）。

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

我想创建一个基类，然后调用它并让每个包含一个自动调用的函数的类如unity3d。我已经尝试了谷歌搜索，但不知道这种类型的行为被调用甚至得到一个有用的结果

Answer 1

也许是这样的：

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 2

为什么不实现静态Manager类，如下所示：

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构造函数都会使用新的CallManager更新Callable。完整的示例程序如下：

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 3

我相信你指的是Template Method设计模式，通常也称为 hooks 。它是许多框架的基石。它的工作原理如下：

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的核心：“不要打电话给我们，我们会打电话给你！”（即你不要调用框架的类 - 框架会打电话给你！）

调用每个继承基类的类而不知道该类是否存在c＃

3 个答案: