Jak radzić sobie z XML w C#

W przypadku plików xml o małych i średnich rozmiarach oczywistym zwycięzcą jest DOM, taki jak XmlDocument (dowolne wersje C#/. NET) lub XDocument (. NET 3.5/C# 3.0). Aby używać xsd, można załadować xml za pomocą XmlReader, A XmlReader akceptuje (to Create) an XmlReaderSettings. Obiekty XmlReaderSettings mają właściwość Schemas , która może być użyta do walidacji XSD (lub dtd).

Do pisania xml stosuje się te same rzeczy, zauważając że trochę łatwiej jest układać zawartość za pomocą LINQ-to-XML (XDocument) niż starszy XmlDocument.

Jednak dla ogromnego xml, DOM może chomp zbyt dużo pamięci, w takim przypadku może być konieczne użycie XmlReader/XmlWriter bezpośrednio.

Wreszcie, do manipulowania xml możesz użyć XslCompiledTransform (warstwy xslt).

Alternatywą dla pracy z xml jest praca z modelem obiektowym; możesz użyć xsd.exe do tworzenia klas, które reprezentują model zgodny z xsd i po prostu załaduj XML jako obiekty , manipuluj nim za pomocą OO, a następnie ponownie serializuj te obiekty; robisz to za pomocą XmlSerializer.

Odpowiedź Nyxtom jest bardzo dobra. Dodałbym jeszcze kilka rzeczy:

Jeśli potrzebujesz dostępu tylko do odczytu dokumentu XML, XPathDocument jest znacznie lżejszym obiektem niż XmlDocument.

Minusem używania XPathDocument jest to, że nie można używać znanych metod SelectNodes i SelectSingleNode XmlNode. Zamiast tego, musisz użyć narzędzi IXPathNavigable: użyj CreateNavigator, aby utworzyć XPathNavigator, i użyj XPathNavigator, aby utworzyć XPathNodeIteratorS, aby iterować listy węzłów znalezionych przez XPath. To ogólnie wymaga kilku linijek kodu więcej niż metody XmlDocument.

Ale: klasy XmlDocument i XmlNode implementują IXPathNavigable, więc każdy kod, który napiszesz, aby użyć tych metod na XPathDocument będzie również działał na XmlDocument. Jeśli przyzwyczaisz się do pisania przeciwko IXPathNavigable, twoje metody mogą działać przeciwko każdemu obiektowi. (Dlatego używanie XmlNode i XmlDocument w podpisach metod jest oznaczane przez FxCop.)

, XDocument i XElement (oraz XNode i XObject) nie implementują IXPathNavigable.

Kolejna rzecz nie odpowiedź nyxtom brzmi XmlReader. Zazwyczaj używa się XmlReader, aby uniknąć napowietrznego parsowania strumienia XML do modelu obiektowego przed rozpoczęciem jego przetwarzania. Zamiast tego używasz XmlReader do przetwarzania strumienia wejściowego po jednym węźle XML na raz. Jest to zasadniczo odpowiedź. NET NA SAX. Pozwala pisać bardzo szybki kod do przetwarzania bardzo dużych dokumentów XML.

XmlReader zapewnia również najprostszy sposób przetwarzania fragmentów dokumentów XML, np. strumień elementów XML bez zwraca element, który SQL Server dla XML RAW.

Kod, który piszesz za pomocą XmlReader, jest na ogół bardzo ściśle powiązany z formatem XML, który czytasz. Korzystanie z XPath pozwala na dużo, dużo bardziej luźne połączenie kodu z XML, dlatego jest to ogólnie właściwa odpowiedź. Ale kiedy musisz użyć XmlReader, naprawdę tego potrzebujesz.

Przede wszystkim poznaj nowe klasy XDocumenti XElement, ponieważ są one ulepszeniem w stosunku do poprzedniej rodziny XmlDocument.

1. pracują z LINQ
Są szybsze i lżejsze]}

Jednakże , Być może będziesz musiał nadal używać starych klas do pracy ze starszym kodem - szczególnie wcześniej wygenerowanych proxy. W takim przypadku musisz zapoznać się z niektórymi wzorami współdziałania między tymi Klasy obsługi XML.

Myślę, że twoje pytanie jest dość szerokie i wymagałoby zbyt wiele w jednej odpowiedzi, aby podać szczegóły, ale jest to pierwsza ogólna odpowiedź, o której pomyślałem i służy jako początek.

101 próbek Linq

Http://msdn.microsoft.com/en-us/library/bb387098.aspx

I próbki Linq do XML

Http://msdn.microsoft.com/en-us/vbasic/bb688087.aspx

I myślę, że Linq ułatwia XML.

