Static readonly vs const

Question

I ve read around about const and static readonly fields  We have some classes which contain only constant values  They are used for various things around in our system  So I am wondering if my observation is correct  Should these kind of constant values always be static readonly for everything that is public  And only use const for internal protected private values  What do you recommend  Should I maybe even not use static readonly fields  but rather use properties maybe

User · Answer

I would use static readonly if the Consumer is in a different assembly  Having the const and the Consumer in two different assemblies is a nice way to shoot yourself in the foot

User · Answer

This is just a supplement to the other answers  I will not repeat them  now four years later    There are situations where a const and a non-const have different semantics  For example   const int y   42   static void Main       short x   42    Console WriteLine x Equals y        prints out True  whereas   static readonly int y   42   static void Main       short x   42    Console WriteLine x Equals y        writes False   The reason is that the method x Equals has two overloads  one that takes in a short  System Int16  and one that takes an object  System Object   Now the question is whether one or both apply with my y argument   When y is a compile-time constant  literal   the const case  it becomes important that there does exist an implicit conversion from int to short provided that the int is a constant  and provided that the C  compiler verifies that its value is within the range of a short  which 42 is   See Implicit constant expression conversions in the C  Language Specification  So both overloads have to be considered  The overload Equals short  is preferred  any short is an object  but not all object are short   So y is converted to short  and that overload is used  Then Equals compares two short of identical value  and that gives true   When y is not a constant  no implicit conversion from int to short exists  That s because in general an int may be too huge to fit into a short   An explicit conversion does exist  but I didn t say Equals  short y   so that s not relevant   We see that only one overload applies  the Equals object  one  So y is boxed to object  Then Equals is going to compare a System Int16 to a System Int32  and since the run-time types do not even agree  that will yield false   We conclude that in some  rare  cases  changing a const type member to a static readonly field  or the other way  when that is possible  can change the behavior of the program

User · Answer

Const  Constant variable values have to be defined along with the declaration and after that it won t change const are implicitly static  so without creating a class instance we can access them  This has a value at compile time  ReadOnly  We can define read-only variable values while declaring as well as using the constructor at runtime  Read-only variables can t access without a class instance  Static readonly  We can define static readonly variable values while declaring as well as only through a static constructor  but not with any other constructor  We can also access these variables without creating a class instance  as static variables   Static readonly will be better choice if we have to consume the variables in different assemblies  Please check the full details in the below blog post  Const Strings     a very convenient way to shoot yourself in the foot

User · Answer

Constants are like the name implies  fields which don t change and are usually defined statically at compile time in the code  Read-only variables are fields that can change under specific conditions  They can be either initialized when you first declare them like a constant  but usually they are initialized during object construction inside the constructor  They cannot be changed after the initialization takes place  in the conditions mentioned above  Static read-only sounds like a poor choice to me since  if it s static and it never changes  so just use it public const  If it can change then it s not a constant and then  depending on your needs  you can either use read-only or just a regular variable  Also  another important distinction is that a constant belongs to the class  while the read-only variable belongs to the instance

User · Answer

Another difference between declaring const and static readonly is in memory allocation   A static field belongs to the type of an object rather than to an instance of that type  As a result  once the class is referenced for the first time  the static field would  live  in the memory for the rest of time  and the same instance of the static field would be referenced by all instances of the type   On the other hand  a const field  belongs to an instance of the type   If memory of deallocation is more important for you  prefer to use const  If speed  then use static readonly

User · Answer

The readonly keyword is different from the const keyword  A const field can only be initialized at the declaration of the field  A readonly field can be initialized either at the declaration or in a constructor  Therefore  readonly fields can have different values depending on the constructor used  Also  while a const field is a compile-time constant  the readonly field can be used for runtime constants  Short and clear MSDN reference here

User · Answer

There is one important question  that is not mentioned anywhere in the above answers  and should drive you to prefer  quot const quot  especially for basic types like  quot int quot    quot string quot  etc  Constants can be used as Attribute parameters  static readonly field not  Azure functions HttpTrigger  not using HttpMethods class in attribute If only microsoft used constants for Http s GET  POST  DELETE etc  It would be possible to write  HttpTrigger AuthorizationLeve Anonymous   HttpMethods Get      COMPILE ERROR  static readonly    But instead I have to resort to  HttpTrigger AuthorizationLeve Anonymous    quot GET quot       STRING  Or use my own constant  public class HttpConstants       public const string Get    quot GET quot       HttpTrigger AuthorizationLeve Anonymous   HttpConstants Get      Compile FINE

User · Answer

