Constants in .NET

There are two types of constants available in c#:

Compile-time constants and runtime constants. They have different behaviors and

using wrong one will cost you performance or correctness.

But Runtime constants are always preferable over

compile-time constants. Though the compile-time constants are slightly faster

but they are not flexible with compare to runtime constants.

The compile-time constants are preferable when performance

is really required and you don’t have any requirements to change the value of

that constant.

Compile-time constant are declared using “const” keyword:

Eg: public const int a=10;

Run-time constants are declared using “readonly” keyword:

Eg: public readonly int a=10;

       CONSTANT                                          READONLY

compile-time – “Const”	run-time – “readonly”
compile-time constant can be declared at class  level	Run-time constant can be declared at class level
compile-time constant can be declared at method  level	Run-time constant Cannot be declared at method level
A compile-time constant is  replaced with the value of that constant in object code. Eg:  public const int a=10;  int b=20;    if(b==a)    compiles to the same IL as if you   had written this:    if(b==10)// means instead of     comparing with variable ‘a’ it   will write its value in compiler-    generated IL. Which increase     speed but for   various situations its not     preferable.	Runtime constants are evaluated at runtime. The IL generated when you reference a read-only constant references the “readonly “ variable, not the value. Eg: public const int a=10; int b=20; if(b==a) compiles to the same IL as if you had written this: if(b==a)// so instead of placing its value as like it do with “const”,  its place variable for “readonly” variables in compiler-generated IL.
compile-time constant cannot     initialize using thenew operator,   even when the type being   initialized is a value type.	runtime constants can be of any type, They must be initialized using constructor, or using initializer.
Compile-time constants can be   used only for primitive types   (built-in integral and floating-    point types), enums, or strings.   These are the only types that     enable you to assign meaningful   constant values in initializers.   As we know that for “const” type   in compiler-generated IL the   variables get replaces with vales   so,these primitive types are the   only ones   that can be replaced with literal    values. in the compiler-generated   IL.	runtime constants can be of any type. Read-only values are also constants, in that they cannot be modified after the constructor has executed. But read-only values are different in that they are assigned at runtime.
Compile-time constants are much    more better in performance but     less flexible with compare     to run-time constants.	Run-time constants are much more flexible but its performance is slower with compare to compile-time constants.
Compile-time constants are, by   definition, static     constants.	readonly values can be used for instance constants, storing different values for each instance of a class type.
Every time application assembly    need to be rebuilt whenever    library assembly which contains      constant gets its constant value    changed ( as the compiler-      generated IL contains values of      compile-time constants instead of         referring variable)	No need to rebuild Application assembly which is referring a library assembly which contains run-time constants whose value is changed and its assembly is rebuilt.

The final advantage of using const over readonly is

performance: Known constant values can generate slightly more efficient code

than the variable accesses necessary for readonly values.

However, any gains are slight and should be weighed against the decreased

flexibility. Be sure to profile performance differences before giving up the

flexibility.