In C #, dovrei usare string.Empty o String.Empty o “” per inizializzare una stringa?

In C #, voglio inizializzare un valore di stringa con una stringa vuota.

Come dovrei farlo? Qual è la strada giusta e perché?

string willi = string.Empty;

o

string willi = String.Empty;

o

string willi = "";

o cosa?

Usa tutto ciò che tu e il tuo team trovate più leggibili.

Altre risposte hanno suggerito che una nuova stringa viene creata ogni volta che si utilizza "". Questo non è vero - a causa del interning delle stringhe, verrà creato una volta per assembly o una volta per AppDomain (o forse una volta per l'intero processo - non sono sicuro su quel fronte). Questa differenza è trascurabile - enormemente, enormemente insignificante.

Ciò che trovi più leggibile, tuttavia, è una questione diversa. È soggettivo e varia da persona a persona, quindi ti suggerisco di scoprire cosa piace alla maggior parte delle persone del tuo team, e tutti lo seguono per coerenza. Personalmente trovo"" più facile da leggere.

La tesi secondo cui ""e " "sono facilmente scambiato per l'altro in realtà non lavare con me. A meno che tu non stia usando un font proporzionale (e non ho lavorato con nessuno degli sviluppatori che lo fanno) è abbastanza facile dire la differenza.

Non c'è davvero alcuna differenza dal punto di vista delle prestazioni e del codice generato. Nel test delle prestazioni, sono andati avanti e indietro tra i quali uno era più veloce rispetto all'altro e solo di millisecondi.

Guardando il codice dietro le quinte, non si vede davvero alcuna differenza. L'unica differenza è nell'IL, chestring.Empty utilizza il codice operativo ldsfld e ""utilizza il codice operativo ldstr, ma questo è solo perchéstring.Empty è statico, ed entrambe le istruzioni fanno la stessa cosa. Se guardi l'assemblaggio che viene prodotto, è esattamente lo stesso.

Codice C #

private void Test1()
{
    string test1 = string.Empty;    
    string test11 = test1;
}

private void Test2()
{
    string test2 = "";    
    string test22 = test2;
}

Codice IL

.method private hidebysig instance void 
          Test1() cil managed
{
  // Code size       10 (0xa)
  .maxstack  1
  .locals init ([0] string test1,
                [1] string test11)
  IL_0000:  nop
  IL_0001:  ldsfld     string [mscorlib]System.String::Empty
  IL_0006:  stloc.0
  IL_0007:  ldloc.0
  IL_0008:  stloc.1
  IL_0009:  ret
} // end of method Form1::Test1

.method private hidebysig instance void 
        Test2() cil managed
{
  // Code size       10 (0xa)
  .maxstack  1
  .locals init ([0] string test2,
                [1] string test22)
  IL_0000:  nop
  IL_0001:  ldstr      ""
  IL_0006:  stloc.0
  IL_0007:  ldloc.0
  IL_0008:  stloc.1
  IL_0009:  ret
} // end of method Form1::Test2

Codice di montaggio

        string test1 = string.Empty;
0000003a  mov         eax,dword ptr ds:[022A102Ch] 
0000003f  mov         dword ptr [ebp-40h],eax 

        string test11 = test1;
00000042  mov         eax,dword ptr [ebp-40h] 
00000045  mov         dword ptr [ebp-44h],eax 

        string test2 = "";
0000003a  mov         eax,dword ptr ds:[022A202Ch] 
00000040  mov         dword ptr [ebp-40h],eax 

        string test22 = test2;
00000043  mov         eax,dword ptr [ebp-40h] 
00000046  mov         dword ptr [ebp-44h],eax 

Il miglior codice non è affatto un codice :

La natura fondamentale della codifica è che il nostro compito, come programmatori, è riconoscere che ogni decisione che prendiamo è un compromesso. […] Inizia con brevità. Aumentare le altre dimensioni come richiesto dal test.

Di conseguenza, meno codice è codice migliore: Preferisco ""a string.Emptyo String.Empty. Quei due sono sei volte più lunghi senza alcun vantaggio aggiunto - certamente senza ulteriore chiarezza, in quanto esprimono esattamente le stesse informazioni.

Una differenza è che se usi una switch-casesintassi, non puoi scrivere case string.Empty:perché non è una costante. Ottieni unCompilation error : A constant value is expected

Guarda questo link per maggiori informazioni: string-empty-versus-empty-quote

preferirei string a String. scegliere string.Emptyoltre ""è una questione di scegliere uno e attenersi ad esso. Il vantaggio dell'uso string.Emptyè ovvio cosa intendi e non copi accidentalmente su caratteri non stampabili come "\x003"nel tuo "".

Non avevo intenzione di entrare, ma sto vedendo alcune informazioni sbagliate che vengono lanciate qui.

Personalmente preferisco string.Empty . Questa è una preferenza personale e mi rivolgo alla volontà di qualunque squadra con cui lavoro caso per caso.

Come altri hanno già detto, non c'è alcuna differenza tra string.Emptye String.Empty.

Inoltre, e questo è un fatto poco noto, l'uso di "" è perfettamente accettabile. Ogni istanza di "" creerà, in altri ambienti, un oggetto. Tuttavia, .NET esegue il interning delle sue stringhe, quindi le istanze future estrarranno la stessa stringa immutabile dal pool interno e qualsiasi hit delle prestazioni sarà trascurabile. Fonte: Brad Abrams .

Personalmente preferisco "" a meno che non ci sia una buona ragione per qualcosa di più complesso.

String.Emptye string.Emptysono equivalenti. Stringè il nome della classe BCL; stringè il suo alias C # (o scorciatoia, se vuoi). Come con Int32e int. Vedi i documenti per ulteriori esempi.

Per quanto ""mi riguarda, non ne sono davvero sicuro.

Personalmente, lo uso sempre string.Empty.

Quasi ogni sviluppatore saprà cosa significa "". Io personalmente incontrato String.Empty la prima volta e ha dovuto passare un po 'di tempo a cercare su Google per capire se davvero sono la stessa identica cosa.

Questo argomento è piuttosto vecchio e lungo, quindi mi scusi se questo comportamento è stato menzionato altrove. (E indicami la risposta che copre questo)

Ho trovato una differenza nel comportamento del compilatore se si utilizzano string.Emptyo doppie virgolette. La differenza si mostra se non si utilizza la variabile stringa inizializzata con string.Empty o con virgolette doppie.

In caso di inizializzazione con string.Emptyl'avviso del compilatore

CS0219 - The variable 'x' is assigned but its value is never used

non viene mai emesso mentre in caso di inizializzazione con virgolette doppie viene visualizzato il messaggio previsto.

Questo comportamento è spiegato nell'articolo Connect a questo link: https://connect.microsoft.com/VisualStudio/feedback/details/799810/c-warning-cs0219-not-reported-when-assign-non-constant-value

Fondamentalmente, se ho capito bene, vogliono consentire a un programmatore di impostare una variabile con il valore di ritorno di una funzione per scopi di debug senza disturbarlo con un messaggio di avviso e quindi hanno limitato l'avviso solo in caso di assegnazioni costanti e stringa. Vuoto non è una costante ma un campo.

Ho eseguito questo test molto semplice usando il seguente metodo in un'applicazione console:

private static void CompareStringConstants()
{
    string str1 = "";
    string str2 = string.Empty;
    string str3 = String.Empty;
    Console.WriteLine(object.ReferenceEquals(str1, str2)); //prints True
    Console.WriteLine(object.ReferenceEquals(str2, str3)); //prints True
}

Ciò suggerisce chiaramente che tutte e tre le variabili str1, str2e str3sebbene siano state inizializzate utilizzando una sintassi diversa, puntano esattamente allo stesso oggetto stringa (di lunghezza zero) in memoria. Ho eseguito questo test nell'applicazione console .NET 4.5. Quindi internamente non hanno alcuna differenza e tutto si riduce alla comodità di quale si desidera utilizzare come programmatore. Questo comportamento della classe di stringa è noto come intern stringhe in .NET. Eric Lippert ha un blog molto bello qui descrivere questo concetto.

Qualsiasi dei precedenti.

Ci sono molte, molte cose migliori da pontificare. Come ad esempio quale corteccia di colore si adatta meglio ad un albero, penso che il marrone sia vago con riflessi di muschio tenero.

Preferisco fortemente String.Empty, a parte gli altri motivi per assicurarti di sapere di cosa si tratta e che non hai rimosso accidentalmente i contenuti, ma principalmente per l'internazionalizzazione. Se vedo una stringa tra virgolette, devo sempre chiedermi se si tratta di un nuovo codice e dovrebbe essere inserito in una tabella di stringhe. Quindi ogni volta che il codice viene modificato / esaminato, devi cercare "qualcosa tra virgolette" e sì, puoi filtrare le stringhe vuote, ma dico alle persone che è buona pratica non mettere mai le stringhe tra virgolette a meno che tu non sappia che non verrà localizzato .

Nessuno ha detto che in VisualStudio String è un codice colore diverso dalla stringa. Il che è importante per la leggibilità. Inoltre, le lettere minuscole vengono generalmente utilizzate per var e tipo, non un grosso problema ma String.Empty è una costante e non una var o un tipo.

string è sinonimo di System.String tipo, sono identici.

I valori sono anche identici: string.Empty == String.Empty == ""

Non userei la costante di carattere "" nel codice, piuttosto string.Emptyo String.Empty- più facile vedere cosa significasse programmatore.

Tra stringe Stringmi piace di più minuscole stringsolo perché ho lavorato con Delphi per molti anni e lo stile di Delphi è minuscolostring .

Quindi, se fossi il tuo capo, scriveresti string.Empty

Vorrei favorire string.Emptysopra String.Empty, perché si può usare senza bisogno di includere unusing System; nel file.

Per quanto riguarda la raccolta ""sopra string.Empty, è preferenze personali e dovrebbe essere decisa dal vostro team.

Non faccio differenza. L'ultimo è il più veloce da digitare però :)

Non importa: sono esattamente la stessa cosa. Tuttavia, la cosa principale è che devi essere coerente

ps Faccio fatica con questo tipo di "qual è la cosa giusta" per tutto il tempo.

È una preferenza totalmente in stile codice, fa come .NET gestisce le stringhe. Tuttavia, ecco le mie opinioni :)

