“静态只读” 与 'const'

Question

我已经阅读了有关 const 和 static readonly 字段的内容。 我们有一些只包含常量值的类。 它们用于我们系统中的各种事物。 所以我想知道我的观察是否正确：

对于所有公开的内容，这些常量值是否应该始终是静态只读的？ 并且仅将 const 用于 internal/protected/private 值？

你有什么建议吗？ 我是否应该不使用 static readonly 字段，而是使用属性？

Answer 1

如果消费者位于不同的程序集中，我将使用静态只读。 将 const 和 Consumer 放在两个不同的程序集中是搬起石头砸自己的脚。

Answer 2

需要注意的一些相关事项：

const int a

• 必须初始化。
• 初始化必须在编译时进行。

readonly int a

• 可以使用默认值，无需初始化。
• 初始化可以在运行时完成（编辑：仅在构造函数内）。

Answer 3

这只是对其他答案的补充。 我不会重复它们（四年后的现在）。

在某些情况下，const 和非常量具有不同的语义。 例如：

const int y = 42;

static void Main()
{
  short x = 42;
  Console.WriteLine(x.Equals(y));
}

打印出True，而：

static readonly int y = 42;

static void Main()
{
  short x = 42;
  Console.WriteLine(x.Equals(y));
}

写入False。

原因是方法 x.Equals 有两个重载，一个重载采用 short (System.Int16)，另一种重载采用 object (object) >系统.对象）。 现在的问题是其中之一或两者是否适用于我的 y 参数。

当 y 是编译时常量（文字）时，即 const 情况，确实存在从 的隐式转换就变得很重要>int to short 前提是 int 是常量，并且 C# 编译器验证其值是否在short 的范围（42 是）。 请参阅 C# 语言规范中的隐式常量表达式转换。 因此必须考虑这两种过载。 首选重载 Equals(short)（任何 short 都是 object，但并非所有 object 都是 >短）。 因此，y 被转换为 short，并使用该重载。 然后，Equals 比较两个相同值的 short，结果为 true。

当y不是常量时，不存在从int到short的隐式转换。 这是因为通常 int 可能太大而无法放入 short 中。 （显式转换确实存在，但我没有说Equals((short)y)，所以这不相关。）我们看到只有一个重载适用，即等于（对象） 一。 因此，y 被装箱到 object。 然后，Equals 将比较 System.Int16 和 System.Int32，并且由于运行时类型甚至不一致，因此将产生false。

我们得出的结论是，在某些（罕见）情况下，将 const 类型成员更改为 static readonly 字段（或其他方式，如果可能的话）可以改变该程序。

Answer 4

需要注意的一件事是 const 仅限于基元/值类型（字符串除外）。

Answer 5

静态只读：

可以在运行时通过静态构造函数更改该值。 但不是通过成员函数。

常量：

默认情况下静态。 值不能从任何地方（构造函数、函数、运行时等，任何地方）更改。

只读：

可以在运行时通过构造函数更改该值。 但不是通过成员函数。

您可以查看我的存储库：C# 属性类型。

Answer 6

readonly 关键字与 const 关键字不同。 const 字段只能在字段声明时初始化。 只读字段可以在声明处或构造函数中初始化。 因此，readonly 字段可以具有不同的值，具体取决于所使用的构造函数。 此外，虽然 const 字段是编译时常量，但 readonly 字段可用于运行时常量

来自 这个简短而清晰的 MSDN 参考。

Answer 7

const 和 readonly 类似，但并不完全相同。

const 字段是编译时常量，这意味着可以在编译时计算该值。 readonly 字段支持在类型构造期间必须运行某些代码的其他场景。 构建后，readonly 字段无法更改。

例如，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, green, blue) = (r, g, b);
}

但是没有什么可以阻止颜色客户对其进行破坏，也许可以通过交换黑色和白色值。 不用说，这会让 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, green, blue) = (r, g, b);
}

有趣的是，const 成员始终是静态的，而只读成员可以是静态的，也可以不是静态的，就像常规字段一样。

可以使用单个关键字来实现这两个目的，但这会导致版本控制问题或性能问题。 假设我们为此使用了单个关键字（const），并且一位开发人员写道：

public class A
{
    public static const C = 0;
}

另一位开发人员编写了依赖于 A 的代码：

public class B
{
    static void Main() => Console.WriteLine(A.C);
}

现在，生成的代码是否可以依赖于 AC 是编译时的事实持续的？ 即，AC的使用可以简单地用值0代替吗？ 如果你对此说“是”，那么这意味着A的开发者不能改变AC的初始化方式——这在未经许可的情况下束缚了A的开发者的手脚。

