What are virtual methods in C#? Explain why members are non-virtual by default, how a virtual call is dispatched at run time, what it costs, when the JIT can devirtualise it, and what can and cannot be virtual.

1. Vtable layout

Shipping MethodTable           ExpressShipping MethodTable
 slot 0: Object.ToString        slot 0: Object.ToString
 slot 1: Object.Equals          slot 1: Object.Equals
 slot 2: Object.GetHashCode     slot 2: Object.GetHashCode
 slot 3: Object.Finalize        slot 3: Object.Finalize
 slot 4: Shipping.Cost  ----->  slot 4: ExpressShipping.Cost   (override replaces slot)

New virtual methods in a derived class get new slots after the inherited ones. A new virtual (hiding) method also gets a new slot (newslot in IL), which is why calls through the base type still hit the base slot.

2. Machine code

; s.Cost(order) with s in rcx
mov  rax, qword ptr [rcx]          ; MethodTable*
mov  rax, qword ptr [rax+40h]      ; vtable chunk pointer
call qword ptr [rax+20h]           ; slot 4

CoreCLR splits vtables into chunks shared between parent and child where slots aren't overridden, saving memory — hence the two loads.

3. Guarded devirtualisation (GDV) example

With dynamic PGO, tier-0 code records which MethodTables appear at a call site. If one dominates, tier-1 emits:

if (obj->MethodTable == ExpressShipping_MT)
    result = 25m;                    // inlined body
else
    result = obj->vtable[4](obj, o); // fallback virtual call

The check is a single compare; the common path becomes inlined code. For megamorphic sites (many types), GDV may not apply. You can observe this with DOTNET_JitDisasm on tier-1 code, or BenchmarkDotNet's disassembler.

4. Virtual calls in constructors and the order of initialisation

Because the object's MethodTable is the most-derived type from the moment of allocation, virtual calls from a base constructor dispatch to derived overrides before the derived constructor runs. CA2214 warns about this; it's a correctness issue, not a performance one.

5. Interface methods, abstract methods and static virtual

• Abstract methods: vtable slots without implementation in the base.
• Interface methods: dispatched via virtual stub dispatch (per-call-site caches), not fixed vtable slots.
• static virtual / static abstract interface members (C# 11): resolved per generic instantiation via constrained calls — no runtime dispatch for value types; used in generic math.

6. Designing virtual members

If you make a member virtual, you're promising:

• which other members call it (self-use) and when,
• what state it may rely on,
• whether overrides must call base.

The Framework Design Guidelines advise: avoid virtual members unless there's a clear scenario; prefer protected virtual hooks called from non-virtual public methods (template method / "non-virtual interface" idiom), so the base keeps control of preconditions and postconditions.

Try it yourself

1. Benchmark virtual vs non-virtual vs sealed calls of a tiny method in a loop.
2. Inspect tier-1 disassembly for a call site that always sees one type, with dynamic PGO on and off (DOTNET_TieredPGO=0).
3. Try declaring virtual on a static method, a field and a struct method and read the errors.
4. Implement the non-virtual-interface idiom: public non-virtual method calling a protected virtual ...Core method.

public class Account
{
    public decimal Balance { get; protected set; }

    // Non-virtual public method, virtual protected hook (NVI idiom)
    public void ApplyMonthlyFee()
    {
        var fee = CalculateFee();
        if (fee < 0) throw new InvalidOperationException("Negative fee");
        Balance -= fee;
    }

    protected virtual decimal CalculateFee() => 5m;
    public override string ToString() => $"{GetType().Name}: {Balance:C}";
}

public sealed class StudentAccount : Account          // sealed: calls can devirtualise
{
    protected override decimal CalculateFee() => 0m;
}

public class PremiumAccount : Account
{
    protected override decimal CalculateFee() =>
        Balance > 10_000m ? 0m : base.CalculateFee() * 2;  // base call is non-virtual
}

// Rules the compiler enforces
public class Rules
{
    // private virtual void A() {}       // CS0621
    // public static virtual void B() {} // error: static virtual only in interfaces
    public virtual int Count { get; set; } // properties can be virtual
    public virtual event EventHandler? Changed;
}