Pourquoi Boolean.ToString affiche-t-il "True" et non "true"

true.ToString() 
false.toString();

Output:
True
False

Y a-t-il une raison valable pour qu'elle soit "vraie" et non "vraie"? Il casse lors de l'écriture de XML car le type booléen de XML est en minuscules et n'est également pas compatible avec le vrai / faux de C # (cependant pas sûr de CLS).

Mettre à jour

Voici ma façon très hacky de le contourner en C # (pour une utilisation avec XML)

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

Bien sûr, cela ajoute 1 méthode de plus à la pile, mais supprime ToLowers () partout.

Seuls les gens de Microsoft peuvent vraiment répondre à cette question. Cependant, je voudrais offrir quelques faits amusants à ce sujet;)

Tout d'abord, voici ce qu'elle dit dans MSDN à propos de la méthode Boolean.ToString () :

Valeur de retour

Type: System.String

TrueString si la valeur de cette instance est vraie, ou FalseString si la valeur de cette instance est fausse.

Remarques

Cette méthode renvoie les constantes "True" ou "False". Notez que XML est sensible à la casse et que la spécification XML reconnaît "vrai" et "faux" comme l'ensemble valide de valeurs booléennes. Si l'objet String renvoyé par la méthode ToString () doit être écrit dans un fichier XML, sa méthode String.ToLower doit être appelée en premier pour le convertir en minuscules.

Voici le fait amusant n ° 1: il ne retourne pas du tout TrueString ou FalseString. Il utilise des littéraux codés en dur "True" et "False". Cela ne vous servirait à rien s'il utilisait les champs, car ils sont marqués comme étant en lecture seule, il n'y a donc pas de changement.

La méthode alternative, Boolean.ToString (IFormatProvider) est encore plus drôle:

Remarques

Le paramètre fournisseur est réservé. Il ne participe pas à l'exécution de cette méthode. Cela signifie que la méthode Boolean.ToString (IFormatProvider), contrairement à la plupart des méthodes avec un paramètre de fournisseur, ne reflète pas les paramètres spécifiques à la culture.

Quelle est la solution? Cela dépend exactement de ce que vous essayez de faire. Quoi qu'il en soit, je parie qu'il faudra un hack;)

... car l'environnement .NET est conçu pour prendre en charge de nombreuses langues.

System.Boolean (dans mscorlib.dll) est conçu pour être utilisé en interne par les langues pour prendre en charge un type de données booléen. C # utilise tous les minuscules pour ses mots clés, d'où «bool», «true» et «false».

VB.NET utilise cependant une casse standard: d'où «booléen», «vrai» et «faux».

Étant donné que les langages doivent fonctionner ensemble, vous ne pouvez pas avoir true.ToString () (C #) donnant un résultat différent de True.ToString () (VB.NET). Les concepteurs CLR ont choisi la notation de casse CLR standard pour le résultat ToString ().

La représentation sous forme de chaîne du booléen true est définie comme étant Boolean.TrueString.

(Il y a un cas similaire avec System.String: C # le présente comme le type 'string').

Pour Xml, vous pouvez utiliser la méthode XmlConvert.ToString .

C'est un code simple pour convertir cela en minuscules.

Cependant, il n'est pas si simple de reconvertir "vrai" en "vrai".

true.ToString().ToLower() 

est ce que j'utilise pour la sortie xml.

Comment n'est-il pas compatible avec C #? Boolean.Parse et Boolean.TryParse est insensible à la casse et l'analyse est effectuée en comparant la valeur à Boolean.TrueString ou Boolean.FalseString qui sont "True" et "False".

EDIT: Lorsque vous regardez la méthode Boolean.ToString dans le réflecteur, il s'avère que les chaînes sont codées en dur, la méthode ToString est donc la suivante:

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

Je sais que la raison pour laquelle c'est ainsi a déjà été abordée, mais en ce qui concerne le formatage booléen "personnalisé", j'ai deux méthodes d'extension dont je ne peux plus me passer :-)

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'utilisation est triviale. Les éléments suivants convertissent diverses valeurs booléennes en leurs représentations portugaises:

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

La raison true est "True" en raison du lien fort de Microsoft avec les normes XML.

Extrait de Wikipédia : "Extensible Markup Language (XML) est un langage de balisage qui définit un ensemble de règles pour coder les documents dans un format qui est à la fois lisible par l'homme et machine."

Lisible par l'homme est subjectif, mais aux yeux de XML, il est préférable d'utiliser le mot "Un" à la place du chiffre "1". Vous remarquerez que cela se produit en utilisant des énumérations, car le mot est sérialisé au lieu de sa valeur ("FirstOption" au lieu de "0" ou "1").

De même, le texte suit généralement CamelCasing . Par conséquent, au lieu de "chaîne", XML préfère "chaîne". C'est pourquoi Boolean.TrueString est "True" et Boolean.FalseString est "False" par défaut.

Cela est probablement lié aux anciens jours VB NOT .Net où bool.ToString produisait True ou False.