Вызов виртуального метода в конструкторе: в чем опасность и как избежать?

Почему вызов виртуального метода в конструкторе — это проблема?

ReSharper предупреждает не просто так. Дело в том, что при создании объекта производного класса конструктор базового класса выполняется до конструктора производного. Это значит, что когда вы вызываете виртуальный метод Initialize внутри конструктора Animal, объект Dog еще не полностью инициализирован. Поля производного класса (Breed) еще имеют значения по умолчанию (null), а не те, которые вы могли бы задать в конструкторе Dog.

Хуже того: если в переопределении виртуального метода используется поле, которое инициализируется в конструкторе производного класса, вы получите логическую ошибку или NullReferenceException. Вот классический пример проблемы:

public class Base
{
    public Base()
    {
        Print(); // Вызов виртуального метода
    }
    public virtual void Print()
    {
        Console.WriteLine("Base");
    }
}

public class Derived : Base
{
    private readonly string _message = "Hello from Derived";
    
    public Derived() : base() // Сначала выполняется Base()
    {
        // _message еще не присвоено!
    }
    
    public override void Print()
    {
        // В этот момент _message = null!
        Console.WriteLine(_message.ToUpper()); // NullReferenceException!
    }
}

Почему это происходит? Порядок инициализации объекта в C#:

• Инициализируются поля базового класса (в порядке их объявления).
• Вызывается конструктор базового класса.
• Инициализируются поля производного класса.
• Вызывается конструктор производного класса.

В нашем примере _message инициализируется после выполнения конструктора Base. Когда Print() вызывается из Base(), поле _message еще null — отсюда исключение.

Как исправить?

Есть несколько подходов, каждый подходит для разных ситуаций:

1. Сделать метод не виртуальным (если это возможно)

public class Animal
{
    public string Name { get; set; }
    public Animal(string name)
    {
        Name = name;
        Console.WriteLine("Animal initialized");
    }
}

2. Вызывать метод после завершения конструкции (Factory Method)

public class Animal
{
    public string Name { get; set; }
    public virtual void Initialize(string name)
    {
        Name = name;
        Console.WriteLine("Animal initialized");
    }
    
    // Защищенный конструктор
    protected Animal() { }
    
    // Фабричный метод
    public static T Create<T>(string name) where T : Animal, new()
    {
        T animal = new T();
        animal.Initialize(name);
        return animal;
    }
}

// Использование:
// Dog dog = Animal.Create<Dog>("Rex");

3. Использовать шаблон Template Method (в конструкторе вызывать только невиртуальный метод, который делегирует виртуальному)

public class Animal
{
    public string Name { get; set; }
    
    public Animal(string name)
    {
        // Безопасно — метод не виртуальный
        InitializeCore(name);
    }
    
    // Невиртуальный "скелет"
    private void InitializeCore(string name)
    {
        Name = name;
        // Дополнительная логика до вызова виртуального метода
        OnInitialized();
    }
    
    // Виртуальный метод для переопределения, но он вызывается ПОСЛЕ инициализации базового класса
    protected virtual void OnInitialized()
    {
        Console.WriteLine("Animal initialized");
    }
}

public class Dog : Animal
{
    public string Breed { get; set; }
    
    public Dog(string name, string breed) : base(name)
    {
        Breed = breed; // Теперь это безопасно
    }
    
    protected override void OnInitialized()
    {
        // Внимание: Breed еще не инициализирован!
        // Console.WriteLine(Breed.Length); // Ошибка!
        Console.WriteLine("Dog initialized");
    }
}

Этот подход требует осторожности — в OnInitialized нельзя полагаться на поля производного класса.

4. Вынести логику инициализации из конструктора (рекомендуемый способ для сложных случаев)

public class Animal
{
    public string Name { get; set; }
    
    public Animal(string name)
    {
        Name = name;
    }
    
    public virtual void AfterConstruction()
    {
        Console.WriteLine("Animal ready");
    }
}

// Использование:
// Dog dog = new Dog("Rex", "Labrador");
// dog.AfterConstruction(); // Явный вызов после создания

Вывод

Главное правило: конструктор не должен вызывать виртуальные методы. Это гарантирует, что объект полностью инициализирован перед тем, как любой переопределенный метод начнет работать с его состоянием. Если вам нужна полиморфная инициализация, используйте фабричные методы или явный вызов после конструктора.

public interface IAnimalInitializer
{
    void Initialize(Animal animal);
}

public class Animal
{
    public string Name { get; private set; }
    private readonly IAnimalInitializer _initializer;

    public Animal(string name, IAnimalInitializer initializer = null)
    {
        Name = name;
        _initializer = initializer;
        // Вызываем инициализатор, если он предоставлен
        _initializer?.Initialize(this);
    }
}

public class DogInitializer : IAnimalInitializer
{
    public void Initialize(Animal animal)
    {
        if (animal is Dog dog)
        {
            dog.Breed = "Unknown"; // Но это нарушает принцип подстановки Лисков
            Console.WriteLine("Dog initialized");
        }
    }
}