Perché non è String.Empty una costante?

StackOverflow https://stackoverflow.com/questions/507923

Domanda

In .Net perché è String.Empty sola lettura, invece di una costante? Mi chiedo solo se qualcuno sa che cosa il ragionamento era dietro questa decisione.

È stato utile?

Soluzione

La ragione per cui static readonly viene utilizzato al posto del const è dovuto da usare con codice non gestito, come indicato da Microsoft qui nel Shared Fonte Common Language Infrastructure 2.0 rilascio . Il file da guardare è sscli20\clr\src\bcl\system\string.cs.

  

La costante Vuoto detiene il vuoto   valore stringa. Abbiamo bisogno di chiamare il   stringa costruttore in modo che la   compilatore non contrassegna questo come un   letterale.

     

Marcatura questo come un letterale significherebbe   che non si presenta come un campo   il quale possiamo accedere da nativo.

Ho trovato queste informazioni da questo pratico articolo a CodeProject .

Altri suggerimenti

Credo che ci sia un sacco di confusione e le risposte negative qui.

Prima di tutto, i campi sono const static membri ( non membri di istanza ).

Controlla la sezione 10.4 Costanti della specifica del linguaggio C #.

  

Anche se le costanti sono considerati   membri statici, una costante dichiarazione   non impone né consente una statica   modificatore.

Se public const membri sono statici, si potrebbe non considerare che una costante creerà un nuovo oggetto.

Detto questo, le seguenti righe di codice che fare esattamente la stessa cosa rispetto alla creazione di un nuovo oggetto. 

public static readonly string Empty = "";
public const string Empty = "";

Ecco una nota di Microsoft che spiega la differenza tra il 2:

  

La parola chiave in sola lettura è diversa da   la parola chiave const. Un campo const può   essere inizializzato solo alla dichiarazione   del campo. Un campo in sola lettura può essere   inizializzato sia presso la dichiarazione   o in un costruttore. Perciò,   campi di sola lettura possono avere diversi   valori in funzione del costruttore   Usato. Inoltre, mentre un campo const è un   compilazione costante di tempo, la sola lettura   campo può essere utilizzato per la fase di esecuzione   costanti, ...

Quindi, trovo che l'unica risposta plausibile è qui. Di Jeff Yates 

String.Empty read only instead of a constant?

Se si effettua una qualsiasi stringa costante , quindi il compilatore è sostituirlo con la realtà stringa in tutto il mondo si chiama e si compila il codice con la stessa stringa in tutto e quando il codice viene eseguito è anche bisogno di leggere ancora e ancora quella stringa dai diversi dati di memoria.

Se si lascia la stringa di leggere su un solo posto in quanto è il String.Empty, il programma di mantenere la stessa stringa su un solo luogo e leggere, o si riferiscono ad essa -. Mantenere i dati in memoria minima

Anche se si compila DLL utilizzando lo String.Empty come const, e per qualsiasi motivo il cambio String.Empty, quindi la DLL compilata non funziona più la stessa, perché il cost rendere il codice all'interno di realtà tenere una copia della stringa su ogni chiamata.

Vedere questo codice di esempio: 

public class OneName
{
    const string cConst = "constant string";
    static string cStatic = "static string";
    readonly string cReadOnly = "read only string";

    protected void Fun()
    {
        string cAddThemAll ;

        cAddThemAll = cConst;
        cAddThemAll = cStatic ;
        cAddThemAll = cReadOnly;    
    }
}

sarà venuto dal compilatore come: 

public class OneName
{
    // note that the const exist also here !
    private const string cConst = "constant string";
    private readonly string cReadOnly;
    private static string cStatic;

    static OneName()
    {
        cStatic = "static string";
    }

    public OneName()
    {
        this.cReadOnly = "read only string";
    }

    protected void Fun()
    {
        string cAddThemAll ;

        // look here, will replace the const string everywhere is finds it.
        cAddThemAll = "constant string";
        cAddThemAll = cStatic;
        // but the read only will only get it from "one place".
        cAddThemAll = this.cReadOnly;

    }
}

