Records

Records are usually introduced as a shorter way to write a class. That undersells them and sets the wrong expectation, because brevity is the side effect.

The real change is what equality means. Two objects of a class are equal when they are the same object. Two records are equal when they hold the same values. Some things in a program have an identity that survives their values changing — an employee is the same employee after a pay rise. Other things are nothing but their values: an amount of money, a date range, a snapshot sent to an API. A record is the type for the second kind.

// A record. One line, and equality is by value.
public record EmployeeSnapshot(string EmployeeId, string FullName, decimal AnnualSalary);

// The same shape as a class.
public class EmployeeSnapshotClass
{
    public string EmployeeId { get; init; } = "";
    public string FullName { get; init; } = "";
    public decimal AnnualSalary { get; init; }
}

EmployeeSnapshot recordA = new EmployeeSnapshot("E-1042", "Asha Rao", 1_200_000m);
EmployeeSnapshot recordB = new EmployeeSnapshot("E-1042", "Asha Rao", 1_200_000m);

Console.WriteLine(recordA == recordB);        // True
Console.WriteLine(recordA.Equals(recordB));   // True

EmployeeSnapshotClass classA = new EmployeeSnapshotClass
{
    EmployeeId = "E-1042", FullName = "Asha Rao", AnnualSalary = 1_200_000m
};
EmployeeSnapshotClass classB = new EmployeeSnapshotClass
{
    EmployeeId = "E-1042", FullName = "Asha Rao", AnnualSalary = 1_200_000m
};

Console.WriteLine(classA == classB);          // False
Console.WriteLine(classA.Equals(classB));     // False

Console.WriteLine(recordA);
// EmployeeSnapshot { EmployeeId = E-1042, FullName = Asha Rao, AnnualSalary = 1200000 }
Console.WriteLine(classA);
// EmployeeSnapshotClass

• The parameters in EmployeeSnapshot(...) are a positional record declaration. Each one becomes a public property with an init accessor, which means it can be set at creation and not afterwards.
• The two records compare equal because the compiler generated an Equals that checks the runtime type and then every declared value. == is wired to it as well.
• The two class instances compare unequal despite holding identical data. The default Equals for a class asks "is this the same object?", and these are two objects.
• ToString differs too. The record prints its values, which makes a log line or a debugger watch window immediately useful. The class prints its type name and nothing else.
• Nothing here is exclusive to records — you could write all of this by hand on the class. Getting Equals, GetHashCode, == and != consistent with each other by hand is about sixty lines of code that has to be revisited every time a property is added.

public record OrderLine(string Sku, int Quantity, decimal UnitPrice)
{
    // Records can hold computed members. This one is derived, so it takes no
    // part in equality — there is no stored field behind it to compare.
    public decimal LineTotal => Quantity * UnitPrice;
}

OrderLine original = new OrderLine("DL-1001", 2, 1_450m);

// "Everything the same, except the quantity."
OrderLine corrected = original with { Quantity = 3 };

Console.WriteLine(original.LineTotal);                     // 2900
Console.WriteLine(corrected.LineTotal);                    // 4350
Console.WriteLine(ReferenceEquals(original, corrected));   // False — a new object
Console.WriteLine(original == corrected);                  // False — different values

// Unchanged copies are equal, which is often exactly what you want in a test.
OrderLine untouched = original with { };
Console.WriteLine(original == untouched);                   // True

• with produces a new object. The original is untouched, so any other code holding a reference to it sees no change. That is the point of the pattern: nothing can be modified behind your back.
• Inside the braces you name only what differs. Everything else is copied. Adding a fourth property to OrderLine does not touch this call site.
• LineTotal recalculates on the new object, because it is computed on every read rather than stored.
• with makes a shallow copy. A property holding a reference to another object gives the copy a reference to the same object, not a copy of it.
• original == untouched being True is the value-equality rule again. Two separate objects, same values, equal.