The readonly keyword is a modifier that you can use on fields. When a field declaration includes a readonly modifier, assignments to the fields introduced by the declaration can only occur as part of the declaration or in a constructor in the same class. Compilers and verification ensure that readonly fields are not written to by any method other than a constructor. Note that reflection can be used to modify a readonly field. 

In this example, the value of the field year cannot be changed in the method ChangeYear, even though it is assigned a value in the class constructor:

class Age

{

    readonly int _year;

    Age(int year)

    {

        _year = year;

    }

    void ChangeYear()

    {

        _year = 1967; // Will not compile.

    }

}

You can assign a value to a readonly field only in the following contexts:

• When the variable is initialized in the declaration, for example:
  public readonly int y = 5;
  
• For an instance field, in the instance constructors of the class that contains the field declaration, or for a static field, in the static constructor of the class that contains the field declaration. These are also the only contexts in which it is valid to pass a readonly field as an out or ref parameter.

The readonly keyword is different from the const keyword. A const field can only be initialized at the declaration of the field. A readonly field can be initialized either at the declaration or in a constructor. Therefore, readonly fields can have different values depending on the constructor used. Also, while a const field is a compile-time constant, the readonly field can be used for runtime constants as in the following example:

public static readonly uint l1 = (uint)DateTime.Now.Ticks;

Also, in C#, there are some performance issues to consider when initializing fields by using inline syntax versus assignment syntax in a constructor. 

When you compile a program developed in language that target CLR, instead of compiling the source code into machine level code the compiler translate it into intermediate language. No matter which language is used to develop the application, it always gets translated in IL (Intermediate Language). This ensures language interoperability.

•  In addition to translating the code into IL the compiler also produce the metadata during the process of compilation.
• The IL and metadata are link an assembly.
• The compiler creates the .EXE or .DLL file.
• When you execute the .EXE or.DLL file, the converted into IL and all other relevant information from the base class library is sent to class loader. The class loader loads the code into the memory.
• Before the code can be executed, the .NET Framework needs to convert IL into native or CPU specific code. The JUST IN TIME (JIT) Compiler translates the code from IL into managed native code. During the process of compilation the JIT compiler compiles only the code that is the required during execution instead of compiling the complete IL code when an uncompelled method is invoked the JIT compiler converts the IL for that method into native code. The process saves time and memory required to convert the complete IL into native code.
• During JIT compilation the code is also check for type safety. Type safety ensure that objects are always are accessed in a compatible way.
• After translating the IL into native code, the converted code is sent to the .NET runtime manager.
• The .NET runtime manager executes the code. While executing the code the security check is performed to ensure the code has appropriate permission for accessing the available resources.