Let’s understand what are they & what is the difference among them.

const int x = 5;

A variable declared a const means that it is a constant & its value cannot be changed at runtime. Once the value is assigned, it can never be altered.

The compiler needs to resolve the constant values during the compilation& hence, it is necessary to assign some value to const variables.

For example:

const int x; 
// is an invalid statement as we didn’t assign any value to xconst int x = 5; 
// is a valid statement

Also, const variables are implicitly static by nature.
For example:

public class ClassA {
    public const int val = 10;
}

We can use ClassA.val notation to access val without initializing the ClassA instance.

readonly int x = 5;

A variable declared readonly means that its value will become readonly once initialized & cannot be altered after that with the difference that the compiler need not resolve the readonly values at runtime.
Instead, the readonly values can be initialized until the class constructor exits. In other words, we can initialize the readonly variables inside the constructor & once the control moves out of the constructor, their value will be freezed & cannot be altered.

Consider the following class ClassA in AssemblyA

public class ClassA 
{
 public const int ConstVal = 5;
 public readonly int ReadOnlyVal; public ClassA() 
 {
  readOnlyVal = 10;
 }
}

Consider there is another assembly AssemblyB that references AssemblyA

When AssemblyB is compiled, ConstVal of class ClassA will be translated into the Intermediate Language (IL) & its value (i.e. 5) will be saved in the compiled AssemblyB code. Thus, if in future, I decide to change the value of ConstVal from 5 to 10, then I have to build both the assemblies again.

Where as, the readonly variable ReadOnlyVal is stored as a ref (memory location) to the variable & if I decide to change the value of ReadOnlyVal in future from 10 to 20, I do not need to rebuild both of the assemblies. Instead, I will build only the AssemblyA containing ClassA & the changed value will be picked up by the AssemblyB’s reference to that readonly variable.