En C#, je devrais utiliser string.Vide ou Chaîne.Vide ou "" pour intérioriser une chaîne?

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

Comment faire? Quelle est la bonne façon, et pourquoi?

string willi = string.Empty;

ou

string willi = String.Empty;

ou

string willi = "";

ou quoi?

628
demandé sur RBT 2008-11-04 22:49:02

29 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éé chaque fois que vous utilisez "" . Ce n'est pas vrai - en raison de l'interning de chaîne, il sera créé soit une fois par assemblage 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 insignifiante.

que vous trouverez plus lisible est une question différente, cependant. C'est subjectif et variera d'une personne à l'autre - donc je vous suggère de trouver ce que la plupart des gens de votre équipe aiment, et tout va avec cela pour la cohérence. Personnellement, je trouve "" plus facile à lire.

l'argument selon lequel "" et " " se confondent facilement ne me convient pas vraiment. Sauf si vous utilisez une police proportionnelle (et je n'ai pas travaillé avec tous les développeurs qui font) il est assez facile de dire la différence.

721
répondu Jon Skeet 2011-12-22 12:04:43

il n'y a vraiment aucune différence du point de vue de la performance et du code généré. Dans les tests de performance, ils ont fait des allers-retours, entre lesquels l'un était plus rapide que l'autre, et seulement par 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 utiliser le opcode ldsfld et "" utilise le code op 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.

C # Code

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

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

IL Code

.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
répondu aBetterGamer 2016-05-17 22:15:43

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. [ ... ] commencer par la brièveté. Augmenter les autres dimensions au besoin par des essais.

par conséquent, moins de code est préférable: préférer "" à string.Empty ou String.Empty . Ces deux sont six fois plus sans avantage ajouté - certainement pas de clarté ajoutée, car ils expriment la même information exacte.

68
répondu Konrad Rudolph 2016-01-26 11:45:29

une différence est que si vous utilisez une syntaxe switch-case , 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-versus-vide-citations

46
répondu Mentoliptus 2015-08-21 08:55:36

je préfère string à String . choisir string.Empty plutôt que "" est une question de choix et de s'y tenir. L'avantage d'utiliser string.Empty est qu'il est très évident ce que vous voulez dire, et vous ne copiez pas accidentellement sur des caractères non imprimables comme "\x003" dans votre "" .

39
répondu Jimmy 2011-12-18 21:29:58

Je n'allais pas me mêler de ça, mais je vois des mauvaises infos qui sont jetées ici.

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 certains l'ont mentionné, il n'y a aucune différence entre string.Empty et String.Empty .

de plus, et c'est un fait peu connu, l'utilisation de "" est parfaitement acceptable. Chaque instance de "à", dans d'autres environnements, créer un objet. Cependant, .NET utilise ses ficelles, de sorte que les instances futures tireront la même ficelle immuable du bassin des internes, et toute performance sera négligeable. Source: Brad Abrams .

18
répondu John Rudy 2008-11-04 21:48:44

personnellement, je préfère "" sauf s'il y a une bonne raison à quelque chose de plus complexe.

13
répondu MidnightGun 2008-11-04 19:50:51

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

en ce qui concerne "" , Je ne suis pas vraiment sûr.

personnellement, j'utilise toujours string.Empty .

12
répondu Silviu Niculita 2017-06-30 07:38:45

presque tous les développeurs sauront ce que " signifie. J'ai personnellement rencontré Chaîne.Vider la première fois et a dû passer un certain temps à chercher google pour savoir si elles sont vraiment sont la même chose exacte.

10
répondu Jason Baker 2009-05-31 19:34:43

ce sujet est assez ancien et long, alors excusez-moi si ce comportement a été mentionné ailleurs. (Et de m'indiquer la réponse qui couvre ce)

j'ai trouvé une différence dans le comportement du compilateur si vous utilisez string.Empty ou des guillemets. La différence s'affiche si vous n'utilisez pas la variable string initialisée avec string.Vide ou avec des guillemets doubles.

en cas d'initialisation avec string.Empty puis le compilateur Avertissement

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 doubles vous obtenez le message attendu.

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

en gros, si j'obtiens le droit, ils veulent permettre à un programmeur de mettre un variable avec la valeur de retour d'une fonction pour des buts de débogage sans l'ennuyer avec un message d'avertissement et donc ils ont limité l'avertissement seulement dans le cas des affectations de coûts et de chaîne.Vide n'est pas une constante mais un champ.

7
répondu Steve 2016-04-30 09:55:52

j'ai effectué ce test très simple en utilisant la fonction suivante dans une application sur 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
}

