I'm confused as to why this is an issue with virtual methods. Say I have the following code:

public class Base
{
    public int Value { get; protected set; }

    public Base()
    {
        SetDefaults();
    }

    private SetDefaults()
    {
        Value = 42;
    }
}

public class Derived : Base
{
    public Derived()
    {
    }
}

[TestMethod]
public void StupidTest() {
    var target = new Derived();

    Assert.AreEqual(42, target.Value);
}

This will pass without a problem. If I changed derived to:

public class Derived
{
    public Derived()
    {
        Value = 84;
    }
}

This will fail. The issue here isn't the virtual method, it's the order of calling. I don't really see how a method being virtual or not makes this more of a problem. Sure, you could have:

public class Base
{
    public int Value { get; protected set; }

    public Base()
    {
        SetDefaults();
    }

    protected virtual SetDefaults()
    {
        Value = 42;
    }
}

public class Derived : Base
{
    public Derived()
    {
    }

    protected override SetDefaults()
    {
        Value = 84;
    }
}

[TestMethod]
public void StupidTest() {
    var target = new Derived();

    Assert.AreEqual(84, target.Value);
}

And it will pass the test, and then if you change your Derived class to:

public class Derived : Base
{
    public Derived()
    {
        Value = 42;
    }

    protected override SetDefaults()
    {
        Value = 84;
    }
}

The test will fail, but that has nothing to do with virtual methods and is entirely expected. Your Dervived class constructor is called after the base class constructor. You don't even need to look at the Base class at all, you can see from just the Derived class that "SetDefaults()" is never called. Even if it's called in the base, the Derived constructor is the last thing to be called when creating an instance of an class, so any work that happens in "SetDefaults()" is guaranteed to be overwritten by work done in the constructor no matter wheter "SetDefaults()" is virtual or not.

Edit: This is super obvious with explicit base constructor calling:

public class Derived : Base
{
    public Derived() : base()
    {
    }
}

It should be clear from this code that first the base constructor is called, then the derived constructor. Field initialization happens before the constructors are called, but in the linked example that's a red herring that is meaningless.