const和readonly的区别

const 与 readonly知多少

Practical Difference between Const & ReadOnly

What is the difference between const and readonly?

Apart from the apparent difference of

• having to declare the value at the time of a definition for a const   const  必须在定义的时候声明值

        VS

        readonly values can be computed dynamically but need to be assigned before the constructor exits.. after that it is frozen.  readonly可以动态计算，但是必须在构造函数退出前分配值，之后就被冻结

• 'const's are implicitly static. You use a ClassName.ConstantName notation to access them.    const是隐式地static，所以你可以使用 类名.变量名 的符号来访问const变量

apart from除……之外

apparent表面的；显然的

implicitly隐式地

notation符号

 

There is a subtle difference. Consider a class defined in AssemblyA.   const和readonly之间还有一些细微的区别。考虑定义在AssemblyA中的类Const_V_Readonly

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

subtle  微妙的；精细的；敏感的；狡猾的；稀薄的

AssemblyB references AssemblyA and uses these values in code. When this is compiled,    AssemblyB引用了AssemblyA，并使用了const和readonly的值 ,代码编译之后

• in the case of the const value, it is like a find-replace, the value 2 is 'baked into' the AssemblyB's IL. This means that if tomorrow I'll update I_CONST_VALUE to 20 in the future. AssemblyB would still have 2 till I recompile it.

const的值，像“搜索-替代”一样。const的值2直接被放到了AssemblyB的IL(·NET框架中中间语言)中。这意味着，如果明天我将const的值更新为20。AssemblyB中引用的const仍然为2，除非我重新编译AssemblyB

• in the case of the readonly value, it is like a ref to a memory location. The value is not baked into AssemblyB's IL. This means that if the memory location is updated, AssemblyB gets the new value without recompilation. So if I_RO_VALUE is updated to 30, you only need to build AssemblyA. All clients do not need to be recompiled.

readonly，就像存储单元(内存)的一个引用。readonly变量的值，没有被直接编译到AssemblyB的IL中。这意味着，如果存储单元被更新了，那么AssemblyB将会获取新的值并且不用重新编译。所以，如果readonly的值被改变为30，你仅仅需要重新编译AssemblyA。而不是所有引用了AssemblyA的客户端需要重新编译。

So if you are confident that the value of the constant won't change use a const.   所以，如果你确信有一个常量不会改变，那么就使用const

public const int CM_IN_A_METER = 100;

But if you have a constant that may change (e.g. w.r.t. precision).. or when in doubt, use a readonly.    但是，如果你有一个常量可能会改变(比如 ：精度) 或者有不确定是否会改变。那么使用readonly

public readonly float PI = 3.14;

Update: Aku needs to get a mention coz he pointed this out first. Also I need to plug where I learned this.. Effective C# - Bill Wagner

doubt  怀疑；疑问；疑惑

 

const string vs. static readonly string in c#

When you use a const string, the compiler embeds the string's value at compile-time.
Therefore, if you use a const value in a different assembly, then update the original assembly and change the value, the other assembly won't see the change until you re-compile it.

A static readonly string is a normal field that gets looked up at runtime. Therefore, if the field's value is changed in a different assembly, the changes will be seen as soon as the assembly is loaded, without recompiling.

This also means that a static readonly string can use non-constant members, such as Environment.UserName or DateTime.Now.ToString(). A const string can only be initialized using other constants or literals.
Also, a static readonly string can be set in a static constructor; a const string can only be initialized inline.

Note that a static string can be modified; you should use static readonly instead.

 

   +1, And the obvious conclusion, from a practical and semantic point-of-view: const should only be used for constants - constants being values that never, ever, ever change.

 

转载于:https://www.cnblogs.com/chucklu/p/4511805.html