Что является неправильным в отношении моего свойства XML / C # boolean? [Дубликат]

Не беспокойтесь, исправляя сломанную систему xml или сражаясь с XmlSerializer, особенно для чего-то такого тривиального. Это не стоит. VB6 не вернется в ближайшее время.

Вместо этого возьмите документ перед его десериализацией и измените значения. Если вы беспокоитесь об изменении их за пределами тегов, используйте регулярные выражения или включите угловые скобки в значениях.

    xml = xml.Replace("True", "true").Replace("False", "false");

Он не выиграет никаких наград за элегантность, но он вернет вас работать. Иногда вам нужно иметь синий воротник.

Что касается производительности, да, вы повторяете строку O (n), но поскольку строки замены имеют одинаковую длину, это не требует каких-либо перемещений Строковые элементы вокруг. Кроме того, в зависимости от реализации может возникнуть больший накладные расходы при модификации XmlSerializer.

На основе другого вопроса о переполнении стека вы можете выполнить:

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

Нет. Сериализатор XML работает с XML-схемой, а «True» и «False» недействительны. Booleans.

Вы можете использовать XML Transform для преобразования этих двух значений или реализовать интерфейс IXmlSerializable и выполнить сериализации и десериализации.

Вот гораздо более чистое решение, которое я придумал, основываясь на некоторых других вопросах, которые я нашел. Это намного чище, потому что тогда вам не нужно ничего в коде, кроме объявления типа SafeBool, например:

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

вы даже можете сделать их необязательными, и все это просто работает. Эта структура SafeBool будет обрабатывать любые варианты вариантов true / false, yes / no или y / n. Он всегда будет сериализован как true / false, однако у меня есть другие структуры, подобные этому, которые я использую для сериализации в качестве y / n или yes / no, когда это требует схема (то есть: BoolYN, BoolYesNo structs).

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

В специальном случае есть невероятно простое и короткое решение.

Сегодня я столкнулся с аналогичной проблемой, с внешним XML-файлом, который содержит значения TRUE / FALSE, которые должны иметь логическое значение значение.

Если для приложения не обязательно, чтобы десериализованный документ содержал собственный bool, но он просто требует десериализации его для чего-то, что ограничено любыми двумя альтернативными значениями, тогда можно просто использовать перечисление (здесь для атрибута в качестве примера):

public enum BOOL {FALSE, TRUE};

public MyClass
{
    [XmlAttribute]
    public BOOL MyStrangeBooleanAttribute {get; set;}
}

Это будет просто десериализовать без каких-либо проблем из элемента вроде этого

<MyClass MyStrangeBooleanAttribute = "TRUE" />

Конечно, это невозможно использовать свойство в коде для прямых логических операций, например

if (MyStrangeBooleanAttribute) // ... doesn't work

Я думаю, что, возможно, с этим можно было бы справиться, указав неявное преобразование, но я его не тестировал, потому что я не это нужно.

Вместо использования True или False используйте 0 или 1. Он будет работать для Boolean.

Я не думаю, что есть. Вы можете сделать это строкой и выполнить сравнение (String.Compare) , установив для параметра ignoreCase значение true.

Я наткнулся на ту же проблему и, основываясь на ответе jman, я решил это так:

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

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

Помните, что это не обязательно по спецификации XML / Serialization, но она работает хорошо и он может обрабатывать широко распространенные значения преобразования (например, строки типа «True», «true», если вы замените ограничение на строку, в которой она также могла бы обрабатывать числа).