Il modo migliore per rilevare XML?

Attualmente, ho il seguente codice c# per estrarre un valore di testo. Se il suo XML, voglio il valore all’interno di esso, in caso contrario, se non il suo XML, è possibile restituire il testo stesso.

String data = "..."
try
{
    return XElement.Parse(data).Value;
}
catch (System.Xml.XmlException)
{
    return data;
}

So eccezioni sono costosi in C#, quindi mi chiedevo se c’era un modo migliore per determinare se il testo che ho a che fare con xml o no?

Ho pensato di regex test, ma io non’ vedere che come alternativa più economica. Nota, sto chiedendo per un meno costoso metodo di fare questo.

  • Le eccezioni sono libero io li tiro via tutto il tempo. Non c’è niente di sbagliato con il codice di cui sopra a meno che non si dimostrano, in realtà è solo un codice di odore. Qualcuno ha provato i metodi riportati di seguito sono effettivamente più veloce, ed è che la velocità necessaria?
  • in realtà, nella maggior parte dei C++ implementazioni, le eccezioni sono lenti. Ma C# potrebbe essere un caso diverso. Non ho usato C#, quindi non posso commentare prestazioni eccezione in C#. Posso in C++ ciclo di 400 milioni di iterazioni al secondo, ma con l’eccezione generata ogni iterazione, è a meno di milioni di iterazioni al secondo.
  • Wow, che un thread, io non anche il codice c# più 🙂 Il miglior consiglio che vorrei dare è oggi, ma vorrei confrontare tutte le diverse parser nel quadro. Si potrebbe anche essere in grado di imbrogliare con alcuni controlli di base. Ci sono anche un 3rd party parser xml disponibili che offrono prestazioni migliori.
  • Anche quando le prestazioni non è un problema, è meglio evitare la generazione di un’eccezione non in circostanze eccezionali. La nostra attrezzatura è costruito per trovare eccezioni e si può ottenere nel modo quando il debug di qualcos’altro. Penso che questo sia un esempio di “fastidioso eccezione“, anche se meno grave di int.Analizzare esempio Eric ha dato.
InformationsquelleAutor cyberconte | 2009-05-21

 

