Modern C# Development: Record Types 101
Tags: csharp, dotnet, beginners, programming
Published: 2024-03-19 22:05:44

Hi lovely readers,

Today, we're diving into the world of records in C#—a fairly new addition to the C# language that can simplify your code. 

### What are Records?

Records were introduced in C# 9. They provide a concise syntax for declaring immutable data types. Think of them as lightweight, immutable classes designed specifically for data storage and retrieval.

### Syntax

Let's start by looking at the basic syntax of a record:

```csharp
public record Person(string FirstName, string LastName);
```

In this example, we've declared a `Person` record with two properties: `FirstName` and `LastName`. This concise syntax, known as positional record syntax, allows us to define properties directly in the record's constructor parameters.

Now, let's see how easy it is to create a new instance of `Person`:

```csharp
var person = new Person("John", "Doe");
```

With records, you can create new instances and initialize their properties in a single line, making the code more concise and readable.

### Comparison with Classes

Now, let's compare records with a traditional class declaration:

```csharp
public class PersonClass
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}
```

In this class declaration, we've defined a `PersonClass` with similar properties `FirstName` and `LastName`. However, unlike records, you need to create a separate body for the class. PersonClass is also mutable, meaning that a value like FirstName in a PersonClass object can be changed after creating the object.

### Immutable by Default:

One of the key features of records is immutability. Records are immutable by default, meaning once a record is created, its properties cannot be modified. This promotes safer code by preventing accidental changes to data.

For example:

```csharp
var person = new Person("John", "Doe"); //record - immutable
var personClass = new PersonClass("John", "Doe"); //class - mutable

person.FirstName = "Dirk"; //not allowed
personClass.FirstName = "Dirk"; //is allowed
```

### Value Equality

Records provide value equality by default, which means two record instances are considered equal if all their properties are equal. This behavior isn’t standard for classes, because classes are only equal based on the location of your heap storage. This makes records great for data processing or DTOs.

Let's see an example:

```csharp
var person1 = new Person("John", "Doe");
var person2 = new Person("John", "Doe");

var personClass1 = new PersonClass("John", "Doe");
var personClass2 = new PersonClass("John", "Doe");

Console.WriteLine(person1 == person2); // Output: True
Console.WriteLine(personClass1 == personClass2) // Output: False

```

### With Expressions

In addition to their immutability and concise syntax, records in C# also introduce a feature called "with expressions". With expressions allow you to create a new record instance that is a copy of an existing one, with some properties modified.

Let's see how with expressions work with our `Person` record:

```csharp
var person1 = new Person("John", "Doe");
var person2 = person1 with { FirstName = "Jane" };

Console.WriteLine(person1); // Output: Person { FirstName = John, LastName = Doe }
Console.WriteLine(person2); // Output: Person { FirstName = Jane, LastName = Doe }

```

In this example, we create a new `person2` record using a with expression applied to the existing `person1` record. We specify the property `FirstName` to be modified, setting it to "Jane". The with expression creates a new record instance with the specified property changed while keeping all other properties the same.

With expressions are super useful when you want to create modified copies of existing records without mutating the original ones.

### Conclusion

Records in C# are great for defining immutable data types, contrasting with the mutable nature of traditional classes. With their simple syntax and built-in features like value equality and with expressions, records are a powerful tool for managing data in your applications.

I hope this helped! Do you have any questions or comments? Please reach out to me on @lovelacecoding on almost every social media platform. Happy coding!