在C#中常量和只读之间有什么区别？
你什么时候会用一个代替另一个？
这说明了这一点。概要：const必须在声明时初始化，readonly可以在构造函数上初始化（因此，根据使用的构造函数，其值不同）。
编辑：关于细微的差异，请参见上面吉树的gotcha
const是编译时常量，而readonly允许在运行时计算值并在构造函数或字段初始值设定项中设置。因此，“const”总是常量，但“readonly”在赋值后是只读的。
C#团队的埃里克·里佩尔（Eric Lippert）有更多关于不同类型不变性的信息。
除了
必须在常量VS只读值的定义时声明该值可以动态计算，但需要在构造函数退出之前赋值。之后，它被冷冻。常量是隐式静态的。您使用ClassName.ConstantName符号来访问它们。
有一个微妙的区别。考虑AssemblyA中定义的类。
public class Const_V_Readonly
{
public const int I_CONST_VALUE = 2;
public readonly int I_RO_VALUE;
public Const_V_Readonly()
{
I_RO_VALUE = 3;
}
}
AssemblyB引用AssemblyA并在代码中使用这些值。编译时：
对于常量值，它就像查找替换。值2被“烘焙”到AssemblyB的IL中。这意味着如果明天我将I_CONST_value更新为20，AssemblyB仍将有2，直到我重新编译它。在只读值的情况下，它类似于对内存位置的引用。该值不会烘焙到AssemblyB的IL中。这意味着如果更新了内存位置，AssemblyB将在不重新编译的情况下获得新值。因此，如果I_RO_VALUE更新为30，则只需要构建AssemblyA，而不需要重新编译所有客户端。
因此，如果你确信常数的值不会改变，那么使用常量。
public const int CM_IN_A_METER = 100;
但是，如果您有一个可能会改变的常数（例如w.r.t.精度），或者当有疑问时，请使用只读。
public readonly float PI = 3.14;
更新：阿库需要被提及，因为他首先指出了这一点。此外，我需要插入我学到的内容：有效的C#-比尔·瓦格纳
标记为const的变量只不过是强类型的#define宏，在编译时，const变量引用被替换为内联文本值。因此，只能以这种方式使用某些内置基元值类型。标记为只读的变量可以在运行时在构造函数中设置，并且它们的只读性也在运行时强制执行。与此相关的性能开销较小，但这意味着您可以对任何类型（甚至引用类型）使用只读。
此外，常量变量本质上是静态的，而只读变量如果需要可以是特定于实例的。
另外，只读引用类型只会使引用只读，而不会使值只读。例如：
public class Const_V_Readonly
{
public const int I_CONST_VALUE = 2;
public readonly char[] I_RO_VALUE = new Char[]{'a', 'b', 'c'};
public UpdateReadonly()
{
I_RO_VALUE[0] = 'V'; //perfectly legal and will update the value
I_RO_VALUE = new char[]{'V'}; //will cause compiler error
}
}
有一件事要补充人们上面所说的。如果程序集包含只读值（例如，只读MaxFooCount=4；），则可以通过使用不同的值（例如只读MaxFooCount=5；）发送该程序集的新版本来更改调用程序集看到的值
但如果使用常量，则在编译调用者时，它将被折叠到调用者的代码中。
如果你已经达到了C#的熟练程度，你就可以阅读比尔·瓦格纳的书《有效的C#：提高你的C语言的50种具体方法》了#它详细回答了这个问题（以及其他49个问题）。
关键区别在于Const是#DEFINE的C等价物。这个数字实际上被替换为a-la预编译器。只读实际上被视为一个变量。
当项目A依赖于项目B中的公共常数时，这种区别尤其重要。假设公共常数发生变化。现在，您选择const/readonly将影响项目A的行为：
Const：项目A不会捕获新值（当然，除非使用新的Const重新编译），因为它是使用中的子常量编译的。
ReadOnly：项目A将始终向项目B请求其变量值，因此它将获取B中公共常量的新值。
老实说，我建议您对除真正的通用常数（例如Pi、Inches_To_厘米）之外的几乎所有内容都使用只读。对于任何可能改变的内容，我建议使用只读。
希望这有帮助，艾伦。
它们都是常量，但在编译时也可以使用常量。这意味着差异的一个方面是，可以使用常量变量作为属性构造函数的输入，但不能使用只读变量。
例子：
public static class Text {
public const string ConstDescription = "This can be used.";
public readonly static string ReadonlyDescription = "Cannot be used.";
}
public class Foo
{
[Description(Text.ConstDescription)]
public int BarThatBuilds {
{ get; set; }
}
[Description(Text.ReadOnlyDescription)]
public int BarThatDoesNotBuild {
{ get; set; }
}
}
又一次抓住了。由于const实际上只适用于基本数据类型，如果您想使用类，您可能会感到“被迫”使用ReadOnly。然而，当心陷阱！ReadOnly表示不能用其他对象替换对象（不能使其引用其他对象）。但是任何引用对象的进程都可以自由修改对象内的值！因此，不要困惑地认为ReadOnly意味着用户无法更改内容。C#中没有简单的语法可以防止类的实例化更改其内部值（据我所知）。
我们办公室的一名团队成员就何时使用常量、静态和只读提供了以下指导：
当您有一个在运行时可以知道的类型的变量（string literal、int、double、enums…），您希望类的所有实例或使用者都可以访问值不应更改的位置时，请使用const。如果您希望类的所有实例或使用者都可以访问值可以更改的数据，请使用静态。当您有一个在运行时无法知道的类型的变量（对象），您希望类的所有实例或使用者都可以访问值不应更改的位置时，请使用静态只读。当您有一个实例级变量时，您将在创建对象时知道该变量不应更改，请使用readonly。
最后一个注意事项：常量字段是静态的，但反之则不是真的。
有一个只读的小陷阱。只读字段可以在构造函数中设置多次。即使在两个不同的链式构造函数中设置了该值，它仍然是允许的。
public class Sample {
private readonly string ro;
public Sample() {
ro = "set";
}
public Sample(string value) : this() {
ro = value; // this works even though it was set in the no-arg ctor
}
}
常量
默认情况下，常量是静态的它们在编译时必须有一个值（例如3.14*2，但不能调用方法）无法在函数中声明复制到使用它们的每个程序集中（每个程序集都获得值的本地副本）可用于属性
只读实例字段
在构造函数退出时必须具有设置值在创建实例时计算
静态只读字段
当代码执行命中类引用时（当创建新实例或执行静态方法时）在完成静态构造函数时必须具有计算值不建议将ThreadStaticAttribute放在这些线程上（静态构造函数将仅在一个线程中执行，并将为其线程设置值；所有其他线程将未初始化此值）
下面是另一个链接，演示const如何不是版本安全的，或者与引用类型无关。
摘要：
const属性的值在编译时设置，不能在运行时更改Const不能被标记为静态的-关键字表示它们是静态的，而只读字段则可以。Const不能是除值（基元）类型以外的任何类型readonly关键字将字段标记为不可更改。但是，属性可以在类的构造函数内更改readonly关键字还可以与static组合，使其以与常量相同的方式（至少在表面上）起作用。当你观察两者之间的IL时，有一个显著的差异常量字段在IL中标记为“literal”，而readonly为“initonly”
常量将作为文本值编译到使用者中，而静态字符串将作为对定义值的引用。
作为练习，尝试创建一个外部库并在控制台应用程序中使用它，然后更改库中的值并重新编译它（而不重新编译用户程序），将DLL放入目录并手动运行EXE，您应该会发现常量字符串没有改变。
还有一个陷阱：只读值可以通过反射被“狡猾”的代码改变。
var fi = this.GetType()
.BaseType
.GetField("_someField",
BindingFlags.Instance | BindingFlags.NonPublic);
fi.SetValue(this, 1);
我可以使用反射更改C#中的私有只读继承字段吗？
常量成员是在编译时定义的，不能在运行时更改。常量使用const关键字声明为字段，并且必须在声明时进行初始化。
public class MyClass
{
public const double PI1 = 3.14159;
}
只读成员就像一个常量，因为它代表一个不变的值。不同之处在于，只读成员可以在运行时在构造函数中初始化，也可以在声明时初始化。
public class MyClass1
{
public readonly double PI2 = 3.14159;
//or
public readonly double PI3;
public MyClass2()
{
PI3 = 3.14159;
}
}
常量
它们不能声明为静态（它们是隐式静态的）常数的值在编译时计算常量仅在声明时初始化
只读的
它们可以是实例级的，也可以是静态的该值在运行时计算readonly可以在声明中初始化，也可以通过构造函数中的代码初始化
Const和readonly相似，但并不完全相同。const字段是一个编译时常量，意味着该值可以在编译时计算。只读字段支持在构造类型期间必须运行某些代码的其他场景。构造后，无法更改只读字段。
例如，const成员可用于定义以下成员：
struct Test
{
public const double Pi = 3.14;
public const int Zero = 0;
}
因为像3.14和0这样的值是编译时间常数。然而，请考虑这样的情况：您定义了一个类型，并希望提供它的一些预制实例。例如，您可能希望定义一个Color类，并为常见颜色（如黑色、白色等）提供“常量”。不可能使用const成员来实现这一点，因为右侧不是编译时常量。可以对常规静态成员执行此操作：
public class Color
{
public static Color Black = new Color(0, 0, 0);
public static Color White = new Color(255, 255, 255);
public static Color Red = new Color(255, 0, 0);
public static Color Green = new Color(0, 255, 0);
public static Color Blue = new Color(0, 0, 255);
private byte red, green, blue;
public Color(byte r, byte g, byte b) {
red = r;
green = g;
blue = b;
}
}
但是，没有什么可以阻止Color的客户破坏它，可能是通过交换Black和White值。不用说，这会给Color类的其他客户端带来恐慌。“只读”功能解决了这种情况。通过在声明中简单地引入readonly关键字，我们保留了灵活的初始化，同时防止了客户机代码乱来。
public class Color
{
public static readonly Color Black = new Color(0, 0, 0);
public static readonly Color White = new Color(255, 255, 255);
public static readonly Color Red = new Color(255, 0, 0);
public static readonly Color Green = new Color(0, 255, 0);
public static readonly Color Blue = new Color(0, 0, 255);
private byte red, green, blue;
public Color(byte r, byte g, byte b) {
red = r;
green = g;
blue = b;
}
}
有趣的是，const成员总是静态的，而只读成员可以是静态的，也可以不是静态的，就像常规字段一样。
可以将一个关键字用于这两个目的，但这会导致版本控制问题或性能问题。假设我们对这个（const）使用了一个关键字，一个开发人员写道：
public class A
{
public static const C = 0;
}
而另一位开发人员编写的代码依赖于a:
public class B
{
static void Main() {
Console.WriteLine(A.C);
}
}
现在，生成的代码是否可以依赖于A.C是一个编译时间常数这一事实？也就是说，A.C的使用是否可以简单地用值0代替？如果你对此说“是”，那么这意味着A的开发者不能改变A.C的初始化方式——这在未经许可的情况下束缚了A的开发者的双手。如果你对这个问题说“不”，那么就会错过一个重要的优化。也许A的作者肯定A的C值永远为零。const和readonly的使用允许A的开发人员指定意图。这有助于更好的版本控制行为和更好的性能。
不同之处在于，静态只读字段的值是在运行时设置的，因此对于程序的不同执行，它可以具有不同的值。但是，const字段的值设置为编译时常量。
记得：对于引用类型，在这两种情况下（静态和实例），只读修饰符只会阻止您将新引用分配给字段。它特别地不使引用指向的对象不可变。
有关详细信息，请参阅有关此主题的C#常见问题解答：http://blogs.msdn.com/csharpfaq/archive/2004/12/03/274791.aspx
C#.Net中常量字段和只读字段之间存在显著差异
const在默认情况下是静态的，需要用常量值初始化，以后不能修改。构造函数中也不允许更改值。它不能与所有数据类型一起使用。对于ex-DateTime。它不能与DateTime数据类型一起使用。
public const DateTime dt = DateTime.Today; //throws compilation error
public const string Name = string.Empty; //throws compilation error
public readonly string Name = string.Empty; //No error, legal
只读可以声明为静态，但不是必需的。无需在声明时进行初始化。它的值可以使用构造函数赋值或更改。因此，它在用作实例类成员时具有优势。两个不同的实例化可能具有不同的只读字段值。对于ex-
class A
{
public readonly int Id;
public A(int i)
{
Id = i;
}
}
然后，只读字段可以用即时特定值初始化，如下所示：
A objOne = new A(5);
A objTwo = new A(10);
这里，实例objOne的只读字段值为5，objTwo的值为10。这不可能使用常量。
只读：可以在运行时通过Ctor更改值。但不通过成员函数
常量：默认情况下为静态。值不能从任何位置更改（Ctor、Function、runtime等no where）
常量
const关键字可以应用于字段或局部变量我们必须在声明时指定常量字段未分配内存，因为编译后常量值嵌入IL代码本身。这就像查找所有出现的常量变量并用其值替换。因此编译后的IL代码将使用硬编码值代替常量变量默认情况下，C#中的常量是静态的。所有对象的值都是常量存在dll版本控制问题-这意味着每当我们更改公共常量变量或属性时（事实上，理论上不应该更改），任何其他使用此变量的dll或程序集都必须重新构建只有C#内置类型可以声明为常量Const字段不能作为ref或out参数传递
只读
readonly关键字仅适用于字段而非局部变量我们可以在声明时或在构造函数中分配只读字段，而不是在任何其他方法中。为只读字段分配动态内存，我们可以在运行时获得该值。只读属于创建的对象，因此只能通过类的实例访问。为了使其成为类成员，我们需要在只读之前添加静态关键字。根据使用的构造函数，值可能不同（因为它属于类的对象）如果将非基元类型（引用类型）声明为只读，则只读引用是不可变的，而不是它所包含的对象。由于该值是在运行时获得的，因此只读字段/财产不存在dll版本控制问题。我们可以在构造函数上下文中将只读字段作为ref或out参数传递。
何时使用常量或只读常量编译时常量：绝对常量，值在声明期间设置，在IL代码本身中只读的运行时常量：可以通过配置文件（即App.config）在构造函数/init中设置，但一旦初始化就不能更改
只读字段的值可以更改。但是，常量字段的值不能更改。
在只读字段中，我们可以在声明时或在该类的构造函数中赋值。如果是常量，我们只能在声明时赋值。
只读可以与静态修饰符一起使用，但常量不能与静态一起使用。
