Quelle est la différence entre String.Empty et "" (chaîne vide) ?

Question

Dans .NET, quelle est la différence entre String.Empty y "" et sont-elles interchangeables, ou y a-t-il une référence sous-jacente ou des problèmes de localisation concernant l'égalité ? String.Empty veillera à ce qu'il n'y ait pas de problème ?

Answer 1

Dans .NET avant la version 2.0, "" crée un objet tandis que string.Empty ne crée aucun objet réf. ce qui rend string.Empty plus efficace.

Dans les versions 2.0 et ultérieures de .NET, toutes les occurrences de l'expression "" font référence à la même chaîne littérale, ce qui signifie que "" est équivalent à .Empty mais toujours pas aussi rapide que .Length == 0 .

.Length == 0 est l'option la plus rapide, mais .Empty permet d'obtenir un code légèrement plus propre.

Ver el .NET pour plus d'informations .

Answer 2

quelle est la différence entre String.Empty et "", et sont-ils interchangeables

string.Empty est un champ en lecture seule alors que "" est une constante de temps de compilation. Les endroits où ils se comportent différemment sont :

Valeur par défaut du paramètre en C# 4.0 ou supérieur

void SomeMethod(int ID, string value = string.Empty)
// Error: Default parameter value for 'value' must be a compile-time constant
{
    //... implementation
}

Expression de cas dans une instruction de commutation

string str = "";
switch(str)
{
    case string.Empty: // Error: A constant value is expected. 
        break;

    case "":
        break;

}

Arguments d'attributs

[Example(String.Empty)]
// Error: An attribute argument must be a constant expression, typeof expression 
//        or array creation expression of an attribute parameter type

Answer 3

Les réponses précédentes étaient correctes pour .NET 1.1 (regardez la date de l'article qu'ils ont lié : 2003). À partir de .NET 2.0 et plus, il n'y a plus de différence. Le JIT finira par référencer le même objet sur le tas de toute façon.

Selon la spécification C#, section 2.4.4.5 : http://msdn.microsoft.com/en-us/library/aa691090(VS.71).aspx

Chaque littéral de chaîne ne donne pas nécessairement lieu à une nouvelle instance de chaîne. Lorsque deux littéraux de chaîne ou plus qui sont équivalents selon l'opérateur d'égalité de chaîne (section 7.9.7) apparaissent dans le même assemblage, ces littéraux de chaîne font référence à la même instance de chaîne.

Quelqu'un en parle même dans les commentaires du billet de Brad Abram.

En résumé, le résultat pratique de "" contre String.Empty est nul. Le JIT finira par s'en rendre compte.

Personnellement, j'ai découvert que le JIT est bien plus intelligent que moi et j'essaie donc de ne pas être trop malin avec des optimisations de micro-compilateur comme celles-ci. Le JIT déploie les boucles for(), supprime le code redondant, inline les méthodes, etc. mieux et à des moments plus appropriés que le compilateur C# ou moi-même ne pourrions jamais anticiper. Laissez le JIT faire son travail :)

Answer 4

String.Empty es un en lecture seule champ tandis que "" es un const . Cela signifie que vous ne pouvez pas utiliser String.Empty dans une instruction switch car il ne s'agit pas d'une constante.

Answer 5

Les réponses ci-dessus sont techniquement correctes, mais ce que vous voulez vraiment utiliser, pour une meilleure lisibilité du code et le moins de chance d'une exception, c'est String.IsNullOrEmpty(s)