What are readonly access modifier fields used for?

Fields with the readonly modifier in C# are used to create fields whose value can only be set once: either at the declaration or in the class constructor. After initialization, their value cannot be changed.

Main advantages and use cases:

1. Ensuring immutability: Guarantees that the field's value remains constant after object creation, enhancing code safety and predictability.
2. Initialization in constructor: Allows deferring the setting of the value until the class instance is created, using data obtained during its creation.
3. Thread safety: Immutable fields often simplify writing thread-safe code, as there is no risk of their values being changed simultaneously from different threads.
4. Performance: The compiler and runtime environment can perform optimizations knowing that the field's value will not change.

Example:

public class ImmutablePoint
{
    public readonly int X; // Can only be set during declaration or in constructor
    public readonly int Y;

    // Constructor allows initializing readonly fields
    public ImmutablePoint(int x, int y)
    {
        X = x;
        Y = y;
    }

    // Attempting to modify readonly field outside constructor will result in a compile-time error
    /*
    public void TryModify()
    {
        // X = 10; // Compile error: Cannot assign to readonly field
    }
    */
}

public class Example
{
    public readonly int InitializedField = 10; // Initialized at declaration

    public Example()
    {
        // InitializedField = 20; // Compile error: Already initialized
    }
}

Difference from constants (const):

Characteristic	readonly field	const field
Data type	Can be of any type.	Only primitive types and string.
Initialization	At declaration or in constructor.	Only at declaration.
Initialization time	During runtime (per instance).	During compilation (statically linked).
Staticness	Can be an instance member or static.	Always static by default (implicitly).
Reference	Stores a reference to an object (if reference type).	Embeds the value directly (for value types).

Using readonly is useful for fields that represent the state of an object that should not change after its creation, such as configuration parameters, identifiers, or references to other immutable objects.