Xml-Serialisierung vs. "True" und "False"

Question

Ich habe ein Problem mit der Deserialisierung einer XML-Datei mit booleschen Werten. Die Quell-XML-Dateien, die ich deserialisiere, wurden aus einer VB6-Anwendung erstellt, in der alle booleschen Werte groß geschrieben werden (True, False). Wenn ich versuche, die XML deserialisiert, ich bin immer ein

System.FormatException: The string 'False' is not a valid Boolean value. 

Gibt es eine Möglichkeit Fall mit einem Attribut zu sagen, ignorieren?

Answer 1

Sie könnten diesen Wert als Zeichenfolge in ein Zeichenfolgenfeld lesen und dann ein readonly-bool-Feld mit einer if-Anweisung verwenden, um bool true oder false zurückzugeben.

Zum Beispiel (unter Verwendung von C#):

public bool str2bool(string str) 
{ 
    if (str.Trim().ToUpper() == "TRUE") 
     return true; 
    else 
     return false; 
} 

Und Sie es in der Vorlage verwenden können: für

<xsl:if test="user:str2bool($mystr)"> 

Answer 2

Ich glaube nicht, dass es gibt. Sie könnten es string machen und einen Vergleich (String.Compare) durchführen, indem Sie den ignoreCase-Wert auf true setzen.

Answer 3

Gibt es nicht. Der XML-Serializer arbeitet mit einem XML-Schema und "True" und "False" sind keine gültigen Booleschen Werte.

Sie könnten entweder eine XML-Transformation verwenden, um diese beiden Werte zu konvertieren, oder Sie können die IXmlSerializable-Schnittstelle implementieren und die Serialisierung und Deserialisierung selbst durchführen.

Answer 4

Anstelle der Verwendung von Wahr oder Falsch, verwenden Sie 0 oder 1. Es wird funktionieren Boolesch.

Answer 5

Basierend auf another stack overflow question Sie tun können:

public class MySerilizedObject 
{ 
    [XmlIgnore] 
    public bool BadBoolField { get; set; } 

    [XmlElement("BadBoolField")] 
    public string BadBoolFieldSerialize 
    { 
     get { return this.BadBoolField ? "True" : "False"; } 
     set 
     { 
      if(value.Equals("True")) 
       this.BadBoolField = true; 
      else if(value.Equals("False")) 
       this.BadBoolField = false; 
      else 
       this.BadBoolField = XmlConvert.ToBoolean(value); 
     } 
    } 
} 

Answer 6

ich auf das gleiche Problem gestolpert und auf die Antwort von jman basiert, löste ich es so:

[XmlIgnore] 
    public bool BadBoolField { get; set; } 

    [XmlAttribute("badBoolField")] 
    public string BadBoolFieldSerializable 
    { 
     get 
     { 
      return this.BadBoolField.ToString(); 
     } 
     set 
     { 
      this.BadBoolField= Convert.ToBoolean(value); 
     } 
    } 

Beachten Sie, dies ist nicht unbedingt nach XML/Serialization-Spezifikation, aber es funktioniert gut und es kann eine weit verbreitete Konvertierung Werte (dh String wie "True", "true", wenn Sie die Einschränkung, eine Zeichenfolge zu sein, könnte auch mit Zahlen umgehen) umgehen.

Answer 7

Hier ist eine viel sauberere Lösung, die ich basierend auf einigen anderen Fragen, die ich gefunden habe, kam. Es ist viel sauberer, weil dann nicht wahr, außer in Ihrem Code etwas brauchen die Art, wie SAFEBOOL zu erklären, wie folgt aus:

public class MyXMLClass 
{ 
    public SafeBool Bool { get; set; } 
    public SafeBool? OptionalBool { get; set; } 
} 

Sie können sogar machen sie optional und es funktioniert einfach. Diese SafeBool-Struktur behandelt alle Fallvarianten von wahr/falsch, ja/nein oder y/n. Es wird immer serialisieren als wahr/falsch, aber ich habe andere Strukturen ähnlich wie ich es verwenden, um speziell als y/n oder ja/nein zu serialisieren, wenn das Schema dies erfordert (zB: BoolYN, BoolYesNo Strukturen).

using System.Xml; 
using System.Xml.Schema; 
using System.Xml.Serialization; 

namespace AMain.CommonScaffold 
{ 
    public struct SafeBool : IXmlSerializable 
    { 
     private bool _value; 

     /// <summary> 
     /// Allow implicit cast to a real bool 
     /// </summary> 
     /// <param name="yn">Value to cast to bool</param> 
     public static implicit operator bool(
      SafeBool yn) 
     { 
      return yn._value; 
     } 

     /// <summary> 
     /// Allow implicit cast from a real bool 
     /// </summary> 
     /// <param name="b">Value to cash to y/n</param> 
     public static implicit operator SafeBool(
      bool b) 
     { 
      return new SafeBool { _value = b }; 
     } 

     /// <summary> 
     /// This is not used 
     /// </summary> 
     public XmlSchema GetSchema() 
     { 
      return null; 
     } 

     /// <summary> 
     /// Reads a value from XML 
     /// </summary> 
     /// <param name="reader">XML reader to read</param> 
     public void ReadXml(
      XmlReader reader) 
     { 
      var s = reader.ReadElementContentAsString().ToLowerInvariant(); 
      _value = s == "true" || s == "yes" || s == "y"; 
     } 

     /// <summary> 
     /// Writes the value to XML 
     /// </summary> 
     /// <param name="writer">XML writer to write to</param> 
     public void WriteXml(
      XmlWriter writer) 
     { 
      writer.WriteString(_value ? "true" : "false"); 
     } 
    } 
} 

Answer 8

Kümmern Sie sich nicht ein gebrochenes xml-System oder kämpfen XmlSerializer, vor allem für etwas so trivial zu fixieren. Es lohnt sich nicht. VB6 kommt nicht so bald zurück.

Greifen Sie stattdessen auf das Dokument zu, bevor es deserialisiert wird, und ändern Sie die Werte. Wenn Sie Bedenken haben, sie außerhalb der Tags zu ändern, verwenden Sie reguläre Ausdrücke oder schließen Sie die spitzen Klammern in die Werte ein.

Es wird keine Auszeichnung für Eleganz gewinnen, aber es bringt Sie zurück zur Arbeit. Manchmal muss man es nur blue kragen.

Für die Leistung, ja, wiederholen Sie durch die Zeichenfolge O (n), aber da die Ersatzzeichenfolgen die gleiche Länge haben, erfordert es keine beweglichen Zeichenfolgenelemente um. Abhängig von der Implementierung kann außerdem ein größerer Aufwand beim Ändern von XmlSerializer entstehen.