What is the difference between a class and an object in C#? Explain how an object is created with new, where it lives, what instance and static members belong to, and how object identity differs from object equality.

1. The class at run time: metadata and MethodTable

When the compiler builds a class it emits metadata (TypeDef, fields, methods, signatures) and IL. At run time, the first use of the type makes the CLR build:

• a MethodTable: type identity, base type pointer, interface map, vtable (slots for virtual methods), base size of instances, and GC info describing which fields are references;
• an EEClass: less frequently used data (field descriptors, method descriptors);
• static storage for static fields, initialised by the type's static constructor.

Every object points to its MethodTable; that is how GetType(), casts, virtual calls and the GC know what the object is.

2. Object layout (64-bit)

[ object header (8 B) ][ MethodTable* (8 B) ][ instance fields ... ]
        ^ sync block index / hash code / thin lock      ^ reference points HERE

• Minimum object size is 24 bytes.
• The runtime may reorder fields of classes for alignment and packing (auto layout).
• Reference fields are grouped so the GC can scan them efficiently.

You can inspect layouts with the ObjectLayoutInspector package or dotnet-dump (dumpobj).

3. Allocation fast path

Each thread has an allocation context — a small region of Gen0 memory. Allocating is: check that current + size <= limit, bump current, write the MethodTable pointer. That's a few instructions, which is why allocation in .NET is cheap; the real cost comes later as GC work proportional to surviving objects. When the context is exhausted, the allocator gets a new chunk, and may trigger a Gen0 GC.

4. Statics and generics

Static fields are per closed type: Cache<int>.Items and Cache<string>.Items are separate. Static fields of reference type are roots for the GC — anything referenced from a static lives forever unless removed, which is the classic static-cache memory leak. [ThreadStatic] and ThreadLocal<T> give per-thread statics; AsyncLocal<T> flows values with async context.

5. Identity mechanics

• ReferenceEquals(a, b) compares the two pointers.
• RuntimeHelpers.GetHashCode(obj) returns the identity hash (stored lazily in the object header), even if GetHashCode is overridden — used by ReferenceEqualityComparer (.NET 5) for identity-based dictionaries.
• Because the GC moves objects during compaction, identity is not the memory address; it's the reference itself, which the GC updates.

6. Objects vs values in domain design

Try it yourself

1. Create two instances of a class and a record with the same data and compare ReferenceEquals, Equals and ==.
2. Print RuntimeHelpers.GetHashCode for both objects.
3. Use ObjectLayoutInspector to print the layout of a class with mixed field types.
4. Add a static counter and observe it shared across all instances and threads.

public class BankAccount
{
    private static int _created;                 // shared by all accounts
    public static decimal InterestRate { get; } = 0.05m;

    private decimal _balance;                    // one per object

    public BankAccount(string owner)
    {
        Owner = owner;
        Id = ++_created;
    }

    public int Id { get; }
    public string Owner { get; }
    public decimal Balance => _balance;

    public void Deposit(decimal amount)
    {
        ArgumentOutOfRangeException.ThrowIfNegativeOrZero(amount);
        _balance += amount;                      // changes only this object
    }

    public static int CreatedCount => _created;  // no 'this' in static members
}

var alice = new BankAccount("Alice");
var bob   = new BankAccount("Bob");
alice.Deposit(100m);

Console.WriteLine(alice.Balance);              // 100
Console.WriteLine(bob.Balance);                // 0
Console.WriteLine(BankAccount.CreatedCount);   // 2

var sameAsAlice = alice;
sameAsAlice.Deposit(50m);
Console.WriteLine(alice.Balance);              // 150: same object
Console.WriteLine(ReferenceEquals(alice, sameAsAlice)); // true