e la chiamata di montaggio 

        cAddThemAll = cConst;
0000003e  mov         eax,dword ptr ds:[09379C0Ch] 
00000044  mov         dword ptr [ebp-44h],eax 
        cAddThemAll = cStatic ;
00000047  mov         eax,dword ptr ds:[094E8C44h] 
0000004c  mov         dword ptr [ebp-44h],eax 
        cAddThemAll = cReadOnly;
0000004f  mov         eax,dword ptr [ebp-3Ch] 
00000052  mov         eax,dword ptr [eax+0000017Ch] 
00000058  mov         dword ptr [ebp-44h],eax

Modifica: Corretto errore di battitura

Questa risposta esiste per scopi storici.

Messaggio:

A causa String è una classe e quindi non può essere una costante.

Discussione estesa:

Un sacco di dialogo utile è stato battuto nel vagliare questa risposta, e invece di eliminarlo, questo contenuto è riprodotto direttamente:

  

In .NET, (a differenza di Java) string e String sono esattamente gli stessi. E sì, si può avere costanti stringa letterali in .NET - DrJokepu 3 febbraio '09 alle 16:57

     

Stai dicendo che una classe non può avere le costanti? - StingyJack 3 febbraio '09 alle 16:58

     

Sì, gli oggetti devono usare in sola lettura. Solo le strutture possono fare costanti. Credo che quando si utilizza string invece di <=> compilatore cambia il const in una sola lettura per voi. Tutto a che fare con il mantenimento programmatori C felice. - Garry Shutler 3 febbraio '09 alle 16:59

     

tvanfosson appena spiegato un po 'più dettagliato. "X non può essere una costante, perché il contenente Y è una classe" era solo un po 'troppo al contesto libero;) - Leonidas 3 febbraio '09 alle 17:01

     

string.Empty è struttura statica che restituisce un'istanza della classe String, cioè la stringa vuota, non la classe stringa stessa. - tvanfosson 3 febbraio '09 alle 17:01

     

Vuoto è un'istanza di sola lettura (non è una proprietà) della classe String. - senfo 3 febbraio '09 alle 17:02

     

Capo male. Continuo a pensare che ho ragione, ma ora sono meno certo. La ricerca necessaria stasera! - Garry Shutler 3 febbraio '09 alle 17:07

     

La stringa vuota è un'istanza della classe stringa. Vuoto è un campo statico (non una proprietà, mi correggo) sulla classe String. In pratica la differenza tra un puntatore e la cosa a cui punta. Se non fosse di sola lettura che potremmo cambiare l'istanza il campo vuoto si riferisce. - tvanfosson 3 febbraio '09 alle 17:07

     

Garry, non c'è bisogno di fare alcuna ricerca. Pensaci. String è una classe. Vuoto è un esempio di una stringa. - senfo 3 febbraio '09 alle 17:12

     

C'è qualcosa che non riesce quasi mai: come sulla terra può il costruttore statico della classe String creare un'istanza della classe String? Non è che una sorta di "uovo o la gallina" scenario? - DrJokepu 3 febbraio '09 alle 17:12   5

     

Questa risposta sarebbe corretta per quasi qualsiasi altra classe ma System.String. NET fa un sacco di performance speciale-involucro per le stringhe, e uno di loro è che si può avere costanti di stringa, basta provare. In questo caso, Jeff Yates ha la risposta corretta. - Joel Mueller 3 febbraio '09 alle 19:25

     

Come descritto in §7.18, una costante espressione è un'espressione che può essere pienamente valutata al momento della compilazione. Poiché l'unico modo per creare un valore non nullo di un riferimento di tipo diverso stringa è di applicare il nuovo operatore, e poiché il nuovo operatore non è consentita in una costante espressione, l'unico valore possibile per le costanti di riferimento tipi diverso stringa è nulla. I due precedenti osservazioni sono state prese direttamente dalla specifica linguaggio C # e ribadire ciò che Joel Mueller menzionato. - senfo 4 febbraio '09 alle 15:05   5

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top