(C# 9.0) Record types vs class vs struct type, positional records and non-destructive mutation

First and foremost: the keyword, record, is of the same category as the keywords struct and class. It has been introduced with C# 9.0. Let's study it threadbare!

class vs struct vs record

This is a summary chart of the status of class, struct and record as of now -

ref/value type classification

class: reference type

struct: value type

record: reference type

Member Properties:

class: no restrictions: the properties and data members can be mutable (i.e, alterable) as well as immutable.

struct: no restrictions: the properties and data members can be mutable (i.e, alterable) as well as immutable.

record: they are designed to be immutable, and they indeed are, if positional syntax [explained later] is used for defining a record, or if the setters are explicitly marked non-public. But if the properties have public setters, then they are mutable i.e., they can be changed anytime.

The Methods of a record that the Compiler Synthesizes

Following is a quick summary of the most important ones:

The operators == and !=

Comparison operators == and != compare the respective values of the properties with regard to their data-types.

GetHashCode

The compiler produces an over-ride of GetHashCode by using the GetHashCode from all the properties of the record, including those from the parent classes! This ensures that a comparison is with regard to not just the values, but also to the types of the records being compared. This method is not directly used by application developers, but the compiler probably uses it for the equality operators.

Copy Constructor

The compiler synthesizes a protected copy constructor. It also creates an internal clone method. The clone method, too, is not directly used by application developers. But the compiler probably uses it for providing the ability to copy records through with expressions.

How to Create a Copy?

Suppose we have a record defined such:

public record PinPoint 
{

  // properties with setter 
  // marked as init - means 
  // init-once 
  public int x { get; init;}

  // property for y 
  public int y { get; init;}

  // ctor 
  public PinPoint(int _x, int _y) => (x, y) = (_x, _y);

}

Below are two examples - the first one creates an exact same copy, and the second one modifies a property during copy -

// a new object 
PinPoint pp1 = new PinPoint(2, 4);

// exact same copy 
// pp2.x will be 2 and pp2.y will be 4 
PinPoint pp2 = pp1 with { };

// copy with modification 
// pp2.x will be 8 and pp2.y will be 4 
PinPoint pp3 = pp1 with { x = 8 };

What is Non-Destructive Mutation?

In the example discussed above, we have created pp2 and pp3 as mutations [i.e., copies] of pp1. The data of pp1 remains same at x = 2, y = 4 after the copy. There is no impact on pp1 during the copy process - its data remains same at x = 2, and y = 4. It has NOT GIVEN its data - it has created mutations of itself, without affecting itself. This is termed as Non-Destructive Mutation.

What are Positional Records?

Positional records is a syntax of defining a record. The setters on the records are marked as init, to make them init-once.

// a record with just the properties x and y 
// defined with the positional syntax 
public record PinPoint (int x, int y);

What is the Deconstruct Method?

"Deconstruct" method is used to quickly extract the data out of a record as shown here -

// suppose we have a PinPoint record 
PinPoint p1 = new PinPoint(2, 4);

// extract both the props into px and py 
// the deconstruct method works behind the scenes 
(int px, int py) = p1;

// px is 2, and py is 4 

Inheritance with Records

The following derives a record called BallPoint, with three properties, from a PinPoint. We have used the positional syntax.

public record BallPoint (int x, int y, int z) : PinPoint (x, y);

// create a ballpoint 
BallPoint bp = new BallPoint(2, 3, 4);

What is PrintMembers? What is its use?

PrintMembers is a method similar to the classic ToString method. It is available on a record and displays its alternate string representation. It accepts a StringBuilder as an argument.

PrintMembers can be found useful to dump the contents of a record including the members from the inheritance chain.

// suppose we have a PinPoint record 
BallPoint p1 = new BallPoint(2, 4, 8);

StringBuilder sb = new StringBuilder();

p1.PrintMembers(sb);

Console.WriteLine(sb.ToString());

// dumps the data like thus 
// BallPoint {x = 2, y = 4, z = 8}