Impossibile utilizzare String.Empty come valore predefinito per un parametro facoltativo

Sto leggendo Effective C # di Bill Wagner. Nell'elemento 14 - Riduci al minimo la logica di inizializzazione duplicata , mostra il seguente esempio di utilizzo della nuova funzionalità di parametri opzionali in un costruttore:

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

Si noti che ha usato ""invece di string.Empty.
Lui commenta:

Noterai [in un esempio sopra] che il secondo costruttore ha specificato "" per il valore predefinito sul parametro name , invece del più consueto string.Empty. Questo perché string.Emptynon è una costante del tempo di compilazione. È una proprietà statica definita nella classe string. Poiché non è una costante di compilazione, non è possibile utilizzarla come valore predefinito per un parametro.

Se non possiamo usare la string.Emptystatica in tutte le situazioni, allora non ne sconfigge lo scopo? Ho pensato che lo avremmo usato per essere sicuri di avere un mezzo indipendente dal sistema per fare riferimento alla stringa vuota. La mia comprensione è sbagliata? Grazie.

AGGIORNAMENTO
Solo un commento di follow-up. Secondo MSDN:

Ogni parametro facoltativo ha un valore predefinito come parte della sua definizione. Se non viene inviato alcun argomento per quel parametro, viene utilizzato il valore predefinito. I valori predefiniti devono essere costanti.

Quindi non saremo in grado di utilizzare System.Environment.NewLinenessuno dei due o utilizzare oggetti appena istanziati come valori predefiniti. Non ho ancora usato VS2010 e questo è deludente!

A partire dal compilatore C # 2.0, non ha comunque molto senso String.Empty, e in effetti in molti casi è una pessimizzazione, poiché il compilatore può inline alcuni riferimenti ""ma non può fare lo stesso conString.Empty .

In C # 1.1 era utile evitare di creare molti oggetti indipendenti che contenevano tutti la stringa vuota, ma quei giorni sono passati. ""funziona bene.

Non c'è niente che ti impedisca di definire la tua costante per la stringa vuota se vuoi davvero usarla come valore di parametro opzionale:

const string String_Empty = "";

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

[Per inciso, una delle ragioni per preferire String.Emptysopra "", in generale, che non è stato menzionato nelle altre risposte, è che ci sono vari caratteri Unicode (falegnami zero larghezza, etc.) che sono effettivamente invisibili ad occhio nudo. Quindi qualcosa che assomiglia ""non è necessariamente una stringa vuota, mentre con String.Emptyte sai esattamente cosa stai usando. Riconosco che questa non è una fonte comune di bug, ma è possibile.]

Dalla domanda originale:

Ho pensato che lo avremmo usato per essere sicuri di avere un mezzo indipendente dal sistema per fare riferimento alla stringa vuota.

In che modo la stringa vuota può variare da sistema a sistema? È sempre una stringa senza caratteri! Sarei davvero paura se mai trovato un'implementazione dove string.Empty == ""restituito falso :) Questo è non è la stessa come qualcosa di simile Environment.NewLine.

Dal post di taglie di Counter Terrorist:

Voglio che String.Empty possa essere usato come parametro predefinito nella prossima versione di C #. : D

Beh, di certo non succederà.

Anche se personalmente avrei gradito anche un meccanismo di default molto diverso, il modo in cui funzionano i parametri opzionali è stato in .NET sin dall'inizio - e significa sempre incorporare una costante nei metadati, in modo che il codice chiamante possa copiare quella costante nella chiamata sito se non viene fornito alcun argomento corrispondente.

Con string.Emptyè davvero inutile: l'uso ""farà quello che vuoi; è che doloroso da usare letterale stringa? (Uso il letterale ovunque - non lo uso mai string.Empty- ma questo è un argomento diverso.)

Questo è ciò che mi sorprende di questa domanda: il reclamo ruota attorno a qualcosa che in realtà non causa un vero problema. È più importante nei casi in cui si desidera che il valore predefinito venga calcolato al momento dell'esecuzione perché potrebbe effettivamente variare. Ad esempio, potrei immaginare casi in cui vuoi essere in grado di chiamare un metodo con un DateTimeparametro e impostarlo come predefinito "l'ora corrente". Al momento, l'unica soluzione vagamente elegante che conosco è:

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

... ma non è sempre appropriato.

In conclusione:

• Dubito fortemente che questo farà mai parte di C #
• Per string.Empty è comunque inutile
• Per altri valori che in realtà non hanno sempre lo stesso valore, può davvero essere un dolore

Non uso mai stringhe vuote, non ne vedo il punto. Forse rende più facile per le persone che sono veramente nuove alla programmazione, ma dubito che sia utile anche per questo.

Penso che l'idea alla base di string.Empty è che migliora la leggibilità. Non è come newline dove c'è qualche differenza tra il modo in cui viene rappresentato su piattaforme diverse. È un peccato che non possa essere utilizzato in un parametro predefinito. Tuttavia, non causerà alcun problema se esegui il port tra Windows e qualcosa come Mono su Linux.

Per tua informazione, sembra che lo stesso vincolo sia imposto sui valori passati ai costruttori di attributi: devono essere costanti. Poiché string.empty è definito come:

public static readonly string Empty

piuttosto che una costante effettiva, non può essere utilizzata.

Io uso string.Empty esclusivamente per la leggibilità.

Se qualcun altro ha bisogno di leggere / modificare il mio codice in un secondo momento, sa che intendevo verificare o impostare qualcosa su una stringa vuota. L'utilizzo di just a ""volte può causare bug e confusione perché potrei aver appena dimenticato di mettere la stringa che volevo lì.

Per esempio:

if(someString == string.Empty)
{

}

vs

if(someString == "")
{

}

La prima ifaffermazione mi sembra molto più deliberata e leggibile. Poiché questa è solo una preferenza, però, non vedo davvero il successo del treno nel dover usare al ""posto di string.Empty.

Forse la migliore soluzione a questo problema è un sovraccarico di questo metodo, in questo modo:

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