Uso sempre i nomi dei tipi BCL quando accedo a metodi, proprietà e campi statici: String.Emptyoppure Int32.TryParse(...)oppureDouble.Epsilon

Uso sempre le parole chiave C # per dichiarare nuove istanze: int i = 0;ostring foo = "bar";

Raramente uso letterali stringa non dichiarati poiché mi piace essere in grado di scansionare il codice per combinarli in costanti denominate riutilizzabili. Il compilatore sostituisce comunque le costanti con i letterali, quindi questo è più un modo per evitare stringhe / numeri magici e dare loro un significato in più con un nome. Inoltre, è più semplice modificare i valori.

Uso il terzo, ma degli altri due il primo sembra meno strano. string è un alias per String, ma vederli attraverso un compito sembra fuori luogo.

Uno dei primi due sarebbe accettabile per me. Eviterei l'ultimo perché è relativamente facile introdurre un bug inserendo uno spazio tra le virgolette. Questo particolare bug sarebbe difficile da trovare per osservazione. Supponendo che non ci siano errori di battitura, tutti sono semanticamente equivalenti.

[MODIFICARE]

Inoltre, potresti voler usare sempre uno stringo Stringper coerenza, ma sono solo io.

Ho assistito personalmente "" a due (minori) problemi. Una volta era dovuto a un errore di uno sviluppatore junior nuovo alla programmazione basata su team, e l'altro era un semplice errore di battitura, ma il fatto è usare la stringa. Vuoto avrebbe evitato entrambi i problemi.

