In c#, the required members are features, that allow the developer to indicate which properties and fields in a class, struct, or record type must be initialized when creating an instance of a class.

The required keyword helps to enforce non-null constraints on object initializations. This allows for better code generation because it is now impossible to forget to set necessary properties when initializing a new instance.

Features of Required Member in C#

• Required members must be initialized, but they can be initialized as null.
• Required members must be at least visible at their containing type.
• A type with a required member cannot be used as a type argument when the type parameters include new constraints.
• When the required member can not be set at the time of creation, then the compiler will issue an error.
• From their base type, the required member automatically inherits their type.

Key Concept of Required Member

Property with Required modifier

A property marked with required must be initialized either through an object initializer

csharp
📄
public class Employee
{
    public required string EmployeeId { get; set; }
    public required string Department { get; set; }
}

// Correct Initialization
var employee = new Employee { EmployeeId = "E123", Department = "IT" };

or constructor. If not the compiler will throw an error. For example:

Using SetsRequiredMembersAttribute

This attribute can be used on constructors to indicate that the required members are set within the constructor. This bypasses the need for object initializers.

csharp
📄
public class Order
{
    public required string OrderId { get; set; }
    public required DateTime OrderDate { get; set; }

    [SetsRequiredMembers]
    public Order()
    {
        OrderId = "Default";
        OrderDate = DateTime.Now;
    }
}

Error Handling

If the required member is not initialized, the compiler throws an error such as CS9035: CS9035: Required member must be set in the object initializer or constructor. This ensures that the consuming code does not miss important fields.

Inheritance

If a base class has required members, the derived class must either initialize them or allow them to be set through object initializers. Therefore, required members must also be handled carefully in derived classes.

Limitations

The required modifier cannot be applied to static members or used with interfaces. Additionally, you can't mark private members as required since they're inaccessible to the caller during object initialization.

Example

Here, is a simple example of the required member of the csharp:

Note: this code will run in the latest version of c-sharp it will be an error if you run below c#11.

csharp
📄
using System;
public class Person
{
    public required string FirstName { get; set; }
    public required string LastName { get; set; }
}

public class Program
{
    public static void Main()
    {
        Person person = new Person { FirstName = "John", LastName = "Doe" };
        Console.WriteLine($"Name: {person.FirstName} {person.LastName}");
    }
}