operator - string c#




In C#, dovrei usare string.Empty o String.Empty o "" per inizializzare una stringa? (20)

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

Uso sempre i nomi dei tipi BCL quando String.Empty metodi, proprietà e campi String.Empty : String.Empty o Int32.TryParse(...) o Double.Epsilon

Io uso sempre le parole chiave C # quando dichiaro nuove istanze: int i = 0; o string foo = "bar";

Raramente uso letterali stringa non dichiarati come mi piace essere in grado di eseguire la scansione del codice per combinarli in costanti con nome riutilizzabili. Il compilatore sostituisce comunque le costanti con i letterali, quindi questo è più di un modo per evitare stringhe / numeri magici e dare un significato un po 'più a loro con un nome. Inoltre cambiare i valori è più facile.

In C #, voglio inizializzare un valore 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?


Ho eseguito questo test molto semplice utilizzando la seguente funzione 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
}

Questo suggerisce chiaramente che tutte e tre le variabili sono str1 , str2 e str3 sebbene inizializzate usando una sintassi diversa ma puntano alla stessa stringa (di lunghezza zero) oggetto in memoria. Ho eseguito questo test in un'applicazione di console 4.5 Net. Quindi internamente non hanno alcuna differenza e tutto si riduce alla comodità di cui si desidera utilizzare come programmatore. Questo comportamento della classe string è noto come internamento di stringhe in .Net. Eric Lippert ha un blog molto carino here descrive questo concetto.


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


Io uso "" perché sarà colorato in modo distintivo in giallo nel mio codice ... per qualche ragione String.Empty è tutto bianco nel mio tema Codice di Visual Studio. E credo che per me sia la cosa più importante.


La stringa vuota è come un set vuoto solo un nome che tutti usano per chiamare "" . Anche nei linguaggi formali le stringhe create da un alfabeto di 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 la stringa vuota in modo che tutti sappiano esattamente a cosa ti riferisci. Ora nel caso in cui lo chiami stringa vuota, perché non usare string.Empty in codice, il suo show indica che l'intenzione è esplicita. Il lato negativo è che non è una costante e quindi non è disponibile ovunque, come negli attributi. (Non è una costante per alcuni motivi tecnici, vedi la fonte di riferimento.)


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 un secondo momento se ne hai un altro "" nel codice.

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


Nessuno ha menzionato che in VisualStudio String è codificato a colori in modo diverso dalla stringa. Che è importante per la leggibilità Inoltre, la lettera minuscola viene solitamente utilizzata per vars e type, non un grosso problema ma String.Empty è una costante e non una var o un tipo.


Non c'è davvero alcuna differenza da un punto di vista di prestazioni e codice generato. Nel test delle prestazioni, andavano avanti e indietro tra quale era più veloce rispetto all'altra e solo di millisecondi.

Osservando il codice dietro le quinte, non vedi alcuna differenza. L'unica differenza è string.Empty , quale string.Empty utilizzare l'opcode ldsfld e "" utilizza l'opcode ldstr , ma solo perché string.Empty è statico e entrambe le istruzioni fanno la stessa cosa. Se guardi l'assemblea prodotta, è esattamente la stessa cosa.

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 assembly

        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 

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

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


Non stavo per entrare, ma sto vedendo alcune informazioni sbagliate che vengono buttate qui.

Io, personalmente, preferisco string.Empty . Questa è una preferenza personale, e mi inchino alla volontà di qualsiasi squadra con cui lavoro, caso per caso.

Come alcuni altri hanno menzionato, non c'è alcuna differenza tra string.Empty e String.Empty .

Inoltre, e questo è un fatto poco conosciuto, l'uso di "" è perfettamente accettabile. Ogni istanza di "", in altri ambienti, creerà un oggetto. Tuttavia, .NET internizza le 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.


Preferirei string a String . scegliere string.Empty over "" è questione di sceglierne uno e attenersi ad esso. Vantaggio dell'uso di string.Empty è molto ovvio cosa intendi, e non copi accidentalmente caratteri non stampabili come "\x003" nel tuo "" .


Qualsiasi dei precedenti.

Ci sono molte, molte cose migliori da pontificare. Come quello che la corteccia di colore si adatta meglio ad un albero, penso marrone vago con sfumature di muschio dolce.


Quasi tutti gli sviluppatori là fuori sapranno cosa significa "". Personalmente ho incontrato String.Empty la prima volta e ho dovuto passare un po 'di tempo a cercare su Google per capire se sono esattamente la stessa cosa.


Stavo solo guardando un 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.


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

Come suggerisce David, la differenza tra String.Empty e "" è piuttosto piccola, ma c'è una differenza. "" realtà crea un oggetto, sarà probabilmente estratto dal pool interno di stringhe, ma comunque ... mentre String.Empty non crea alcun oggetto ... quindi se stai cercando davvero l'efficienza della memoria, ti suggerisco String.Empty Tuttavia, dovresti tenere a mente che la differenza è così trival che non ti piacerà mai vederlo nel tuo codice ...
Come per System.String.Empty o string.Empty o String.Empty ... il mio livello di assistenza è basso ;-)


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

[MODIFICARE]

Inoltre, potresti voler usare sempre string o String per coerenza, ma sono solo io.


Il miglior codice non è affatto un codice :

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

Di conseguenza, meno codice è un codice migliore: preferisci "" a string.Empty o String.Empty . Quei due sono sei volte più lunghi senza alcun beneficio aggiunto - certamente nessuna chiarezza aggiunta, poiché esprimono esattamente le stesse informazioni.


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

Anche i valori sono identici: string.Empty == String.Empty == ""

Non string.Empty costante di carattere "" nel codice, piuttosto string.Empty o String.Empty - più facile vedere cosa intendesse il programmatore.

Tra string e String mi piace la string minuscola più semplicemente perché lavoravo con Delphi per molti anni e lo stile Delphi è una string minuscola.

Quindi, se fossi il tuo capo, string.Empty scrivendo una string.Empty


Usa 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 dell'internamento delle stringhe, verrà creato una volta per assembly o una volta per AppDomain (o forse una sola volta per l'intero processo - non sicuro su quel fronte). Questa differenza è trascurabile - in maniera massiccia, massicciamente insignificante.

Che trovi più leggibile è una questione diversa, comunque. È soggettivo e varierà da persona a persona, quindi ti suggerisco di scoprire a cosa piace la maggior parte delle persone della tua squadra, e tutto questo per coerenza. Personalmente trovo che "" più facile da leggere.

L'argomento che "" e " " si confondono facilmente l'uno con l'altro non si lava veramente 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 capire la differenza.





initialization