En C#, je devrais utiliser string.Vide ou Chaîne.Vide ou "" pour intérioriser une chaîne?
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.
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
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.
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
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 ""
.
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 .
personnellement, je préfère "" sauf s'il y a une bonne raison à quelque chose de plus complexe.
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
.
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.
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.
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.
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.
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.
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.
string
est synonyme de System.String
type, ils sont identiques.
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
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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 queString.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èreString.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 pourSystem.String.Empty
oustring.Empty
ouString.Empty
... mon niveau de soins est faible ;-)
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.)
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#.