I thought it’d be interesting to compare the three C# types, struct, class and record. I’m sure we all know that a struct is a value type and a class a reference type, but what’s a record.

The record “keyword defines a reference type that has built-in functionality for encapsulating data” (see Records (C# reference)).

Before we get into record. let’s review what struct and classes give us using the example of a Person type which has a FirstName property.

struct

struct Person
{
  public string FirstName { get; set; }
}

• A struct extends System.ValueType and structs are “allocated either on the stack or inline in containing types and deallocated when the stack unwinds or when their containing type gets deallocated. Therefore, allocations and deallocations of value types are in general cheaper than allocations and deallocations of reference types.” See Choosing Between Class and Struct.
• ToString() will output YouNameSpace.Person by default.
• Structs cannot be derived from anything else (although they can implement interfaces).
• Structs should be used instead of classes where instances are small and short-lived or are commonly embedded in other objects.
• As structs are ValueTypes they are boxed or cast to a reference type or one of the interfaces then implement.
• As a function of being a ValueType, structs are passed by value

class

class Person
{
  public string FirstName { get; set; }
}

• A class extends System.Object and classes are reference types and allocated on the heap.
• ToString() will output YouNameSpace.Person by default.
• Obviously classes may extend other class but cannot extend a record and vice versa, records cannot extend classes.
• Reference types are passed by reference.

record

Records can have properties supplied via the constructor and the compiler turns these into readonly properties. The syntax is similar to TypeScript in that we can declare the properties in a terse syntax, such as

record Person(string FirstName);

Whilst records are primarily aimed at being immutable we can still declare them with mutability, i.e.

class Person
{
  public string FirstName { get; set; }
}

• Records can only inherit for other records, for example

  record Scooby() : PersonRecord("Scooby");
  

• Records use value comparison (not reference comparison) via IEquatable
• ToString formats output to show the property values
• Records support the with keyword which allows us to create a copy of a record and mutate at the point of copying. Obviously as records are generally aimed at being immutable this use of with allows us to copy an existing record with some changes, for example

  var p = somePerson with { FirstName = "Scrappy" };
  

  This is not a great example with our record which has a single property, but if we assume Person also had a LastName property set to “Doo” then we’d essentially have created a new record with the same LastName but now with the new FirstName of “Scrappy”.

  We can also copy whole records by not supplying any values within the { } i.e.

  var p = somePerson with { };