Quelle est la différence entre const et readonly?

Il y a un piège avec consts! Si vous faites référence à une constante d'une autre assemblée, sa valeur sera compilée directement dans l'Assemblée appelante. De cette façon, lorsque vous mettez à jour la constante dans l'ensemble référencé, elle ne change pas dans l'ensemble appelant!

constantes

• les constantes sont statiques par défaut
• ils doivent avoir une valeur au moment de la compilation (vous pouvez par exemple avoir 3.14 * 2, mais ne pouvez pas appeler les méthodes)
• pourrait être déclaré dans les fonctions
• sont copiés dans chaque assemblage qui les utilise (chaque assemblage obtient une copie locale des valeurs)
• peut être utilisé dans les attributs

Readonly champs d'instance

• Doit avoir la valeur de consigne, le temps que le constructeur sort
• sont évalués lors de la création de l'instance

Static readonly fields

• sont évalués lorsque l'exécution du code atteint la référence de classe (lorsque la nouvelle instance est créée ou qu'une méthode statique est exécutée)
• doit avoir une valeur évaluée au moment où le constructeur statique est fait
• il n'est pas recommandé de mettre ThreadStaticAttribute sur ceux-ci (les constructeurs statiques seront exécutés dans un seul thread et définiront la valeur pour son thread; tous les autres threads auront cette valeur non initialisée)

Juste pour ajouter, En lecture seule pour les types référence ne fait que la référence readonly pas les valeurs. Par exemple:

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

cela explique . Résumé: const doit être initialisé au moment de la déclaration, readonly peut être initialisé sur le constructeur (et donc avoir une valeur différente selon le constructeur utilisé).

EDIT: See Gotcha gishu's above for the subtle difference""

const : ne peut être changé nulle part.

readonly : cette valeur ne peut être modifiée que par le constructeur. Ne peut pas être changé dans les fonctions normales.

il y a un petit gotcha avec readonly. Un champ readonly peut être défini plusieurs fois dans le(s) constructeur (s). Même si la valeur est définie dans deux différents constructeurs enchaînés, elle est quand même autorisée.

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 membre constant est défini au moment de la compilation et ne peut pas être modifié au moment de l'exécution. Les constantes sont déclarées comme un champ, en utilisant le mot-clé const et doivent être initialisées comme elles sont déclarées.

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

Un readonly membre est comme une constante en ce qu'il représente une valeur immuable. La différence est qu'un membre readonly peut être initialisé à l'exécution, dans un constructeur, ainsi que d'être initialisé comme ils sont déclarés.

public class MyClass1
{
     public readonly double PI2 = 3.14159;

     //or

     public readonly double PI3;

     public MyClass2()
     {
         PI3 = 3.14159;
     }
}

const

• ils ne peuvent pas être déclarés comme static (ils sont implicitement statiques)
• la valeur de constante est évaluée au moment de la compilation
• les constantes sont initialisées à la déclaration seulement

readonly

• ils peuvent être au niveau de l'instance ou statique
• la valeur est évaluée au temps d'exécution
• ne peut être initialisé que par une déclaration ou un code dans le constructeur

un const est une constante de temps de compilation alors que readonly permet de calculer une valeur à l'exécution et de la régler dans le constructeur ou le Field initializer. Ainsi, un 'const' est toujours constant mais 'readonly' est lu-seulement une fois qu'il est assigné.

Eric Lippert de l'équipe C#, a plus d'informations sur les différents types de l'immuabilité

voici un autre lien démontrant comment la version de const n'est pas sûre, ou pertinente pour les types de référence.

résumé :