Sì, questo è molto un appello di giudizio, ma quando una lingua ti dà più modi di fare le cose, tendo a inclinarmi verso quello che ha la supervisione più compilatore e la più forte applicazione in fase di compilazione. Questo non è "". Si tratta di esprimere l'intento specifico.

Se digiti string.EMpty o Strng.Empty, il compilatore ti informa che hai sbagliato. Subito. Semplicemente non si compila. Come sviluppatore stai citando l' intenzione specifica che il compilatore (o un altro sviluppatore) non può in alcun modo fraintendere, e quando lo fai in modo sbagliato, non puoi creare un bug.

Se digiti "" quando intendi "" o viceversa, il compilatore fa felicemente ciò che gli hai detto di fare. Un altro sviluppatore può o meno essere in grado di raccogliere le tue intenzioni specifiche. Bug creato.

Molto prima di string.Empty era una cosa che ho usato una libreria standard che definiva la costante EMPTY_STRING. Usiamo ancora quella costante nelle istruzioni case in cui string.Empty non è consentito.

Quando possibile, metti il ​​compilatore al lavoro per te ed elimina la possibilità di errore umano, non importa quanto piccolo. IMO, questo supera la "leggibilità" come altri hanno citato.

Specificità e compilazione dei tempi di esecuzione. È per cena.

