C# interview questions: What is the Difference Between `const`, `readonly`, and `static` in C#

What is the Difference Between const, readonly, and static in C#?

In C#, there are three commonly used keywords to manage constants and static members: const, readonly, and static. While they all affect how values are stored and used, they have different applications and rules.

Quick Answer:

• const: Represents constant values that are known at compile time. These values cannot be changed once declared.
• readonly: Variables that can only be assigned at declaration or in a constructor, and are fixed for the lifetime of the object instance.
• static: Variables or methods that belong to the class itself rather than any instance of the class.

What is const in C#?

The const keyword defines a constant value that cannot be modified after its declaration. It must be initialized at the time of declaration, and the value is embedded into the code at compile time.

Example:

public class MathConstants
{
    public const double Pi = 3.14159;
}

What is readonly in C#?

The readonly keyword allows a variable to be initialized either at the point of declaration or in a constructor. After the variable is assigned, it cannot be modified. It is typically used for runtime constants.

Example:

public class Example
{
    public readonly int Year;

    public Example(int year)
    {
        Year = year; // Value can be set in the constructor
    }
}

What is static in C#?

The static keyword means that a variable or method belongs to the class itself, rather than to instances of the class. This means the variable or method can be accessed without creating an instance of the class.

Example:

public class Calculator
{
    public static int Counter;

    public static int Add(int a, int b)
    {
        return a + b;
    }
}

5Ws Explanation

1. What:

• const: A compile-time constant.
• readonly: A runtime constant, assigned either at declaration or in the constructor.
• static: A class-level variable or method that belongs to the class itself.

2. Why:

• Use const for values that are known at compile time and will never change.
• Use readonly for values that can only be set at runtime but must remain constant once assigned.
• Use static for members that should be shared across all instances of a class.

3. When:

• const: When you have values like mathematical constants that won’t change.
• readonly: When you need to initialize a value at runtime but don’t want it to change afterward.
• static: When you need class-level functionality that is shared across all instances.

4. Where:

• const and readonly are used for constants in fields.
• static can be used for methods or fields that don’t depend on the instance of the class.

5. Who:

• Developers use const and readonly for defining constants in their applications.
• static is used by developers when creating utility methods or class-wide states like counters.

Code Examples

1. const Example:

public class Constants
{
    public const double Gravity = 9.81;
    // Cannot be changed once declared
}

2. readonly Example:

public class Config
{
    public readonly string ConnectionString;

    public Config(string connectionString)
    {
        ConnectionString = connectionString; // Can only be set in the constructor
    }
}

3. static Example:

public class Logger
{
    public static int LogCount;

    public static void Log(string message)
    {
        LogCount++;
        Console.WriteLine(message);
    }
}

Key Points & Tips

• Tip 1: Use const for values that you know will never change at compile time (like Pi or mathematical constants).

  提示1：对于编译时确定且永不改变的值（例如圆周率 Pi），使用 const。

• Tip 2: Use readonly for values that need to be initialized at runtime but shouldn’t change afterward, like configuration settings or object properties.

  提示2：对于运行时初始化但之后不能更改的值（例如配置设置或对象属性），使用 readonly。

• Tip 3: Use static for members that should be shared among all instances of a class, such as utility functions or global counters.

  提示3：对于类的所有实例共享的成员（例如工具函数或全局计数器），使用 static。

Comparison Table: const vs readonly vs static

Interview Questions (中英对照)

Q1. What is the difference between const and readonly in C#?

In C#, const is a compile-time constant, meaning its value is set at compile time and cannot change. readonly is a runtime constant, meaning its value can be set in the constructor but cannot be modified afterward.

Q1. C# 中 const 和 readonly 有什么区别？

在 C# 中，const 是编译时常量，表示它的值在编译时设置且无法更改。而 readonly 是运行时常量，表示它的值可以在构造函数中设置，但之后无法修改。

Q2. When would you use static in C#?

static is used when a member belongs to the class itself, rather than any specific instance. It is typically used for utility functions or global counters that should be shared among all instances of a class.

Q2. 你会在何时使用 C# 中的 static？

static 用于成员属于类本身，而不是特定实例时。它通常用于类的所有实例之间共享的工具函数或全局计数器。

Q3. Can a readonly field be static in C#?

Yes, a readonly field can be static. This means the field can be initialized at runtime and its value will be shared across all instances, but it cannot be modified after initialization.

Q3. 在 C# 中，readonly 字段可以是静态的吗？

可以，readonly 字段可以是静态的。这意味着该字段可以在运行时初始化，其值将在所有实例之间共享，但初始化后无法修改。

Q4. What happens if you try to modify a const value at runtime?

You will get a compile-time error because const values are determined at compile time and cannot be modified during the execution of the program.

Q4. 如果在运行时尝试修改 const 值会发生什么？

你会得到一个编译时错误，因为 const 值在编译时确定，在程序执行期间无法修改。

Conclusion

Understanding the differences between const, readonly, and static is essential for writing efficient and maintainable C# code. Use const for compile-time constants, readonly for values that need to be set at runtime but not modified afterward, and static for class-level members that should be shared across all instances.

结论

理解 C# 中 const、readonly 和 static 之间的区别对于编写高效和可维护的代码至关重要。使用 const 定义编译时常量，使用 readonly 定义运行时初始化但不可修改的值，使用 static 定义类级别的共享成员。

Would you like to explore more on this topic or examples of usage in real-world scenarios?