类间通信如何规避链式引用与单例模式？——GameManager与Pipe类的便捷通信方案咨询

你提到的链式传参太繁琐、单例又容易内存泄漏的问题，我太懂了！在游戏开发里这种跨层级的类通信简直是家常便饭，给你分享几个不用链式传参也不用单例的靠谱方案：

一、事件/消息总线（Event Bus） #

这是解耦类间通信最常用的方式，相当于一个"消息中转站"——GameManager和Pipe不需要知道彼此的存在，只需要和总线打交道。

原理很简单：

• 定义一个全局的事件总线类，提供「订阅事件」「发布事件」「取消订阅」的方法
• GameManager在初始化时订阅它关心的事件（比如OnPipePassed）
• Pipe在需要通知GameManager时，直接向总线发布OnPipePassed事件
• 反过来，如果GameManager要给Pipe发消息，也可以让Pipe订阅对应的事件

举个C#的简单示例（你可以根据自己的语言调整）：

// 全局事件总线
public static class EventBus
{
    // 用字典存储事件名和对应的委托列表
    private static Dictionary<string, Delegate> _eventDictionary = new Dictionary<string, Delegate>();

    // 订阅事件
    public static void Subscribe<T>(string eventName, Action<T> handler)
    {
        if (!_eventDictionary.ContainsKey(eventName))
        {
            _eventDictionary[eventName] = null;
        }
        _eventDictionary[eventName] = (Action<T>)_eventDictionary[eventName] + handler;
    }

    // 发布事件
    public static void Publish<T>(string eventName, T data)
    {
        if (_eventDictionary.TryGetValue(eventName, out Delegate handler))
        {
            ((Action<T>)handler)?.Invoke(data);
        }
    }

    // 取消订阅（重要！避免内存泄漏）
    public static void Unsubscribe<T>(string eventName, Action<T> handler)
    {
        if (_eventDictionary.TryGetValue(eventName, out Delegate existingHandler))
        {
            var handlerToRemove = (Action<T>)existingHandler - handler;
            if (handlerToRemove == null)
            {
                _eventDictionary.Remove(eventName);
            }
            else
            {
                _eventDictionary[eventName] = handlerToRemove;
            }
        }
    }
}

// GameManager里订阅事件
public class GameManager
{
    private void Start()
    {
        EventBus.Subscribe<int>("OnPipePassed", HandlePipePassed);
    }

    private void HandlePipePassed(int score)
    {
        Debug.Log($"获得分数：{score}");
        // 处理分数逻辑
    }

    private void OnDestroy()
    {
        // 一定要取消订阅！不然会内存泄漏
        EventBus.Unsubscribe<int>("OnPipePassed", HandlePipePassed);
    }
}

// Pipe里发布事件
public class Pipe
{
    private void OnPlayerPassed()
    {
        // 发布事件，传递分数数据
        EventBus.Publish<int>("OnPipePassed", 10);
    }
}

注意：一定要在对象销毁时取消订阅，不然会因为委托持有对象引用导致内存泄漏。如果怕忘记，也可以用弱引用委托来实现事件总线，进一步降低泄漏风险。

二、依赖注入（Dependency Injection） #

如果你的项目里可以引入依赖注入的思路（不用复杂框架，自己写个简单容器也行），可以把GameManager的实例注册到一个全局的容器里，Pipe需要时直接从容器获取，不用一层层传递。

比如自己实现一个简单的DI容器：

public static class GameContainer
{
    private static Dictionary<Type, object> _services = new Dictionary<Type, object>();

    // 注册服务（比如GameManager实例）
    public static void Register<T>(T service) where T : class
    {
        if (_services.ContainsKey(typeof(T)))
        {
            _services[typeof(T)] = service;
        }
        else
        {
            _services.Add(typeof(T), service);
        }
    }

    // 获取服务（Pipe里用这个拿GameManager）
    public static T Get<T>() where T : class
    {
        if (_services.TryGetValue(typeof(T), out object service))
        {
            return service as T;
        }
        return null;
    }
}

// 在GameWorld初始化时注册GameManager
public class GameWorld
{
    public GameManager GameManager;

    private void Awake()
    {
        GameContainer.Register(GameManager);
    }
}

// Pipe里直接获取GameManager
public class Pipe
{
    private GameManager _gameManager;

    private void Start()
    {
        _gameManager = GameContainer.Get<GameManager>();
    }

    private void OnPlayerPassed()
    {
        _gameManager?.AddScore(10);
    }

    private void OnDestroy()
    {
        // 可以把引用置空，帮助GC回收
        _gameManager = null;
    }
}

这种方式比链式传参简洁，而且比单例灵活——你可以控制GameManager的生命周期，比如在游戏场景销毁时从容器里移除实例，避免内存泄漏。

三、全局事件委托（针对简单场景） #

如果你的需求很简单，不想搞复杂的总线或容器，也可以让GameManager暴露静态的事件委托（注意不是单例，只是静态事件）：

public class GameManager
{
    // 静态事件，Pipe可以直接订阅
    public static event Action<int> OnPipePassed;

    public void AddScore(int score)
    {
        // 处理分数逻辑
    }

    // 如果需要主动触发事件，也可以用这个方法
    public static void TriggerPipePassed(int score)
    {
        OnPipePassed?.Invoke(score);
    }
}

// Pipe里直接订阅或触发
public class Pipe
{
    private void Start()
    {
        // 如果需要监听GameManager的消息，订阅事件
        GameManager.OnPipePassed += HandlePipePassed;
    }

    private void HandlePipePassed(int score)
    {
        // 处理逻辑
    }

    private void OnPlayerPassed()
    {
        // 直接触发GameManager的事件
        GameManager.TriggerPipePassed(10);
    }

    private void OnDestroy()
    {
        GameManager.OnPipePassed -= HandlePipePassed;
    }
}

这种方式最轻量化，但要注意：静态事件同样会持有订阅者的引用，所以必须在对象销毁时取消订阅，不然一样会内存泄漏。

内容的提问来源于stack exchange，提问作者Marcus Cazzola