Performance .NET IsValidXml Méthode d'extension

Question

J'ai une application héritage que je hérité qui passe beaucoup de XML autour comme des chaînes.

Je dois souvent la possibilité de vérifier si une chaîne XML sera valide. Quel est le moyen le plus rapide et moins coûteuse pour vérifier si une chaîne est valide XML dans .NET?

Je travaille dans .NET 3.5 et utilisez le plus souvent cela comme une méthode d'extension (hors de chaîne) dans celui-ci projet dans la solution.

UPDATE :
Ce que je veux dire par dans mon cas « valide » est correctement formé XML. Je ne ai pas besoin de valider les ressources ou le schéma.

Answer 1

Il est impossible de valider le bien-formedness d'une chaîne XML sans l'analyser. Et une référence rapide montre que la façon la plus rapide pour analyser une chaîne pour voir si elle est valide (en fait le moyen le plus rapide pour analyser la chaîne particulière I en utilisant comme un cas de test) est avec un XmlReader:

    static void Main(string[] args)
    {
        const int iterations = 20000;
        const string xml = @"<foo><bar><baz a='b' c='d'/><foo><bar><baz a='b' c='d'/></bar><bar/></foo><foo><bar><baz a='b' c='d'/></bar><bar/></foo><foo><bar><baz a='b' c='d'/></bar><bar/></foo><foo><bar><baz a='b' c='d'/></bar><bar/></foo><foo><bar><baz a='b' c='d'/></bar><bar/></foo><foo><bar><baz a='b' c='d'/></bar><bar/></foo><foo><bar><baz a='b' c='d'/></bar><bar/></foo><foo><bar><baz a='b' c='d'/></bar><bar/></foo><foo><bar><baz a='b' c='d'/></bar><bar/></foo></bar><bar/></foo>";

        Stopwatch st = new Stopwatch();

        st.Start();
        for (int i=0; i<iterations; i++)
        {
            using (StringReader sr = new StringReader(xml))
            using (XmlReader xr = XmlReader.Create(sr))
            {
                while (xr.Read())
                {
                }
            }
        }
        st.Stop();
        Console.WriteLine(String.Format("XmlReader: {0} ms.", st.ElapsedMilliseconds));

        st.Reset();
        st.Start();
        for (int i=0; i<iterations; i++)
        {
            XElement.Parse(xml);
        }
        st.Stop();
        Console.WriteLine(String.Format("XElement: {0} ms.", st.ElapsedMilliseconds));

        st.Reset();
        st.Start();
        for (int i = 0; i < iterations; i++)
        {
            XmlDocument d= new XmlDocument();
            d.LoadXml(xml);
        }
        st.Stop();
        Console.WriteLine(String.Format("XmlDocument: {0} ms.", st.ElapsedMilliseconds));

        st.Reset();
        st.Start();
        for (int i = 0; i < iterations; i++)
        {
            using (StringReader sr = new StringReader(xml))
            {
                XPathDocument d = new XPathDocument(new StringReader(xml));                    
            }
        }
        st.Stop();
        Console.WriteLine(String.Format("XPathDocument: {0} ms.", st.ElapsedMilliseconds));

        Console.ReadKey();
    }

Sur ma machine XmlReader est presque deux fois plus vite que l'une des alternatives. C'est logique. Bien que je ne l'ai pas utilisé réflecteur pour vérifier, je serais très surpris si XmlDocument, XDocument et XPathDocument n'étaient pas tous en utilisant XmlReader sous le capot.

Answer 2

Je ne suis pas au courant d'une installation intégrée dans .NET pour valider la forme ness (?) De XML sans l'analyser. Étant donné que, quelque chose comme cela devrait fonctionner:

public static class XmlUtilities
{
    public static bool IsXml(this string data)
    {
        if (string.IsNullOrEmpty(data)) return false;

        try
        {
            System.Xml.XmlDocument doc = new System.Xml.XmlDocument();

            doc.LoadXml(data);

            return true;            
        }
        catch
        {
            return false;
        }
    }
}

Answer 3

D'accord avec Adam, et la version XElement:

public static class XmlUtilities
{

    public static bool IsXml(this string data)
    {
        if (string.IsNullOrEmpty(data)) return false;

        try
        {
            var doc = XElement.Parse(data)

            return true;            
        }
        catch (XmlException)
        {
            return false;
        }
    }
}