What is Constants(const) in C#?


Constants are immutable values that are known at compile time and do not change for the life of the program. Constants are declared with the const modifier. Only the C# built-in types may be declared as const. Reference type constants other than String can only be initialized with a null value. User-defined types, including classes, structs, and arrays, cannot be const. Use the readonly modifier to create a class, struct, or array that is initialized one time at run time (for example, in a constructor) and thereafter cannot be changed.

C# does not support const methods, properties, or events.

The enum type enables you to define named constants for integral built-in types (for example, int, uint, long, and so on). For more information, see enum.

Constants must be initialized as they are declared. For example:

class Calendar1
    public const int Months = 12;

In this example, the constant Month is always 12, and it cannot be changed even by the class itself. In fact, when the compiler encounters a constant identifier in C# source code (for example, Months), it substitutes the literal value directly into the intermediate language (IL) code that it produces. Because there is no variable address associated with a constant at run time, const fields cannot be passed by reference and cannot appear as an l-value in an expression.

Note. Use caution when you refer to constant values defined in other codes, such as DLLs. If a new version of the DLL defines a new value for the constant, your program will still hold the old literal value until it is recompiled against the new version.

Multiple constants of the same type can be declared at the same time, for example:

class Calendar2
    public const int Months = 12, Weeks = 52, Days = 365;

The expression that is used to initialize a constant can refer to another constant if it does not create a circular reference. For example:

class Calendar3
    public const int Months = 12;
    public const int Weeks = 52;
    public const int Days = 365;

    public const double DaysPerWeek = (double) Days / (double) Weeks;
    public const double DaysPerMonth = (double) Days / (double) Months;

Constants can be marked as public, private, protected, internal, protected, internal, or private protected. These access modifiers define how users of the class can access the constant. For more information, see Access Modifiers.

Constants are accessed as if they were static fields because the value of the constant is the same for all instances of the type. You do not use the static keyword to declare them. Expressions that are not in the class that defines the constant must use the class name, a period, and the name of the constant to access the constant. For example:

int birthstones = Calendar.Months;

Characteristics of Constants

  1. Immutable: Once initialized, the value of a constant cannot be modified or reassigned.
  2. Known at Compile-Time: Constant values must be known at compile-time and cannot be computed at runtime.
  3. Scoped: Constants are scoped to the block in which they are defined, similar to variables.
  4. Type-Specific: Constants must be of a specific data type, such as int, string, or double.

Benefits of Constants

  1. Readability: Constants improve code readability by providing descriptive names for fixed values.
  2. Maintainability: By centralizing fixed values in constants, it becomes easier to modify them later if needed, reducing the risk of errors.
  3. Performance: Constants are resolved at compile-time, resulting in potentially faster execution compared to variables.
  4. Compiler Optimization: Constants can enable certain compiler optimizations, leading to more efficient code generation.

Best Practices for Using Constants:

  1. Descriptive Naming: Use descriptive names for constants to convey their purpose and usage clearly.
  2. Grouping: Group related constants together to organize them logically, improving code organization.
  3. Avoid Magic Numbers: Replace magic numbers in your code with named constants to enhance readability and maintainability.
  4. Use Constants for Read-Only Values: Reserve constants for values that are truly constant and not subject to change during runtime.
  5. Consider Enums: For related constant values, consider using enums instead of individual constants to create more expressive and type-safe code.


Constants play a vital role in C# programming, providing a mechanism for defining and using fixed values throughout your code. By leveraging constants effectively, you can improve code readability, maintainability, and performance. Understanding when and how to use constants is essential for writing clear, efficient, and maintainable C# code.

Similar Articles