XML in C# lesen
Es gibt mehrere Möglichkeiten, eine XML-Datei in C# zu lesen, und jede Methode hat ihre Vor- und Nachteile, und die Wahl hängt von den Anforderungen des Projekts ab. Im Folgenden finden Sie einige Möglichkeiten zum Lesen einer XML-Datei in C#:
- Verwenden von XmlDocument
- Verwenden von XDocument
- Verwenden von XmlReader
- Verwenden von XML für LINQ
- Verwenden von XPath
Hier ist der Inhalt der XML-Datei, die ich erstellt habe und die zur Demonstration zukünftiger Methoden verwendet wird:
< ?xml Ausführung = „1,0“ Codierung = „utf-8“ ? >
< Mitarbeiter >
< Mitarbeiter >
< Ausweis > 1 Ausweis >
< Name > Sam Mist Name >
< Abteilung > Marketing Abteilung >
< Gehalt > 50000 Gehalt >
Mitarbeiter >
< Mitarbeiter >
< Ausweis > 2 Ausweis >
< Name > Jane Doe Name >
< Abteilung > Finanzen Abteilung >
< Gehalt > 60000 Gehalt >
Mitarbeiter >
< Mitarbeiter >
< Ausweis > 3 Ausweis >
< Name > James Name >
< Abteilung > Humanressourcen Abteilung >
< Gehalt > 70000 Gehalt >
Mitarbeiter >
Mitarbeiter >
1: Verwenden von XmlDocument
Um eine XML-Datei in C# zu lesen, können Sie die XmlDocument-Klasse oder die XDocument-Klasse verwenden, die beide Teil des System.Xml-Namespace sind. Die XmlDocument-Klasse bietet einen DOM-Ansatz (Document Object Model) zum Lesen von XML, während die XDocument-Klasse einen LINQ-Ansatz (Language-Integrated Query) bereitstellt. Hier ist ein Beispiel für die Verwendung der XmlDocument-Klasse zum Lesen einer XML-Datei:
Verwenden des Systems;
mit System.Xml;
Klassenprogramm
{
statische Leere Main ( Zeichenfolge [ ] args )
{
XmlDocument doc = neues XmlDocument ( ) ;
doc.Load ( „mitarbeiter.xml“ ) ;
XmlNodeList-Knoten = doc.DocumentElement.SelectNodes ( „/mitarbeiter/mitarbeiter“ ) ;
für jede ( XmlNode-Knoten In Knoten )
{
Zeichenfolge Ausweis = node.SelectSingleNode ( 'Ausweis' ) .InnerText;
Stringname = node.SelectSingleNode ( 'Name' ) .InnerText;
string abteilung = node.SelectSingleNode ( 'Abteilung' ) .InnerText;
Zeichenfolge Gehalt = node.SelectSingleNode ( 'Gehalt' ) .InnerText;
Console.WriteLine ( „ID: {0}, Name: {1}, Abteilung: {2}, Gehalt: {3}“ , Ausweis , Name, Abteilung, Gehalt ) ;
}
}
}
Dieser Code verwendet die XmlDocument-Klasse zum Laden der XML-Datei und die SelectNodes-Methode zum Abrufen einer Liste von Mitarbeiterknoten. Anschließend werden für jeden Mitarbeiterknoten mithilfe der SelectSingleNode-Methode die Werte der untergeordneten Knoten „id“, „Name“, „Abteilung“ und „Gehalt“ abgerufen und mit Console.WriteLine angezeigt:
2: XDocument verwenden
Alternativ können Sie auch die XDocument-Klasse verwenden, um eine XML-Datei mithilfe eines LINQ-Ansatzes zu lesen. Nachfolgend finden Sie den Code, der die Vorgehensweise veranschaulicht:
Verwenden des Systems;Klassenprogramm
{
statische Leere Main ( Zeichenfolge [ ] args )
{
XDocument doc = XDocument.Load ( „mitarbeiter.xml“ ) ;
für jede ( XElement-Element In doc.Descendants ( 'Mitarbeiter' ) )
{
int Ausweis = int.Parse ( element.Element ( 'Ausweis' ) .Wert ) ;
Stringname = element.Element ( 'Name' ) .Wert;
string abteilung = element.Element ( 'Abteilung' ) .Wert;
int Gehalt = int.Parse ( element.Element ( 'Gehalt' ) .Wert ) ;
Console.WriteLine ( $ „ID: {id}, Name: {name}, Abteilung: {department}, Gehalt: {salary}“ ) ;
}
}
}
Die XML-Datei wird mithilfe der XDocument.Load-Methode in ein XDocument-Objekt geladen. Die „Mitarbeiter“-Elemente der XML-Datei werden dann alle mithilfe der Descendants-Technik abgerufen. Auf die untergeordneten Elemente jedes Elements wird mit der Element-Methode zugegriffen und ihre Werte werden mit der Value-Eigenschaft extrahiert. Abschließend werden die extrahierten Daten auf der Konsole ausgegeben.
Beachten Sie, dass XDocument zum Namespace System.Xml.Linq gehört. Daher müssen Sie die folgende using-Anweisung am Anfang Ihrer C#-Datei einfügen
3: Verwenden von XmlReader
XmlReader ist eine schnelle und effiziente Möglichkeit, eine XML-Datei in C# zu lesen. Es liest die Datei sequentiell, was bedeutet, dass jeweils nur ein Knoten geladen wird, was es ideal für die Arbeit mit großen XML-Dateien macht, die andernfalls nur schwer im Speicher verarbeitet werden könnten.
Verwenden des Systems;mit System.Xml;
Klassenprogramm
{
statische Leere Main ( Zeichenfolge [ ] args )
{
verwenden ( XmlReader-Reader = XmlReader.Create ( „mitarbeiter.xml“ ) )
{
während ( Leser.Lesen ( ) )
{
Wenn ( reader.NodeType == XmlNodeType.Element && Leser.Name == 'Mitarbeiter' )
{
Console.WriteLine ( 'AUSWEIS: ' + Reader.GetAttribute ( 'Ausweis' ) ) ;
Reader.ReadToDescendant ( 'Name' ) ;
Console.WriteLine ( 'Name: ' + Reader.ReadElementContentAsString ( ) ) ;
Reader.ReadToNextSibling ( 'Abteilung' ) ;
Console.WriteLine ( 'Abteilung: ' + Reader.ReadElementContentAsString ( ) ) ;
Reader.ReadToNextSibling ( 'Gehalt' ) ;
Console.WriteLine ( 'Gehalt: ' + Reader.ReadElementContentAsString ( ) ) ;
}
}
}
}
}
In diesem Beispiel verwenden wir die Methode XmlReader.Create, um eine Instanz von XmlReader zu erstellen und den XML-Dateipfad als Parameter zu übergeben. Anschließend verwenden wir eine While-Schleife, um die XML-Datei Knoten für Knoten mithilfe der Read-Methode von XmlReader zu lesen.
Innerhalb der Schleife prüfen wir zunächst mithilfe der Eigenschaften „NodeType“ und „Name“ von XmlReader, ob der aktuelle Knoten ein Mitarbeiterelement ist. Wenn ja, verwenden wir die GetAttribute-Methode, um den Wert des ID-Attributs abzurufen.
Als Nächstes verwenden wir die ReadToDescendant-Methode, um den Leser zum Namenselement innerhalb des Mitarbeiterelements zu verschieben. Der Wert des Namenselements wird dann mithilfe der ReadElementContentAsString-Funktion abgerufen.
In ähnlicher Weise verwenden wir die ReadToNextSibling-Methode, um den Leser zum nächsten Geschwisterelement zu bewegen und den Wert der Abteilungs- und Gehaltselemente abzurufen.
Schließlich verwenden wir den Block, um sicherzustellen, dass das XmlReader-Objekt ordnungsgemäß entsorgt wird, nachdem wir mit dem Lesen der XML-Datei fertig sind:
4: XML zu LINQ
Das Lesen einer XML-Datei mit LINQ to XML in C# ist eine leistungsstarke Möglichkeit, auf XML-Daten zuzugreifen und diese zu bearbeiten. LINQ to XML ist eine Komponente der LINQ-Technologie, die eine einfache und effiziente API für die Arbeit mit XML-Daten bereitstellt.
Verwenden des Systems;mit System.Linq;
mit System.Xml.Linq;
Klassenprogramm
{
statische Leere Main ( Zeichenfolge [ ] args )
{
XDocument doc = XDocument.Load ( „mitarbeiter.xml“ ) ;
var Mitarbeiter = von e In doc.Descendants ( 'Mitarbeiter' )
wählen neu
{
Id = e.Element ( 'Ausweis' ) .Wert,
Name = e.Element ( 'Name' ) .Wert,
Abteilung = e.Element ( 'Abteilung' ) .Wert,
Gehalt = e.Element ( 'Gehalt' ) .Wert
} ;
für jede ( var Mitarbeiter In Mitarbeiter )
{
Console.WriteLine ( $ „ID: {employee.Id}, Name: {employee.Name}, Abteilung: {employee.Department}, Gehalt: {employee.Salary}“ ) ;
}
}
}
In diesem Code laden wir zunächst die XML-Datei mit der Methode XDocument.Load(). Dann verwenden wir LINQ to XML, um die XML-Daten abzufragen und die Elemente „ID“, „Name“, „Abteilung“ und „Gehalt“ für jedes Mitarbeiterelement auszuwählen. Wir speichern diese Daten in einem anonymen Typ und durchlaufen dann die Ergebnisse, um die Mitarbeiterinformationen auf der Konsole auszugeben.
5: XPath verwenden
XPath ist eine Abfragesprache, die zum Navigieren durch ein XML-Dokument verwendet wird, um bestimmte Elemente, Attribute und Knoten zu finden. Es ist ein effektives Tool zum Suchen und Filtern von Informationen in einem XML-Dokument. In C# können wir die XPath-Sprache verwenden, um Daten aus XML-Dateien zu lesen und zu extrahieren.
Verwenden des Systems;mit System.Xml.XPath;
mit System.Xml;
Klassenprogramm
{
statische Leere Main ( Zeichenfolge [ ] args )
{
XmlDocument doc = neues XmlDocument ( ) ;
doc.Load ( „mitarbeiter.xml“ ) ;
// Erstellen Sie einen XPathNavigator aus dem Dokument
XPathNavigator nav = doc.CreateNavigator ( ) ;
// Kompilieren Sie den XPath-Ausdruck
XPathExpression Ausdruck = nav.Compile ( „/mitarbeiter/mitarbeiter/name“ ) ;
// Werten Sie den Ausdruck aus und durchlaufen Sie die Ergebnisse
XPathNodeIterator iterator = nav.Select ( Ausdruck ) ;
während ( iterator.MoveNext ( ) )
{
Console.WriteLine ( iterator.Aktueller.Wert ) ;
}
}
}
Dieser Code lädt die Datei „employees.xml“ mithilfe eines XmlDocument, erstellt einen XPathNavigator aus dem Dokument und kompiliert einen XPath-Ausdruck, um alle
Notiz: Die Verwendung von XPath kann eine leistungsstarke und flexible Möglichkeit sein, Elemente und Attribute aus einem XML-Dokument auszuwählen, sie kann jedoch auch komplexer sein als einige der anderen Methoden, die wir besprochen haben.
Abschluss
Die Verwendung der XmlDocument-Klasse bietet vollständige DOM-Manipulationsfunktionen, kann jedoch langsamer und speicherintensiver sein als die anderen Methoden. Die XmlReader-Klasse ist eine gute Option zum Lesen großer XML-Dateien, da sie einen schnellen, nur vorwärts gerichteten und nicht zwischengespeicherten Stream-basierten Ansatz bietet. Die XDocument-Klasse bietet eine einfachere und prägnantere Syntax, ist jedoch möglicherweise nicht so leistungsfähig wie der XmlReader. Darüber hinaus bieten die Methoden LINQ to XML und XPath leistungsstarke Abfragefunktionen zum Extrahieren spezifischer Daten aus einer XML-Datei.