C# Record Explained

In C#, a record is a feature introduced in C# 9.0 that allows you to define lightweight, immutable data structures in a concise and expressive manner. Records provide a convenient way to define types that are primarily used to store and represent data.

Records are reference types that provide built-in functionality for immutability, value-based equality, and concise syntax for defining data models. Records are particularly useful for representing data that is primarily used for storing values rather than behavior. 

Here are the key aspects and features of records in C#:

1. Immutable by Default:
Records are immutable by default, meaning their values cannot be modified after creation. This is essential for creating reliable and predictable data structures.

2. Data-Centric:
Records are designed to represent data, making them an excellent choice for modeling objects that primarily hold data without behavior.

3. Concise Syntax:
C# records offer a concise syntax for defining properties and initializing their values. You can define a record using the record keyword, followed by the record's name and its properties.

   public record Person(string FirstName, string LastName);

4. Property Definitions:
Properties in a record are defined directly within the record declaration. The properties are implicitly read-only, meaning you cannot assign new values to them once the record is created.

5. Value Equality:
Records automatically implement value equality based on their property values. This means two record instances with the same property values are considered equal.

6. Deconstructor:
Records provide a deconstructor, which allows you to easily destructure a record into its constituent properties.

Person person1 = new Person("Ajeet", "Kumar");
person1.Deconstruct(out string firstName, out string lastName);
Console.WriteLine(firstName);
Console.WriteLine(lastName);
public record Person(string FirstName, string LastName);

7. Inheritance and Overriding:
Records can inherit from other classes and interfaces, and you can override methods, including ToString(), GetHashCode(), and Equals().

Here's a simple example of using a record:

public record Person(string FirstName, string LastName);

class Program
{
    static void Main()
    {
        Person person1 = new Person("John", "Doe");
        Person person2 = new Person("John", "Doe");

        Console.WriteLine(person1.Equals(person2));  // Outputs: True

        // Deconstruction
        var (firstName, lastName) = person1;
        Console.WriteLine($"First Name: {firstName}, Last Name: {lastName}");
    }
}

In this example, we define a record Person with two properties (FirstName and LastName). We create two instances of the Person record and demonstrate value equality and deconstruction features.

Custom Constructor in Records

In C#, records are a special kind of type introduced in C# 9.0 that provides a succinct way to declare a type and is often used to model immutable data. Records automatically provide a default constructor, which initializes the properties of the record.

Here's an example of a record in C#:

public record Person(string FirstName, string LastName);

In this example, a Person record is defined with two properties: FirstName and LastName. The default constructor for this record is automatically provided by the compiler. The FirstName and LastName are positional parameters of primary constructor. Additional constructors can be defined in the record but they must call this primary constructor.

public record Person(string FirstName, string LastName)
{
    public Person(string fullName)
        : this(
            fullName.Split(' ').ElementAtOrDefault(0) ?? string.Empty,
            fullName.Split(' ').ElementAtOrDefault(1) ?? string.Empty)
    {
    }
}

Record types with a primary constructor require every additional constructor to delegate to another constructor using this(...).

In this modified example, we have added a custom constructor Person(string fullName) that takes a full name and initializes the FirstName and LastName properties accordingly.

Note that if you need custom initialization logic for your record, you can still use methods or factory methods to achieve the desired behavior:  

Keep in mind that records are primarily designed for immutability and straightforward data representation, so complex initialization logic is generally better suited for methods or factory methods.

Remark: Records can be defined with or without class keyword. Look at the following records examples which are defined below.

// record with class keyword, Positional record
public record class Person(string FirstName, string LastName);

// record without class keyword, Positional record
// class keyword is optional, but recommended for clarity
public record Employee(string FirstName, string LastName);

// Inheritance with records
public record class Manager(string FirstName, string LastName, string Department) : Employee(FirstName, LastName);

// Immutable record
public record class Student
{
    public string FirstName { get; init; }
    public string LastName { get; init; }
    public Student(string firstName, string lastName)
    {
        this.FirstName = firstName;
        this.LastName = lastName;
    }
}

// Mutable record
public record Doctor
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public Doctor(string firstName, string lastName)
    {
        this.FirstName = firstName;
        this.LastName = lastName;
    }
}

C# Event Definition & Record

Can event be defined in record in C#?
In C#, events cannot be defined directly within a record type. Records are designed to be lightweight data structures that represent immutable values, and they are primarily used for data storage and retrieval. Events, on the other hand, are mechanisms used to provide notifications or callback functionality when something happens in a class or object.

If you need to define events in your C# code, you typically do so within a class rather than a record. Here's an example of how you would define an event within a class:

public class MyClass
{
    public event EventHandler MyEvent;

    public void DoSomething()
    {
        // Trigger the event when something happens
        MyEvent?.Invoke(this, EventArgs.Empty);
    }
}

In this example, MyClass has an event called MyEvent, and you can subscribe to this event and handle its occurrences in other parts of your code.

Records are more suitable for scenarios where you want to define simple data structures with value semantics and automatic implementations of equality, immutability, and other features. Events are typically associated with classes that represent behavior or functionality.

If you need a combination of events and data storage, you can use a class to encapsulate both your data and event-handling logic.

FAQs about Record

Should Record must be immutable?

Answer: No. You can define record property with get and set. It means that record need not be immutable. We can create mutable record but this is not default behavior.

Is Record a reference type?

Answer: Yes. But you can create record struct which is value type.

What is Non-Destructive Mutation w.r.t. Record?

Answer: By default, properties on a record are init-only or immutable, meaning you cannot directly alter them once created. To update a value, you use the with expression to declare what changes are being made:

// 1. Create the original record
public record Employee(string Name, string Role, int Salary);
var dev = new Employee("Alice", "Junior Dev", 50000);

// 2. Perform a non-destructive mutation
var promotedDev = dev with { Role = "Senior Dev", Salary = 70000 };

// 3. The original remains unchanged
// dev.Role is still "Junior Dev"
// promotedDev.Role is "Senior Dev"

The readonly keyword is not valid with a class or record class but is valid with record struct. Why?

public readonly record struct Master
{
    public string FirstName { get; init; }
    public string LastName { get; init; }
    public Master(string firstName, string lastName)
    {
        this.FirstName = firstName;
        this.LastName = lastName;
    }
}

Answer: The readonly is valid with record struct, but not with class or record class, because reference types and value types have different mutability models in C#. For structs, readonly means: After construction, instance members cannot modify the state of that struct.

public readonly struct Point
{
    public int X { get; }
    public Point(int x)
    {
        X = x;
    }
    public void Change()
    {
        // X = 10; // Error
    }
}