Question

I have an Abstract class and a Derived class. The abstract class defines an abstract property named Message. In the derived class, the property is implemented by overriding the abstract property. The constructor of the derived class takes a string argument and assigns it to its Message property. In Resharper, this assignment leads to a warning “Virtual member call in constructor”.

The AbstractClass has this definition:

public abstract class AbstractClass {
    public abstract string Message { get; set; }

    protected AbstractClass() {}

    public abstract void PrintMessage();
}

And the DerivedClass is as follows:

using System;

public class DerivedClass : AbstractClass {
    private string _message;

    public override string Message {
        get { return _message; }
        set { _message = value; }
    }

    public DerivedClass(string message) {
        Message = message; // Warning: Virtual member call in a constructor
    }

    public DerivedClass() : this("Default DerivedClass message") {}

    public override void PrintMessage() {
        Console.WriteLine("DerivedClass PrintMessage(): " + Message);
    }
}

I did find some other questions about this warning, but in those situations there is an actual call to a method. For instance, in this question, the answer by Matt Howels contains some sample code. I’ll repeat it here for easy reference.

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());
    }
}

Matt doesn’t describe on what error the warning would appear, but I’m assuming it will be on the call to DoSomething in the Parent constructor. In this example, I understand what is meant by a virtual member being called. The member call occurs in the base class, in which only a virtual method exists.

In my situation however, I don’t see why assigning a value to Message would be calling a virtual member. Both the call to and the implementation of the Message property are defined in the derived class.

Although I can get rid of the error by making my Derived Class sealed, I would like to understand why this situation is resulting in the warning.

Update
Based on Brett’s answer, I did my best to create a ChildClass derived from the DerivedClass that will ultimately result in an exception. This is what I came up with:

using System;

public class ChildClass : DerivedClass {
    private readonly string _foo;

    public ChildClass() : base("Default ChildClass Message") {
        _foo = "ChildClass foo";
    }

    public override string Message {
        get { return base.Message; }
        set {
            base.Message = value;
            Console.WriteLine(_foo.ToUpper() + " received " + value);
        }
    }
}

Off course it’s a bit silly to be using _foo in the Message setter, but the point is that ReSharper doesn’t see anything wrong with this class.

If however, you try to use the ChildClass in a program like this:

internal class Program {
    private static void Main() {
        var childClass = new ChildClass();
        childClass.PrintMessage();
    }
}

You’ll get a NullReferenceException when creating the ChildClass object. The exception will be thrown by the ChildClass’ attempt to use _foo.ToUpper() as _foo isn’t initialized yet.

Answer 1

It’s because your Message property can be overridden by class ChildClass : DerivedClass – at which point it’s possible to invoke code in Message on ChildClass from the ctor in DerivedClass, and your ChildClass instance may not be full initialised.

That’s why making your DerivedClass sealed solves the problem – it cannot be inherited.