常量：无法在任何地方更改。

只读：此值只能在构造函数中更改。无法在正常功能中更改。

常量将作为文本值编译到使用者中，而静态字符串将作为对定义值的引用。

作为练习，尝试创建一个外部库并在控制台应用程序中使用它，然后更改库中的值并重新编译它（而不重新编译用户程序），将DLL放入目录并手动运行EXE，您应该会发现常量字符串没有改变。

常量成员是在编译时定义的，不能在运行时更改。常量使用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如何不是版本安全的，或者与引用类型无关。

摘要：

const属性的值在编译时设置，不能在运行时更改Const不能被标记为静态的-关键字表示它们是静态的，而只读字段则可以。Const不能是除值（基元）类型以外的任何类型readonly关键字将字段标记为不可更改。但是，属性可以在类的构造函数内更改readonly关键字还可以与static组合，使其以与常量相同的方式（至少在表面上）起作用。当你观察两者之间的IL时，有一个显著的差异常量字段在IL中标记为“literal”，而readonly为“initonly”

还有一个陷阱：只读值可以通过反射被“狡猾”的代码改变。

var fi = this.GetType()
             .BaseType
             .GetField("_someField", 
                       BindingFlags.Instance | BindingFlags.NonPublic);
fi.SetValue(this, 1);

我可以使用反射更改C#中的私有只读继承字段吗？