const and readonly are similar  but they are not exactly the same    A const field is a compile-time constant  meaning that that value can be computed at compile-time  A readonly field enables additional scenarios in which some code must be run during construction of the type  After construction  a readonly field cannot be changed   For instance  const members can be used to define members like   struct Test       public const double Pi   3 14      public const int Zero   0      Since values like 3 14 and 0 are compile-time constants  However  consider the case where you define a type and want to provide some pre-fab instances of it  E g   you might want to define a Color class and provide  constants  for common colors like Black  White  etc  It isn t possible to do this with const members  as the right hand sides are not compile-time constants  One could do this with regular static members   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    gt   red  green  blue     r  g  b       But then there is nothing to keep a client of Color from mucking with it  perhaps by swapping the Black and White values  Needless to say  this would cause consternation for other clients of the Color class  The  readonly  feature addresses this scenario    By simply introducing the readonly keyword in the declarations  we preserve the flexible initialization while preventing client code from mucking around   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    gt   red  green  blue     r  g  b       It is interesting to note that const members are always static  whereas a readonly member can be either static or not  just like a regular field   It is possible to use a single keyword for these two purposes  but this leads to either versioning problems or performance problems  Assume for a moment that we used a single keyword for this  const  and a developer wrote   public class A       public static const C   0      and a different developer wrote code that relied on A   public class B       static void Main     gt  Console WriteLine A C       Now  can the code that is generated rely on the fact that A C is a compile-time constant  I e   can the use of A C simply be replaced by the value 0  If you say  yes  to this  then that means that the developer of A cannot change the way that A C is initialized -- this ties the hands of the developer of A without permission    If you say  no  to this question then an important optimization is missed  Perhaps the author of A is positive that A C will always be zero  The use of both const and readonly allows the developer of A to specify the intent  This makes for better versioning behavior and also better performance

User · Answer

One thing to note is const is restricted to primitive value types  the exception being strings

User · Answer

My preference is to use const whenever I can  which  as mentioned in previous answers  is limited to literal expressions or something that does not require evaluation  If I hit up against that limitation  then I fallback to static readonly  with one caveat  I would generally use a public static property with a getter and a backing private static readonly field as Marc mentions here

User · Answer

const    value should be given upon declaration compile time constant   readonly    value can be given upon declaration or during runtime using constructors The value may vary depend upon the constructor used  run time constant

User · Answer

public static readonly fields are a little unusual  public static properties  with only a get  would be more common  perhaps backed by a private static readonly field    const values are burned directly into the call-site  this is double edged    it is useless if the value is fetched at runtime  perhaps from config if you change the value of a const  you need to rebuild all the clients but it can be faster  as it avoids a method call       which might sometimes have been inlined by the JIT anyway   If the value will never change  then const is fine - Zero etc make reasonable consts  p Other than that  static properties are more common

User · Answer

Static Read Only  The value can be changed through a static constructor at runtime  But not through a member function  Constant  By default static  A value cannot be changed from anywhere  constructor  function  runtime  etc  nowhere   Read Only  The value can be changed through a constructor at runtime  But not through a member function  You can have a look at my repository  C  property types

User · Answer

A few more relevant things to be noted  const int a  must be initialized  initialization must be at compile time   readonly int a  can use a default value  without initializing  initialization can be done at run time  Edit  within constructor only

User · Answer

A const  being determined at compile-time  can be used in cases where a readonly static can t  like in switch statements  or attribute constructors  This is because readonly fields are only resolved at run-time  and some code constructs require compile time assurance  A readonly static can be calculated in a constructor  which is often an essential and useful thing  The difference is functional  as should be their usage in my opinion   In terms of memory allocation  at least with strings  being a reference type   there seems to be no difference in that both are interned and will reference the one interned instance   Personally  my default is readonly static  as it makes more semantic and logical sense to me  especially since most values are not needed at compile time  And  by the way  public readonly statics are not unusual or uncommon at all as the marked answer states  for instance  System String Empty is one

User · Answer

Const  Const is nothing but  quot constant quot   a variable of which the value is constant but at compile time  And it s mandatory to assign a value to it  By default a const is static and we cannot change the value of a const variable throughout the entire program  Static ReadOnly  A Static Readonly type variable s value can be assigned at runtime or assigned at compile time and changed at runtime  But this variable s value can only be changed in the static constructor  And cannot be changed further  It can change only once at runtime  Reference  c-sharpcorner

User · Answer

There is a minor difference between const and static readonly fields in C  Net const must be initialized with value at compile time  const is by default static and needs to be initialized with constant value  which can not be modified later on  It can not be used with all datatypes  For ex- DateTime  It can not be used with DateTime datatype  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 can be declared as static  but not necessary  No need to initialize at the time of declaration  Its value can be assigned or changed using constructor once  So there is a possibility to change value of readonly field once  does not matter  if it is static or not   which is not possible with const

User · Answer

A static readonly field is advantageous when exposing to other assemblies a value that might change in a later version   For instance  suppose assembly X exposes a constant as follows   public const decimal ProgramVersion   2 3    If assembly Y references X and uses this constant  the value 2 3 will be baked into assembly Y when compiled  This means that if X is later recompiled with the constant set to 2 4  Y will still use the old value of 2 3 until Y is recompiled  A static readonly field avoids this problem   Another way of looking at this is that any value that might change in the future is not constant by definition  and so should not be represented as one

[c#] 'Static readonly' vs. 'const'

Examples related to c#

Examples related to constants