Modo migliore per rilevare XML?
https://stackoverflow.com/questions/891223
-
23-08-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Al momento, ho il seguente codice C # per estrarre un valore di testo. Se il suo XML, voglio che il valore al suo interno - in caso contrario, se non la sua XML, si può semplicemente restituire il testo stesso
.String data = "..."
try
{
return XElement.Parse(data).Value;
}
catch (System.Xml.XmlException)
{
return data;
}
Lo so eccezioni sono costosi in C #, quindi mi chiedevo se ci fosse un modo migliore per determinare se il testo ho a che fare con è XML o no?
Ho pensato di test regex, ma io non vedo' che come alternativa più economica. Nota, sto chiedendo un meno costoso metodo di fare questo.
Soluzione
Si potrebbe fare un controllo preliminare per un (scritto a mano libera.) Inizialmente avevo l'uso di un'espressione regolare, ma Trim () [0] è identico a quello che avrebbe fatto regex. // 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;
}
Altri suggerimenti
Il codice indicato di seguito corrisponderà 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;
}
}
}
Prefisso telefonico internazionale:
if (!XmlExpresssion.TryParse(s, out result))
result = s;
Console.WriteLine(result);
Aggiornamento: (post originale è al di sotto) Colin ha la brillante idea di spostare l'istanza regex 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 nuovi 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.
Il gioco è fatto. regex precompilati sono la strada da percorrere, e abbastanza efficiente per l'avvio.
(Post originale)
I messo insieme il seguente programma di riferimento gli esempi di codice che sono stati forniti per questa risposta, per dimostrare il ragionamento per il mio post, nonché di valutare la velocità delle risposte privded.
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
Prova 4 ha impiegato troppo tempo, come 30 minuti più tardi è stato ritenuto troppo lento. Per dimostrare come molto 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 fuori per un milione di esecuzioni, che avrebbe preso 3456 secondi, o poco più di 57 minuti.
Questo è un buon esempio del perché regex complesso sono una cattiva idea se siete alla ricerca di codice efficiente. Tuttavia ha dimostrato che semplice regex può ancora essere buona risposta in alcuni casi - vale a dire la piccola 'pre-test' di XML in colinBurnett risposta ha creato un caso base potenzialmente più costoso, (regex è stato creato nel caso 2), ma anche un altro molto più breve caso evitando l'eccezione.
Lo trovo un modo perfettamente accettabile di gestire la situazione (è probabilmente il modo mi piacerebbe gestire esso pure). Non riuscivo a trovare qualsiasi tipo di "XElement.TryParse (stringa)" in MSDN, quindi il modo lo avete avrebbe funzionato bene.
Non c'è modo di convalidare che il testo è diverso da XML fare qualcosa di simile XElement.Parse. Se, ad esempio, l'ultima ad angolo stretto-staffa non è presente nel campo di testo allora non è XML valido, ed è molto improbabile che ti posto questo con RegEx o analisi del testo. Ci sono certo numero di caratteri non validi, sequenze illegali ecc che parsiing RegEx molto probabilmente perdere.
Tutto quello che può sperare di fare è quello di scorciatoia vostri casi di fallimento.
Quindi, se vi aspettate di vedere un sacco di dati non XML e il caso meno del previsto è XML quindi impiegando RegEx o stringa ricerche per rilevare le parentesi angolari potrebbe risparmiare un po 'di tempo, ma mi piacerebbe suggeriscono che questo è solo utile se siete in batch un sacco di elaborazione di dati in un loop stretto.
Se, invece, l'utente è l'analisi di dati inseriti da un modulo web o un'applicazione WinForms, allora penso che pagare il costo della deroga potrebbe essere migliore di spendere i dev e test di sforzo per garantire che il codice scorciatoia non lo fa generare risultati falsi positivi / negativi.
Non è chiaro dove stai ricevendo il vostro XML da (file, flusso, testo o da qualche altra parte), ma ricordate che gli spazi bianchi, i commenti, i marchi di ordine di byte e altre cose può ottenere in termini di regole semplici, come "deve iniziare con un <".
Perché è regex costoso? Non si uccide 2 piccioni con 1 pietra (partita e analizzare)?
Esempio semplice analisi di tutti gli elementi, ancora più facile se è solo un 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;
...
}
Come notato da @JustEngland nel commento eccezioni non sono costosi, un debugger li intercettare loro potrebbe prendere tempo, ma nel solito sono ben esecuzione e di buone pratiche. Vedi quanto costoso sono eccezioni in C #? .
Un modo migliore sarebbe quello di rotolare il proprio stile di funzione TryParse:
[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;
}
}
}
L'attributo DebuggerNonUserCode rende il debugger saltare l'eccezione catturato per ottimizzare la vostra esperienza di debug.
Utilizzato in questo modo:
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 per creare un metodo di estensione per il TryParse, ma non è possibile creare uno statico chiamato su un tipo piuttosto che un esempio.
Clue - tutti XML valido deve iniziare con "<?xml "
Si può avere a che fare con le differenze di set di caratteri, ma il controllo ASCII, UTF-8 e Unicode coprirà il 99,5% del xml là fuori.
Il modo in cui si suggeriscono sarà costoso se si intende utilizzare in un ciclo in cui la maggior parte del xml s non sono valied, In caso di valied xml vostro codice funzionerà come se non ci sono la gestione delle eccezioni ... quindi se nella maggior parte dei casi il tuo xml è valied o non lo usa in loop, il codice funziona bene
Se vuoi sapere se è valida, perché non utilizzare il built-in oggetto .NetFX piuttosto che scriverne uno da zero?
Spero che questo aiuti,
Bill
Una variazione sulla tecnica di Colin Burnett: si potrebbe fare una semplice espressione regolare all'inizio per vedere se il testo inizia con un tag, quindi provare a analizzarlo. Probabilmente> 99% di stringhe si tratta con che iniziano con un elemento valido sono XML. In questo modo si potrebbe saltare il trattamento regex per conclamata XML valido e anche saltare l'elaborazione delle eccezioni basata in quasi tutti i casi.
Qualcosa di simile ^<[^>]+> probabilmente farebbe il trucco.
Io non sono esattamente sicuro se la vostra esigenza considera il formato del file e come a questa domanda è stato chiesto molto tempo fa e mi capita di cercare una cosa simile, mi piacerebbe che tu sappia cosa ha funzionato per me, quindi se qualcuno viene qui questo potrebbe aiutare :)
Possiamo usare Path.GetExtension (filePath) e verificare se è XML usalo altro saggio fare ciò che mai è necessario
Come su questo, prendere la stringa o un oggetto e saltarla in in un nuovo XDocument o XElement. Tutto si risolve con ToString ().
