En C #, dois-je utiliser string.Empty ou String.Empty ou "" pour initialiser une chaîne?
En C #, je souhaite 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?
tilisez 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'internat de chaîne, il sera créé soit une fois par Assemblée, soit une fois par AppDomain (ou éventuellement une fois pour l'ensemble du processus - pas certain à cet égard). Cette différence est négligeable - massivement, massivement non significative.
Ce que vous trouvez plus lisible est une question différente, cependant. C’est subjectif et cela varie d’une personne à l’autre - je vous suggère donc de découvrir ce que la plupart des membres de votre équipe apprécient, et que tous s’associent à cela pour plus de cohérence. Personnellement, je trouve "" plus facile à lire.
L'argument voulant que "" et " " se confondent facilement ne me trompe pas vraiment. Sauf si vous utilisez une police proportionnelle (et que je n'ai pas travaillé avec les développeurs qui le font), il est assez facile de faire la différence.
Il n'y a vraiment aucune différence entre la performance et le point de vue généré par le code. Lors des tests de performances, ils allaient et venaient entre lesquels l’une é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 réside dans l'IL, où string.Empty utilise l'opcode ldsfld et "" utilise l'opcode ldstr, mais c'est uniquement parce que string.Empty est statique, et les deux instructions font la même chose. Si vous regardez l'Assemblée qui est produite, 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
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 comme requis par les tests.
Par conséquent, moins de code correspond à un meilleur code: préférez "" à string.Empty ou String.Empty. Ces deux sont six fois plus longs sans avantage supplémentaire - certainement pas de clarté supplémentaire, car ils expriment exactement la même information.
Une différence est que si vous utilisez une syntaxe switch-case, vous ne pouvez pas écrire case string.Empty: car ce n'est pas une constante. Vous obtenez un Compilation error : A constant value is expected
Regardez ce lien pour plus d’informations: string-empty-versus-empty-quotes
Je préférerais string à String. choisir string.Empty sur "" consiste à en choisir un et à s'y tenir. L'avantage d'utiliser string.Empty est très clair ce que vous voulez dire, et vous ne copiez pas accidentellement des caractères non imprimables comme "\x003" dans votre "".
Je n'allais pas en parler, mais je vois des informations erronées 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 l'é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 "" créera, dans d'autres environnements, un objet. Toutefois, .NET interne ses chaînes, de sorte que les instances futures extrairont la même chaîne immuable du pool interne et que toute perte de performances sera négligeable. Source: Brad Abrams .
Personnellement, je préfère "" à moins qu'il y ait une bonne raison pour quelque chose de plus complexe.
String.Empty et string.Empty sont équivalents. String est le nom de la classe BCL; string est son alias C # (ou son raccourci, si vous voulez). Identique à Int32 et int. Voir la documentation pour plus d'exemples.
En ce qui concerne "", je ne suis pas vraiment sûr.
Personnellement, j'utilise toujours string.Empty.
À peu près tous les développeurs savent ce que signifie "". J'ai personnellement rencontré String.Empty la première fois et j'ai dû passer du temps à chercher sur Google pour savoir si elles étaient vraiment are exactement la même chose.
Ce sujet est assez ancien et long, alors excusez-moi si ce comportement a été mentionné ailleurs. (Et pointez-moi vers 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 chaîne initialisée avec string.Empty ou avec des guillemets doubles.
En cas d’initialisation avec string.Empty alors 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 guillemets doubles, vous obtenez le message attendu.
Ce comportement est expliqué dans l'article de Connect sur ce lien: https://connect.Microsoft.com/VisualStudio/feedback/details/799810/c-warning-cs0219-not-reported-when-assign-non- valeur constante
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. Ils ont donc limité l’avertissement uniquement en cas d’affectations coûteuses et de chaîne. Vide n'est pas une constante mais un champ.
Tout ce qui précède.
Il y a beaucoup, beaucoup de choses meilleures à pontifier. Tels que la couleur de l'écorce qui convient le mieux à un arbre, je pense à un marron vague avec des nuances de mousse de dulcet.
J'ai effectué ce test très simple en utilisant la méthode suivante dans une application 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 bien qu'initialisées à l'aide d'une syntaxe différente, pointent vers le même objet chaîne (de longueur nulle) en mémoire. J'ai effectué ce test dans l'application console .NET 4.5. Donc, en interne, ils ne font aucune différence et tout se résume à la commodité de celle que vous souhaitez utiliser en tant que programmeur. Ce comportement de la classe de chaîne est appelé chaîne interning dans .NET. Eric Lippert a un très beau blog ici décrivant ce concept.
Je préfère fortement String.Empty, en dehors des autres raisons de vous assurer de savoir de quoi il s'agit et de ne pas en avoir supprimé le contenu par inadvertance, mais avant tout pour l'internationalisation. Si je vois une chaîne entre guillemets, je dois toujours me demander s'il s'agit d'un nouveau code et s'il doit être placé dans un tableau de chaînes. Donc, chaque fois que le code est modifié/révisé, vous devez rechercher "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 jamais mettre des chaînes entre guillemets, sauf si vous savez qu'il ne sera pas localisé .
string est synonyme de System.String type, ils sont identiques.
Les valeurs sont également identiques: string.Empty == String.Empty == ""
Je n'utiliserais pas la constante de caractère "" dans le code, mais plutôt string.Empty ou String.Empty - il serait plus facile de voir ce que programmeur voulait dire.
Entre string et String J'aime les minuscules string plus simplement parce que je travaillais avec Delphi pendant de nombreuses années et que le style Delphi est en minuscule string.
Donc, si j'étais votre patron, vous écririez string.Empty
Personne n'a mentionné que dans VisualStudio, la couleur de la chaîne est différente de celle de la chaîne. Ce qui est important pour la lisibilité. En outre, les minuscules sont généralement utilisées pour les types vars et, pas un gros problème, mais String.Empty est une constante et non une var ou un type.
Je ne fais pas de différence. Le dernier est le plus rapide à taper cependant :)
Je préférerais string.Empty à String.Empty parce que vous pouvez l'utiliser sans avoir à inclure un using System; dans votre fichier.
En ce qui concerne la cueillette "" sur string.Empty, il s'agit d'une préférence personnelle qui devrait être décidée par votre équipe.
Ce n'est pas grave - ils sont exactement la même chose. Cependant, l’essentiel est que vous doit être cohérent
p.s. Je lutte avec ce genre de "quoi de la bonne chose" tout le temps.
C'est totalement une préférence de style code, faites à la façon dont .NET gère les chaînes. Cependant, voici mes opinions :)
J'utilise toujours les noms de type BCL lors de l'accès à des méthodes, propriétés et champs statiques: String.Empty ou Int32.TryParse(...) ou Double.Epsilon
J'utilise toujours les mots-clés C # lors de la déclaration de nouvelles instances: int i = 0; ou string foo = "bar";
J'utilise rarement des littéraux de chaîne non déclarés, car j'aime scanner le code pour les combiner en constantes nommées réutilisables. De toute façon, le compilateur remplace les constantes par les littéraux, c’est donc un moyen d’éviter les chaînes/nombres magiques et de leur donner un peu plus de sens avec un nom. De plus, changer les valeurs est plus facile.
J'utilise le troisième, mais le premier semble moins étrange des deux autres. string est un alias pour String, mais le fait de les voir tout au long d'une affectation est déplacé.
L'un ou l'autre des deux premiers serait acceptable pour moi. J'éviterais le dernier car il est relativement facile d'introduire un bogue en mettant un espace entre les guillemets. Ce bug particulier serait difficile à trouver par observation. En supposant qu'il n'y ait pas de fautes de frappe, tous sont sémantiquement équivalents.
[MODIFIER]
Aussi, vous voudrez peut-être toujours utiliser soit string ou String pour la cohérence, mais ce n'est que moi.
J'ai personnellement été témoin "" de deux problèmes (mineurs). Une fois était due à une erreur d'un développeur débutant débutant dans la programmation en équipe et l'autre était une simple faute de frappe, mais le fait est d'utiliser string.Empty aurait évité les deux problèmes.
Oui, c’est vraiment un jugement, mais quand un langage vous donne plusieurs façons de faire les choses, j’ai tendance à m’appuyer sur celui qui a le plus de contrôle sur les compilateurs et le plus puissant en matière de compilation. C'est pas "". Il s’agit d’exprimer une intention spécifique.
Si vous tapez string.EMpty ou Strng.Empty, le compilateur vous indique que vous vous êtes trompé. Immédiatement. Il ne sera tout simplement pas compilé. En tant que développeur, vous citez spécifique l'intention que le compilateur (ou un autre développeur) ne puisse en aucun cas se méprendre, et lorsque vous le faites mal, vous ne pouvez pas créer de bogue.
Si vous tapez "" quand vous voulez dire "" ou vice-versa, le compilateur fait ce que vous lui demandez. Un autre développeur peut ou non être en mesure de comprendre votre intention spécifique. Bug créé.
Bien avant que string.Empty soit une chose, j'ai utilisé une bibliothèque standard qui définissait la constante EMPTY_STRING. Nous utilisons toujours cette constante dans les instructions case où string.Empty n'est pas autorisé.
Autant que possible, mettez le compilateur à votre service et éliminez le risque d'erreur humaine, aussi minime soit-il. OMI, cela l'emporte sur la "lisibilité" comme d'autres l'ont cité.
Spécificité et mise en application du temps de compilation. C'est pour le dîner.
Le compilateur devrait les rendre tous les mêmes à long terme. Choisissez un standard pour que votre code soit facile à lire et respectez-le.
Je ne faisais que regarder du code et cette question m'a traversé l'esprit, que j'avais déjà lue auparavant. C'est certainement une question de lisibilité.
Considérez le code C # suivant ...
(customer == null) ? "" : customer.Name
contre
(customer == null) ? string.empty : customer.Name
Personnellement, je trouve ce dernier moins ambigu et plus facile à lire.
Comme l'ont souligné d'autres personnes, les différences réelles sont négligeables.
J'utilise "" car il sera coloré distinctement en jaune dans mon code ... pour une raison quelconque, String.Empty est tout blanc dans mon thème Code Visual Studio. Et je crois que cela compte le plus pour moi.
La chaîne vide est comme un ensemble vide, juste un nom que tout le monde utilise pour appeler "". Dans les langages formels, les chaînes créées à partir d'un alphabet de longueur nulle sont appelées chaînes vides. Le set et la chaîne ont tous deux un symbole spécial. Chaîne vide: ε et ensemble vide:. Si vous souhaitez parler de cette chaîne de longueur nulle, appelez-la la chaîne vide afin que tout le monde sache exactement à quoi vous faites référence. Maintenant, si vous nommez la chaîne vide, pourquoi ne pas utiliser string.Empty dans le code, cela montre que l'intention est explicite. L’inconvénient est que ce n’est pas une constante et qu’il n’est donc pas disponible partout, comme dans les attributs. (Ce n'est pas une constante pour certaines raisons techniques, voir la source de référence.)
Je pense que la seconde est "appropriée", mais pour être honnête, je ne pense pas que cela importera. Le compilateur devrait être assez intelligent pour compiler n'importe lequel de ceux-ci dans le même bytecode. J'utilise "" moi-même.
Bien que la différence soit très, TRÈS petite, la différence existe toujours.
1) "" crée un objet alors que String.Empty ne le fait pas. Mais cet objet sera créé une fois et sera référencé à partir du pool de chaînes ultérieurement si vous avez un autre "" dans le code.
2) Chaîne et chaîne sont identiques, mais je recommanderais d'utiliser String.Empty (ainsi que String.Format, String.Copy, etc.), car la notation par points indique la classe, pas l'opérateur, et la classe commençant par une majuscule est conforme à Normes de codage C #.
Sur http://blogs.msdn.com/b/brada/archive/2003/04/22/49997.aspx :
Comme David l’implique, la différence entre
String.Emptyet""est assez petite, mais il existe une différence.""crée réellement un objet, il sera probablement extrait du pool interne de chaînes, mais quand même ... tandis queString.Emptyne crée aucun objet ... donc si vous recherchez réellement l'efficacité de la mémoire , Je suggèreString.Empty. Cependant, gardez à l'esprit que la différence est si importante que vous ne voudrez jamais la voir dans votre code ...
Quant àSystem.String.Emptyoustring.EmptyouString.Empty... mon niveau de soins est faible ;-)