虚方法在构造函数中的调用陷阱：深入理解C#多态机制

guchen66
3 阅读4分钟

问题背景

在C#开发中，我们经常使用继承和多态来构建灵活的代码结构。但在构造函数中调用虚方法时，可能会遇到一个隐蔽的陷阱：子类的属性可能还未初始化，导致获取到null值。本文将深入分析这个问题的根本原因，并提供解决方案。

核心问题示例

让我们从一个实际场景开始，假设我们正在构建一个组件系统：

class Config
{
    public override string ToString()
    {
        return "Config";
    }
}
​
class BaseComponent
{
    public BaseComponent(Config config)
    {
        Config = config;
        Initialize();
    }
​
    public virtual Config Config { get; }
    
    public virtual void Initialize()
    {
    }
}
​
class DerivedComponent : BaseComponent
{
    public DerivedComponent(Config config) : base(config)
    {
        Config = config;
    }
​
    public override Config Config { get; }
    
    public override void Initialize()
    {
        var config = Config;
        Console.WriteLine($"DerivedComponent.Initialize: Config={config}");
    }
}
​
class Program
{
    static void Main(string[] args)
    {
        Config config = new Config();
        DerivedComponent component = new DerivedComponent(config);
        component.Initialize();
    }
}

运行结果会是什么？你可能会惊讶地发现：

DerivedComponent.Initialize: Config=null
DerivedComponent.Initialize: Config=Config

是的，第一次调用Initialize()时，Config是null，而第二次调用时才有值。

执行流程分析

1. 构造函数执行顺序

当创建DerivedComponent实例时，执行流程如下：

  1. 进入DerivedComponent构造函数：public DerivedComponent(Config config) : base(config)

  2. 跳转到BaseComponent构造函数：执行base(config)

  3. 在BaseComponent构造函数中：

    • 执行Config = config;：给BaseComponent.Config赋值
    • 执行Initialize();：调用虚方法，实际执行DerivedComponent.Initialize()

  4. 执行DerivedComponent.Initialize() ：

    • 此时DerivedComponent构造函数还未执行到Config = config;
    • 所以var config = Config;获取到的是null

  5. 返回DerivedComponent构造函数：继续执行Config = config;

  6. 在Main方法中：调用component.Initialize()，此时Config已有值

2. 内存状态分析

执行过程中，对象的内存状态变化如下：

执行时刻BaseComponent.ConfigDerivedComponent.Config
BaseComponent构造函数刚执行完Config = config✅ 有值❌ null
BaseComponent构造函数执行Initialize()时✅ 有值❌ null
DerivedComponent构造函数执行Config = config后✅ 有值✅ 有值
Main中调用component.Initialize()时✅ 有值✅ 有值

根本原因

1. 多态机制的作用

在BaseComponent构造函数中调用Initialize()时，虽然执行的是BaseComponent的代码，但当前对象的真实类型是DerivedComponent。因此，虚方法调用会根据对象的实际类型（运行时类型）来决定执行哪个实现，而不是根据当前代码所在的类（编译时类型）。

2. 两个独立的属性

BaseComponent.Config和DerivedComponent.Config是两个独立的属性：

  • BaseComponent.Config：基类定义的虚属性
  • DerivedComponent.Config：子类重写的属性

当在BaseComponent构造函数中执行Config = config;时，编译器根据代码所在的类（BaseComponent）决定绑定到BaseComponent.Config，而不是DerivedComponent.Config。

3. 只读属性的构造函数初始化

C#中有一个特殊设计：只读自动属性（只有get访问器）可以在构造函数中赋值。这是因为构造函数负责初始化对象状态，应该能设置只读成员。

// 只读属性在构造函数中可以赋值
public override Config Config { get; }
​
public DerivedComponent(Config config) : base(config)
{
    Config = config; // 合法，直接初始化后备字段
}

但这种初始化是直接操作后备字段，而不是通过setter方法。因此，在BaseComponent构造函数中赋值的是BaseComponent.Config的后备字段，而不是DerivedComponent.Config的。

解决方案

1. 添加set访问器

如果将属性改为可读写，问题就解决了：

class BaseComponent
{
    public virtual Config Config { get; set; }
    // ...
}
​
class DerivedComponent : BaseComponent
{
    public override Config Config { get; set; }
    // ...
}

这样，在BaseComponent构造函数中执行Config = config;时，会调用虚方法set_Config，由于多态机制，实际执行的是DerivedComponent的setter，从而给DerivedComponent.Config赋值。

2. 避免在构造函数中调用虚方法

更安全的做法是避免在构造函数中调用虚方法，而是使用其他初始化方法：

class BaseComponent
{
    public BaseComponent(Config config)
    {
        Config = config;
        // 不在这里调用虚方法
    }
    
    public void Start()
    {
        Initialize(); // 在对象完全构造后调用
    }
    
    protected virtual void Initialize() { }
    // ...
}
​
// 使用方式
DerivedComponent component = new DerivedComponent(config);
component.Start(); // 此时所有属性都已初始化

框架设计中的应用

虽然这是一个陷阱，但在框架设计中也可以巧妙利用：

1. 模板方法模式的变体

public abstract class DatabaseMigrationBase
{
    protected DatabaseMigrationBase(string connectionString)
    {
        ConnectionString = connectionString;
        RegisterMigrations(); // 虚方法，由子类实现
    }
    
    public string ConnectionString { get; }
    public List<MigrationScript> Scripts { get; } = new();
    
    protected abstract void RegisterMigrations();
    
    public void Execute()
    {
        // 执行迁移逻辑...
    }
}

2. 强制子类提供构造期常量

public abstract class FeatureFlagBase
{
    public FeatureFlagBase()
    {
        FeatureName = GetFeatureName(); // 虚方法，子类返回字符串常量
        IsEnabled = CheckFeatureEnabled();
    }
    
    public string FeatureName { get; }
    public bool IsEnabled { get; }
    
    protected abstract string GetFeatureName();
    protected virtual bool CheckFeatureEnabled() => true;
}

总结

  1. 构造函数中调用虚方法是个陷阱：多态已经激活，但子类状态还没准备好
  2. this指向真实对象：即使在基类构造函数中，this指向的也是正在被构造的子类对象
  3. 虚方法看运行时类型：无论变量声明为什么类型，虚方法调用只取决于对象的真实类型
  4. 属性绑定看编译时位置：在基类代码中访问的是基类的属性，在子类代码中访问的是子类的属性
  5. 只读属性的特殊初始化：只读自动属性可以在构造函数中赋值，但这是直接操作后备字段

通过理解这些机制，我们可以避免陷阱，同时在框架设计中巧妙利用这些特性。

参考资料

本文基于林德熙大佬的博客总结：blog.lindexi.com/

avatar
文章
阅读
粉丝