¿Cuál es la diferencia entre const y readonly?

Hay un gotcha con conss! Si hace referencia a una constante de otro ensamblado, su valor se compilará directamente en el ensamblado que llama. De esta manera, cuando actualice la constante en el ensamblado referenciado, ¡no cambiará en el ensamblado que llama!

Constantes

• Las constantes son estáticas por defecto
• Deben tener un valor en el momento de la compilación (puede tener, por ejemplo, 3.14 * 2, pero no puede llamar a métodos)
• Podría declararse dentro de funciones
• Se copian en cada ensamblado que los usa (cada ensamblado obtiene una copia local de los valores)
• Se puede usar en atributos

Campos de instancia de solo lectura

• Debe tener un valor establecido, para cuando el constructor salga
• Se evalúan cuando se crea la instancia

Campos de lectura estáticos

• Se evalúan cuando la ejecución de código alcanza la referencia de clase (cuando se crea una nueva instancia o se ejecuta un método estático)
• Debe tener un valor evaluado en el momento en que se realiza el constructor estático
• No se recomienda poner ThreadStaticAttribute en estos (los constructores estáticos se ejecutarán en un solo subproceso y establecerán el valor para su subproceso; todos los demás subprocesos tendrán este valor sin inicializar)

Solo para agregar, ReadOnly para tipos de referencia solo hace que la referencia readonly no los valores. Por ejemplo:

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

Esto lo explica. Resumen: const debe inicializarse en el momento de la declaración, readonly puede inicializarse en el constructor (y por lo tanto tener un valor diferente dependiendo del constructor utilizado).

EDITAR: Ver Gishu's gotcha arriba para la sutil diferencia

const: No se puede cambiar en ninguna parte.

readonly: Este valor solo se puede cambiar en el constructor. No se puede cambiar en funciones normales.

Hay un pequeño gotcha con readonly. Un campo de solo lectura se puede establecer varias veces dentro del constructor(s). Incluso si el valor se establece en dos constructores encadenados diferentes, todavía está permitido.

public class Sample {
    private readonly string ro;

    public Sample() {
        ro = "set";
    }

    public Sample(string value) : this() {
        ro = value; // this works even though it was set in the no-arg ctor
    }
}

Un miembro constante se define en tiempo de compilación y no se puede cambiar en tiempo de ejecución. Las constantes se declaran como un campo, usando la palabra clave const y deben inicializarse a medida que se declaran.

public class MyClass
{
    public const double PI1 = 3.14159;
}

Un miembro readonly es como una constante en que representa un valor inmutable. La diferencia es que un miembro readonly puede inicializarse en tiempo de ejecución, en un constructor, además de poder inicializarse a medida que se declaran.

public class MyClass1
{
     public readonly double PI2 = 3.14159;

     //or

     public readonly double PI3;

     public MyClass2()
     {
         PI3 = 3.14159;
     }
}

Const

• Pueden no ser declarados como static (son implícitamente estáticos)
• El valor de la constante se evalúa en tiempo de compilación
• las constantes se inicializan solo en la declaración

Readonly

• Pueden ser a nivel de instancia o estáticas
• El valor se evalúa en tiempo de ejecución
• readonly se puede inicializar en declaración o por código en el constructor

Una const es una constante en tiempo de compilación, mientras que readonly permite que un valor se calcule en tiempo de ejecución y se establezca en el constructor o inicializador de campos. Por lo tanto, una 'const' es siempre constante, pero 'readonly' es de solo lectura una vez que se asigna.

Eric Lippert del equipo de C# tiene más información sobre diferentes tipos de inmutabilidad

Aquí hay otro enlace que demuestra cómo const no es una versión segura o relevante para los tipos de referencia.

Resumen:

• El valor de su propiedad const se establece en tiempo de compilación y no puede cambiar en tiempo de ejecución
• Const no puede ser marcado como estático - la palabra clave denota que son estáticos, a diferencia de los campos de solo lectura que pueden.
• Const no puede ser nada excepto los tipos de valor (primitivos)
• La palabra clave readonly marca el campo como inmutable. Sin embargo, la propiedad se puede cambiar dentro del constructor de la clase
• La palabra clave readonly only también se puede combinar con static para que actúe de la misma manera que una const (al menos en la superficie). Hay una diferencia marcada cuando se mira la IL entre los dos
• los campos const están marcados como" literal "en IL mientras que readonly es"initonly"

Otro gotcha: los valores de readonly pueden ser cambiados por código "tortuoso" vía reflexión.

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

¿Puedo cambiar un campo privado heredado de solo lectura en C# usando reflexión?

Solo lectura : El valor se puede cambiar a través de Ctor en tiempo de ejecución. Pero no a través de la Función miembro

Constante : Por defult estática. El valor no se puede cambiar desde ninguna parte (Ctor, Función, tiempo de ejecución, etc.)

Creo que un valor const es el mismo para todos los objetos (y debe inicializarse con una expresión literal), mientras que readonly puede ser diferente para cada instanciación...

