解析XmlDocument时处理错误

Question

I'm still getting comfortable working with XML files. I've been looking at a number of examples online and have been struck by the lack of error handling.

The most common error is something like el.Attributes["name"].Value . Since XML is human-editable, it's possible that the attribute is missing. And trying to reference the Value property on null will raise an exception. Other issues would be related to data not being in the expected format.

So I started writing some helper extension methods along the lines of the following:

public static class XmlHelpers
{
    public static string GetValue(this XmlAttribute attr, string defaultValue = "")
    {
        if (attr != null)
            return attr.Value;
        return defaultValue;
    }

    public static bool GetValueBool(this XmlAttribute attr, bool defaultValue = false)
    {
        bool value;
        if (bool.TryParse(attr.GetValue(), out value))
            return value;
        return defaultValue;
    }
}

I know this will work. But am I missing anything? Does XmlDocument already provide functionality that makes this type of stuff unnecessary? I'm just wondering how others are dealing with this.

I realize that many XML files are never edited by humans. And, for that reason, many people may just write code that assumes there will be no errors. If there is an error, then there's an exception. I can understand that. But I was hoping to give my app a little more flexibility if the files are edited by humans, and something isn't formatted quite right.

Answer 1

Depending on what errors you're interested in accommodating (and what the XML you're parsing looks like), the XmlSerializer class might be of use:

void Main()
{
    var xmlSerializer = new XmlSerializer(typeof(Foo));
    var foo1 = (Foo)xmlSerializer.Deserialize(new StringReader(@"<Foo a=""11""></Foo>"));
    Console.WriteLine(foo1.A); // 11

    var foo2 = (Foo)xmlSerializer.Deserialize(new StringReader(@"<Foo></Foo>"));
    Console.WriteLine(foo2.A); // 10 (fell back to the default)

    // throws format exception
    var foo3 = (Foo)xmlSerializer.Deserialize(new StringReader(@"<Foo a=""x""></Foo>"));
}

// Define other methods and classes here
[XmlRoot("Foo")]
public class Foo {
    public Foo() { this.A = 10; }

    [XmlAttribute("a")]
    public int A { get; set; }
}

Handling parsing errors is obviously more difficult. One way could be to use XmlSerializer as described above but use string for all types (perhaps with wrapper properties that incorporate the handling of bad formatting). To get more type-safety, you could define custom types that implement IXmlSerializable "safely" and which define implicit conversions to a System type.

Answer 2

You're not really talking about "errors" here, you're talking about things that can legitimately happen. XML is a very flexible format. One of the problems is that conventional programming languages are far less flexible.

The kind of flexibility you are looking for is built into XML-oriented languages like XPath, XQuery, and XSLT. Low-level programming against DOM interfaces is really hard work compared with XPath, for the reasons you are discovering.