Por que Boolean.ToString produz "True" e não "true"

true.ToString() 
false.toString();

Output:
True
False

Existe uma razão válida para ser "verdadeiro" e não "verdadeiro"? Ele quebra ao escrever XML, pois o tipo booleano do XML é minúsculo e também não é compatível com true / false do C # (embora não tenha certeza sobre o CLS).

Atualizar

Aqui está minha maneira muito hacky de contornar isso em C # (para uso com XML)

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

É claro que isso adiciona mais 1 método à pilha, mas remove ToLowers () em todos os lugares.

Somente pessoas da Microsoft podem realmente responder a essa pergunta. No entanto, gostaria de oferecer alguns fatos interessantes sobre o assunto;)

Primeiro, é o que diz no MSDN sobre o método Boolean.ToString () :

Valor de retorno

Tipo: System.String

TrueString se o valor desta instância for verdadeiro ou FalseString se o valor dessa instância for falso.

Observações

Este método retorna as constantes "Verdadeiro" ou "Falso". Observe que o XML diferencia maiúsculas de minúsculas e que a especificação XML reconhece "true" e "false" como o conjunto válido de valores booleanos. Se o objeto String retornado pelo método ToString () for gravado em um arquivo XML, seu método String.ToLower deverá ser chamado primeiro para convertê-lo em minúsculas.

Aí vem o fato divertido # 1: ele não retorna TrueString ou FalseString. Ele usa literais codificados como "Verdadeiro" e "Falso". Não faria nenhum bem se eles usassem os campos, porque eles são marcados como somente leitura, para que não haja como alterá-los.

O método alternativo, Boolean.ToString (IFormatProvider) é ainda mais engraçado:

Observações

O parâmetro provider está reservado. Não participa da execução deste método. Isso significa que o método Boolean.ToString (IFormatProvider), diferente da maioria dos métodos com um parâmetro de provedor, não reflete as configurações específicas da cultura.

Qual a solução? Depende do que exatamente você está tentando fazer. Seja o que for, aposto que será necessário um hack;)

... porque o ambiente .NET foi projetado para suportar vários idiomas.

O System.Boolean (em mscorlib.dll) foi projetado para ser usado internamente pelos idiomas para oferecer suporte a um tipo de dados booleano. C # usa todas as letras minúsculas para suas palavras-chave, portanto 'bool', 'true' e 'false'.

No entanto, o VB.NET usa caixa padrão: daí 'Boolean', 'True' e 'False'.

Como os idiomas precisam trabalhar juntos, você não poderia ter true.ToString () (C #), dando um resultado diferente a True.ToString () (VB.NET). Os designers do CLR escolheram a notação de caixa padrão do CLR para o resultado ToString ().

A representação em cadeia do valor booleano true é definida como Boolean.TrueString.

(Existe um caso semelhante com System.String: C # o apresenta como o tipo 'string').

Para o Xml, você pode usar o método XmlConvert.ToString .

É um código simples converter tudo isso para minúsculas.

Não é tão simples converter "true" de volta para "True", no entanto.

true.ToString().ToLower() 

é o que eu uso para a saída xml.

Como isso não é compatível com C #? Boolean.Parse e Boolean.TryParse não fazem distinção entre maiúsculas e minúsculas e a análise é feita comparando o valor com Boolean.TrueString ou Boolean.FalseString que são "True" e "False".

EDIT: Ao olhar para o método Boolean.ToString no refletor, verifica-se que as seqüências de caracteres são codificadas permanentemente, portanto o método ToString é o seguinte:

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

Sei que a razão pela qual ela é desse jeito já foi abordada, mas quando se trata de formatação booleana "personalizada", tenho dois métodos de extensão que não podem mais viver sem :-)

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

O uso é trivial. A seguir, converte vários valores bool para suas representações em português:

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

O motivo trueé "Verdadeiro", devido ao forte vínculo da Microsoft com os padrões XML.

Da Wikipedia : "Extensible Markup Language (XML) é uma linguagem de marcação que define um conjunto de regras para codificar documentos em um formato que é legível por humanos e legível por máquina".

Legível por humanos é subjetivo, mas aos olhos do XML, é preferível usar a palavra "Um" no lugar de um número "1". Você notará que isso acontece usando enumerações, pois a palavra é serializada em vez de seu valor ("FirstOption" em vez de "0" ou "1").

Da mesma forma, o texto geralmente segue o CamelCasing . Portanto, em vez de "string", o XML prefere "String". É por isso que Boolean.TrueString é "True" e Boolean.FalseString é "False" por padrão.

Provavelmente isso remete aos velhos tempos do VB NOT .Net quando o bool.ToString produziu True ou False.