C# Structs and Records

Value types are usually small and short-lived, and avoiding separate objects can make performance-sensitive code faster.

public struct Point
{
    public int X { get; set; }
    public int Y { get; set; }
    public Point(int x, int y) { X = x; Y = y; }
    public double DistanceFromOrigin => Math.Sqrt(X * X + Y * Y);
}

var a = new Point(3, 4);
var b = a;          // b is a COPY
b.X = 100;          // a.X is still 3

• Structs can have fields, properties, methods and constructors, but can't inherit from other structs or classes (they can implement interfaces).
• Keep structs small (a few fields) and preferably immutable: readonly struct Money with { get; } or init properties prevents confusing copy-and-change bugs.

A record declares a data type in one line:

public record Product(string Name, decimal Price);

var p1 = new Product("Mug", 8.50m);
var p2 = new Product("Mug", 8.50m);
Console.WriteLine(p1 == p2);       // True: same values
Console.WriteLine(p1);             // Product { Name = Mug, Price = 8.50 }
var sale = p1 with { Price = 6.00m };

From that one line, the compiler generates a constructor, init properties, value equality (== and Equals compare every property), a readable ToString, and deconstruction (var (name, price) = p1;).

The with expression creates a copy with some properties changed, leaving the original untouched. This is called non-destructive mutation, and it's the natural way to "change" immutable data. record struct gives you the same features on a value type.

A struct always has a value, even if you never call a constructor. default(Point) and every item in a new Point[] array have all fields set to their defaults, so X and Y are 0. Design structs so that this all-zero state still makes sense.

When a value type is stored in a variable of type object, or of an interface type, C# copies it into a new object on the heap. This is called boxing, and the box is a separate copy:

Point p = new Point(1, 2);
object boxed = p;              // boxing makes a copy
p.X = 99;
Console.WriteLine(((Point)boxed).X);   // 1: the box didn't change

Getting the value back out with a cast is called unboxing. Boxing is rare in modern code thanks to generics, which is one reason List<int> replaced the old non-generic ArrayList. When it does happen in a tight loop, it costs extra memory and time, and the copy can cause confusing bugs like the one above.