C# constants tutorial with code examples

In C#, constants are a way to define values that do not change throughout the program’s execution. Using constants is an excellent way to improve code readability, maintainability, and reduce errors by giving meaningful names to fixed values.

In this tutorial, we’ll cover the following topics:

Let’s dive into each section with examples!

1. Declaring Constants

In C#, constants are declared using the const keyword. They must be assigned a value at the time of declaration, and this value cannot be changed later in the program.

Syntax:

const <data_type> <constant_name> = <value>;

Example:

using System;

public class ConstantsExample
{
    // Declaring constants
    const int DaysInWeek = 7;
    const double Pi = 3.14159;

    public static void Main()
    {
        Console.WriteLine("Days in a week: " + DaysInWeek);
        Console.WriteLine("Value of Pi: " + Pi);
    }
}

In this example:

• DaysInWeek and Pi are constants.
• Attempting to change them later in the code will result in a compilation error.

2. Using Constants

Constants can be used anywhere in the code where a fixed value is required. They are especially useful for values that have a clear meaning, like mathematical constants or business-related values.

Example:

using System;

public class AreaCalculator
{
    const double Pi = 3.14159;

    public static void Main()
    {
        double radius = 5.0;
        double area = Pi * radius * radius;

        Console.WriteLine("Area of the circle with radius 5: " + area);
    }
}

Here, the Pi constant is used to calculate the area of a circle. Using Pi as a constant instead of a hardcoded number enhances readability and makes the code easier to understand.

3. Constants with Arithmetic Expressions

Constants can also be involved in arithmetic expressions to define derived constant values.

Example:

using System;

public class MathConstants
{
    const int CircleDegree = 360;
    const double HalfCircleDegree = CircleDegree / 2.0;
    const double QuarterCircleDegree = CircleDegree / 4.0;

    public static void Main()
    {
        Console.WriteLine("Half Circle: " + HalfCircleDegree + " degrees");
        Console.WriteLine("Quarter Circle: " + QuarterCircleDegree + " degrees");
    }
}

In this example:

• HalfCircleDegree and QuarterCircleDegree are constants derived from the CircleDegree constant.
• Defining related values in this way makes them consistent and helps avoid calculation errors throughout the code.

4. Scope of Constants

Constants have the same scope rules as variables in C#. They can be declared at different levels, such as:

• Within a class (class-level constants)
• Within a method (method-level constants)

Example:

using System;

public class ScopeExample
{
    const string Greeting = "Hello"; // Class-level constant

    public static void Main()
    {
        const string Name = "John"; // Method-level constant
        Console.WriteLine(Greeting + ", " + Name + "!");
    }
}

In this example:

• Greeting is a class-level constant accessible from any method in the class.
• Name is a method-level constant, accessible only within the Main method.

5. Constants vs. Readonly Fields

In C#, readonly fields and const fields are both used to represent values that should not change. However, there are some key differences:

• const values are compile-time constants, meaning they are set during compilation.
• readonly fields can only be assigned a value at declaration or in a constructor, so they can represent runtime constants.

Example of readonly:

using System;

public class ReadOnlyExample
{
    public readonly double Radius;

    public ReadOnlyExample(double radius)
    {
        Radius = radius; // Value can be assigned in the constructor
    }

    public static void Main()
    {
        ReadOnlyExample circle = new ReadOnlyExample(5.0);
        Console.WriteLine("Radius: " + circle.Radius);
    }
}

In this example:

• Radius is a readonly field that can be assigned when an object is instantiated, making it flexible for runtime values.

Summary Comparison

Summary

Constants in C# are essential for values that should not change.

They enhance readability, prevent errors, and are particularly useful in areas like:

• Defining fixed mathematical constants (Pi, E, etc.).
• Setting application-wide constant values (e.g., configuration limits).
• Declaring values in calculations or expressions that are used repeatedly.