如何在不使用全局变量的情况下让对象实现全局访问？

方案一：手动构造函数传递（轻量级依赖注入） #

不用依赖注入框架也能实现依赖传递——在程序的入口点（比如main函数、启动类）创建好你的TManager实例，然后把它通过构造函数传给所有需要它的类。

举个C#示例：

public static void Main()
{
    // 先加载配置和其他共享对象
    var appConfig = LoadAppConfig();
    var sharedDataService = new SharedDataService();
    
    // 创建管理器实例
    var manager = new TManager(appConfig, sharedDataService);
    
    // 把管理器传给需要的类
    var userService = new UserService(manager);
    var orderProcessor = new OrderProcessor(manager);
    
    // 启动业务逻辑
    userService.ProcessUserRequests();
}

这种方式完全没有全局变量，所有依赖都是显式传递的，你能清楚看到哪些类用到了共享对象，测试时还能轻松替换TManager的实例（比如传一个模拟的配置对象）。

方案二：受控单例模式 #

如果实在不想每个类都传构造参数，可以用受控初始化的单例，而非随意定义的全局变量。核心是把单例的初始化逻辑放在启动阶段，禁止外部随意创建实例：

举个Java示例：

public class TManager {
    private static TManager instance;
    private final AppConfig config;
    private final SharedService sharedService;

    // 私有构造，禁止外部创建
    private TManager(AppConfig config, SharedService sharedService) {
        this.config = config;
        this.sharedService = sharedService;
    }

    // 仅在启动时调用的初始化方法
    public static void initialize(AppConfig config, SharedService sharedService) {
        if (instance != null) {
            throw new IllegalStateException("TManager已经初始化过了");
        }
        instance = new TManager(config, sharedService);
    }

    // 获取实例的方法
    public static TManager getInstance() {
        if (instance == null) {
            throw new IllegalStateException("TManager还没初始化，请先调用initialize方法");
        }
        return instance;
    }
}

使用时，在程序启动时先调用TManager.initialize(...)，之后其他类就可以通过TManager.getInstance()获取实例了。这种方式避免了全局变量的随意性，你能严格控制初始化时机，测试时也可以加个仅用于测试的重置方法来替换实例。

方案三：上下文参数传递 #

如果有些类只是在执行特定方法时需要访问共享对象，没必要把TManager存成类成员，可以直接把它作为方法参数传递：

举个Python示例：

class PaymentHandler:
    def process_payment(self, amount, context: TManager):
        # 从上下文拿配置和共享服务
        payment_config = context.get_payment_config()
        payment_gateway = context.get_payment_gateway()
        
        # 执行支付逻辑
        payment_gateway.charge(amount, payment_config.currency)

# 调用时
manager = TManager(app_config, payment_gateway)
handler = PaymentHandler()
handler.process_payment(100.0, manager)

这种方式适合临时需要访问共享对象的场景，减少类的长期依赖，代码更灵活。

核心思路总结 #

不管选哪种方案，核心都是把共享对象的创建和生命周期管理集中到程序启动阶段，而不是让它变成随处可见的全局变量。这样既能保证需要的类能访问到共享对象，又能保持代码的可维护性——比如你想替换配置对象时，只需要修改启动入口的代码，不用到处找全局变量的引用。

你之前觉得依赖注入不合适，其实手动的构造函数传递就是最基础的DI，完全不需要框架，既满足了共享需求，又比全局变量可控得多。

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