c# Qual è la differenza tra const e readonly?




14 Answers

C'è un pasticcio con le Sense! Se si fa riferimento a una costante da un altro assieme, il suo valore verrà compilato direttamente nell'assieme di chiamata. In questo modo quando aggiorni la costante nell'assieme di riferimento non cambierà nell'assieme di chiamata!

c# .net const constants readonly

Qual è la differenza tra const e readonly e usi l'una rispetto all'altra?




Giusto per aggiungere, ReadOnly per i tipi di riferimento rende solo il riferimento in sola lettura non i valori. Per esempio:

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



const : non può essere modificato da nessuna parte.

readonly : questo valore può essere modificato solo nel costruttore. Non può essere cambiato in normali funzioni.




Un membro costante viene definito in fase di compilazione e non può essere modificato in fase di runtime. Le costanti sono dichiarate come un campo, utilizzando la parola chiave const e devono essere inizializzate così come vengono dichiarate.

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

Un membro di readonly è come una costante in quanto rappresenta un valore immutabile. La differenza è che un membro di readonly può essere inizializzato in fase di runtime, in un costruttore, oltre a poter essere inizializzato come vengono dichiarati.

public class MyClass1
{
     public readonly double PI2 = 3.14159;

     //or

     public readonly double PI3;

     public MyClass2()
     {
         PI3 = 3.14159;
     }
}

const

  • Non possono essere dichiarati come static (sono implicitamente statici)
  • Il valore della costante viene valutato al momento della compilazione
  • le costanti sono inizializzate solo a dichiarazione

sola lettura

  • Possono essere a livello di istanza o statici
  • Il valore viene valutato in fase di esecuzione
  • readonly può essere inizializzato in dichiarazione o tramite codice nel costruttore



Ecco un altro link che dimostra come const non è sicuro per la versione, o rilevante per i tipi di riferimento.

Riepilogo :

  • Il valore della proprietà const è impostato al momento della compilazione e non può essere modificato in fase di runtime
  • Const non può essere contrassegnato come statico: la parola chiave indica che sono statici, a differenza dei campi readonly che possono.
  • Const non può essere nient'altro che tipi di valore (primitivi)
  • La parola chiave readonly contrassegna il campo come non modificabile. Tuttavia la proprietà può essere modificata all'interno del costruttore della classe
  • La parola chiave only onlyly può anche essere combinata con static per farlo agire allo stesso modo di un const (atleast sulla superficie). C'è una differenza marcata quando si guarda l'IL tra i due
  • i campi const sono contrassegnati come "letterali" in IL mentre readonly è "initonly"



Sola lettura : il valore può essere modificato tramite Ctor in fase di runtime. Ma non attraverso la funzione membro

Costante : per difetto statico. Il valore non può essere modificato da qualsiasi luogo (Ctor, Funzione, runtime ecc. No-where)




Uno dei membri del team nel nostro ufficio ha fornito le seguenti indicazioni su quando utilizzare const, static e readonly:

  • Usa const quando hai una variabile di un tipo che puoi conoscere al runtime (string letteral, int, double, enum, ...) che vuoi che tutte le istanze o i consumatori di una classe abbiano accesso a dove il valore non dovrebbe cambiare.
  • Usa statico quando hai dati che vuoi che tutte le istanze o i consumatori di una classe abbiano accesso a dove il valore può cambiare.
  • Usa statico readonly quando hai una variabile di un tipo che non puoi sapere in runtime (oggetti) a cui vuoi che tutte le istanze o i consumatori di una classe abbiano accesso dove il valore non dovrebbe cambiare.
  • Usa readonly quando hai una variabile a livello di istanza che saprai al momento della creazione dell'oggetto che non dovrebbe cambiare.

Un'ultima nota: un campo const è statico, ma l'inverso non è vero.




Le variabili marcate const sono poco più delle macro #define fortemente tipizzate, al momento della compilazione i riferimenti alle variabili const vengono sostituiti con valori letterali incorporati. Di conseguenza, solo alcuni tipi di valori primitivi predefiniti possono essere utilizzati in questo modo. Le variabili contrassegnate in sola lettura possono essere impostate, in un costruttore, in fase di esecuzione e la loro sola lettura viene applicata anche durante l'esecuzione. Ci sono alcuni minori costi di performance associati a questo, ma significa che puoi usare readonly con qualsiasi tipo (anche con tipi di riferimento).

Inoltre, le variabili const sono intrinsecamente statiche, mentre le variabili readonly possono essere specifiche dell'istanza, se lo si desidera.




C'è una notevole differenza tra i campi const e readonly in C # .Net

const è di default statico e deve essere inizializzato con un valore costante, che non può essere modificato in seguito. La modifica del valore non è consentita anche nei costruttori. Non può essere utilizzato con tutti i tipi di dati. Per ex-DateTime. Non può essere utilizzato con datatype 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 può essere dichiarato come statico, ma non necessario. Non è necessario inizializzarsi al momento della dichiarazione. Il suo valore può essere assegnato o modificato usando il costruttore. Quindi, si avvantaggia quando usato come membro della classe di istanza. Due diverse istanze possono avere un valore diverso del campo di sola lettura. Per ex -

class A
{
    public readonly int Id;

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

Quindi il campo readonly può essere inizializzato con valori specifici istantanei, come segue:

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

Qui, istanza objOne avrà valore di campo readonly come 5 e objTwo ne ha 10. Quale non è possibile usando const.




Costante

Dobbiamo fornire il valore al campo const quando viene definito. Il compilatore salva quindi il valore della costante nei metadati dell'assembly. Ciò significa che una costante può essere definita solo per il tipo primitivo come booleano, char, byte e così via. Le costanti sono sempre considerate membri statici, non membri di istanze.

Sola lettura

I campi di sola lettura possono essere risolti solo in fase di runtime. Ciò significa che possiamo definire un valore per un valore utilizzando il costruttore per il tipo in cui è dichiarato il campo. La verifica viene eseguita dal compilatore in modo che i campi di sola lettura non vengano scritti da alcun metodo diverso dal costruttore.

Maggiori informazioni su entrambi spiegati qui in questo articolo




Un const deve essere hard-coded , dove come readonly può essere impostato nel costruttore della classe.




ReadOnly: il valore verrà inizializzato solo una volta dal costruttore della classe.
const: può essere inizializzato in qualsiasi funzione ma solo una volta




Le variabili costanti sono dichiarate e inizializzate in fase di compilazione. Il valore non può essere modificato dopo i reparti. Le variabili di sola lettura verranno inizializzate solo dal costruttore statico della classe. La sola lettura viene utilizzata solo quando si desidera assegnare il valore in fase di esecuzione.




Una cosa da aggiungere a ciò che le persone hanno detto sopra. Se si dispone di un assembly che contiene un valore di sola lettura (ad esempio, MaxFooCount = 4;), è possibile modificare il valore che chiama gli assembly inviando una nuova versione di quell'assembly con un valore diverso (ad esempio, readFly MaxFooCount = 5;)

Ma con un const, sarebbe piegato nel codice del chiamante quando il chiamante è stato compilato.

Se hai raggiunto questo livello di competenza di C #, sei pronto per il libro di Bill Wagner, Effective C #: 50 modi specifici per migliorare il tuo C # che risponde a questa domanda in dettaglio, (e 49 altre cose).




Related