Uno de los miembros del equipo en nuestra oficina proporcionó la siguiente orientación sobre cuándo usar const, static y readonly:

• Use const cuando tenga una variable de un tipo que pueda conocer en tiempo de ejecución (string literal, int, double, enums,...) que desea que todas las instancias o consumidores de una clase tengan acceso a donde el valor no debe cambiar.
• Use static cuando tenga datos a los que desea que todas las instancias o consumidores de una clase tengan acceso donde el valor puede cambiar.
• Use static readonly cuando tiene una variable de un tipo que no puede saber en tiempo de ejecución (objetos) que desea que todas las instancias o consumidores de una clase tengan acceso a donde el valor no debe cambiar.
• Use readonly cuando tenga una variable de nivel de instancia que sabrá en el momento de la creación del objeto que no debe cambiar.

Una nota final: un campo const es estático, pero el inverso no es verdadero.

Ambos son constantes, pero una const está disponible también en tiempo de compilación. Esto significa que un aspecto de la diferencia es que puede usar variables const como entrada para atribuir constructores, pero no variables readonly.

Ejemplo:

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

Las variables marcadas const son poco más que fuertemente tipeadas #define macros, en tiempo de compilación las referencias de las variables const se reemplazan con valores literales en línea. Como consecuencia, solo ciertos tipos de valores primitivos incorporados pueden usarse de esta manera. Las variables marcadas como readonly se pueden establecer, en un constructor, en tiempo de ejecución y su valor de solo lectura también se aplica durante el tiempo de ejecución. Hay algunos costos de rendimiento menores asociados con esto, pero significa que puede usar readonly con cualquier tipo (incluso tipos de referencia).

Además, las variables const son inherentemente estáticas, mientras que las variables readonly pueden ser específicas de la instancia si se desea.

La palabra clave readonly es diferente de la palabra clave const. Un campo const solo se puede inicializar en la declaración del campo. Un campo readonly se puede inicializar en la declaración o en un constructor. Por lo tanto, los campos readonly pueden tener diferentes valores dependiendo del constructor utilizado. Además, mientras que un campo const es una constante en tiempo de compilación, el campo readonly se puede usar para constantes de tiempo de ejecución como en el siguiente ejemplo:

public static readonly uint l1 = (uint) DateTime.Now.Ticks;

La palabra clave readonly es diferente de la palabra clave const. Un campo const solo puede inicializarse en la declaración del campo. Un campo readonly puede inicializarse en la declaración o en un constructor . Por lo tanto, los campos readonly pueden tener diferentes valores dependiendo del constructor utilizado. Además, mientras que un campo const es una constante en tiempo de compilación , el campo readonly puede ser se utiliza para constantes de tiempo de ejecución como en el siguiente ejemplo:

public static readonly uint timeStamp = (uint)DateTime.Now.Ticks;

Another gotcha.

Dado que const realmente solo funciona con tipos de datos básicos, si desea trabajar con una clase, puede sentirse "forzado" a usar ReadOnly. Sin embargo, cuidado con la trampa! ReadOnly significa que no puede reemplazar el objeto con otro objeto (no puede hacer que se refiera a otro objeto). Pero cualquier proceso que tenga una referencia al objeto es libre de modificar los valores dentro ¡el objeto!

Así que no se confunda en pensar que ReadOnly implica que un usuario no puede cambiar las cosas. No hay una sintaxis simple en C# para evitar que una instanciación de una clase cambie sus valores internos (que yo sepa).

Hay una diferencia notable entre los campos const y readonly en C#.Net

Const es por defecto estático y necesita ser inicializado con un valor constante, que no se puede modificar más adelante. El cambio de valor tampoco está permitido en los constructores. No se puede utilizar con todos los tipos de datos. Para ex-DateTime. No se puede utilizar con el tipo de datos 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

Readonly se puede declarar como estático, pero no es necesario. No es necesario inicializar en el momento de la declaración. Su valor puede ser asignado o cambiado usando constructor. Por lo tanto, da ventaja cuando se utiliza como miembro de la clase de instancia. Dos instancias diferentes pueden tener un valor diferente del campo readonly. Para ex -

class A
{
    public readonly int Id;

    public A(int i)
    {
        Id = i;
    }
}

Luego el campo readonly se puede inicializar con valores específicos instantáneos, de la siguiente manera:

A objOne = new A(5);
A objTwo = new A(10);

Aquí, la instancia objOne tendrá el valor del campo readonly como 5 y objTwo tiene 10. Lo cual no es posible usando const.

Una constante se compilará en el consumidor como un valor literal, mientras que la cadena estática servirá como referencia al valor definido.

Como ejercicio, intente crear una biblioteca externa y consumirla en una aplicación de consola, luego altere los valores en la biblioteca y recompile (sin recompilar el programa consumidor), suelte la DLL en el directorio y ejecute el EXE manualmente, debería encontrar que la cadena constante no cambia.

Constante

Necesitamos proporcionar el valor al campo const cuando se define. El compilador guarda el valor de la constante en los metadatos del ensamblado. Esto significa que una constante puede ser definida solo para el tipo primitivo como booleano, char, byte y así sucesivamente. Las constantes siempre se consideran miembros estáticos, no miembros de instancia.

