¿Por qué Boolean.ToString muestra "True" y no "true"?

true.ToString() 
false.toString();

Output:
True
False

¿Hay alguna razón válida para que sea "Verdadero" y no "verdadero"? Se rompe cuando se escribe XML, ya que el tipo booleano de XML es minúscula y tampoco es compatible con C / 'verdadero / falso (aunque no estoy seguro acerca de CLS).

Actualizar

Aquí está mi manera muy hacky de evitarlo en C # (para usar con XML)

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

Por supuesto, eso agrega 1 método más a la pila, pero elimina ToLowers () en todas partes.

Solo las personas de Microsoft realmente pueden responder esa pregunta. Sin embargo, me gustaría ofrecer algunos datos divertidos al respecto;)

Primero, esto es lo que dice en MSDN sobre el método Boolean.ToString () :

Valor de retorno

Tipo: System.String

TrueString si el valor de esta instancia es verdadero, o FalseString si el valor de esta instancia es falso.

Observaciones

Este método devuelve las constantes "Verdadero" o "Falso". Tenga en cuenta que XML distingue entre mayúsculas y minúsculas, y que la especificación XML reconoce "verdadero" y "falso" como el conjunto válido de valores booleanos. Si el objeto String devuelto por el método ToString () se va a escribir en un archivo XML, primero se debe llamar a su método String.ToLower para convertirlo a minúsculas.

Aquí viene el hecho divertido # 1: no devuelve TrueString o FalseString en absoluto. Utiliza literales codificados "Verdadero" y "Falso". No te haría ningún bien si usara los campos, porque están marcados como de solo lectura, por lo que no hay que cambiarlos.

El método alternativo, Boolean.ToString (IFormatProvider) es aún más divertido:

Observaciones

El parámetro del proveedor está reservado. No participa en la ejecución de este método. Esto significa que el método Boolean.ToString (IFormatProvider), a diferencia de la mayoría de los métodos con un parámetro de proveedor, no refleja la configuración específica de la cultura.

¿Cual es la solución? Depende de qué es exactamente lo que intentas hacer. Sea lo que sea, apuesto a que requerirá un hack;)

... porque el entorno .NET está diseñado para admitir muchos idiomas.

System.Boolean (en mscorlib.dll) está diseñado para ser utilizado internamente por idiomas para admitir un tipo de datos booleano. C # usa todas las minúsculas para sus palabras clave, por lo tanto, 'bool', 'true' y 'false'.

Sin embargo, VB.NET utiliza una carcasa estándar: de ahí 'Boolean', 'True' y 'False'.

Dado que los lenguajes tienen que funcionar juntos, no podría tener true.ToString () (C #) dando un resultado diferente a True.ToString () (VB.NET). Los diseñadores de CLR eligieron la notación de carcasa CLR estándar para el resultado ToString ().

La representación de cadena del verdadero booleano se define como Boolean.TrueString.

(Hay un caso similar con System.String: C # lo presenta como el tipo 'string').

Para Xml puede usar el método XmlConvert.ToString .

Es un código simple para convertir eso en minúsculas.

Sin embargo, no es tan simple convertir "verdadero" a "verdadero".

true.ToString().ToLower() 

es lo que uso para la salida xml.

¿Cómo no es compatible con C #? Boolean.Parse y Boolean. TryParse no distingue entre mayúsculas y minúsculas y el análisis se realiza comparando el valor con Boolean.TrueString o Boolean.FalseString, que son "True" y "False".

EDITAR: Al mirar el método Boolean.ToString en el reflector, resulta que las cadenas están codificadas por lo que el método ToString es el siguiente:

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

Sé que la razón por la cual ya se ha abordado, pero cuando se trata de formato booleano "personalizado", tengo dos métodos de extensión sin los que ya no puedo vivir :-)

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);
    }
}

El uso es trivial. Lo siguiente convierte varios valores bool a sus representaciones portuguesas:

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

La razón truees "verdadera" es por el fuerte vínculo de Microsoft con los estándares XML.

De Wikipedia : "Extensible Markup Language (XML) es un lenguaje de marcado que define un conjunto de reglas para codificar documentos en un formato que es legible por humanos y por máquina".

La lectura humana es subjetiva, pero a los ojos de XML, se prefiere usar la palabra "Uno" en lugar del número "1". Notará que esto sucede usando enumeraciones, ya que la palabra se serializa en lugar de su valor ("FirstOption" en lugar de "0" o "1").

Del mismo modo, el texto sigue comúnmente a CamelCasing . Por lo tanto, en lugar de "cadena", XML prefiere "Cadena". Es por eso que Boolean.TrueString es "True" y Boolean.FalseString es "False" de forma predeterminada.

Esto probablemente se refiere a los viejos días de VB NOT .Net cuando bool.ToString produjo True o False.