Impossible d'utiliser String.Empty comme valeur par défaut pour un paramètre facultatif

Je lis Effective C # de Bill Wagner. Dans l' élément 14 - Minimiser la logique d'initialisation en double , il montre l'exemple suivant d'utilisation de la nouvelle fonctionnalité de paramètres facultatifs dans un constructeur:

public MyClass(int initialCount = 0, string name = "")

Notez qu'il a utilisé à la ""place de string.Empty.
Il commente:

Vous noterez [dans un exemple ci-dessus] que le deuxième constructeur a spécifié "" pour la valeur par défaut sur le paramètre de nom , plutôt que la plus habituelle string.Empty. C'est parce que ce string.Emptyn'est pas une constante de compilation. C'est une propriété statique définie dans la classe de chaînes. Étant donné qu'il ne s'agit pas d'une constante de compilation, vous ne pouvez pas l'utiliser pour la valeur par défaut d'un paramètre.

Si nous ne pouvons pas utiliser la string.Emptystatique dans toutes les situations, cela ne va-t-il pas à l'encontre de son objectif? J'ai pensé que nous l'utiliserions pour être sûrs d'avoir un moyen indépendant du système de faire référence à la chaîne vide. Ma compréhension est-elle erronée? Merci.

MISE
À JOUR Juste un commentaire de suivi. Selon MSDN:

Chaque paramètre facultatif a une valeur par défaut dans le cadre de sa définition. Si aucun argument n'est envoyé pour ce paramètre, la valeur par défaut est utilisée. Les valeurs par défaut doivent être des constantes.

Ensuite, nous ne pouvons pas utiliser System.Environment.NewLineni l'un ni l'autre, ni utiliser des objets nouvellement instanciés comme valeurs par défaut. Je n'ai pas encore utilisé VS2010, et c'est décevant!

À partir du compilateur C # 2.0, il y a très peu d'intérêt de String.Emptytoute façon, et en fait, dans de nombreux cas, c'est une pessimisation, puisque le compilateur peut intégrer certaines références à ""mais ne peut pas faire de même avec String.Empty.

En C # 1.1, il était utile d'éviter de créer de nombreux objets indépendants contenant tous la chaîne vide, mais ces jours sont révolus. ""fonctionne très bien.

Rien ne vous empêche de définir votre propre constante pour la chaîne vide si vous voulez vraiment l'utiliser comme valeur de paramètre facultative:

const string String_Empty = "";

public static void PrintString(string s = String_Empty)
{
    Console.WriteLine(s);
}

[En aparté, l' une des raisons de préférer String.Emptyplus ""en général, qui n'a pas été mentionné dans les autres réponses, est qu'il ya différents caractères Unicode (joiners zéro largeur, etc.) qui sont effectivement invisibles à l'œil nu. Donc, quelque chose qui ressemble ""n'est pas nécessairement la chaîne vide, alors qu'avec String.Emptyvous savez exactement ce que vous utilisez. Je reconnais que ce n'est pas une source courante de bogues, mais c'est possible.]

De la question d'origine:

J'ai pensé que nous l'utiliserions pour être sûrs d'avoir un moyen indépendant du système de faire référence à la chaîne vide.

De quelle manière la chaîne vide peut-elle varier d'un système à l'autre? C'est toujours une chaîne sans caractères! J'aurais vraiment peur si jamais je trouvais une implémentation string.Empty == ""retournée false :) Ce n'est pas la même chose que quelque chose comme Environment.NewLine.

Extrait du message sur les primes de Counter Terrorist:

Je veux String.Empty peut être utilisé comme paramètre par défaut dans la prochaine version C #. :RÉ

Eh bien, cela n'arrivera certainement pas.

Bien que j'aurais personnellement aimé un mécanisme par défaut très différent aussi, la façon dont les paramètres optionnels fonctionnent est dans .NET depuis le début - et cela signifie toujours incorporer une constante dans les métadonnées, afin que le code appelant puisse copier cette constante dans l'appel site si aucun argument correspondant n'est fourni.

Avec string.Emptyc'est vraiment inutile - utiliser ""fera ce que vous voulez; est-ce si pénible d'utiliser la chaîne littérale? (J'utilise le littéral partout - je n'utilise jamais string.Empty- mais c'est un argument différent.)

C'est ce qui me surprend dans cette question - la plainte tourne autour de quelque chose qui ne pose pas vraiment de problème. C'est plus important dans les cas où vous souhaitez que la valeur par défaut soit calculée au moment de l'exécution, car elle peut en fait varier. Par exemple, je pourrais imaginer des cas où vous souhaitez pouvoir appeler une méthode avec un DateTimeparamètre et la définir par défaut sur "l'heure actuelle". Pour le moment, la seule solution de contournement vaguement élégante que je connaisse est:

public void RecordTime(string message, DateTime? dateTime = null)
{
    var realDateTime = dateTime ?? DateTime.UtcNow;
}

... mais ce n'est pas toujours approprié.

En conclusion:

• Je doute fort que cela fasse jamais partie de C #
• Car string.Emptyc'est inutile de toute façon
• Pour d'autres valeurs qui n'ont vraiment pas toujours la même valeur, cela peut vraiment être pénible

Je n'utilise jamais de chaîne, vide, je n'en vois pas l'intérêt. Peut-être que cela facilite les choses pour les personnes qui sont vraiment novices en programmation, mais je doute que ce soit utile même pour cela.

Je pense que l'idée derrière string.Empty est qu'elle améliore la lisibilité. Ce n'est pas comme une nouvelle ligne où il y a une différence entre la façon dont elle est représentée sur différentes plates-formes. C'est dommage qu'il ne puisse pas être utilisé dans un paramètre par défaut. Cependant, cela ne posera aucun problème si vous portez entre Windows et quelque chose comme Mono sous Linux.

En tant que FYI, il semble que la même contrainte soit imposée aux valeurs transmises aux constructeurs d'attributs - elles doivent être constantes. Puisque string.empty est défini comme:

public static readonly string Empty

plutôt qu'une constante réelle, elle ne peut pas être utilisée.

J'utilise string.Emptyuniquement pour la lisibilité.

Si quelqu'un d'autre a besoin de lire / modifier mon code plus tard, il sait que je voulais vérifier ou définir quelque chose sur une chaîne vide. Utiliser juste ""peut parfois causer des bugs et de la confusion parce que j'ai peut-être oublié de mettre la chaîne que je voulais.

Par exemple:

if(someString == string.Empty)
{

}

contre

if(someString == "")
{

}

La première ifdéclaration me semble tellement plus délibérée et lisible. Parce que ce n'est qu'une préférence cependant, je ne vois vraiment pas le train-smash d'avoir à utiliser ""au lieu de string.Empty.

La meilleure solution à ce problème est peut-être une surcharge de cette méthode, de cette manière:

public static void PrintString() 
{ 
    PrintString(string.Empty);
}