使用接口时如何避免未初始化属性，确保实例始终处于有效状态？

我完全懂你的痛点——刚切换到接口规范时，很容易遇到这种"实例创建后状态无效"的坑，本来想让代码更规范，结果反而引入了意外的null，确实闹心。下面给你几个实践中常用的解决方案，帮你在保持接口优势的同时，避免这种初始化风险：

1. 把核心初始化逻辑放回构造器，接口方法负责后续业务 #

如果你的属性必须依赖输入才能处于有效状态，那完全可以把这个输入的初始化逻辑放回构造器，接口的Handle方法只负责处理后续的业务逻辑（比如更新状态、执行操作），而不是初始化核心属性。这样既保留了接口的抽象，又确保实例创建时就处于有效状态：

internal interface IMyInterface
{
    void HandleAdditionalProcessing(); // 负责后续操作，而非初始化
}

class MyClass2 : IMyInterface
{
    public string SomePropertyDerivedFromInput { get; } // 设为只读，避免后续被意外修改
    public MyClass2(string input)
    {
        // 构造器完成核心初始化，确保属性必有效
        SomePropertyDerivedFromInput = input + " derived";
    }

    public void HandleAdditionalProcessing()
    {
        // 这里处理后续业务，比如日志、状态更新等
        Console.WriteLine($"Processing {SomePropertyDerivedFromInput}");
    }
}

// 使用时，实例创建就带输入，属性直接有效
var myClass2 = new MyClass2("hello");
Console.WriteLine(myClass2.SomePropertyDerivedFromInput ?? "null"); // 输出 hello derived
myClass2.HandleAdditionalProcessing();

这种方式最贴近你之前的安全模式，同时保留了接口的扩展性——不同的实现类可以在构造器里完成自己的初始化，再通过接口统一处理后续逻辑。

2. 用工厂模式封装实例创建+初始化的完整流程 #

如果确实需要把初始化逻辑放在Handle方法里（比如输入是动态的、需要延迟加载），那可以用工厂类来封装"创建实例+执行初始化"的完整流程，禁止外部代码直接new实例，确保拿到的实例一定是初始化完成的：

internal interface IMyInterface
{
    void Handle(string input);
    string SomePropertyDerivedFromInput { get; }
}

class MyClass2 : IMyInterface
{
    // 把构造器设为私有，外部只能通过工厂创建
    private MyClass2() {}
    public string SomePropertyDerivedFromInput { get; private set; }

    public void Handle(string input)
    {
        SomePropertyDerivedFromInput = input + " derived";
    }
}

// 工厂类负责创建+初始化的完整流程
static class MyInterfaceFactory
{
    public static IMyInterface CreateAndInitialize(string input)
    {
        var instance = new MyClass2();
        instance.Handle(input); // 强制调用初始化逻辑
        return instance;
    }
}

// 使用时，只能通过工厂获取实例，状态一定有效
var myClass2 = MyInterfaceFactory.CreateAndInitialize("hello");
Console.WriteLine(myClass2.SomePropertyDerivedFromInput ?? "null"); // 输出 hello derived

这种方式把初始化的责任从调用方转移到了工厂，调用方根本没有机会拿到未初始化的实例，从根源上避免了失误。

3. 对属性访问做防护，明确未初始化的错误 #

如果以上两种方式都不适用（比如确实需要延迟初始化），那可以在属性访问时添加检查，一旦发现未初始化就抛出明确的异常，而不是返回模糊的null——这样错误会在第一时间暴露，而不是在后续业务中悄悄引发问题：

class MyClass2 : IMyInterface
{
    private string _somePropertyDerivedFromInput;
    public string SomePropertyDerivedFromInput 
    { 
        get
        {
            // 未初始化时抛出明确异常，而非返回null
            if (_somePropertyDerivedFromInput == null)
                throw new InvalidOperationException("实例未初始化，请先调用Handle方法！");
            return _somePropertyDerivedFromInput;
        }
        private set => _somePropertyDerivedFromInput = value;
    }

    public void Handle(string input)
    {
        _somePropertyDerivedFromInput = input + " derived";
    }
}

// 使用时，如果忘记调用Handle，会直接抛出明确异常，而不是输出null
var myClass2 = new MyClass2();
// Console.WriteLine(myClass2.SomePropertyDerivedFromInput); // 这里会抛出InvalidOperationException，直接定位问题
myClass2.Handle("hello");
Console.WriteLine(myClass2.SomePropertyDerivedFromInput); // 输出 hello derived

这种方式虽然会增加一点代码，但错误信息非常明确，比悄悄返回null更容易排查问题。

4. 调整接口设计，让"初始化"成为契约的一部分 #

如果你的场景中，实例必须经过初始化才能使用，那可以把初始化逻辑直接纳入接口契约，结合不可变对象的思路，让Handle返回一个已初始化的实例：

// 调整接口，让Handle返回一个已初始化的实例（不可变设计）
internal interface IMyInterface
{
    IMyInterface Handle(string input);
    string SomePropertyDerivedFromInput { get; }
}

class MyClass2 : IMyInterface
{
    public string SomePropertyDerivedFromInput { get; }

    // 私有构造器，只允许通过Handle创建实例
    private MyClass2(string derivedValue)
    {
        SomePropertyDerivedFromInput = derivedValue;
    }

    // Handle方法返回一个新的、已初始化的实例
    public IMyInterface Handle(string input)
    {
        return new MyClass2(input + " derived");
    }
}

// 使用时，必须通过Handle获取已初始化的实例
var myClass2 = new MyClass2(string.Empty).Handle("hello");
Console.WriteLine(myClass2.SomePropertyDerivedFromInput); // 输出 hello derived

这种不可变的设计方式，确保每个实例一旦创建就处于有效状态，完全避免了未初始化的问题，但适合属性不需要后续修改的场景。

备注：内容来源于stack exchange，提问作者me.at.coding