Struct or class: how do you decide in C#, and how do you prove the choice was right? Explain the criteria, the costs on each side (copying, boxing, allocation, GC), the defaults you would recommend, and how you would measure the impact.

1. Where the bytes go

class Coordinate { double Lat; double Lon; }
  heap object: [header 8][MT 8][Lat 8][Lon 8] = 32 bytes + 8-byte reference wherever stored
Coordinate[1_000_000] (class): 8 MB of references + 32 MB of objects = ~40 MB, scattered

readonly struct Coordinate { double Lat; double Lon; }
  inline: [Lat 8][Lon 8] = 16 bytes
Coordinate[1_000_000] (struct): ~16 MB, contiguous

Plus, iterating the struct array reads memory sequentially (prefetch-friendly); iterating the class array chases pointers (cache misses).

2. Copying cost model

• ≤ 16 bytes: often passed and returned in registers (x64 SysV ABI uses two registers for many 16-byte structs; Windows x64 passes >8-byte structs by hidden reference — the JIT optimises copies, but details vary by platform).
• Larger structs: copied via stack memory on each call/assignment. The JIT can elide some copies (struct promotion, copy propagation), but complex code paths keep them.
• in parameters avoid copies only for readonly structs (otherwise defensive copies appear on member calls).

3. Hidden boxing checklist

• Passing to object parameters (string.Format, Console.WriteLine("{0}", x), logging message templates).
• Using IEquatable<object>/non-generic interfaces (IComparable).
• Storing in ArrayList, Hashtable, Dictionary<string, object>.
• Calling ToString()/GetHashCode()/Equals(object) when not overridden.
• foreach over a struct collection via IEnumerable<T> boxes the struct enumerator.
• Pattern matching x is IFoo f on a struct.

Each box costs ~24+ bytes and a copy.

4. GC interaction

• Structs inside classes or arrays live on the heap with their container; they don't add separate objects, but if they contain references, the GC scans those fields.
• Structs with no references in arrays let the GC skip scanning the array contents entirely — a big win for large numeric arrays.
• Large struct arrays (≥ 85 KB) go to the LOH — allocate once and reuse.

5. BenchmarkDotNet setup

[MemoryDiagnoser, DisassemblyDiagnoser(maxDepth: 2)]
public class CoordinateBench
{
    private readonly double[] _lats = ..., _lons = ...;
    [Benchmark(Baseline = true)] public double ClassVersion() { /* allocate + sum */ }
    [Benchmark] public double StructVersion() { /* fill array + sum */ }
}

Run in Release, with realistic data sizes, and compare ratios rather than absolute numbers. Confirm with a production-like load test — micro-benchmarks can mislead when the real bottleneck is I/O.

6. Structs and frameworks

• EF Core: structs work as complex types/value converters (e.g. strongly typed IDs with HasConversion), not as entities.
• System.Text.Json: serialises structs fine; readonly record struct with constructor binding.
• DI: services must be classes.
• Default values: default(OrderId) with Guid.Empty must be handled (validation, EF sentinel config).

Try it yourself

1. Benchmark 1 million Coordinate allocations as class vs struct, then summing them.
2. Add a method taking object and call it with the struct; observe allocations.
3. Grow the struct to 64 bytes and benchmark passing by value vs in.
4. Run dotnet-counters during a load test before and after the change.

// Good struct: small, immutable, single value, used in bulk
public readonly record struct GeoPoint(double Lat, double Lon)
{
    public static GeoPoint Origin => default;               // all-zero default is meaningful
}

// Good struct: strongly typed ID, avoids mixing up Guids
public readonly record struct CustomerId(Guid Value);

// Better as a class: large, has identity, mutated over time
public sealed class Route
{
    public Guid Id { get; } = Guid.CreateVersion7();
    private readonly List<GeoPoint> _points = [];
    public IReadOnlyList<GeoPoint> Points => _points;
    public void Add(GeoPoint p) => _points.Add(p);
}

// Passing a medium struct without copying
public static double DistanceKm(in GeoPoint a, in GeoPoint b) { /* haversine */ return 0; }

// Avoid boxing in generic code
public static bool AllEqual<T>(ReadOnlySpan<T> items) where T : IEquatable<T>
{
    for (int i = 1; i < items.Length; i++)
        if (!items[i].Equals(items[0])) return false;   // constrained call, no box
    return true;
}