cela suggère clairement que les trois variables à savoir str1 , str2 et str3 sont initialisées en utilisant une syntaxe différente mais pointent vers la même chaîne (de longueur zéro) objet en mémoire . J'ai effectué ce test dans L'application console .Net 4.5. Donc à l'intérieur ils n'ont aucune différence et tout se résume à la commodité de celui que vous voulez utiliser comme un programmeur. Ce comportement de la classe string est connu comme chaîne de stage .Net. Eric Lippert a un très beau blog ici décrivant ce concept.

7
répondu RBT 2017-08-26 02:54:28

Tout ce qui précède.

il y a beaucoup, beaucoup de choses meilleures à pontifier. Comme ce que la couleur de l'écorce convient le mieux à un arbre, je pense brun vague avec des teintes de mousse dulcet.

6
répondu Quibblesome 2008-11-04 19:50:53

je préfère String.Vide, à côté d'autres raisons pour s'assurer que vous savez ce que c'est et que vous n'avez pas accidentellement supprimé le contenu, mais surtout pour l'internationalisation. Si je vois une chaîne de caractères entre guillemets, alors je me demande toujours si c'est un nouveau code et s'il doit être placé dans une table de caractères. Donc chaque fois que le code est modifié / revu vous devez chercher "quelque chose entre guillemets" et oui vous pouvez filtrer les chaînes vides mais je dis aux gens que c'est une bonne pratique de ne mettez jamais de chaîne de caractères entre guillemets sauf si vous savez qu'elle ne sera pas localisée.

5
répondu 2009-01-22 17:03:09

personne n'a mentionné que dans VisualStudio la chaîne de caractères est codée différemment de la chaîne de caractères. Ce qui est important pour la lisibilité. En outre, la minuscule est habituellement utilisée pour les VAR et le type, pas une grosse affaire, mais la corde.Vide est une constante et non un var ou un type.

5
répondu Dimitry 2012-05-24 16:16:36

Je ne fais pas de différence. Le dernier est le plus rapide à type de bien :)

4
répondu 2008-11-04 19:52:56

string est synonyme de System.String type, ils sont identiques.

Les valeurs de

sont également identiques: string.Empty == String.Empty == ""

Je n'utiliserais pas la constante de caractère " "dans le code, plutôt string.Empty ou String.Empty - plus facile de voir ce que programmeur signifiait.

entre string et String j'aime les minuscules string plus juste parce que je travaillais avec Delphi pour beaucoup d'années et le style Delphi est minuscule string .

donc, si j'étais votre patron, vous écririez string.Empty

4
répondu zendar 2008-11-04 20:00:50

cela n'a pas d'importance - ils sont exactement la même chose. Toutefois, l'essentiel est que vous doit être cohérente

p. S. Je me bats avec ce genre de "ce qui est juste" tout le temps.

3
répondu Calanus 2008-11-04 20:01:25

j'utilise le troisième, mais des deux autres le premier semble moins étrange. string est un pseudonyme pour String, mais les voir à travers une tâche semble étrange.

2
répondu plinth 2008-11-04 19:51:36

l'un des deux premiers serait acceptable pour moi. Je voudrais éviter de le dernier, car il est relativement facile d'introduire un bug en mettant un espace entre les guillemets. Ce bogue particulier serait difficile à trouver par observation. En supposant sans fautes, tous sont sémantiquement équivalents.

[EDIT]

aussi, vous pourriez vouloir toujours utiliser string ou String pour la cohérence, mais c'est juste moi.

2
répondu tvanfosson 2008-11-04 20:02:10

c'est totalement une préférence de style code, faites comme .NET gère les chaînes. Cependant, voici mes opinions :)

j'utilise toujours les noms de type BCL pour accéder aux méthodes, propriétés et champs statiques: String.Empty ou Int32.TryParse(...) ou Double.Epsilon

j'utilise toujours les mots-clés C# pour déclarer de nouvelles instances: int i = 0; ou string foo = "bar";

j'utilise rarement des caractères littéraux de chaîne non déclarés car j'aime pouvoir scanner le code pour les combiner en constantes nommées réutilisables. Le compilateur remplace les constantes par les littérales de toute façon donc c'est plus une façon d'éviter les chaînes magiques/nombres et de leur donner un peu plus de sens avec un nom. De plus, changer les valeurs est plus facile.

2
répondu mckamey 2010-08-31 21:52:36

j'ai personnellement assisté "" à deux problèmes (mineurs). Une fois était due à une erreur d'un développeur junior nouveau à la programmation par équipe, et l'autre était une simple typographie, mais le fait est d'utiliser string.Vide aurait évité les deux problèmes.

Oui, c'est vraiment un appel de jugement, mais quand un langage vous donne plusieurs façons de faire les choses, j'ai tendance à me pencher vers celle qui a le plus de supervision du compilateur et la plus forte exécution de la compilation. Que est pas "". C'est tout en exprimant une intention spécifique.

