C#每日面试题-常量和只读变量的区别
在C#开发中，常量（const）和只读变量（readonly）是两种常用的"不可修改"变量类型，初学者很容易混淆------它们看似都不能被重新赋值，实则在编译时机、赋值规则、适用场景等核心维度存在本质差异。这也是面试中考察基础语法功底的高频考点，很多开发者因为没吃透底层逻辑而丢分。今天我们就从"定义本质、核心特性、代码实践、区别总结、面试坑点"五个层面，彻底讲清两者的区别与适用场景。
一、先搞懂：常量和只读变量分别是什么？
在讲区别之前，我们先明确两者的核心定义和本质------这是理解后续差异的基础：
1. 常量（const）：编译时就"刻死"的值
常量是用 const 关键字声明的变量，本质是"编译时常量"。它的核心特点是：值必须在声明时确定，且在编译阶段就被直接嵌入到生成的IL代码中。简单说，常量就像一个"硬编码的数值标签"，程序运行时根本不会为它分配独立的内存空间，而是直接使用它的字面量。
语法格式：访问修饰符 const 数据类型 常量名 = 常量值;
2. 只读变量（readonly）：运行时才"固定"的值
只读变量是用 readonly 关键字声明的变量，本质是"运行时常量"。它的核心特点是：值可以在声明时确定，也可以在构造函数中确定，在程序运行阶段才会分配内存并赋值。只读变量更像一个"一旦赋值就锁死的容器"，运行时会占用独立内存，只是赋值后无法修改。
语法格式：访问修饰符 readonly 数据类型 变量名;（赋值可在声明时或构造函数中）
核心本质区别：常量的"不可修改"是编译期强制的（值直接嵌入代码），只读变量的"不可修改"是运行期强制的（内存赋值后锁死）。
二、核心特性对比：从5个关键维度拆解
我们通过"赋值时机、数据类型限制、内存分配、访问修饰符、继承与实例化"5个核心维度，对比两者的特性差异，再结合代码示例加深理解：
1. 赋值时机：编译时确定 vs 运行时确定
-
常量（const）：必须在声明时直接赋值，且赋值的表达式必须是"编译时就能计算出结果"的常量表达式（比如字面量、其他常量的运算、枚举值等）。不允许在构造函数或其他方法中赋值。
-
只读变量（readonly）：有两种赋值时机------① 声明时直接赋值（可选）；② 在当前类的实例构造函数或静态构造函数中赋值（仅能赋值一次）。支持使用运行时才能确定的值（比如方法返回值、用户输入、配置文件读取结果等）。
代码示例：
csharp
using System;
using System.Configuration;
public class Test
{
// 1. 常量：必须声明时赋值，且值为编译时常量
public const int ConstNum = 100; // 合法：字面量（编译时确定）
public const int ConstSum = ConstNum + 50; // 合法：常量表达式（编译时可计算）
// public const int ConstErr = DateTime.Now.Year; // 非法：DateTime.Now.Year是运行时确定的值
// 2. 只读变量：可声明时赋值，或构造函数中赋值
public readonly int ReadOnlyNum1 = 200; // 合法：声明时赋值
public readonly int ReadOnlyNum2;
public static readonly int StaticReadOnlyNum;
// 实例构造函数：给实例只读变量赋值
public Test()
{
ReadOnlyNum2 = 300; // 合法：实例构造函数中赋值
// ReadOnlyNum1 = 400; // 非法：已在声明时赋值，不可重复赋值
}
// 静态构造函数：给静态只读变量赋值
static Test()
{
// 合法：使用运行时确定的值（读取配置文件）
StaticReadOnlyNum = int.Parse(ConfigurationManager.AppSettings["MaxCount"]);
}
}2. 数据类型限制：仅值类型 vs 任意类型
-
常量（const）：仅支持"值类型"和"string类型"，不支持引用类型（除string外）。因为引用类型的对象需要在运行时分配内存，无法在编译时确定其引用地址。
-
只读变量（readonly）：支持任意数据类型------值类型（int、bool、DateTime等）、引用类型（string、数组、自定义类等）。注意：对于引用类型的只读变量，"不可修改"的是"引用地址"，而非引用对象的内部成员（对象内部属性仍可修改）。
代码示例：
csharp
using System;
public class Person
{
public string Name { get; set; }
public int Age { get; set; }
}
public class Test
{
// 1. 常量的类型限制
public const string ConstStr = "Hello"; // 合法：string类型（特殊的引用类型，编译时可确定）
// public const Person ConstPerson = new Person(); // 非法：引用类型（除string外）不支持const
// 2. 只读变量的类型支持
public readonly Person ReadOnlyPerson = new Person { Name = "张三", Age = 25 }; // 合法：引用类型
public readonly int[] ReadOnlyArray = new int[] { 1, 2, 3 }; // 合法：数组（引用类型）
public void ModifyReadOnlyObj()
{
// 合法：修改引用对象的内部成员（只读变量锁的是引用地址，不是对象内容）
ReadOnlyPerson.Age = 30;
ReadOnlyArray[0] = 100;
// 非法：修改只读变量的引用地址（重新赋值）
// ReadOnlyPerson = new Person();
// ReadOnlyArray = new int[] { 4, 5, 6 };
}
}3. 内存分配：无内存 vs 有内存
-
常量（const） ：编译时会被直接替换为字面量，程序运行时不会为常量分配独立的内存空间。比如
int a = ConstNum;编译后会直接变成int a = 100;。 -
只读变量（readonly）：运行时会为其分配独立的内存空间（实例只读变量分配在堆上，静态只读变量分配在静态内存区），变量存储的是具体的值或引用地址。
4. 访问修饰符：默认private vs 支持任意修饰符
-
常量（const） ：默认访问修饰符是
private，如果需要外部访问，必须显式指定public等修饰符。 -
只读变量（readonly）：支持所有访问修饰符（public、private、protected、internal等），无默认修饰符（需显式指定）。
5. 继承与实例化：静态特性 vs 实例/静态均可
-
常量（const） ：天生是静态的（static），无需也不能加
static关键字，直接通过"类名.常量名"访问，不能通过实例访问。 -
只读变量（readonly） ：可分为"实例只读变量"和"静态只读变量"------① 实例只读变量：无
static，通过实例访问，每个实例的只读变量值可不同；② 静态只读变量：加static，通过类名访问，整个程序域内值唯一。
代码示例：
csharp
public class Test
{
// 常量：天生静态，通过类名访问
public const int ConstVal = 100;
// 实例只读变量：通过实例访问
public readonly int InstanceReadOnlyVal;
// 静态只读变量：通过类名访问
public static readonly int StaticReadOnlyVal = 200;
// 不同实例的只读变量可赋值为不同值
public Test(int val)
{
InstanceReadOnlyVal = val;
}
}
// 调用示例
class Program
{
static void Main()
{
// 常量：类名直接访问
Console.WriteLine(Test.ConstVal);
// 静态只读变量：类名直接访问
Console.WriteLine(Test.StaticReadOnlyVal);
// 实例只读变量：通过实例访问，不同实例值可不同
Test t1 = new Test(300);
Test t2 = new Test(400);
Console.WriteLine(t1.InstanceReadOnlyVal); // 输出300
Console.WriteLine(t2.InstanceReadOnlyVal); // 输出400
}
}三、核心区别总结表（面试必背）
| 对比维度 | 常量（const） | 只读变量（readonly） |
|---|---|---|
| 本质 | 编译时常量，值嵌入IL代码 | 运行时常量，内存中存储值/引用 |
| 赋值时机 | 仅能在声明时赋值，且为编译时常量表达式 | 声明时或构造函数中赋值（仅一次），支持运行时确定值 |
| 数据类型限制 | 仅支持值类型和string | 支持任意数据类型（值类型、引用类型） |
| 内存分配 | 无独立内存，值直接替换 | 有独立内存（堆/静态区） |
| 访问修饰符 | 默认private，需显式指定public | 支持所有修饰符，需显式指定 |
| 静态特性 | 天生静态，无需static，类名访问 | 可实例/静态（加static），实例访问/类名访问 |
| 引用类型支持 | 仅支持string，不支持其他引用类型 | 支持所有引用类型，锁引用地址不锁对象内容 |
| 修改影响 | 修改后需重新编译所有引用它的项目（否则用旧值） | 修改后仅需编译当前项目，引用项目无需重新编译 |
四、面试高频考点与易错点（避坑指南）
1. 高频面试题及标准答案
-
问：C#中const和readonly的核心区别是什么？
答：核心区别在于"值确定的时机"------const是编译时常量，值必须在声明时确定且嵌入代码，无内存；readonly是运行时常量，值可在构造函数中确定，有独立内存。此外，const仅支持值类型和string，天生静态；readonly支持任意类型，可实例可静态。
-
问：为什么const不能用于引用类型（除string外）？
答：因为引用类型的对象需要在运行时分配内存并确定引用地址，而const是编译时常量，编译时无法确定引用地址，因此仅支持string（C#对string做了特殊优化，编译时可确定其字面量）。
-
问：readonly引用类型变量，能修改其内部成员吗？为什么？
答：可以。因为readonly限制的是"变量的引用地址"（不能重新赋值），而非"引用对象的内容"。对象的内部属性/字段属于对象本身，与变量的引用地址无关，因此可以修改。
-
问：修改const常量后，为什么引用它的项目必须重新编译？
答：因为const的值在编译时会直接嵌入到引用项目的IL代码中，而非运行时读取。如果不重新编译引用项目，引用项目会继续使用旧的嵌入值，导致程序异常。而readonly存储在内存中，修改后仅需编译当前项目，引用项目运行时会读取新值。
2. 开发/面试易错点
-
易错点1：给const加static关键字------错误！const天生是静态的，加static会编译报错。
-
易错点2：在普通方法中给readonly变量赋值------错误！readonly仅能在声明时或构造函数中赋值，普通方法中无法修改。
-
易错点3：认为readonly引用类型变量不可修改------错误！仅引用地址不可修改，对象内部成员可正常修改。
-
易错点4：用运行时变量给const赋值------错误！const必须用编译时可确定的常量表达式赋值（如字面量、其他const）。
五、实际开发场景：该用const还是readonly？
记住两个核心原则，轻松选择：
-
如果值是"永远不变的固定常量"（比如数学常数π、固定的状态码、字符串常量），且类型是值类型或string------用const。
示例：
public const double Pi = 3.1415926;、public const int SuccessCode = 200; -
如果值需要"运行时确定"（比如读取配置文件、方法返回值、用户输入），或类型是引用类型（除string外），或需要每个实例有不同的固定值------用readonly。
示例：
public static readonly string ConnectionString = ConfigurationManager.ConnectionStrings["Default"].ConnectionString;、public readonly Person CurrentUser;
总结
const和readonly的核心区别，本质是"编译时"与"运行时"的差异------const是"硬编码的固定值"，高效但灵活度低；readonly是"运行时固定的容器"，灵活度高但有内存开销。理解这一点，就能轻松区分两者的用法和适用场景。
面试中考察这两个知识点，不仅是考察语法记忆，更考察对C#编译原理和内存模型的理解。建议结合上面的代码示例动手实践，尤其是"readonly引用类型的修改"和"不同赋值时机的差异"，加深对底层逻辑的理解。
如果有疑问或其他开发中的实战问题，欢迎在评论区交流～