Perché Boolean.ToString produce "True" e non "true"

true.ToString() 
false.toString();

Output:
True
False

C'è un motivo valido per essere "Vero" e non "vero"? Si interrompe quando si scrive XML come il tipo booleano di XML è minuscolo e inoltre non è compatibile con true / false di C # (non sono sicuro di CLS).

Aggiornare

Ecco il mio modo molto confuso di aggirarlo in C # (per l'uso con XML)

internal static string ToXmlString(this bool b)
{
    return b.ToString().ToLower();
}

Ovviamente ciò aggiunge un altro metodo allo stack, ma rimuove ToLowers () ovunque.

Solo le persone Microsoft possono davvero rispondere a questa domanda. Tuttavia, vorrei offrire alcuni fatti divertenti al riguardo;)

Innanzitutto, questo è ciò che dice in MSDN sul metodo Boolean.ToString () :

Valore di ritorno

Tipo: System.String

TrueString se il valore di questa istanza è vero o FalseString se il valore di questa istanza è falso.

Osservazioni

Questo metodo restituisce le costanti "Vero" o "Falso". Si noti che XML fa distinzione tra maiuscole e minuscole e che la specifica XML riconosce "true" e "false" come l'insieme valido di valori booleani. Se l'oggetto String restituito dal metodo ToString () deve essere scritto in un file XML, è necessario prima chiamare il suo metodo String.ToLower per convertirlo in minuscolo.

Ecco il fatto divertente n. 1: non restituisce TrueString o FalseString. Utilizza letterali hardcoded "True" e "False". Non ti farebbe nulla di buono se usasse i campi, perché sono contrassegnati come di sola lettura, quindi non è possibile cambiarli.

Il metodo alternativo, Boolean.ToString (IFormatProvider) è ancora più divertente:

Osservazioni

Il parametro del provider è riservato. Non partecipa all'esecuzione di questo metodo. Ciò significa che il metodo Boolean.ToString (IFormatProvider), a differenza della maggior parte dei metodi con un parametro provider, non riflette le impostazioni specifiche della cultura.

Qual è la soluzione? Dipende da cosa stai esattamente cercando di fare. Qualunque cosa sia, scommetto che richiederà un hack;)

... perché l'ambiente .NET è progettato per supportare molte lingue.

System.Boolean (in mscorlib.dll) è progettato per essere utilizzato internamente dalle lingue per supportare un tipo di dati booleano. C # usa tutte le lettere minuscole per le sue parole chiave, quindi "bool", "true" e "false".

VB.NET utilizza tuttavia il case standard: da qui 'Boolean', 'True' e 'False'.

Poiché le lingue devono lavorare insieme, non è possibile avere true.ToString () (C #) che dia un risultato diverso a True.ToString () (VB.NET). I progettisti di CLR hanno scelto la notazione di involucro CLR standard per il risultato ToString ().

La rappresentazione in formato stringa del valore booleano true è definita come Boolean.TrueString.

(C'è un caso simile con System.String: C # lo presenta come il tipo 'stringa').

Per Xml è possibile utilizzare il metodo XmlConvert.ToString .

È un semplice codice per convertirlo in minuscolo.

Tuttavia, non è così semplice convertire "vero" in "Vero".

true.ToString().ToLower() 

è quello che uso per l'output XML.

In che modo non è compatibile con C #? Boolean.Parse e Boolean. TryParse non fanno distinzione tra maiuscole e minuscole e l'analisi viene eseguita confrontando il valore con Boolean.TrueString o Boolean.FalseString che sono "True" e "False".

EDIT: guardando il metodo Boolean.ToString nel riflettore si scopre che le stringhe sono hard coded, quindi il metodo ToString è il seguente:

public override string ToString()
{
    if (!this)
    {
        return "False";
    }
    return "True";
}

Conosco il motivo per cui è già stato affrontato, ma quando si tratta di formattazione booleana "personalizzata", ho due metodi di estensione di cui non posso più vivere senza :-)

public static class BoolExtensions
{
    public static string ToString(this bool? v, string trueString, string falseString, string nullString="Undefined") {
        return v == null ? nullString : v.Value ? trueString : falseString;
    }
    public static string ToString(this bool v, string trueString, string falseString) {
        return ToString(v, trueString, falseString, null);
    }
}

L'uso è banale. Quanto segue converte vari valori bool nelle loro rappresentazioni portoghesi:

string verdadeiro = true.ToString("verdadeiro", "falso");
string falso = false.ToString("verdadeiro", "falso");
bool? v = null;
string nulo = v.ToString("verdadeiro", "falso", "nulo");

Il motivo trueè "True" a causa del forte legame di Microsoft con gli standard XML.

Da Wikipedia : "Extensible Markup Language (XML) è un linguaggio di markup che definisce un insieme di regole per la codifica dei documenti in un formato che è sia leggibile dall'uomo che leggibile dalla macchina".

Leggibile dall'uomo è soggettivo, ma agli occhi di XML, si preferisce usare la parola "Uno" al posto del numero "1". Noterai che ciò accade usando enum, poiché la parola viene serializzata invece del suo valore ("FirstOption" invece di "0" o "1").

Allo stesso modo, il testo segue comunemente CamelCasing . Pertanto, anziché "stringa", XML preferisce "stringa". Questo è il motivo per cui Boolean.TrueString è "True" e Boolean.FalseString è "False" per impostazione predefinita.

Ciò probabilmente risale ai vecchi giorni VB NOT .Net quando bool.ToString produceva True o False.