Jeśli pracujesz w. NET 3.5 i nie boisz się kodu eksperymentalnego możesz sprawdzić LINQ to XSD ( http://blogs.msdn.com/xmlteam/archive/2008/02/21/linq-to-xsd-alpha-0-2.aspx ), które generują klasy. NET z XSD (w tym wbudowane reguły z XSD).

Następnie ma możliwość zapisu bezpośrednio do pliku i odczytu z pliku, zapewniając, że jest zgodny z regułami XSD.

Zdecydowanie sugeruję posiadanie XSD dla każdego dokumentu XML, który pracujesz z:

• pozwala na egzekwowanie reguł w XML
• pozwala innym zobaczyć, jak XML jest/ będzie strukturą
• może być używany do walidacji XML

Uważam, że Liquid XML Studio to świetne narzędzie do generowania XSD i jest darmowe!

Jeśli utworzysz wpisany zestaw danych w Projektancie, automatycznie otrzymasz XSD, silnie wpisany obiekt i możesz załadować i zapisać xml za pomocą jednej linii kodu.

Moja osobista opinia, jako programisty C#, jest taka, że najlepszym sposobem radzenia sobie z XML w C # jest delegowanie tej części kodu do projektu VB. NET. W. NET 3.5, VB. NET ma literały XML, które sprawiają, że radzenie sobie z XML jest znacznie bardziej intuicyjne. Zobacz tutaj, na przykład:

Przegląd LINQ do XML w Visual Basic

(upewnij się, że strona wyświetla kod VB, a nie kod C#.)

Resztę projektu napisałbym w C#, ale obsługiwał XML w odwołanym VB projekt.

Zapis XML z klasą XmlDocument

//itemValues is collection of items in Key value pair format
//fileName i name of XML file which to creatd or modified with content
    private void WriteInXMLFile(System.Collections.Generic.Dictionary<string, object> itemValues, string fileName)
    {
        string filePath = "C:\\\\tempXML\\" + fileName + ".xml";
        try
        {

            if (System.IO.File.Exists(filePath))
            {
                XmlDocument doc = new XmlDocument();
                doc.Load(filePath);                   

                XmlNode rootNode = doc.SelectSingleNode("Documents");

                XmlNode pageNode = doc.CreateElement("Document");
                rootNode.AppendChild(pageNode);


                foreach (string key in itemValues.Keys)
                {

                    XmlNode attrNode = doc.CreateElement(key);
                    attrNode.InnerText = Convert.ToString(itemValues[key]);
                    pageNode.AppendChild(attrNode);
                    //doc.DocumentElement.AppendChild(attrNode);

                }
                doc.DocumentElement.AppendChild(pageNode);
                doc.Save(filePath);
            }
            else
            {
                XmlDocument doc = new XmlDocument();
                using(System.IO.FileStream fs = System.IO.File.Create(filePath))
                {
                    //Do nothing
                }

                XmlNode rootNode = doc.CreateElement("Documents");
                doc.AppendChild(rootNode);
                doc.Save(filePath);

                doc.Load(filePath);

                XmlNode pageNode = doc.CreateElement("Document");
                rootNode.AppendChild(pageNode);

                foreach (string key in itemValues.Keys)
                {                          
                    XmlNode attrNode = doc.CreateElement(key);                           
                    attrNode.InnerText = Convert.ToString(itemValues[key]);
                    pageNode.AppendChild(attrNode);
                    //doc.DocumentElement.AppendChild(attrNode);

                }
                doc.DocumentElement.AppendChild(pageNode);

                doc.Save(filePath);

            }
        }
        catch (Exception ex)
        {

        }

    }

OutPut look like below
<Dcouments>
    <Document>
        <DocID>01<DocID>
        <PageName>121<PageName>
        <Author>Mr. ABC<Author>
    <Dcoument>
    <Document>
        <DocID>02<DocID>
        <PageName>122<PageName>
        <Author>Mr. PQR<Author>
    <Dcoument>
</Dcouments>

Nyxtom,

Czy "doc" i "xdoc" nie powinny pasować do przykładu 1?

XDocument **doc** = XDocument.Load(pathToXml);
List<Person> people = (from xnode in **xdoc**.Element("People").Elements("Person")
                   select new Person
                   {
                       Name = xnode.Attribute("Name").Value
                   }).ToList();

Odpowiedź Cookeya jest dobra... ale tutaj są szczegółowe instrukcje jak utworzyć silnie wpisany obiekt z XSD (lub XML) i serialize/deserialize w kilku wierszach kodu:

Instrukcje

Jeśli kiedykolwiek będziesz musiał przekonwertować dane pomiędzy XmlNode XNode XElement
(np. w celu użycia LINQ) to rozszerzenie może być pomocne dla Ciebie:

public static class MyExtensions
{
    public static XNode GetXNode(this XmlNode node)
    {
        return GetXElement(node);
    }

    public static XElement GetXElement(this XmlNode node)
    {
        XDocument xDoc = new XDocument();
        using (XmlWriter xmlWriter = xDoc.CreateWriter())
            node.WriteTo(xmlWriter);
        return xDoc.Root;
    }

    public static XmlNode GetXmlNode(this XElement element)
    {
        using (XmlReader xmlReader = element.CreateReader())
        {
            XmlDocument xmlDoc = new XmlDocument();
            xmlDoc.Load(xmlReader);
            return xmlDoc;
        }
    }

    public static XmlNode GetXmlNode(this XNode node)
    {
        return GetXmlNode(node);
    }
}

Użycie:

XmlDocument MyXmlDocument = new XmlDocument();
MyXmlDocument.Load("MyXml.xml");
XElement MyXElement = MyXmlDocument.GetXElement(); // Convert XmlNode to XElement
List<XElement> List = MyXElement.Document
   .Descendants()
   .ToList(); // Now you can use LINQ
...