How do methods work in C#? Explain instance versus static methods, method signatures and overloading (and how overload resolution picks a method), expression-bodied methods, and extension methods including the C# 14 extension members syntax.

1. Instance methods: the hidden this

In IL, an instance method has an implicit first argument ldarg.0 = this. Calls use call or callvirt:

• C# emits callvirt for almost all instance calls on reference types — even non-virtual ones — because callvirt performs a null check on the receiver, giving you NullReferenceException at the call site rather than inside the method.
• For virtual methods, callvirt dispatches through the method table (vtable). For interface methods, the runtime uses virtual stub dispatch with per-call-site caches.
• Static methods use plain call: no receiver, no null check, no dispatch — which makes them easy to inline.

For structs, this is a managed reference (ref T) to the struct, which is why a mutating struct method changes the variable it is called on (and why calling it on a copy changes the copy).

2. Overload resolution details worth knowing

Better conversion target rules (simplified):

1. Identity conversion beats any other.
2. If there is an implicit conversion from T1 to T2 but not back, T1 is better (string is better than object; int is better than long).
3. Signed integral types beat unsigned ones for the same size in certain cases (int over uint).
4. For lambdas, the candidate whose delegate return type matches the lambda body better wins.

Tie-breakers when conversions are equal:

• Non-generic beats generic (M(string) over M<T>(T)).
• More specific generic beats less specific (M<T>(List<T>) over M<T>(T)).
• Normal form beats params expanded form.
• A candidate with all arguments matching explicitly beats one needing default values.
• C# 13 added OverloadResolutionPriorityAttribute, letting library authors steer callers toward a new overload (e.g. a span overload) without breaking existing ones.
• C# 13/14 also prefer ReadOnlySpan<T> overloads with first-class span conversions in more cases.

The base/derived trap: if a derived class declares an applicable method, the compiler does not even consider base-class overloads that might be a better match:

class Base    { public void Write(int x) => Console.WriteLine("Base.int"); }
class Derived : Base { public void Write(double x) => Console.WriteLine("Derived.double"); }

new Derived().Write(5);   // "Derived.double" - int converts to double

3. Overloading vs overriding vs hiding

Hiding with new is almost always a smell — which method runs depends on the variable's declared type.

4. How extension methods are compiled and resolved

name.IsBlank();
// compiles to
StringExtensions.IsBlank(name);

The method is marked with [Extension] in metadata. Lookup order:

1. The compiler first tries instance members of the receiver's type. If any applicable instance method exists, extension methods are not considered.
2. Otherwise it searches static classes in enclosing namespaces, then using directives, from the innermost scope outwards, stopping at the first scope that has an applicable candidate.

Consequences:

• Adding an instance method with the same name to a type silently changes which method runs in all callers on the next compile.
• Two extensions with the same signature in different imported namespaces → ambiguity error, or a silent switch if one scope is "closer".
• Extensions on interfaces (IEnumerable<T>) are how LINQ adds dozens of operators without changing the interface.

5. C# 14 extension members under the hood

The extension(Receiver r) { ... } block declares members for a receiver type. The compiler emits:

• Ordinary static methods (so existing callers and reflection see familiar methods), plus
• Metadata describing the extension block, so the compiler can expose extension properties (orders.IsEmpty), static extension members (IEnumerable<T>.Empty), and user-defined operators on types you do not own.

The disambiguation syntax still exists: you can call EnumerableExtensions.get_IsEmpty(orders)-style members via the containing static class when two extensions clash. Extension properties are still computed on every access — they cannot add state to the target type.

6. Static abstract interface members (C# 11)

Static methods can now take part in polymorphism through generics:

public interface IParsable<TSelf> where TSelf : IParsable<TSelf>
{
    static abstract TSelf Parse(string s, IFormatProvider? provider);
}

static T ParseAll<T>(string s) where T : IParsable<T> => T.Parse(s, CultureInfo.InvariantCulture);

This is the basis of .NET 7+ generic math (INumber<T>). The call is resolved per closed generic type, with no virtual dispatch at run time for value types.

Try it yourself

1. Reproduce the base/derived overload trap and fix it with a using-free design or by adding the overload to the derived class.
2. Add an instance method with the same name as an existing extension method and watch call sites switch silently.
3. Write a C# 14 extension property on IEnumerable<T> and look at the generated metadata in ILSpy.
4. Call Log(null) with Log(object) and Log(string), then add Log(Uri) and read CS0121.

public sealed class Order
{
    private readonly List<OrderLine> _lines = [];

    // Static factory: no 'this', validates input
    public static Order Create(int customerId)
    {
        ArgumentOutOfRangeException.ThrowIfNegativeOrZero(customerId);
        return new Order { CustomerId = customerId };
    }

    public int CustomerId { get; private init; }

    // Overloads: same intent, different inputs
    public void AddLine(OrderLine line) => _lines.Add(line);
    public void AddLine(string sku, int quantity, decimal price) =>
        AddLine(new OrderLine(sku, quantity, price));

    // Expression-bodied instance method
    public decimal Total() => _lines.Sum(l => l.Quantity * l.Price);
}

public sealed record OrderLine(string Sku, int Quantity, decimal Price);

// Classic extension method
public static class OrderExtensions
{
    public static bool IsLarge(this Order order) => order.Total() > 1_000m;
}

// C# 14 extension members: methods, properties and static members
public static class StringExtensions
{
    extension(string? s)
    {
        public bool IsBlank => string.IsNullOrWhiteSpace(s);              // extension property
        public string Truncate(int max) =>
            s is null ? "" : s.Length <= max ? s : s[..max];
    }

    extension(string)
    {
        public static string JoinLines(IEnumerable<string> lines) =>     // static extension
            string.Join(Environment.NewLine, lines);
    }
}

// Usage
var order = Order.Create(customerId: 7);
order.AddLine("SKU-1", 2, 19.95m);
bool large = order.IsLarge();
bool blank = "  ".IsBlank;
string text = string.JoinLines(["a", "b"]);