Uso "" perché sarà colorato in modo distintivo giallo nel mio codice ... per qualche motivo String.Empty è tutto bianco nel mio tema di Visual Studio Code. E credo che ciò che conta di più per me.

Il compilatore dovrebbe renderli tutti uguali a lungo termine. Scegli uno standard in modo che il tuo codice sia facile da leggere e seguilo.

Stavo solo guardando un po 'di codice e questa domanda mi è venuta in mente che avevo letto qualche tempo prima. Questa è certamente una questione di leggibilità.

Considera il seguente codice C # ...

(customer == null) ? "" : customer.Name

vs

(customer == null) ? string.empty : customer.Name

Personalmente trovo quest'ultimo meno ambiguo e più facile da leggere.

Come sottolineato da altri, le differenze effettive sono trascurabili.

Penso che il secondo sia "corretto", ma ad essere sincero non penso che avrà importanza. Il compilatore dovrebbe essere abbastanza intelligente da compilare uno qualsiasi di quelli esattamente nello stesso bytecode. Uso "" me stesso.

Mentre la differenza è molto, MOLTO piccola, la differenza esiste ancora.

1) "" crea oggetto mentre String.Empty no. Ma questo oggetto verrà creato una volta e verrà referenziato dal pool di stringhe in seguito se nel codice è presente un altro "".

2) String e string sono le stesse, ma consiglierei di usare String.Empty (così come String.Format, String.Copy ecc.) Poiché la notazione punto indica la classe, non l'operatore, e la classe che inizia con la lettera maiuscola è conforme a Standard di codifica C #.

Su http://blogs.msdn.com/b/brada/archive/2003/04/22/49997.aspx :

Come suggerisce David, ci sono differenze tra String.Emptye ""sono piuttosto piccole, ma c'è una differenza. ""in realtà crea un oggetto, probabilmente verrà estratto dal pool interno di stringhe, ma comunque ... mentre String.Emptynon crea alcun oggetto ... quindi, se in definitiva stai cercando l'efficienza della memoria, ti suggerisco String.Empty. Tuttavia, si dovrebbe tenere a mente la differenza è così banale che ti piacerà mai vedere nel codice ...
Per quanto riguarda System.String.Emptyo string.Emptyo String.Empty... il mio livello di attenzione è basso ;-)

La stringa vuota è come set vuoto solo un nome che tutti usano per chiamare "". Anche nei linguaggi formali le stringhe create da un alfabeto che hanno lunghezza zero sono chiamate stringhe vuote. Sia il set che la stringa hanno un simbolo speciale per questo. Stringa vuota: ε e set vuoto: ∅. Se vuoi parlare di questa stringa di lunghezza zero, la chiamerai stringa vuota in modo che tutti sappiano esattamente a cosa ti riferisci. Ora nel caso in cui la si denomini come stringa vuota, perché non usarla string.Emptynel codice, mostra che l'intenzione è esplicita. L'aspetto negativo è che non è una costante e quindi non disponibile ovunque, come negli attributi. (Non è una costante per alcuni motivi tecnici, vedere la fonte di riferimento.)

Preferisco ""perché è più corto e String.Emptyrisolve un problema che non esiste.