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

Question

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

Comment dois-je m'y prendre ? Quelle est la bonne méthode, et pourquoi ?

string willi = string.Empty;

o

string willi = String.Empty;

o

string willi = "";

ou quoi ?

Answer 1

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'internalisation des chaînes, il sera créé soit une fois par assemblage, soit une fois par AppDomain (ou peut-être une fois pour l'ensemble du processus - je ne suis pas sûr à ce sujet). Cette différence est négligeable - massivement, massivement insignifiante.

Ce que vous trouvez le plus lisible est cependant une autre question. C'est subjectif et cela varie d'une personne à l'autre. Je vous suggère donc de trouver ce que la plupart des membres de votre équipe préfèrent et de vous en tenir à cela par souci de cohérence. Personnellement, je trouve que "" plus facile à lire.

L'argument selon lequel "" y " " sont facilement confondus les uns avec les autres, ça ne me plaît pas vraiment. A moins que vous n'utilisiez une police proportionnelle (et je n'ai pas travaillé avec des polices de caractères de ce type), il n'y a pas de différence entre les deux. tout les développeurs qui le font), il est assez facile de faire la différence.

Answer 2

Il n'y a vraiment aucune différence du point de vue des performances et du code généré. Dans les tests de performance, ils ont fait des allers-retours entre l'un et l'autre, et seulement pour quelques millisecondes.

En regardant le code en coulisse, on ne voit pas vraiment de différence non plus. La seule différence réside dans l'IL, qui string.Empty utiliser l'opcode ldsfld y "" utilise l'opcode ldstr mais 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, il est exactement le même.

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

Answer 3

Le meilleur code est celui qui n'existe pas 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 par la brièveté. Augmentez les autres dimensions selon les besoins des tests.

Par conséquent, moins de code est un meilleur code : Préférer "" a string.Empty o String.Empty . Ces deux-là sont six fois plus longtemps sans aucun avantage supplémentaire - et certainement pas plus de clarté, puisqu'ils expriment exactement la même information.

Answer 4

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

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

Answer 5

Je préférerais string a String . en choisissant string.Empty sur "" il s'agit d'en choisir un et de s'y tenir. Avantage de l'utilisation string.Empty c'est qu'il est très évident de comprendre ce que vous voulez dire, et que vous ne copiez pas accidentellement des caractères non imprimables tels que "\x003" dans votre "" .