Are these Virtual Member Call in Constructor warnings legitimate?

I'm getting Resharper warnings here in the base form where I set the EditMyDataObject property, and in the extended form where I grab the Text value and then restore it afterwards.

In both cases nothing is blowing up when I run the app. I don't think there's any potential for problems as implemented because my overridden property doesn't depend on anything initialized in the constructor, but would appreciate a 2nd opinion before gagging Resharper.

public class MyDataObject
{
    //Data Members

    public MyDataObject()
    {
    }
}

public class MyDataObjectEx : MyDataObject
{
    //Data Members

    public MyDataObjectEx()
    {
    }

    public MyDataObjectEx(MyDataObject myDataObject)
    {
    }       
}

public partial class MyDataObjectEditFrm : Form
{
    private MyDataObject _myDataObject;

    protected virtual MyDataObject EditMyDataObject
    {
        get { return _myDataObject; }
        set { _myDataObject = value; }
    }

    /// <summary>
    /// Parameterless constructor needed for designer support of derived classes.
    /// </summary>
    protected MyDataObjectEditFrm()
    {
        InitializeComponent();
    }

    protected MyDataObjectEditFrm(MyDataObject myDataObject)
    {
        InitializeComponent();
        EditMyDataObject = myDataObject;  // Warning: Virtual member call in a constructor

        Text = GetDialogNameFromInputParameters()

        //Remainder of initialization here
    }

    GetDialogNameFromInputParameters()
    {
        //Figure out what the text should be
    }
}


public partial class MyDataObjectExEditFrm : MyDataObjectEditFrm
{
    private MyDataObjectEx _myDataObjectEx;

    protected override MyDataObject EditMyDataObject
    {
        get { return _myDataObjectEx; }
        set
        {
            if (value == null)
                _myDataObjectEx = null;
            else _myDataObjectEx = value as MyDataObjectEx ?? new MyDataObjectEx(value);
        }

    }

    public MyDataObjectExEditFrm(MyDataObject myDataObject) : base(myDataObject)
    {
        //preserve the value computed and set in the base class to prevent the generic form name from the designer overriding it here
        string dialogText = Text; // Warning: Virtual member call in a constructor
        InitializeComponent();
        Text = dialogText; // Warning: Virtual member call in a constructor


        //Remainder of additional initialization for extended data here
    }
}

• EDIT: wrong, thanks Daniel If you want, you can remove the first warning by setting the underlying variable instead of property. I don't have an opinion on this being a good idea or not, I'm just saying. - jv42
• @jv42: That would change the behavior. Have a look at the overridden property, it has some logic in it... - Daniel Hilgarth
• @vj42: I think I tried that, but it caused problems when MyDataObjectExEditForm was only passed a base MyDataObject because it wasn't converted to a MyDataObjectEx - Dan Neely
• Yes sorry, I missed the fact that you were actually overriding it in the derived class. - jv42
• You can always pipe the virtual call into an abstract method, which forces any derived classes to implement this abstract method. This means that its impossible for the class not to implement the method, which means that there can never be any errors with missing methods in an inherited class. This future proofs your class. - Contango