• la valeur de votre propriété const est définie au moment de la compilation et ne peut pas changer au moment de l'exécution
• Const ne peut pas être marqué comme statique - le mot-clé indique qu'ils sont statiques, contrairement aux champs readonly qui peuvent.
• Const ne peut pas être rien, sauf de la valeur (primitive) de types
• Le mot clé readonly marque le champ immuable. Cependant la propriété peut être changée à l'intérieur du constructeur de la classe
• le mot-clé readonly only peut également être combiné avec static pour le faire agir de la même manière qu'un const (atleast sur la surface). Il y a une différence marquée lorsque vous regardez L'IL entre les deux
• const les champs sont marqués comme "littéral" dans IL tandis que readonly est "initonly"

encore un autre gotcha: les valeurs readonly peuvent être changées par le code "devious" via la réflexion.

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

puis-je changer un champ privé hérité readonly en C# en utilisant la réflexion?

Lire Seulement : La valeur peut être changée par L'intermédiaire de Ctor à l'exécution. Mais pas par la fonction de membre

Constante : Par défaut statique. La valeur ne peut être changée de n'importe où ( Ctor, Function, runtime etc no-where)

je crois qu'une valeur const est la même pour tous les objets (et doit être initialisée avec une expression littérale), alors que readonly peut être différent pour chaque instanciation...

l'un des membres de l'équipe de notre Bureau a fourni les directives suivantes sur le moment d'utiliser const, static, et readonly:

• Utiliser const quand vous avez une variable d'un type que vous pouvez connaître au moment de l'exécution (un littéral de chaîne, int, double, les énumérations...) que vous voulez que toutes les instances ou les consommateurs d'une classe aient accès à où la valeur ne devrait pas changer.
• utilisez statique lorsque vous avez des données qui vous voulez toutes les instances ou les consommateurs d'une classe à avoir accès à l'endroit où la valeur peut changer.
• Utiliser static readonly quand vous avez une variable d'un type que vous ne pouvez pas savoir au moment de l'exécution (objets) que vous souhaitez toutes les instances ou les consommateurs d'une classe à avoir accès à l'endroit où la valeur ne doit pas changer.
• Utiliser readonly quand vous avez une instance de niveau variable, vous saurez au moment de la création de l'objet cela ne devrait pas changer.

Une dernière remarque: const champ est statique, mais l'inverse n'est pas vrai.

ils sont tous les deux constants, mais un const est également disponible au moment de la compilation. Cela signifie que l'un des aspects de la différence est que vous pouvez utiliser des variables const comme entrée pour attribuer des constructeurs, mais pas seulement des variables readonly.

exemple:

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

les Variables marquées const ne sont guère plus que des macros #define fortement dactylographiées, au moment de la compilation les références des variables const sont remplacées par des valeurs littérales inline. En conséquence, seuls certains types de valeurs primitives peuvent être utilisés de cette manière. Les Variables marquées "readonly" peuvent être définies, dans un constructeur, à l'exécution et leur "read-only-ness" est également appliqué à l'exécution. Il y a des coûts de performance mineurs associés à cela, mais cela signifie que vous pouvez utiliser readonly avec n'importe quel type (même types de référence).

de plus, les variables const sont intrinsèquement statiques, alors que les variables readonly peuvent être spécifiques à une instance si on le souhaite.

le mot clé readonly est différent du mot clé const. Const champ ne peut être initialisé à la déclaration du champ. Un champ readonly peut être initialisé soit dans la déclaration soit dans un constructeur. Par conséquent, les champs readonly peuvent avoir des valeurs différentes selon le constructeur utilisé. En outre, alors qu'un champ const est une constante de temps de compilation, le champ readonly peut être utilisé pour les constantes d'exécution comme dans l'exemple suivant:

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

le readonly mot clé est différent du const mot clé. Un champ const ne peut être initialisé qu'à la déclaration de ce champ. Un champ en lecture seule peut être initialisé soit à la déclaration 151990920 "ou dans un constructeur . Par conséquent ,les champs readonly peuvent avoir des valeurs différentes selon le constructeur utilisé. En outre, alors qu'un const est un temps de compilation constante, le readonly champ peut être utilisé pour runtime constantes comme dans l'exemple suivant:

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