Question En C #, devrais-je utiliser string.Empty ou String.Empty ou "" pour initialiser une chaîne?


En C #, je veux initialiser une valeur de chaîne avec une chaîne vide.

Comment dois-je faire cela? Quelle est la bonne façon, et pourquoi?

string willi = string.Empty;

ou

string willi = String.Empty;

ou

string willi = "";

ou quoi?


617
2017-11-04 19:49


origine


Réponses:


Utilisez ce que vous et votre équipe trouvez le plus lisible.

D'autres réponses ont suggéré qu'une nouvelle chaîne est créée chaque fois que vous utilisez "". Ce n'est pas vrai - en raison de l'internement de chaîne, il sera créé soit une fois par assembly ou une fois par AppDomain (ou peut-être une fois pour l'ensemble du processus - pas sûr sur ce front). Cette différence est négligeable - massivement, massivement insignifiant.

Ce que vous trouvez plus lisible est cependant une question différente. C'est subjectif et ça va varier d'une personne à l'autre - alors je vous suggère de savoir ce que la plupart des gens de votre équipe aiment, et tous vont avec cela pour la cohérence. Personnellement je trouve "" plus facile à lire.

L'argument selon lequel "" et " " se trompent facilement l'un l'autre ne me lave pas vraiment. Sauf si vous utilisez une police proportionnelle (et je n'ai pas travaillé avec tout les développeurs qui le font) il est assez facile de faire la différence.


709
2017-11-04 20:07



Il n'y a pas vraiment de différence entre un point de vue généré par la performance et le code. Dans les tests de performance, ils allaient et venaient entre lesquels l'un était plus rapide que l'autre, et seulement en millisecondes.

En regardant le code des coulisses, vous ne voyez vraiment aucune différence non plus. La seule différence est dans l'IL, qui string.Empty utilise l'opcode ldsfld et "" utilise l'opcode ldstrmais c'est seulement parce que string.Empty est statique, et les deux instructions font la même chose. Si vous regardez l'assemblage qui est produit, c'est exactement la même chose.

Code C #

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

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

Code 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

Code d'assemblage

        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 

355
2017-10-19 13:31



Le meilleur code est pas de code du tout:

La nature fondamentale du codage est que notre tâche, en tant que programmeurs, est de reconnaître que chaque décision que nous prenons est un compromis. [...] Commencez avec brièveté. Augmentez les autres dimensions selon les besoins du test.

Par conséquent, moins de code est meilleur code: Préférez "" à string.Empty ou String.Empty. Ces deux sont six fois plus longtemps sans avantage supplémentaire - certainement pas de clarté supplémentaire, car ils expriment exactement la même information.


68
2017-11-04 20:04



Une différence est que si vous utilisez un switch-case la syntaxe, vous ne pouvez pas écrire case string.Empty: parce que ce n'est pas une constante. Vous obtenez un Compilation error : A constant value is expected

Regardez ce lien pour plus d'informations: chaîne-vide-contre-vide-citations


45
2017-08-26 08:58



je préfèrerais string à String. choisir string.Empty plus de "" est une question d'en choisir un et de s'y tenir. Avantage d'utiliser string.Empty est ce que vous voulez dire, et vous ne copiez pas accidentellement des caractères non imprimables comme "\x003" dans ton "".


38
2017-11-04 19:52



Je n'allais pas entrer, mais je vois de mauvaises infos se faire jeter ici.

Moi, personnellement, je préfère string.Empty. C'est une préférence personnelle, et je me plie à la volonté de n'importe quelle équipe avec laquelle je travaille au cas par cas.

Comme d'autres l'ont mentionné, il n'y a aucune différence entre string.Empty et String.Empty.

De plus, et ceci est un fait peu connu, l'utilisation de "" est parfaitement acceptable. Chaque instance de "" va, dans d'autres environnements, créer un objet. Toutefois, .NET internaute ses chaînes, de sorte que les instances futures tireront la même chaîne immuable du pool interne, et toute atteinte de performance sera négligeable. La source: Brad Abrams.


18
2017-11-04 20:07



Personnellement, je préfère "" à moins qu'il y ait une bonne raison à quelque chose de plus complexe.


13
2017-11-04 19:50



String.Empty et string.Empty sont équivalents. String est le nom de la classe BCL; string est son alias C # (ou raccourci, si vous voulez). Pareil avec Int32 et int. Voir les docs pour plus d'exemples.

Autant que "" est concerné, je ne suis pas vraiment sûr.

Personnellement, j'utilise toujours string.Empty.


12
2017-11-04 19:53



Presque tous les développeurs savent ce que signifie "". J'ai personnellement rencontré String.Empty la première fois et j'ai dû passer un peu de temps à chercher sur google pour savoir si vraiment sont exactement la même chose.


10
2018-05-31 19:34



Ce sujet est assez ancien et long, excusez-moi si ce comportement a été mentionné ailleurs. (Et pointez-moi à la réponse qui couvre cela)

J'ai trouvé une différence dans le comportement du compilateur si vous utilisez string.Empty ou des guillemets doubles. La différence se manifeste si vous n'utilisez pas la variable de chaîne initialisée avec string.Empty ou avec des guillemets doubles.

En cas d'initialisation avec string.Empty puis l'avertissement du compilateur

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

n'est jamais émis alors qu'en cas d'initialisation avec des guillemets, vous obtenez le message attendu.

Ce comportement est expliqué dans l'article Connect à ce lien: https://connect.microsoft.com/VisualStudio/feedback/details/799810/c-warning-cs0219-not-reported-when-assign-non-constant-value 

Fondamentalement, si je comprends bien, ils veulent permettre à un programmeur de définir une variable avec la valeur de retour d'une fonction à des fins de débogage sans le déranger avec un message d'avertissement et ainsi limiter l'avertissement uniquement en cas d'affectations coûteuses. Vide n'est pas une constante mais un champ.


7
2018-04-29 21:09