如何在初始化阶段绑定事件以避免两阶段初始化（Two-Phase-Initialization）？

让我来给你几个优雅的解决方案，彻底摆脱两阶段初始化的麻烦：

方案1：构造函数注入事件处理委托 #

这个方案直接把事件处理逻辑强制在创建对象时就传入，构造函数内部完成事件绑定+初始化操作，从根源上避免了“先绑定事件再调用init”的顺序问题，也不会出现忘记初始化的情况。

修改后的代码示例：

public delegate void ErrorHandling(int value);

public class ExampleClass {
    public int Value { get; }
    public event ErrorHandling OnError;

    // 构造函数同时接收业务参数和事件处理委托
    public ExampleClass(int value, ErrorHandling errorHandler) {
        Value = value;
        // 绑定事件（如果传入了处理逻辑）
        OnError += errorHandler;
        // 直接执行初始化逻辑，此时事件已经绑定完成
        Initialize();
    }

    private void Initialize() {
        // 这里做原本init里的初始化操作
        OnError?.Invoke(Value); // 事件触发时已有处理逻辑
    }
}

// 调用示例
int Main() {
    // 创建对象时一步到位，无需后续操作
    var example = new ExampleClass(2, val => {
        Console.WriteLine($"处理错误：值为{val}");
    });
    return 0;
}

如果业务上允许“无事件处理”的场景，可以重载一个不带errorHandler参数的构造函数，但建议优先使用带委托的构造函数，强制调用方考虑事件处理逻辑。

方案2：工厂方法封装完整初始化流程 #

把对象的创建、事件绑定、初始化逻辑全部封装到静态工厂方法里，外部代码只能通过工厂方法获取完全初始化完成的对象，彻底杜绝未初始化对象被使用的可能。

示例代码：

public delegate void ErrorHandling(int value);

public class ExampleClass {
    public int Value { get; }
    public event ErrorHandling OnError;
    // 私有构造函数，禁止外部直接创建对象
    private ExampleClass(int value) {
        Value = value;
    }

    private void Initialize() {
        // 执行初始化逻辑
        OnError?.Invoke(Value);
    }

    // 静态工厂方法，对外提供对象创建入口
    public static ExampleClass Create(int value, ErrorHandling errorHandler) {
        var instance = new ExampleClass(value);
        // 绑定事件
        instance.OnError += errorHandler;
        // 执行初始化
        instance.Initialize();
        return instance;
    }

    // 重载工厂方法，支持无事件处理的场景
    public static ExampleClass Create(int value) {
        return Create(value, null);
    }
}

// 调用示例
int Main() {
    var example = ExampleClass.Create(2, val => {
        Console.WriteLine($"处理错误：值为{val}");
    });
    // 此时对象已经完全就绪，可以直接使用
    return 0;
}

这个方案的优势是封装性极强，外部完全不需要关心内部的初始化流程，拿到的对象一定是可用状态，适合复杂初始化场景。

方案3：延迟初始化（适用于非立即触发事件的场景） #

如果你的初始化事件不需要在对象创建后立刻触发，可以把初始化逻辑延迟到第一次使用对象的公共成员时执行。这样调用方可以先绑定事件，再通过访问属性/调用方法触发初始化，避免事件丢失。

示例代码：

public delegate void ErrorHandling(int value);

public class ExampleClass {
    private int _value;
    public event ErrorHandling OnError;
    private bool _isInitialized = false;

    public int Value {
        get {
            EnsureInitialized();
            return _value;
        }
    }

    public ExampleClass(int value) {
        _value = value;
    }

    // 确保初始化只执行一次
    private void EnsureInitialized() {
        if (!_isInitialized) {
            // 执行初始化逻辑
            OnError?.Invoke(_value);
            _isInitialized = true;
        }
    }

    // 所有公共方法都要先调用EnsureInitialized
    public void DoBusinessLogic() {
        EnsureInitialized();
        // 业务逻辑代码
    }
}

// 调用示例
int Main() {
    var example = new ExampleClass(2);
    // 先绑定事件
    example.OnError += val => {
        Console.WriteLine($"处理错误：值为{val}");
    };
    // 第一次访问Value时触发初始化和事件
    var val = example.Value;
    return 0;
}

这个方案比较灵活，但要注意所有公共成员都必须调用EnsureInitialized，否则可能出现部分成员未初始化的情况。

总结 #

优先推荐方案1或方案2，它们从设计层面杜绝了两阶段初始化的隐患，确保对象创建即就绪。如果业务场景特殊无法强制绑定事件，再考虑方案3。

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