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。这不可能使用常量。

常量

const关键字可以应用于字段或局部变量我们必须在声明时指定常量字段未分配内存，因为编译后常量值嵌入IL代码本身。这就像查找所有出现的常量变量并用其值替换。因此编译后的IL代码将使用硬编码值代替常量变量默认情况下，C#中的常量是静态的。所有对象的值都是常量存在dll版本控制问题-这意味着每当我们更改公共常量变量或属性时（事实上，理论上不应该更改），任何其他使用此变量的dll或程序集都必须重新构建只有C#内置类型可以声明为常量Const字段不能作为ref或out参数传递

只读

readonly关键字仅适用于字段而非局部变量我们可以在声明时或在构造函数中分配只读字段，而不是在任何其他方法中。为只读字段分配动态内存，我们可以在运行时获得该值。只读属于创建的对象，因此只能通过类的实例访问。为了使其成为类成员，我们需要在只读之前添加静态关键字。根据使用的构造函数，值可能不同（因为它属于类的对象）如果将非基元类型（引用类型）声明为只读，则只读引用是不可变的，而不是它所包含的对象。由于该值是在运行时获得的，因此只读字段/财产不存在dll版本控制问题。我们可以在构造函数上下文中将只读字段作为ref或out参数传递。

另外，只读引用类型只会使引用只读，而不会使值只读。例如：

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
  }
}

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。这不可能使用常量。

它们都是常量，但在编译时也可以使用常量。这意味着差异的一个方面是，可以使用常量变量作为属性构造函数的输入，但不能使用只读变量。

例子：

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相似，但并不完全相同。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的开发人员指定意图。这有助于更好的版本控制行为和更好的性能。