如果您对这个问题说“不”，那么就会错过一个重要的优化。 也许 A 的作者肯定 AC 永远为零。 const 和 readonly 的使用允许 A 的开发人员指定意图。 这可以实现更好的版本控制行为和更好的性能。

Answer 8

我的偏好是尽可能使用 const ，正如前面的答案中提到的，它仅限于文字表达式或不需要评估的东西。

如果我遇到了这个限制，那么我会回退到静态只读，但有一个警告。 我通常会使用带有 getter 和支持 private static readonly 字段的公共静态属性，正如 Marc 提到的 这里。

Answer 9

Const：常量变量值必须与声明一起定义，之后就不会改变。const 是隐式静态的，因此无需创建类实例我们就可以访问它们。 strong> 这在编译时有价值。

ReadOnly：我们可以在声明时定义只读变量值，也可以在运行时使用构造函数。 如果没有类实例，则无法访问只读变量。

静态只读：我们可以在声明时定义静态只读变量值，也可以仅通过静态构造函数来定义，但不能使用任何其他构造函数。 我们还可以在不创建类实例的情况下访问这些变量（作为静态变量）。

如果我们必须使用不同程序集中的变量，静态只读将是更好的选择。 请查看以下博客文章中的完整详细信息：

Const Strings – 一种非常方便的搬起石头砸自己脚的方法

Answer 10

静态只读字段在暴露时是有利的
其他程序集的值可能会在更高版本中更改。

例如，假设程序集 X 公开一个常量，如下所示：

public const decimal ProgramVersion = 2.3;

如果程序集 Y 引用 X 并使用此常量，则值 2.3
编译时将被烘焙到程序集 Y 中。 这意味着
如果稍后将 X 重新编译并将常量设置为 2.4，Y 仍将
使用旧值 2.3，直到重新编译 Y。 静态的
readonly 字段避免了这个问题。

另一种看待这个问题的方式是，任何可能的值
根据定义，未来的变化并不是恒定的，因此也应该
不能被表示为一个。

Answer 11

Const： Const只不过是“常量”，是一个其值在编译时不变的变量。 并且必须为其分配一个值。 默认情况下，const 是静态的，我们无法在整个程序中更改 const 变量的值。

静态只读：静态只读类型变量的值可以在运行时分配，也可以在编译时分配并在运行时更改。 但该变量的值只能在静态构造函数中更改。 并且无法进一步改变。 它只能在运行时更改一次

参考：c-sharpcorner

Answer 12

C# 中的 const 和静态只读字段之间存在细微差别。Net

const 必须在编译时用值进行初始化。

const 默认是静态的，需要用常量值初始化，以后不能修改。
它不能与所有数据类型一起使用。 对于前日期时间。 它不能与 DateTime 数据类型一起使用。

public const DateTime dt = DateTime.Today;  //throws compilation error
public const string Name = string.Empty;    //throws compilation error
public static readonly string Name = string.Empty; //No error, legal

readonly 可以声明为静态，但不是必需的。 声明时无需初始化。 可以使用构造函数一次对其值进行赋值或更改。 所以有可能改变只读字段的值一次（没关系，无论它是否是静态的），这是 const 不可能的。

Answer 13

const：

1. 应在声明时给出值
2. 编译时常量

只读：

1. 可以在声明时或在运行时使用构造函数给出值。该值可能会根据所使用的构造函数而有所不同。
2. 运行时间常数

Answer 14

const（在编译时确定）可以在只读静态不能使用的情况下使用，例如在 switch 语句或属性构造函数中。 这是因为只读字段仅在运行时解析，并且某些代码构造需要编译时保证。 可以在构造函数中计算只读静态，这通常是必不可少且有用的事情。 区别是功能性的，我认为它们的用法也应该如此。

就内存分配而言，至少对于字符串（作为一种引用类型）来说，似乎没有什么区别，因为两者都被实习并且将引用一个实习实例。

就我个人而言，我的默认值是只读静态，因为它对我来说更具语义和逻辑意义，特别是因为大多数值在编译时不需要。 顺便说一句，公共只读静态变量并不罕见或不常见，正如标记的答案所述：例如，System.String.Empty 就是其中之一。

Answer 15

如果您可以提供编译时常量，请使用const：

private const int Total = 5;

如果您需要在运行时评估值，请使用static readonly：

private static readonly int GripKey = Animator.StringToHash("Grip");

这将给出编译错误，因为这是不可能的在编译时获取值。

private const int GripKey = Animator.StringToHash("Grip");

Answer 16

Const、readonly、static readonly - 执行类似操作但有重要区别的关键字：

