Pagbabasa ng XML sa C#
Mayroong ilang mga paraan upang basahin ang isang XML file sa C# at ang bawat pamamaraan ay may mga pakinabang at disadvantage nito, at ang pagpili ay depende sa mga kinakailangan ng proyekto. Nasa ibaba ang ilang mga paraan upang basahin ang isang XML file sa C#:
- Gamit ang XmlDocument
- Gamit ang XDocument
- Gamit ang XmlReader
- Paggamit ng Xml sa LINQ
- Gamit ang XPath
Narito ang nilalaman ng XML file na aking nilikha at gagamitin para sa pagpapakita sa mga paparating na pamamaraan:
< ?xml bersyon = '1.0' encoding = 'utf-8' ? >
< mga empleyado >
< empleado >
< id > 1 id >
< pangalan > Sam bosh pangalan >
< departamento > Marketing departamento >
< suweldo > 50000 suweldo >
empleado >
< empleado >
< id > 2 id >
< pangalan > Jane Doe pangalan >
< departamento > Pananalapi departamento >
< suweldo > 60000 suweldo >
empleado >
< empleado >
< id > 3 id >
< pangalan > James pangalan >
< departamento > Human Resources departamento >
< suweldo > 70000 suweldo >
empleado >
mga empleyado >
1: Paggamit ng XmlDocument
Upang magbasa ng XML file sa C#, maaari mong gamitin ang XmlDocument class o XDocument class, na parehong bahagi ng System.Xml namespace. Ang XmlDocument class ay nagbibigay ng DOM (Document Object Model) na diskarte para sa pagbabasa ng XML, samantalang ang XDocument class ay nagbibigay ng LINQ (Language-Integrated Query) na diskarte. Narito ang isang halimbawa ng paggamit ng klase ng XmlDocument upang basahin ang isang XML file:
gamit ang System;
gamit ang System.Xml;
Programa ng klase
{
static void Main ( string [ ] args )
{
XmlDocument doc = bagong XmlDocument ( ) ;
doc.Mag-load ( 'employees.xml' ) ;
XmlNodeList nodes = doc.DocumentElement.SelectNodes ( '/empleyado/empleyado' ) ;
foreach ( XmlNode node sa mga node )
{
string id = node.SelectSingleNode ( 'id' ) .InnerText;
string name = node.SelectSingleNode ( 'pangalan' ) .InnerText;
string department = node.SelectSingleNode ( 'kagawaran' ) .InnerText;
string na suweldo = node.SelectSingleNode ( 'suweldo' ) .InnerText;
Console.WriteLine ( 'ID: {0}, Pangalan: {1}, Departamento: {2}, Salary: {3}' , id , pangalan, departamento, suweldo ) ;
}
}
}
Ginagamit ng code na ito ang klase ng XmlDocument upang i-load ang XML file at ang SelectNodes na paraan upang makuha ang isang listahan ng mga node ng empleyado. Pagkatapos, para sa bawat node ng empleyado, ginagamit nito ang SelectSingleNode na paraan para kunin ang mga value ng id, pangalan, departamento, at salary child node at ipakita ang mga ito gamit ang Console.WriteLine:
2: Paggamit ng XDocument
Bilang kahalili, maaari mo ring gamitin ang klase ng XDocument upang magbasa ng XML file gamit ang isang LINQ na diskarte, at sa ibaba ay ang code na naglalarawan kung paano ito gagawin:
gamit ang System;Programa ng klase
{
static void Main ( string [ ] args )
{
XDocument doc = XDocument.Load ( 'employees.xml' ) ;
foreach ( Elemento ng XElement sa doc.Mga Kaapu-apuhan ( 'empleado' ) )
{
int id = int.I-parse ( elemento.Elemento ( 'id' ) .Halaga ) ;
string name = element.Element ( 'pangalan' ) .Halaga;
string department = elemento.Elemento ( 'kagawaran' ) .Halaga;
int suweldo = int.Parse ( elemento.Elemento ( 'suweldo' ) .Halaga ) ;
Console.WriteLine ( $ 'ID: {id}, Pangalan: {name}, Departamento: {department}, Salary: {salary}' ) ;
}
}
}
Ang XML file ay na-load sa isang XDocument object gamit ang XDocument.Load method. Ang mga elemento ng 'empleyado' ng XML file ay kinukuha lahat gamit ang Descendants technique. Para sa bawat elemento, ang mga child element nito ay ina-access gamit ang Element method, at ang kanilang mga value ay kinukuha gamit ang Value property. Sa wakas, ang nakuhang data ay naka-print sa console.
Tandaan na ang XDocument ay kabilang sa System.Xml.Linq namespace, kaya kailangan mong isama ang sumusunod gamit ang statement sa tuktok ng iyong C# file
3: Paggamit ng XmlReader
Ang XmlReader ay isang mabilis at mahusay na paraan upang basahin ang isang XML file sa C#. Binabasa nito ang file nang sunud-sunod, na nangangahulugang naglo-load lamang ito ng isang node sa isang pagkakataon, na ginagawa itong perpekto para sa pagtatrabaho sa malalaking XML file na kung hindi man ay mahirap hawakan sa memorya.
gamit ang System;gamit ang System.Xml;
Programa ng klase
{
static void Main ( string [ ] args )
{
gamit ( XmlReader reader = XmlReader.Create ( 'employees.xml' ) )
{
habang ( mambabasa.Basahin ( ) )
{
kung ( reader.NodeType == XmlNodeType.Element && mambabasa.Pangalan == 'empleado' )
{
Console.WriteLine ( 'ID: ' + reader.GetAttribute ( 'id' ) ) ;
reader.ReadToDescendant ( 'pangalan' ) ;
Console.WriteLine ( 'Pangalan: ' + reader.ReadElementContentAsString ( ) ) ;
reader.ReadToNextSibling ( 'kagawaran' ) ;
Console.WriteLine ( 'Kagawaran:' + reader.ReadElementContentAsString ( ) ) ;
reader.ReadToNextSibling ( 'suweldo' ) ;
Console.WriteLine ( 'Suweldo:' + reader.ReadElementContentAsString ( ) ) ;
}
}
}
}
}
Sa halimbawang ito, ginagamit namin ang XmlReader.Gumawa ng paraan upang lumikha ng isang instance ng XmlReader at ipasa ang path ng XML file bilang isang parameter. Pagkatapos ay gagamit kami ng while loop para basahin ang XML file node sa pamamagitan ng node gamit ang Read method ng XmlReader.
Sa loob ng loop, tinitingnan muna namin kung ang kasalukuyang node ay isang elemento ng empleyado gamit ang mga katangian ng NodeType at Pangalan ng XmlReader. Kung gayon, ginagamit namin ang GetAttribute na paraan upang makuha ang halaga ng katangian ng id.
Susunod, ginagamit namin ang ReadToDescendant na paraan upang ilipat ang mambabasa sa elemento ng pangalan sa loob ng elemento ng empleyado. Ang halaga ng elemento ng pangalan ay makukuha sa pamamagitan ng paggamit ng ReadElementContentAsString function.
Katulad nito, ginagamit namin ang ReadToNextSibling na paraan upang ilipat ang mambabasa sa susunod na elemento ng kapatid at makuha ang halaga ng mga elemento ng departamento at suweldo.
Panghuli, ginagamit namin ang paggamit ng block upang matiyak na ang XmlReader object ay maayos na itinapon pagkatapos naming basahin ang XML file:
4: XML hanggang LINQ
Ang pagbabasa ng XML file gamit ang LINQ hanggang XML sa C# ay isang mahusay na paraan upang ma-access at mamanipula ang XML data. Ang LINQ hanggang XML ay isang bahagi ng teknolohiya ng LINQ na nagbibigay ng simple at mahusay na API para sa pagtatrabaho sa XML data.
gamit ang System;gamit ang System.Linq;
gamit ang System.Xml.Linq;
Programa ng klase
{
static void Main ( string [ ] args )
{
XDocument doc = XDocument.Load ( 'employees.xml' ) ;
var empleyado = mula sa e sa doc.Mga Kaapu-apuhan ( 'empleado' )
pumili bago
{
Id = e.Elemento ( 'id' ) .Halaga,
Pangalan = e.Elemento ( 'pangalan' ) .Halaga,
Departamento = e.Elemento ( 'kagawaran' ) .Halaga,
Sahod = e.Elemento ( 'suweldo' ) .Halaga
} ;
foreach ( var empleyado sa mga empleyado )
{
Console.WriteLine ( $ 'Id: {employee.Id}, Pangalan: {employee.Name}, Department: {employee.Department}, Salary: {employee.Salary}' ) ;
}
}
}
Sa code na ito, nilo-load muna namin ang XML file gamit ang XDocument.Load() na paraan. Pagkatapos, ginagamit namin ang LINQ hanggang XML upang i-query ang XML data at piliin ang id, pangalan, departamento, at mga elemento ng suweldo para sa bawat elemento ng empleyado. Iniimbak namin ang data na ito sa isang hindi kilalang uri at pagkatapos ay umiikot sa mga resulta upang i-print ang impormasyon ng empleyado sa console.
5: Paggamit ng XPath
Ang XPath ay isang query language na ginagamit upang mag-navigate sa isang XML na dokumento upang mahanap ang mga partikular na elemento, katangian, at node. Ito ay isang epektibong tool para sa paghahanap at pag-filter ng impormasyon sa isang XML na dokumento. Sa C#, maaari naming gamitin ang wikang XPath upang basahin at kunin ang data mula sa mga XML file.
gamit ang System;gamit ang System.Xml.XPath;
gamit ang System.Xml;
Programa ng klase
{
static void Main ( string [ ] args )
{
XmlDocument doc = bagong XmlDocument ( ) ;
doc.Mag-load ( 'employees.xml' ) ;
// Lumikha ng XPathNavigator mula sa dokumento
XPathNavigator nav = doc.CreateNavigator ( ) ;
// I-compile ang XPath expression
XPathExpression expr = nav.Compile ( '/empleyado/empleyado/pangalan' ) ;
// Suriin ang expression at ulitin ang mga resulta
XPathNodeIterator iterator = nav.Select ( expr ) ;
habang ( iterator.MoveNext ( ) )
{
Console.WriteLine ( iterator.Current.Value ) ;
}
}
}
Nilo-load ng code na ito ang file na 'employees.xml' gamit ang isang XmlDocument, gumagawa ng XPathNavigator mula sa dokumento, at nag-compile ng XPath expression upang piliin ang lahat ng
Tandaan: Ang paggamit ng XPath ay maaaring maging isang malakas at nababaluktot na paraan upang pumili ng mga elemento at katangian mula sa isang XML na dokumento, ngunit maaari rin itong maging mas kumplikado kaysa sa ilan sa iba pang mga pamamaraan na aming tinalakay.
Konklusyon
Ang paggamit ng klase ng XmlDocument ay nagbibigay ng ganap na mga kakayahan sa pagmamanipula ng DOM, ngunit maaari itong maging mas mabagal at mas masinsinang memory kaysa sa iba pang mga pamamaraan. Ang klase ng XmlReader ay isang magandang opsyon para sa pagbabasa ng malalaking XML file, dahil nagbibigay ito ng mabilis, forward-only, at hindi naka-cach na stream-based na diskarte. Ang klase ng XDocument ay nagbibigay ng mas simple at mas maigsi na syntax, ngunit maaaring hindi ito kasinghusay ng XmlReader. Bukod pa rito, ang mga pamamaraan ng LINQ sa XML at XPath ay nagbibigay ng malakas na kakayahan sa pag-query upang kunin ang partikular na data mula sa isang XML file.