Readonly

Los campos de solo lectura solo se pueden resolver en tiempo de ejecución. Eso significa que podemos definir un valor para un valor usando el constructor para el tipo en el que se declara el campo. La verificación es realizada por el compilador en el que los campos readonly no son escritos por ningún método que no sea el constructor.

Más sobre ambos explicado aquí en este artículo

Principalmente; puede asignar un valor a un campo de lectura estático a un valor no constante en tiempo de ejecución, mientras que a const se le debe asignar un valor constante.

A const tiene que ser codificado, donde as readonly puede ser establecido en el constructor de la clase.

Const y readonly son similares, pero no son exactamente iguales. Un campo const es una constante en tiempo de compilación, lo que significa que ese valor se puede calcular en tiempo de compilación. Un campo de solo lectura habilita escenarios adicionales en los que se debe ejecutar algún código durante la construcción del tipo. Después de la construcción, un campo de solo lectura no se puede cambiar.

Por ejemplo, los miembros const se pueden usar para definir miembros como:

struct Test
{
    public const double Pi = 3.14;
    public const int Zero = 0;
}

Ya que valores como 3.14 y 0 son constantes en tiempo de compilación. Obstante, considere el caso en el que define un tipo y desea proporcionar algunas instancias prefabricadas del mismo. Por ejemplo, es posible que desee definir una clase de color y proporcionar "constantes"para colores comunes como Negro, Blanco, etc. No es posible hacer esto con miembros const, ya que los lados de la mano derecha no son constantes en tiempo de compilación. Uno podría hacer esto con miembros estáticos regulares:

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

Pero entonces no hay nada para evitar que un cliente de Color se meta con él, tal vez intercambiando los valores en Blanco y Negro. No hace falta decir que esto causaría consternación para otros clientes de la clase Color. La función "readonly" aborda este escenario. Simplemente introduciendo la palabra clave readonly en las declaraciones, preservamos la inicialización flexible mientras evitamos que el código del cliente se escurra.

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

Es interesante notar que los miembros const son siempre estáticos, mientras que un miembro readonly puede ser estático o no, al igual que un campo regular.

Es posible utilizar un solo palabra clave para estos dos propósitos, pero esto conduce a problemas de versiones o problemas de rendimiento. Supongamos por un momento que usamos una sola palabra clave para esto (const) y un desarrollador escribió:

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

Y un desarrollador diferente escribió código que se basó en A:

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

Ahora, ¿puede el código que se genera confiar en el hecho de que A. C es una constante en tiempo de compilación? Es decir, ¿se puede simplemente sustituir el uso de A.c. por el valor 0? Si usted dice " sí " a esto, entonces eso significa que el desarrollador de un no se puede cambiar la forma en que A. C se inicializa this esto ata las manos del desarrollador de A sin permiso. Si dices " no " a esta pregunta, entonces se pierde una optimización importante. Tal vez el autor de A es positivo que A. C siempre será cero. El uso de const y readonly permite al desarrollador de A especificar la intent. Esto permite un mejor comportamiento de control de versiones y también un mejor rendimiento.

ReadOnly :El valor se inicializará solo una vez desde el constructor de la clase.
const: se puede inicializar en cualquier función pero solo una vez

La diferencia es que el valor de un campo estático de solo lectura se establece en tiempo de ejecución, por lo que puede tener un valor diferente para diferentes ejecuciones del programa. Sin embargo, el valor de un campo const se establece en una constante de tiempo de compilación.

Recuerda: Para los tipos de referencia, en ambos casos (estático e instancia), el modificador readonly solo impide asignar una nueva referencia al campo. Específicamente no hace inmutable el objeto señalado por la referencia.

Para detalles, por favor refiérase a las Preguntas frecuentes de C# sobre este tema: http://blogs.msdn.com/csharpfaq/archive/2004/12/03/274791.aspx

Las variables constantes se declaran e inicializan en tiempo de compilación. El valor no se puede cambiar después de las salas. Las variables de solo lectura solo se inicializarán desde el constructor estático de la clase. Solo lectura se usa solo cuando queremos asignar el valor en tiempo de ejecución.

Un campo const solo se puede inicializar en la declaración del campo. Un campo readonly se puede inicializar en la declaración o en un constructor.

Una cosa que añadir a lo que la gente ha dicho anteriormente. Si tiene un ensamblado que contiene un valor readonly (por ejemplo, readonly MaxFooCount = 4;), puede cambiar el valor que ven los ensamblados que llaman enviando una nueva versión de ese ensamblado con un valor diferente (por ejemplo, readonly MaxFooCount = 5;)

Pero con una const, se pliega en el código de la persona que llama cuando se compila la persona que llama.

Si ha alcanzado este nivel de dominio de C#, está listo para el libro de Bill Wagner, C # Efectivo: 50 Formas Específicas de Mejorar Su C# Que responde a esta pregunta en detalle, (y 49 otras cosas).