• Const - 是一个变量，其值是常量并在编译时分配。 您必须为其分配一个值。 默认常量是静态的，我们无法在整个程序中更改 const 变量的值。

• 只读 - 表示我们可以在运行时更改的值，或者我们可以在运行时 更改 const 变量的值。可以在运行时分配它，但只能通过非静态构造函数。

• 静态只读 - 值可以在运行时分配或在编译时分配并在运行时更改时间。 但该变量的值只能在静态构造函数中更改。 并且无法进一步改变。 在执行期间只能更改一次。

您可以在此处找到示例 - https://www.c-sharpcorner.com/UploadFile/c210df/difference- Between-const-readonly-and-static-readonly-in- C 升号/

Answer 17

声明 const 和 static readonly 之间的另一个区别在于内存分配。

静态字段属于对象的类型，而不是该类型的实例。 因此，一旦第一次引用该类，静态字段将在其余时间“存活”在内存中，并且该类型的所有实例都将引用该静态字段的同一实例。

另一方面，const 字段“属于类型的实例。

如果释放内存对您来说更重要，则更喜欢使用const。如果速度快，那么使用静态只读。

Answer 18

顾名思义，常量是不会改变的字段，通常在编译时在代码中静态定义。

只读变量是在特定条件下可以更改的字段。

它们可以在您第一次将它们声明为常量时进行初始化，但通常它们是在构造函数内的对象构造过程中进行初始化的。

在上述情况下，初始化发生后它们无法更改。

静态只读对我来说听起来是一个糟糕的选择，因为如果它是静态的并且永远不会改变，那么只需使用它 public const 即可。 如果它可以改变，那么它就不是常量，然后根据您的需要，您可以使用只读变量或仅使用常规变量。

另外，另一个重要的区别是常量属于类，而只读变量属于实例！

Answer 19

有一个重要的问题，在上面的答案中没有提到，并且应该促使您更喜欢“const”，特别是对于“int”，“string”等基本类型。

常量可以用作属性参数< /strong>，静态只读字段不行！

Azure 函数 HttpTrigger，不在属性中使用 HttpMethods 类

如果只有微软对 H​​ttp 的 GET、POST、DELETE 等使用常量，

就可以这样写

[HttpTrigger(AuthorizationLeve.Anonymous,  HttpMethods.Get)] // COMPILE ERROR: static readonly, 

，但我必须求助于

[HttpTrigger(AuthorizationLeve.Anonymous,  "GET")] // STRING

或使用我自己的常量：

public class HttpConstants
{
    public const string Get = "GET";
}

[HttpTrigger(AuthorizationLeve.Anonymous,  HttpConstants.Get)] // Compile FINE!

Answer 20

常量

1. 只能应用于字段。 值应该在代码编译时。
2. 适合在编译代码之前删除代码中已知的魔术“字符串”、“int/double”（原始类型）等。
3. 编译后，该值将被放置在所有使用常量的编译代码中。 因此，如果您有一个巨大的字符串在很多地方使用，那么在将其设置为 const 之前要小心。 考虑使用静态只读。

静态只读

1. 静态只读适用于字段/属性，静态可用于方法。
   （旁注）当静态应用于方法时，编译的代码不会将“this”参数传递给方法，因此您无法访问对象的实例数据。
2. 适用于编译代码后可能更改的值。 就像从配置初始化的值一样，在应用程序启动期间等。
3. 编译代码后，对值的引用在 IL 代码中使用，与使用 const 相比可能会慢一些，但编译后的代码很小

在重构期间，所有 const 都可以安全地转换为静态只读，但反之亦然，正如我们在上面看到的，转换后的代码可能会中断，因为某些静态只读变量可以在构造函数中初始化。

Answer 21

我不相信上面提到的另一个区别：

const 和 static readonly 值无法获取 CodeLens 在 Visual Studio 中应用于它们IDE。

static 仅获取属性 DO 获取应用于它们的 CodeLens。

我认为添加 CodeLens 非常有价值。

注意：当前使用 Visual Studio 2022。

Answer 22

public static readonly 字段有点不寻常； public static 属性（只有 get）会更常见（可能由 private static readonly 字段支持）。

const 值直接烧录到调用站点中； 这是双刃剑：

• 如果在运行时获取值是没有用的，也许从配置中获取，
• 如果更改 const 的值，则需要重建所有客户端，
• 但它可以更快，因为它避免了方法调用...
• ...有时可能会被 JIT 内联

如果值永远改变，那么 const 就可以 - 零 等构成合理的 consts ;p 除此之外， static 属性更为常见。