Виртуальный член вызова в конструкторе

Существует различие между C++ и C# в этом конкретном случае. В C++ не инициализируется объект, и поэтому небезопасно вызвать virutal функцию в конструкторе. В C#, когда объект класса создается, все его участники являются инициализированным нулем. Возможно вызвать виртуальную функцию в конструкторе, но если Вы будете, мог бы получить доступ к участникам, которые являются все еще нулевыми. Если Вы не должны получать доступ к участникам, довольно безопасно вызвать виртуальную функцию в C#.

Поскольку, пока конструктор не завершил выполнение, объект не полностью инстанцируют. Любые участники, на которых ссылается виртуальная функция, не могут быть инициализированы. В C++, когда Вы находитесь в конструкторе, this только, относится к статическому типу конструктора, Вы находитесь в, а не фактический динамический тип объекта, который создается. Это означает, что вызов виртуальной функции даже не мог бы пойти, где Вы ожидаете его к.

Да, это вообще плохо для вызова виртуального метода в конструкторе.

На данном этапе objet еще не может быть полностью создан, и инварианты, ожидаемые методами еще, не могут содержать.

В C#, выполнения конструктора базового класса прежде конструктор производного класса, таким образом, любые поля экземпляра, которые производный класс мог бы использовать в возможно переопределенном виртуальном участнике, еще не инициализируются.

Действительно отмечают, что это просто предупреждение , чтобы заставить Вас обратить внимание и удостовериться, что это в порядке. Существуют фактические примеры использования для этого сценария, Вы просто имеете к , документируют поведение из виртуального участника, что это не может использовать поля экземпляра, объявленные в производном классе ниже, где конструктор, называющий его.

Причины предупреждения уже описаны, но как Вы зафиксировали бы предупреждение? Необходимо изолировать или класс или виртуального участника.

  class B
  {
    protected virtual void Foo() { }
  }

  class A : B
  {
    public A()
    {
      Foo(); // warning here
    }
  }

можно изолировать класс A:

  sealed class A : B
  {
    public A()
    {
      Foo(); // no warning
    }
  }

Или можно изолировать метод Foo:

  class A : B
  {
    public A()
    {
      Foo(); // no warning
    }

    protected sealed override void Foo()
    {
      base.Foo();
    }
  }

Правила C# очень отличаются от того из Java и C++.

, Когда Вы находитесь в конструкторе для некоторого объекта в C#, тот объект существует в полностью инициализированный (просто не "созданный") форма как ее полностью производный тип.

namespace Demo
{
    class A 
    {
      public A()
      {
        System.Console.WriteLine("This is a {0},", this.GetType());
      }
    }

    class B : A
    {      
    }

    // . . .

    B b = new B(); // Output: "This is a Demo.B"
}

Это означает, что, если Вы вызываете виртуальную функцию от конструктора A, это решит к любому переопределению в B, если Вам предоставят.

Даже при намеренной установке A и B как это, полностью понимая поведение системы, Вы могли быть в для шока позже. Скажите, что Вы вызвали виртуальные функции в конструкторе B, "зная", что они будут обработаны B или как соответствующие. Тогда передачи времени, и кто-то еще решает, что они должны определить C и переопределить некоторые виртуальные функции там. Внезапно конструктор B заканчивает код вызова в C, который мог привести к довольно удивительному поведению.

Это - вероятно, хорошая идея избежать виртуальных функций в конструкторах так или иначе, так как правила настолько отличающиеся между C#, C++ и Java. Ваши программисты не могут знать, что ожидать!

Для ответа на вопрос рассмотрите этот вопрос: что будет ниже кода, распечатывают, когда эти Child объект инстанцируют?

class Parent
{
    public Parent()
    {
        DoSomething();
    }

    protected virtual void DoSomething() 
    {
    }
}

class Child : Parent
{
    private string foo;

    public Child() 
    { 
        foo = "HELLO"; 
    }

    protected override void DoSomething()
    {
        Console.WriteLine(foo.ToLower()); //NullReferenceException!?!
    }
}

ответ - то, что на самом деле NullReferenceException будет брошен, потому что foo является пустым. основного конструктора объекта вызывают перед его собственным конструктором . При наличии virtual вызов в конструкторе объекта Вы представляете возможность, что наследование объектов выполнит код, прежде чем они были полностью инициализированы.

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

Однако, если Ваш дизайн удовлетворяет принцип замены Лисков, никакой вред не будет причинен. Вероятно, вот почему это терпело - предупреждение, не ошибка.

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

internal class Parent
{
    public Parent()
    {
        Console.WriteLine("Parent ctor");
        Console.WriteLine(Something);
    }

    protected virtual string Something { get; } = "Parent";
}

internal class Child : Parent
{
    public Child()
    {
        Console.WriteLine("Child ctor");
        Console.WriteLine(Something);
    }

    protected override string Something { get; } = "Child";
}

риск здесь состоял бы в том, чтобы дочерний класс установил свойство от своего конструктора, в этом случае, изменение в значении произошло бы после того, как конструктора базового класса вызвали.

Мой вариант использования - то, что я хочу, чтобы дочерний класс обеспечил определенное значение или служебный класс, такой как преобразователь, и я не хочу должным быть называть метод инициализации на основе.

вывод вышеупомянутого при инстанцировании дочернего класса:

Parent ctor
Child
Child ctor
Child