13 Replies
  1. 19

    Si potrebbe fare un controllo preliminare per un < poiché tutti XML deve iniziare con uno e la maggior parte di tutti i non-XML non iniziare con uno.

    (A mano libera scritti.)

    //Has to have length to be XML
    if (!string.IsNullOrEmpty(data))
    {
        //If it starts with a < after trimming then it probably is XML
        //Need to do an empty check again in case the string is all white space.
        var trimmedData = data.TrimStart();
        if (string.IsNullOrEmpty(trimmedData))
        {
           return data;
        }
    
        if (trimmedData[0] == '<')
        {
            try
            {
                return XElement.Parse(data).Value;
            }
            catch (System.Xml.XmlException)
            {
                return data;
            }
        }
    }
    else
    {
        return data;
    }

    Mi aveva originariamente l’uso di un’espressione regolare, ma il Trim()[0] è identico a quello che regex che vorresti fare.

    • +1 per il concetto dal momento che saranno estirpare il 99% delle eccezioni, ma non sento la regex è necessario qui. StartsWith o IndexOf sarebbe meglio e più velocemente.
    • Um, StartsWith non funziona in quanto gli spazi sono consentiti e IndexOf richiederebbe sapere tutto prima che l’indice di essere lo spazio. Se IndexOf potrebbe essere utilizzato e potrai modificare la mia risposta.
  2. 7

    Il codice indicato di seguito troverà tutti i seguenti formati xml:

    <text />                             
    <text/>                              
    <text   />                           
    <text>xml data1</text>               
    <text attr='2'>data2</text>");
    <text attr='2' attr='4' >data3 </text>
    <text attr>data4</text>              
    <text attr1 attr2>data5</text>

    Ed ecco il codice:

    public class XmlExpresssion
    {
        //EXPLANATION OF EXPRESSION
        //<        :   \<{1}
        //text     :   (?<xmlTag>\w+)  : xmlTag is a backreference so that the start and end tags match
        //>        :   >{1}
        //xml data :   (?<data>.*)     : data is a backreference used for the regex to return the element data      
        //</      :   <{1}/{1}
        //text     :   \k<xmlTag>
        //>        :   >{1}
        //(\w|\W)* :   Matches attributes if any
    
        //Sample match and pattern egs
        //Just to show how I incrementally made the patterns so that the final pattern is well-understood
        //<text>data</text>
        //@"^\<{1}(?<xmlTag>\w+)\>{1}.*\<{1}/{1}\k<xmlTag>\>{1}$";
    
        //<text />
        //@"^\<{1}(?<xmlTag>\w+)\s*/{1}\>{1}$";
    
        //<text>data</text> or <text />
        //@"^\<{1}(?<xmlTag>\w+)((\>{1}.*\<{1}/{1}\k<xmlTag>)|(\s*/{1}))\>{1}$";
    
        //<text>data</text> or <text /> or <text attr='2'>xml data</text> or <text attr='2' attr2 >data</text>
        //@"^\<{1}(?<xmlTag>\w+)(((\w|\W)*\>{1}(?<data>.*)\<{1}/{1}\k<xmlTag>)|(\s*/{1}))\>{1}$";
    
        private const string XML_PATTERN = @"^\<{1}(?<xmlTag>\w+)(((\w|\W)*\>{1}(?<data>.*)\<{1}/{1}\k<xmlTag>)|(\s*/{1}))\>{1}$";
    
        //Checks if the string is in xml format
        private static bool IsXml(string value)
        {
            return Regex.IsMatch(value, XML_PATTERN);
        }
    
        ///<summary>
        ///Assigns the element value to result if the string is xml
        ///</summary>
        ///<returns>true if success, false otherwise</returns>
        public static bool TryParse(string s, out string result)
        {
            if (XmlExpresssion.IsXml(s))
            {
                Regex r = new Regex(XML_PATTERN, RegexOptions.Compiled);
                result = r.Match(s).Result("${data}");
                return true;
            }
            else
            {
                result = null;
                return false;
            }
        }
    
    }

    Codice chiamante:

    if (!XmlExpresssion.TryParse(s, out result)) 
        result = s;
    Console.WriteLine(result);
    • Io sono sospettoso di questo dato che l’XML non è un normale linguaggio e, quindi, non è possibile analizzare XML con regex: stackoverflow.com/questions/6751105/… …ma, per l’identificazione di XML, forse potrebbe funzionare se non stai facendo un pieno di analizzare.
  3. 5

    Aggiornamento: (post originale qui di seguito)
    Colin ha la brillante idea di spostare l’espressione regolare istanza al di fuori delle chiamate in modo che siano creati una sola volta. Heres il nuovo programma:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Xml.Linq;
    using System.Diagnostics;
    using System.Text.RegularExpressions;
    
    namespace ConsoleApplication3
    {
        delegate String xmltestFunc(String data);
    
        class Program
        {
            static readonly int iterations = 1000000;
    
            private static void benchmark(xmltestFunc func, String data, String expectedResult)
            {
                if (!func(data).Equals(expectedResult))
                {
                    Console.WriteLine(data + ": fail");
                    return;
                }
                Stopwatch sw = Stopwatch.StartNew();
                for (int i = 0; i < iterations; ++i)
                    func(data);
                sw.Stop();
                Console.WriteLine(data + ": " + (float)((float)sw.ElapsedMilliseconds / 1000));
            }
    
            static void Main(string[] args)
            {
                benchmark(xmltest1, "<tag>base</tag>", "base");
                benchmark(xmltest1, " <tag>base</tag> ", "base");
                benchmark(xmltest1, "base", "base");
                benchmark(xmltest2, "<tag>ColinBurnett</tag>", "ColinBurnett");
                benchmark(xmltest2, " <tag>ColinBurnett</tag> ", "ColinBurnett");
                benchmark(xmltest2, "ColinBurnett", "ColinBurnett");
                benchmark(xmltest3, "<tag>Si</tag>", "Si");
                benchmark(xmltest3, " <tag>Si</tag> ", "Si" );
                benchmark(xmltest3, "Si", "Si");
                benchmark(xmltest4, "<tag>RashmiPandit</tag>", "RashmiPandit");
                benchmark(xmltest4, " <tag>RashmiPandit</tag> ", "RashmiPandit");
                benchmark(xmltest4, "RashmiPandit", "RashmiPandit");
                benchmark(xmltest5, "<tag>Custom</tag>", "Custom");
                benchmark(xmltest5, " <tag>Custom</tag> ", "Custom");
                benchmark(xmltest5, "Custom", "Custom");
    
                //"press any key to continue"
                Console.WriteLine("Done.");
                Console.ReadLine();
            }
    
            public static String xmltest1(String data)
            {
                try
                {
                    return XElement.Parse(data).Value;
                }
                catch (System.Xml.XmlException)
                {
                    return data;
                }
            }
    
            static Regex xmltest2regex = new Regex("^[ \t\r\n]*<");
            public static String xmltest2(String data)
            {
                //Has to have length to be XML
                if (!string.IsNullOrEmpty(data))
                {
                    //If it starts with a < then it probably is XML
                    //But also cover the case where there is indeterminate whitespace before the <
                    if (data[0] == '<' || xmltest2regex.Match(data).Success)
                    {
                        try
                        {
                            return XElement.Parse(data).Value;
                        }
                        catch (System.Xml.XmlException)
                        {
                            return data;
                        }
                    }
                }
               return data;
            }
    
            static Regex xmltest3regex = new Regex(@"<(?<tag>\w*)>(?<text>.*)</\k<tag>>");
            public static String xmltest3(String data)
            {
                Match m = xmltest3regex.Match(data);
                if (m.Success)
                {
                    GroupCollection gc = m.Groups;
                    if (gc.Count > 0)
                    {
                        return gc["text"].Value;
                    }
                }
                return data;
            }
    
            public static String xmltest4(String data)
            {
                String result;
                if (!XmlExpresssion.TryParse(data, out result))
                    result = data;
    
                return result;
            }
    
            static Regex xmltest5regex = new Regex("^[ \t\r\n]*<");
            public static String xmltest5(String data)
            {
                //Has to have length to be XML
                if (!string.IsNullOrEmpty(data))
                {
                    //If it starts with a < then it probably is XML
                    //But also cover the case where there is indeterminate whitespace before the <
                    if (data[0] == '<' || data.Trim()[0] == '<' || xmltest5regex.Match(data).Success)
                    {
                        try
                        {
                            return XElement.Parse(data).Value;
                        }
                        catch (System.Xml.XmlException)
                        {
                            return data;
                        }
                    }
                }
                return data;
            }
        }
    
        public class XmlExpresssion
        {
            //EXPLANATION OF EXPRESSION
            //<        :   \<{1}
            //text     :   (?<xmlTag>\w+)  : xmlTag is a backreference so that the start and end tags match
            //>        :   >{1}
            //xml data :   (?<data>.*)     : data is a backreference used for the regex to return the element data      
            //</      :   <{1}/{1}
            //text     :   \k<xmlTag>
            //>        :   >{1}
            //(\w|\W)* :   Matches attributes if any
    
            //Sample match and pattern egs
            //Just to show how I incrementally made the patterns so that the final pattern is well-understood
            //<text>data</text>
            //@"^\<{1}(?<xmlTag>\w+)\>{1}.*\<{1}/{1}\k<xmlTag>\>{1}$";
    
            //<text />
            //@"^\<{1}(?<xmlTag>\w+)\s*/{1}\>{1}$";
    
            //<text>data</text> or <text />
            //@"^\<{1}(?<xmlTag>\w+)((\>{1}.*\<{1}/{1}\k<xmlTag>)|(\s*/{1}))\>{1}$";
    
            //<text>data</text> or <text /> or <text attr='2'>xml data</text> or <text attr='2' attr2 >data</text>
            //@"^\<{1}(?<xmlTag>\w+)(((\w|\W)*\>{1}(?<data>.*)\<{1}/{1}\k<xmlTag>)|(\s*/{1}))\>{1}$";
    
            private static string XML_PATTERN = @"^\<{1}(?<xmlTag>\w+)(((\w|\W)*\>{1}(?<data>.*)\<{1}/{1}\k<xmlTag>)|(\s*/{1}))\>{1}$";
            private static Regex regex = new Regex(XML_PATTERN, RegexOptions.Compiled);
    
            //Checks if the string is in xml format
            private static bool IsXml(string value)
            {
                return regex.IsMatch(value);
            }
    
            ///<summary>
            ///Assigns the element value to result if the string is xml
            ///</summary>
            ///<returns>true if success, false otherwise</returns>
            public static bool TryParse(string s, out string result)
            {
                if (XmlExpresssion.IsXml(s))
                {
                    result = regex.Match(s).Result("${data}");
                    return true;
                }
                else
                {
                    result = null;
                    return false;
                }
            }
    
        }
    
    
    }

    Ed ecco i risultati:

    <tag>base</tag>: 3.667
     <tag>base</tag> : 3.707
    base: 40.737
    <tag>ColinBurnett</tag>: 3.707
     <tag>ColinBurnett</tag> : 4.784
    ColinBurnett: 0.413
    <tag>Si</tag>: 2.016
     <tag>Si</tag> : 2.141
    Si: 0.087
    <tag>RashmiPandit</tag>: 12.305
     <tag>RashmiPandit</tag> : fail
    RashmiPandit: 0.131
    <tag>Custom</tag>: 3.761
     <tag>Custom</tag> : 3.866
    Custom: 0.329
    Done.

    C’è l’hanno. Precompilato regex sono la strada da percorrere, e abbastanza efficiente per l’avvio.




    (post originale)

    Che messo insieme il seguente programma di benchmark gli esempi di codice che sono stati forniti per questa risposta, per dimostrare il ragionamento per il mio post, nonché di valutare la velocità del privded risposte.

    Senza ulteriori indugi, ecco il programma.

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Xml.Linq;
    using System.Diagnostics;
    using System.Text.RegularExpressions;
    
    namespace ConsoleApplication3
    {
        delegate String xmltestFunc(String data);
    
        class Program
        {
            static readonly int iterations = 1000000;
    
            private static void benchmark(xmltestFunc func, String data, String expectedResult)
            {
                if (!func(data).Equals(expectedResult))
                {
                    Console.WriteLine(data + ": fail");
                    return;
                }
                Stopwatch sw = Stopwatch.StartNew();
                for (int i = 0; i < iterations; ++i)
                    func(data);
                sw.Stop();
                Console.WriteLine(data + ": " + (float)((float)sw.ElapsedMilliseconds / 1000));
            }
    
            static void Main(string[] args)
            {
                benchmark(xmltest1, "<tag>base</tag>", "base");
                benchmark(xmltest1, " <tag>base</tag> ", "base");
                benchmark(xmltest1, "base", "base");
                benchmark(xmltest2, "<tag>ColinBurnett</tag>", "ColinBurnett");
                benchmark(xmltest2, " <tag>ColinBurnett</tag> ", "ColinBurnett");
                benchmark(xmltest2, "ColinBurnett", "ColinBurnett");
                benchmark(xmltest3, "<tag>Si</tag>", "Si");
                benchmark(xmltest3, " <tag>Si</tag> ", "Si" );
                benchmark(xmltest3, "Si", "Si");
                benchmark(xmltest4, "<tag>RashmiPandit</tag>", "RashmiPandit");
                benchmark(xmltest4, " <tag>RashmiPandit</tag> ", "RashmiPandit");
                benchmark(xmltest4, "RashmiPandit", "RashmiPandit");
    
                //"press any key to continue"
                Console.WriteLine("Done.");
                Console.ReadLine();
            }
    
            public static String xmltest1(String data)
            {
                try
                {
                    return XElement.Parse(data).Value;
                }
                catch (System.Xml.XmlException)
                {
                    return data;
                }
            }
    
            public static String xmltest2(String data)
            {
                //Has to have length to be XML
                if (!string.IsNullOrEmpty(data))
                {
                    //If it starts with a < then it probably is XML
                    //But also cover the case where there is indeterminate whitespace before the <
                    if (data[0] == '<' || new Regex("^[ \t\r\n]*<").Match(data).Success)
                    {
                        try
                        {
                            return XElement.Parse(data).Value;
                        }
                        catch (System.Xml.XmlException)
                        {
                            return data;
                        }
                    }
                }
               return data;
            }
    
            public static String xmltest3(String data)
            {
                Regex regex = new Regex(@"<(?<tag>\w*)>(?<text>.*)</\k<tag>>");
                Match m = regex.Match(data);
                if (m.Success)
                {
                    GroupCollection gc = m.Groups;
                    if (gc.Count > 0)
                    {
                        return gc["text"].Value;
                    }
                }
                return data;
            }
    
            public static String xmltest4(String data)
            {
                String result;
                if (!XmlExpresssion.TryParse(data, out result))
                    result = data;
    
                return result;
            }
    
        }
    
        public class XmlExpresssion
        {
            //EXPLANATION OF EXPRESSION
            //<        :   \<{1}
            //text     :   (?<xmlTag>\w+)  : xmlTag is a backreference so that the start and end tags match
            //>        :   >{1}
            //xml data :   (?<data>.*)     : data is a backreference used for the regex to return the element data      
            //</      :   <{1}/{1}
            //text     :   \k<xmlTag>
            //>        :   >{1}
            //(\w|\W)* :   Matches attributes if any
    
            //Sample match and pattern egs
            //Just to show how I incrementally made the patterns so that the final pattern is well-understood
            //<text>data</text>
            //@"^\<{1}(?<xmlTag>\w+)\>{1}.*\<{1}/{1}\k<xmlTag>\>{1}$";
    
            //<text />
            //@"^\<{1}(?<xmlTag>\w+)\s*/{1}\>{1}$";
    
            //<text>data</text> or <text />
            //@"^\<{1}(?<xmlTag>\w+)((\>{1}.*\<{1}/{1}\k<xmlTag>)|(\s*/{1}))\>{1}$";
    
            //<text>data</text> or <text /> or <text attr='2'>xml data</text> or <text attr='2' attr2 >data</text>
            //@"^\<{1}(?<xmlTag>\w+)(((\w|\W)*\>{1}(?<data>.*)\<{1}/{1}\k<xmlTag>)|(\s*/{1}))\>{1}$";
    
            private const string XML_PATTERN = @"^\<{1}(?<xmlTag>\w+)(((\w|\W)*\>{1}(?<data>.*)\<{1}/{1}\k<xmlTag>)|(\s*/{1}))\>{1}$";
    
            //Checks if the string is in xml format
            private static bool IsXml(string value)
            {
                return Regex.IsMatch(value, XML_PATTERN);
            }
    
            ///<summary>
            ///Assigns the element value to result if the string is xml
            ///</summary>
            ///<returns>true if success, false otherwise</returns>
            public static bool TryParse(string s, out string result)
            {
                if (XmlExpresssion.IsXml(s))
                {
                    Regex r = new Regex(XML_PATTERN, RegexOptions.Compiled);
                    result = r.Match(s).Result("${data}");
                    return true;
                }
                else
                {
                    result = null;
                    return false;
                }
            }
    
        }
    
    
    }

    Ed ecco i risultati. Ognuno è stato eseguito 1 milione di volte.

    <tag>base</tag>: 3.531
     <tag>base</tag> : 3.624
    base: 41.422
    <tag>ColinBurnett</tag>: 3.622
     <tag>ColinBurnett</tag> : 16.467
    ColinBurnett: 7.995
    <tag>Si</tag>: 19.014
     <tag>Si</tag> : 19.201
    Si: 15.567

    Test 4 ha preso troppo a lungo, come 30 minuti più tardi è stato considerato troppo lento. A dimostrazione di quanto più lento è stato, qui è lo stesso test eseguito solo 1000 volte.

    <tag>base</tag>: 0.004
     <tag>base</tag> : 0.004
    base: 0.047
    <tag>ColinBurnett</tag>: 0.003
     <tag>ColinBurnett</tag> : 0.016
    ColinBurnett: 0.008
    <tag>Si</tag>: 0.021
     <tag>Si</tag> : 0.017
    Si: 0.014
    <tag>RashmiPandit</tag>: 3.456
     <tag>RashmiPandit</tag> : fail
    RashmiPandit: 0
    Done.

    Estrapolando un milione di esecuzioni, si sarebbe preso 3456 secondi, o poco più di 57 minuti.

    Questo è un buon esempio del perché complesso regex sono una cattiva idea se si sta cercando di codice efficiente. Tuttavia, esso ha dimostrato che la semplice espressione regolare può ancora essere una buona risposta in alcuni casi – cioè il piccolo “pre-test” di xml in colinBurnett risposta creato un potenzialmente più costoso di base, (regex è stato creato nel caso 2), ma anche molto più altro caso, evitando l’eccezione.

    • Provare di nuovo con la Regex le istanze create solo una volta usando un campo statico di tenere loro. Dubito che una non trascurabile parte del tempo nella creazione di istanze e compilazione delle espressioni regolari più volte.
    • Call – aggiornato il post con i risultati
    • In realtà, la regex nel mio esempio è del tutto inutile con if (data[0] == '<' || data.TrimStart()[0] == '<'). Quest’ultimo è esattamente ciò che “^[ \t\r\n]*<” stava cercando.
    • Aggiunto il test personalizzati, il che rende il cambiamento.
  4. 3

    Io credo che sia perfettamente accettabile il modo di gestire la vostra situazione (è probabilmente il modo in cui mi piacerebbe gestire come bene). Non riuscivo a trovare qualsiasi tipo di “XElement.TryParse(stringa)” in MSDN, quindi il modo in cui avete a lavorare bene.

  5. 3

    Non c’è modo di convalida che il testo XML altri di fare qualcosa di simile XElement.Analizzare. Se, per esempio, l’ultimo close-angolo-staffa manca il campo di testo, quindi non è un XML valido, ed è molto improbabile che si sarà posto questa con RegEx o analisi del testo. Ci sono un certo numero di caratteri illegali, illeciti sequenze ecc che RegEx parsiing sarà più probabile perdere.

    Tutti che si può sperare di fare è a corto di tagliare i casi di fallimento.

    Quindi, se si aspettano di vedere un sacco di dati XML non e il meno atteso caso è di tipo XML e quindi impiegando RegEx o una sottostringa di ricerche per rilevare parentesi angolari potrebbe risparmiare un po ‘ di tempo, ma vorrei suggerire questo è solo utile se hai l’elaborazione in batch di grandi quantità di dati in un loop stretto.

    Se, invece, questa è l’analisi l’utente ha inserito i dati da un modulo web o un form di windows app quindi penso che il pagamento del costo dell’Eccezione può essere di meglio che trascorrere il dev e test di sforzo assicurando che il vostro taglio corto codice non genera falsi positivi/negativi risultati.

    Non è chiaro dove stai ricevendo il vostro in XML (file, stream, una casella di testo o da qualche altra parte), ma ricordate che lo spazio, i commenti, in ordine di byte di marchi e altre cose possono ottenere nel modo di semplici regole come “si deve iniziare con un <“.

  6. 1

    Perché regex costoso? Non è uccidere 2 piccioni con 1 pietra (match e analizza)?

    Semplice esempio l’analisi di tutti gli elementi, ancora più facile se si tratta di un solo elemento!

    Regex regex = new Regex(@"<(?<tag>\w*)>(?<text>.*)</\k<tag>>");
    MatchCollection matches = regex.Matches(data);
    foreach (Match match in matches)
    {
        GroupCollection groups = match.Groups;
        string name = groups["tag"].Value;
        string value = groups["text"].Value;
        ...
    }
    • Solo per notare, che non verificare la validità dell’xml (che potrebbe non essere valido nella porzione di testo)
    • Inoltre non determinare che tutti i tag sono stati chiusi (rendendo XML non valido)
  7. 1

    Come indicato da @JustEngland nel commento eccezioni non sono così costosi, un debugger intercettare li potrebbe richiedere del tempo, ma in genere sono ben performante e di buone pratiche. Vedere Come costosi sono delle eccezioni in C#?.

    Un modo migliore sarebbe quello di rotolare il vostro proprio TryParse funzione di stile:

    [System.Diagnostics.DebuggerNonUserCode]
    static class MyXElement
    {
        public static bool TryParse(string data, out XElement result)
        {
            try
            {
                result = XElement.Parse(data);
                return true;
            }
            catch (System.Xml.XmlException)
            {
                result = default(XElement);
                return false;
            }
        }
    }

    Il DebuggerNonUserCode attributo rende il debugger di saltare l’eccezione catturata per semplificare la vostra esperienza di debug.

    Utilizzati come questo:

        static void Main()
        {
            var addressList = "line one~line two~line three~postcode";
    
            var address = new XElement("Address");
            var addressHtml = "<span>" + addressList.Replace("~", "<br />") + "</span>";
    
            XElement content;
            if (MyXElement.TryParse(addressHtml, out content))
                address.ReplaceAll(content);
            else
                address.SetValue(addressHtml);
    
            Console.WriteLine(address.ToString());
            Console.ReadKey();
        }
    }

    Avrei preferito creare un metodo di estensione per TryParse, ma non è possibile creare uno statico chiamato un tipo piuttosto che di un’istanza.

    • Sarebbe molto più bello avere un TryParse nel quadro, ma questo è un trucco molto utile per pulire l’esperienza di debug.
  8. 0

    Indizio — tutti xml valido deve iniziare con "<?xml

    Si può avere a che fare con il set di caratteri differenze, ma il controllo ASCII, utf-8 unicode e coprirà il 99,5% di xml là fuori.

    • La “<?xml version=’1.0′?>” non è necessario e tutti gli standard parser (C#, PHP, Python, etc.) Ho usato felicemente analizzare senza.
    • Quello che Colin ha detto + OP è molto probabile che il lavoro con frammenti XML
  9. 0

    Modo da te suggerito può essere molto costoso se si intende utilizzare in un ciclo in cui la maggior parte delle s xml non sono valied, In caso di valied xml codice funzionerà come ci sono non la gestione delle eccezioni… quindi se nella maggior parte dei casi xml è valied o non la usa in loop, il tuo codice funziona bene

  10. 0

    Se si desidera sapere se è valido, perché non utilizzare il built-in .NetFX oggetto, piuttosto che scriverne uno da zero?

    Spero che questo aiuta,

    Bill

  11. 0

    Una variazione su Colin Burnett tecnica: si potrebbe fare una semplice espressione regolare all’inizio per vedere se il testo inizia con un tag, per poi tentare di analizzarlo. Probabilmente >99% di stringhe si che fare con quella di iniziare con un valido elemento XML. In questo modo si potrebbe saltare la regex di elaborazione per conclamata XML valido e anche saltare l’eccezione a base di elaborazione in quasi ogni caso.

    Qualcosa di simile ^<[^>]+> sarebbe probabilmente fare il trucco.

  12. 0

    Io non sono esattamente sicuro di se la vostra esigenza considera il formato del file e come è stata fatta questa domanda molto tempo indietro, & mi capita di cercare una cosa simile, vorrei sapere che cosa ha funzionato per me , quindi se uno viene qui questo potrebbe aiutare 🙂

    Possiamo usare Percorso.GetExtension(filePath) e verificare se è XML quindi utilizzare altri saggi fare quello che mai è necessario

  13. -2

    Come questo, prendere una stringa o un oggetto e il lancio di un nuovo XDocument o XElement. Tutto si risolve utilizzando il metodo ToString().

    • -1 gettare l’eccezione se non XML

Lascia un commento