Readonly and Constant Variables in C#

Vithal Wadje

3y299.7k11100Article

C# variableConstant in C#C# readonlyreadonly variable

11 Comments

Join the conversation! Your thoughts help the community grow.

Amin Rezaei2y ago
Const fields cannot be used with a static modifier, while readonly fields can be used with a static modifier.
Amin Rezaei2y ago
Which is true??
Amin Rezaei2y ago
Readonly can not be declared using static keywords because they are, by default, static.
ashok kumar5y ago
Simple and awesome explanation.
Ed Isenberg6y ago
This should be corrected. Readonly can be declared static.
Sangeeta Singh7y ago
Readonly are not static implicitly and can be declared static if required.
jubula samal8y ago
Nicely explained along with example. Got clear everything on constant and readonly
ashish mistry8y ago
Above you have mentioned "Readonly can not be declared using static keyword because they are by default static.". are you sure ?
Avinava Basu9y ago
But my question is why are we not able to change a 'const' variable(not readonly)? What's so unique about it? Is it stored somewhere that cannot be accessed?
Vithal Wadje11y ago
Dan Schroeder sir for you valuable feedback and reading ,yes I have sent request to Content manager Dinesh Beniwal sir to correct grammatical mistakes of this article .you will see change within 24 hr. again thanks
Dan Schroeder11y ago
Nice article, but there are so many spelling, grammar, and copy/paste errors in it, that some of the information is confusing, hard to follow, or just plain wrong. I've used const and readonly for a long time, so I understood what you were getting at, but you should give this another read-through or two and fix it up to help less experienced C# developers.

Introduction

Whenever I interview any candidate, I always ask this question, "what are readonly and constant variables?" What is the difference between a const and a readonly in C#? Believe me, even the most experienced candidates get confused. In this article, let's learn what const and readonly are in C# and when to use them.

What is a Constant variable ib C#?

A variable whose value can not be changed during the execution of the program is called a constant variable. The cost keyword in C# is used to declare a constant variable.

In the above definition, the value can not be changed during the execution of the program, which means we cannot assign values to the constant variable at run time. Instead, it must be assigned at the compile time.

There are two types of constants in C#, compile-time constant and runtime constant.

In the above diagram, we can see the Constants are of two types

Compile time constants (const)
Runtime constants (Readonly)

Compile time constants

The compile time constants are declared by using the const keyword, in which the value can not be changed during the execution of the program.

Syntax

int const a=10;

Some key points about const variable

It must be assigned a value at the time of declaration.
```
int const a=10;
```

const only allows constant variables into the expression.

int const a=10;
int const b=20; // correct
int const c=a+b; 

int  d=1;
int const c=d+b;   //compile time error because d variable is the non constant into expression.

const can be declared at the class level and inside the method.
const can not be declared using static keywords because they are, by default, static.
constants are absolute constants whose values cannot be changed or assigned at the run time.
constant variables are compile-time variables.

When to use const

The const is used when its value is constant. Such PI values cannot be changed, but according to your needs, you can use them as you wish rather than declaring PI values.

Example of const variable.

using System;  
  
namespace UsingConst  
{  
    class Program  
    {  
        const int a = 10;  
           
       static void Main(string[] args)  
        {  
            const int b = 20;  
            const int c = b + a;  
            Console.WriteLine(c);  
            Console.ReadLine();  
        }  
    }  
}

The output of the above program is 30. From the above example, we see that the const must be assigned the value at declaration time, and in expression, both the variables must be const.

Runtime constants (Readonly)

The Run time constants are declared by using the Readonly keyword, whose value can not be changed during the execution of the program.

int Readonly a; or
int Readonly a=0;

Some key points about const variable

It's not just to assign a value at the time of declaration. We can also assign the value for read-only through the constructor
```
int readonly a;
a=0;
```
Readonly allows readonly constant and non read-only constant variables into the expression.
```
int readonly a=10;

int b=1;
int readonly c=a+b;
```
Readonly can be declared only at the class level, not inside the method.
Readonly can not be declared using static keywords because they are, by default, static.
Readonly constant's value can be set through the reference variable.
Readonly constant variables are runtime time constant variables.

When to use Readonly

We can use Readonly when its value is not an absolute constant, which means it can be changed frequently, such as dollars vs INR. In this requirement, we can set the value through a configuration file or another variable expression to avoid changing the class file frequently.

Example of Readonly variable

Let's define the value from the config file for a readonly constant variable, which will be set through the constructor.

<configuration>  
  <appSettings>   
    <add key="DollarPrice" value="61.23"/>  
  </appSettings>
</configuration>

Now, let us explain it through this sample program

using System;  
using System.Configuration;  
  
namespace Usingreadonly
{  
    class Program  
    {  
        readonly int a = 10;  
        int b = 30;  
        int c;  
        readonly string r;  
        public Program()  
        {  
            r = ConfigurationManager.AppSettings["DollarPrice"];  
            Console.WriteLine("The dollar value is:"+" "+r);  
            Console.WriteLine();  
            c = a + b;  
            Console.WriteLine("The addition of readonly constant and non Readonly constant is :"+Environment.NewLine+ c);  
            Console.ReadLine();  
        }  
  
        static void Main(string[] args)  
        {  
            Program p = new Program();  
             
            Console.ReadLine();  
        }  
    }  
}

In the above program, we have assigned the value for the readonly constant through the constructor defined in the config file since a readonly constant isn't necessary to assign the value at the time of declaration.

Now run the program. The output will be:

Let us outline the differences between const and readonly variables.

const fields need to be initialized with declaration only, while readonly fields can be initialized at the declaration or in the constructor.
const variables can be declared in methods, while readonly fields cannot be declared in methods.
const fields cannot be used with a static modifier, while readonly fields can be used with a static modifier.
const field is a compile-time constant. The readonly field can be used for run-time constants.

Summary

I hope this article is useful for potential interviews. If you have any suggestions regarding this article, then don't hesitate to get in touch with me.