si vous tapez string.Vide ou Strng.Vide, le compilateur vous fait savoir que vous l'avez mal fait. Immédiatement. Il ne compilera tout simplement pas. En tant que développeur, vous citez spécifique l'intention que le compilateur (ou un autre développeur) ne peut en aucune façon mal interpréter, et lorsque vous le faites mal, vous ne pouvez pas créer un bogue.

Si vous tapez "" quand vous voulez dire "" ou vice-versa, le compilateur ne heureusement que vous lui avez dit de faire. Un autre développeur peut être en mesure ou non de glaner votre intention spécifique. Bug créé.

bien avant la corde.Empty était une chose que j'ai utilisé une bibliothèque standard qui a défini la constante EMPTY_STRING. Nous utilisons toujours cette constante dans les déclarations où string.Vide n'est pas autorisé.

autant que possible, mettez le compilateur pour travailler pour vous, et d'éliminer la possibilité d'erreur humaine, peu importe comment les petits. IMO, c'atouts de "lisibilité" comme d'autres l'ont cité.

de la Spécificité et de la compilation de l'application. C'est ce qui est pour le dîner.

2
répondu RhinoTX 2017-05-18 15:44:15

je préférerais string.Empty plutôt que String.Empty parce que vous pouvez l'utiliser sans avoir à inclure un using System; dans votre fichier.

quant à la cueillette "" sur string.Empty , c'est une préférence personnelle et doit être décidé par votre équipe.

2
répondu Andrew 2017-08-26 03:16:16

le compilateur devrait les rendre tous les mêmes à long terme. Choisissez une norme de sorte que votre code sera facile à lire, et de s'y tenir.

1
répondu Chris Marasti-Georg 2008-11-04 19:52:02

je regardais juste un code et cette question m'est venue à l'esprit que j'avais lue quelque temps auparavant. C'est certainement une question de lisibilité.

Considérer le code C# suivant...

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

vs

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

personnellement, je trouve ce dernier moins ambigu et plus facile à lire.

comme d'autres l'ont souligné, les différences réelles sont négligeables.

1
répondu Remotec 2017-01-10 16:11:03

j'utilise "" parce qu'elle sera de couleur distinctive jaune dans mon code... pour une raison quelconque de la Chaîne.Empty est tout blanc dans mon thème Visual Studio. Et je crois que m'importe le plus.

1
répondu 5argon 2017-05-24 17:14:22

je pense que le second est "correct", mais pour être honnête, je ne pense pas que ce sera important. Le compilateur devrait être assez intelligent pour compiler n'importe lequel de ceux-ci exactement au même bytecode. J'utilise "" moi-même.

0
répondu Magus 2008-11-04 19:52:04

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

comme David le laisse entendre, il y a une différence assez faible entre String.Empty et "" , mais il y a une différence. "" crée en fait un objet, il sera probablement retiré de la liste des cordes internes, mais tout de même... tandis que String.Empty ne crée aucun objet... donc, si vous êtes vraiment à la recherche en fin de compte dans l'efficacité de la mémoire, je suggère String.Empty . Cependant, vous devez garder à l'esprit que la différence est si trivalente que vous n'aimerez jamais le voir dans votre code...

Comme pour System.String.Empty ou string.Empty ou String.Empty ... mon niveau de soins est faible ;-)

0
répondu sergiol 2011-11-16 08:17:45

la chaîne vide est comme un ensemble vide juste un nom que tout le monde utilise pour appeler "" . Aussi dans les langues formelles les chaînes créées à partir d'un alphabet qui ont une longueur zéro sont appelées la chaîne vide. Set et string ont un symbole spécial pour cela. Empty string: ε et empty set: chan. Si vous voulez parler de cette chaîne de longueur zéro, vous l'appellerez la chaîne vide pour que tout le monde sache exactement à quoi vous faites référence. Maintenant, dans le cas où vous l'appelez la chaîne vide pourquoi ne pas utiliser string.Empty dans le code, par ses spectacles, l'intention est explicite. L'inconvénient est que ce n'est pas une constante et donc pas disponible partout, comme dans les attributs. (Ce n'est pas une constante pour des raisons techniques, voir la source de référence.)

0
répondu Wouter 2017-12-10 19:44:57

alors que la différence est très, très faible, la différence existe toujours.

1) "" crée un objet tout en chaîne.Vide ne l'est pas. Mais cet objet ne sera créé qu'une fois et sera référencé à partir du pool de chaînes de caractères plus tard si vous avez un autre "" dans le code.

2) La Chaîne et la chaîne sont les mêmes, mais je recommande D'utiliser la chaîne.Vide (ainsi que de la Chaîne.Format De Chaîne De Caractères.Copie etc.) puisque la notation par points indique la classe, pas l'opérateur, et ayant la classe commencer par la lettre majuscule est conforme aux normes de codage c#.

-1
répondu user34577 2008-11-05 07:12:38