C# Required Properties

Introduction

When working with objects in C#, ensuring that all necessary properties are initialized during object creation is crucial for writing reliable code. Prior to C# 11, developers had to rely on constructors with parameters or throw exceptions in property setters to enforce this behavior. The required properties feature introduced in C# 11 provides a cleaner, more elegant solution to this common problem.

Required properties enable you to declare that certain properties must be initialized when an object is created, making your code more robust and self-documenting.

Understanding Required Properties

The required modifier is applied to properties to indicate that they must be initialized when an object is created. This helps prevent the common error of forgetting to set essential properties.

Basic Syntax

csharp

public class Person
{
    public required string Name { get; set; }
    public required int Age { get; set; }
    public string? Address { get; set; }  // Not required
}

In this example, Name and Age must be initialized when creating a Person object, while Address remains optional.

How Required Properties Work

When you mark a property as required, the compiler enforces that the property is initialized during object creation, typically through object initializers.

Example: Using Required Properties

csharp

// This compiles correctly because all required properties are initialized
var person1 = new Person
{
    Name = "John Doe",
    Age = 30
};

// This will NOT compile - Age is missing
var person2 = new Person
{
    Name = "Jane Smith"
};  // Compiler error: 'Person.Age' must be initialized

Compiler Error

If you don't initialize all required properties, you'll receive a compile-time error similar to:

Error CS9035: Required member 'Person.Age' must be set in the object initializer or constructor.

This early feedback helps catch initialization errors before your code even runs.

Required Properties vs. Constructor Parameters

Let's compare the traditional constructor approach with the required properties approach:

Traditional Constructor Approach

csharp

public class Person
{
    public string Name { get; }
    public int Age { get; }
    public string? Address { get; set; }

    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }
}

// Usage:
var person = new Person("John Doe", 30);

Required Properties Approach

csharp

public class Person
{
    public required string Name { get; set; }
    public required int Age { get; set; }
    public string? Address { get; set; }
}

// Usage:
var person = new Person
{
    Name = "John Doe",
    Age = 30
};

The required properties approach offers several advantages:

• It's more flexible when you have many properties
• Properties can still be changed after initialization (if not read-only)
• It works well with object initialization syntax
• Property names are explicitly stated in the initialization code

Using Required Properties with Constructors

You can combine required properties with constructors for even more flexibility:

csharp

public class Employee
{
    public required string Name { get; set; }
    public required int EmployeeId { get; set; }
    public string Department { get; set; }
    public decimal Salary { get; set; }

    // Constructor that sets some properties
    public Employee(string department, decimal salary)
    {
        Department = department;
        Salary = salary;
    }
}

// Usage - still must set required properties
var employee = new Employee("Engineering", 75000m)
{
    Name = "Sarah Johnson",
    EmployeeId = 12345
};

In this example, the constructor sets Department and Salary, but you must still initialize the required properties Name and EmployeeId.

SetsRequiredMembers Attribute

If your constructor sets all required members, you can use the [SetsRequiredMembers] attribute to inform the compiler that the constructor satisfies the requirement:

csharp

public class Employee
{
    public required string Name { get; set; }
    public required int EmployeeId { get; set; }
    
    [SetsRequiredMembers]
    public Employee(string name, int employeeId)
    {
        Name = name;
        EmployeeId = employeeId;
    }
}

// Now this is allowed without object initializer
var employee = new Employee("Alice Smith", 54321);

Required Properties with Init-Only Setters

Required properties work particularly well with init-only properties, which can only be set during initialization:

csharp

public class ImmutablePerson
{
    public required string Name { get; init; }
    public required int Age { get; init; }
}

// This works
var person = new ImmutablePerson
{
    Name = "Robert Brown",
    Age = 45
};

// This won't compile - can't change init-only properties after initialization
// person.Name = "Robert Green";  // Error!

This combination ensures that not only are all required properties set during initialization, but they can't be changed afterward.

Real-World Application: Configuration Objects

Required properties are particularly useful for configuration objects:

csharp

public class DatabaseConfig
{
    public required string ConnectionString { get; init; }
    public required string DatabaseName { get; init; }
    public int Timeout { get; init; } = 30;  // Default value
    public int MaxConnections { get; init; } = 100;  // Default value
}

public class ApiService
{
    private readonly DatabaseConfig _config;
    
    public ApiService(DatabaseConfig config)
    {
        _config = config;
    }
    
    public void Connect()
    {
        Console.WriteLine($"Connecting to {_config.DatabaseName} with: {_config.ConnectionString}");
        Console.WriteLine($"Timeout: {_config.Timeout}s, Max Connections: {_config.MaxConnections}");
    }
}

// Usage
DatabaseConfig config = new()
{
    ConnectionString = "Server=myserver;User Id=admin;Password=password;",
    DatabaseName = "CustomersDb"
    // No need to set Timeout and MaxConnections as they have default values
};

var service = new ApiService(config);
service.Connect();

Output:

Connecting to CustomersDb with: Server=myserver;User Id=admin;Password=password;
Timeout: 30s, Max Connections: 100

Limitations and Considerations

While required properties are powerful, there are some things to keep in mind:

1. Required properties cannot have default values directly in their declaration
2. Required properties only work with object initializers or constructors marked with [SetsRequiredMembers]
3. Required properties must be public or accessible from where the object is being initialized
4. For inheritance scenarios, derived classes inherit the required modifier from base classes

Summary

Required properties in C# provide a clean, declarative way to ensure that essential properties are initialized when objects are created. This feature:

• Improves code reliability by catching missing initializations at compile-time
• Makes code intent clearer by explicitly marking which properties are mandatory
• Works well with object initializer syntax
• Combines effectively with init-only properties for creating immutable objects

By using required properties, you can write more robust code with fewer initialization bugs and clearer semantics about what data is necessary for your objects to function correctly.

Exercises

1. Create a Product class with required properties for Name, Price, and SKU, along with optional properties.
2. Implement a UserRegistration class that uses required properties for essential user information and demonstrates proper validation.
3. Refactor an existing class that uses constructor parameters to use required properties instead, and compare the differences.
4. Create a class hierarchy with required properties and observe how they behave with inheritance.

Additional Resources

• C# Required Members Documentation
• What's new in C# 11
• Object Initialization in C#