Hoe lees ik en verminder ik een XML-bestand in C #?

Hoe lees en lees en parseer een XML-bestand in C #?

Antwoord 1, Autoriteit 100%

xmldocument om een ​​XML uit String of vanuit het bestand te lezen.

XmlDocument doc = new XmlDocument();
doc.Load("c:\\temp.xml");

of

doc.LoadXml("<xml>something</xml>");

Zoek vervolgens een knooppunt eronder IE zoals deze

XmlNode node = doc.DocumentElement.SelectSingleNode("/book/title");

of

foreach(XmlNode node in doc.DocumentElement.ChildNodes){
   string text = node.InnerText; //or loop through its children as well
}

Lees vervolgens de tekst in die knooppunt zoals deze

string text = node.InnerText;

of lees een attribuut

string attr = node.Attributes["theattributename"]?.InnerText

Controleer altijd voor null op attributen [“Iets”] omdat het null zal zijn als het kenmerk niet bestaat.

Antwoord 2, Autoriteit 44%

LINQ naar XML Voorbeeld:

// Loading from a file, you can also load from a stream
var xml = XDocument.Load(@"C:\contacts.xml");
// Query the data and write out a subset of contacts
var query = from c in xml.Root.Descendants("contact")
            where (int)c.Attribute("id") < 4
            select c.Element("firstName").Value + " " +
                   c.Element("lastName").Value;
foreach (string name in query)
{
    Console.WriteLine("Contact's Full Name: {0}", name);
}

referentie : LINQ naar XML bij MSDN

Antwoord 3, Autoriteit 4%

Hier is een applicatie die ik schreef voor het lezen van XML-sitemaps:

using System;
using System.Collections.Generic;
using System.Windows.Forms; 
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
using System.Data;
using System.Xml;
namespace SiteMapReader
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Please Enter the Location of the file");
            // get the location we want to get the sitemaps from 
            string dirLoc = Console.ReadLine();
            // get all the sitemaps 
            string[] sitemaps = Directory.GetFiles(dirLoc);
            StreamWriter sw = new StreamWriter(Application.StartupPath + @"\locs.txt", true);
            // loop through each file 
            foreach (string sitemap in sitemaps)
            {
                try
                {
                    // new xdoc instance 
                    XmlDocument xDoc = new XmlDocument();
                    //load up the xml from the location 
                    xDoc.Load(sitemap);
                    // cycle through each child noed 
                    foreach (XmlNode node in xDoc.DocumentElement.ChildNodes)
                    {
                        // first node is the url ... have to go to nexted loc node 
                        foreach (XmlNode locNode in node)
                        {
                            // thereare a couple child nodes here so only take data from node named loc 
                            if (locNode.Name == "loc")
                            {
                                // get the content of the loc node 
                                string loc = locNode.InnerText;
                                // write it to the console so you can see its working 
                                Console.WriteLine(loc + Environment.NewLine);
                                // write it to the file 
                                sw.Write(loc + Environment.NewLine);
                            }
                        }
                    }
                }
                catch { }
            }
            Console.WriteLine("All Done :-)"); 
            Console.ReadLine(); 
        }
        static void readSitemap()
        {
        }
    }
}

Code op plakbak
http://pastebin.com/yK7cSNeY

Antwoord 4, autoriteit 3%

Er zijn veel manieren, sommige:

• XmlSerializer. gebruik een klasse met het doelschema
  u wilt lezen – gebruik XmlSerializer
  om de gegevens in een XML te laden in
  een instantie van de klasse.
• Linq 2 xml
• XmlTextReader.
• XmlDocument
• XPathDocument (alleen-lezen toegang)

Antwoord 5, autoriteit 2%

Je zou een DataSet kunnen gebruiken om XML-strings te lezen.

var xmlString = File.ReadAllText(FILE_PATH);
var stringReader = new StringReader(xmlString);
var dsSet = new DataSet();
dsSet.ReadXml(stringReader);

Dit ter informatie plaatsen.

Antwoord 6

U kunt:

• Gebruik XmlSerializer-klasse
• Gebruik XmlDocument-klasse

Voorbeelden staan op de meegeleverde msdn-pagina’s

Antwoord 7

Linq naar XML.

Bovendien heeft VB.NET veel betere ondersteuning voor xml-parsing via de compiler dan C#. Als je de mogelijkheid en de wens hebt, bekijk het dan.

Antwoord 8

Bekijk XmlTextReaderklasse bijvoorbeeld.

Antwoord 9

 public void ReadXmlFile()
    {
        string path = HttpContext.Current.Server.MapPath("~/App_Data"); // Finds the location of App_Data on server.
        XmlTextReader reader = new XmlTextReader(System.IO.Path.Combine(path, "XMLFile7.xml")); //Combines the location of App_Data and the file name
        while (reader.Read())
        {
            switch (reader.NodeType)
            {
                case XmlNodeType.Element:
                    break;
                case XmlNodeType.Text:
                    columnNames.Add(reader.Value);
                    break;
                case XmlNodeType.EndElement:
                    break;
            }
        }
    }

U kunt de eerste instructie vermijden en gewoon de padnaam opgeven in de constructor van XmlTextReader.

Antwoord 10

Er zijn verschillende manieren, afhankelijk van waar je wilt komen.
XmlDocument is lichter dan XDocument, maar als je minimalistisch wilt verifiëren dat een string XML bevat, dan is reguliere expressie mogelijk de snelste en lichtste keuze die je kunt maken. Ik heb bijvoorbeeld Smoke Tests met SpecFlow geïmplementeerd voor mijn API en ik wil testen of een van de resultaten in een geldige XML is – dan zou ik een reguliere expressie gebruiken. Maar als ik waarden uit deze XML moet halen, dan zou ik het met XDocument ontleden om het sneller en met minder code te doen. Of ik zou XmlDocument gebruiken als ik met een grote XML moet werken (en soms werk ik met XML’s van ongeveer 1 miljoen regels, zelfs meer); dan kon ik het zelfs regel voor regel lezen. Waarom? Probeer meer dan 800 MB in privébytes te openen in Visual Studio; zelfs bij productie zou je geen objecten groter dan 2GB moeten hebben. Dat kan met een twerk, maar dat mag niet. Als u een document zou moeten ontleden dat VEEL regels bevat, dan zou dit document waarschijnlijk CSV zijn.

Ik heb deze opmerking geschreven, omdat ik veel voorbeelden zie met XDocument. XDocument is niet geschikt voor grote documenten, of wanneer u alleen wilt controleren of de inhoud XML-geldig is. Als je wilt controleren of de XML zelf klopt, dan heb je Schema nodig.

Ik heb het voorgestelde antwoord ook naar beneden gestemd, omdat ik denk dat het de bovenstaande informatie in zichzelf nodig heeft. Stel je voor dat ik moet verifiëren of 200 miljoen XML, 10 keer per uur, geldige XML is. XDocument zal veel middelen verspillen.

prasanna venkatesh stelt ook dat je zou kunnen proberen de string in een dataset te vullen, het zal ook geldige XML aangeven.

Antwoord 11

Als u een bepaalde waarde uit een XML-bestand wilt ophalen

XmlDocument _LocalInfo_Xml = new XmlDocument();
            _LocalInfo_Xml.Load(fileName);
            XmlElement _XmlElement;
            _XmlElement = _LocalInfo_Xml.GetElementsByTagName("UserId")[0] as XmlElement;
            string Value = _XmlElement.InnerText;