XML in eine Datei schreiben. Einfaches Schreiben und Lesen von XML mit XmlSerializer
- bekannte Webseiten, die ebenfalls ein XML-Analogon mit nicht strengen Prüfungen sind.
XML-, FastInfoset- und HTML-Lese-/Schreibobjekte erweitern die Möglichkeiten zum Lesen einer Textdatei durch die integrierte Verarbeitung von Markup-Tags.
Sie werden auch für DOM Builder/DOM Writer-Objekte (siehe unten) als Datenquellen verwendet.
XML 1C-Dateien enthalten Textinformationen, das heißt, sie sind es Textdateien. Die Objekte XML Reader 1C und XML Writer 1C sind ein „Add-on“, das die Arbeit mit 1C XML-Datei-Tags erleichtert.
Die Objekte ReadFastInfoset 1C und WriteFastInfoset 1C, ReadHTML 1C und WriteHTML 1C sind ReadXML 1C und WriteXML 1C völlig ähnlich und dienen dazu, auf die gleiche Weise mit anderen Formaten zu arbeiten.
XML 1C-Datei, die in den Beispielen verwendet wird
Verzeichnis>
Verzeichnis>
Text valueProps>
Verzeichnis>
Konfiguration>
Beispiel 1: Lesen XML-Datei 1C zum Wertebaum mit ReadingXML 1C
//öffne die XML 1C-Datei zum Lesen mit ReadingXML 1C
File = New XMLReader();
File.OpenFile("D:\ConfigurationStructure.xml");
//Vorbereiten des Wertebaums
//Jeder XML-Zweig kann einen Namen, Attribute und einen Wert haben
dzXML = New ValueTree();
dzXML.Columns.Add("Name");
dzXML.Columns.Add("Value");
dzXML.Columns.Add("Attribute");
//da ein XML-String mehrere Attribute haben kann, schreiben wir diese in die Wertetabelle
//Jedes Attribut hat einen Namen und einen Wert
tAttributes = NewValueTable();
attribute.Columns.Add("Name");
attribute.Columns.Add("Value");
// Die Verschachtelungsebene hilft uns zu verstehen, wann wir einen verschachtelten Zweig hinzufügen müssen und wann wir zur höheren Ebene zurückkehren müssen
NestingLevel = 0;
//aktuelle Zeile – Baumgrenze, ändert sich mit zunehmender Verschachtelung
CurrentRow = Undefiniert;
//Das Lesen der XML 1C-Datei erfolgt nicht zeilenweise, aber je nach Struktur wird am Ende der Datei beim Lesen FALSE zurückgegeben
While File.Read()-Schleife
//uns interessieren drei Arten von Knoten – der Anfang des Elements, der Text (der Wert des Elements) und das Ende des Elements (um eine Ebene höher zurückzukehren)
Wenn File.NodeType = XMLNodeType.ElementStart, dann
NestingLevel = NestingLevel + 1;
//Wenn dies die erste Zeile ist, fügen Sie sie ganz oben im Baum hinzu und speichern Sie nur den Namen
Wenn CurrentRow = Undefiniert, dann
CurrentRow = dzXML.Rows.Add();
CurrentLine.Name = File.Name;
Weitermachen;
Ansonsten
// verschachtelte Zeilen
CurrentRow = CurrentRow.Rows.Add();
CurrentLine.Name = File.Name; //Name speichern
//hat dieses Element XML-Attribute?
Wenn File.NumberAttributes() > 0, dann
//Wenn ja – kopieren Sie die vorbereitete leere Tabelle, um Attribute zu speichern
tAttributesNode = tAttributes.Copy();
//Durchlaufe die Anzahl der Attribute für dieses Element
Für Count = 0 durch File.NumberAttributes()-1 Schleife
// Merken Sie sich für jedes Attribut den Namen und den Wert
String = tNodeAttributes.Add();
String.Name = File.AttributeName(N);
String.Value = File.AttributeValue(Ac);
EndCycle;
//speichere die Attributtabelle des Elements in der aktuellen Zeile
CurrentRow.Attributes = tAttributesNode;
EndIf;
EndIf;
ElseIf File.NodeType = XMLNodeType.EndElement Then
// Verschachtelungsebene am Anfang des Elements erhöhen, Verschachtelungsebene am Ende des Elements verringern
NestingLevel = NestingLevel - 1;
//gibt die aktuelle Zeile eine Ebene nach oben zurück
CurrentRow = CurrentRow.Parent;
ElseIf File.NodeType = XMLNodeType.Text Then
//Wenn das Element einen Wert hat, speichern Sie ihn einfach
CurrentLine.Value = File.Value;
EndIf;
EndCycle;
File.Close();
Beispiel 2. Schreiben einer 1C XML-Datei mit dem WriteXML 1C-Objekt
//Erstelle eine WriteXML 1C-Datei
File = New XMLWriter();
File.OpenFile("D:\ConfigurationStructure.xml", "UTF-8");
File.WriteItemStart("Configuration");
// durch Metadaten umgehen wir alle Verzeichnisse (weitere Details finden Sie unter „Arbeiten mit Metadaten“)
Für jedes Verzeichnis aus der Metadata.Catalogs-Schleife
//WriteItemStart – öffnet einen neuen [untergeordneten] Zweig
File.WriteItemStart("Directory");
//WriteAttribute – schreibt das Attribut in den zuvor geöffneten Zweig
File.WriteAttribute("Name", Directory.Name);
File.WriteAttribute("Synonym", Directory.Synonym);
// Durch Metadaten umgehen wir alle Details des Verzeichnisses
Für jede Props aus der Handbook.Props-Schleife
EndCycle;
// durch Metadaten umgehen wir alle tabellarischen Teile des Verzeichnisses
Für jede PM aus der Directory.TabularParts-Schleife
File.WriteItemBeginning("TablePart");
File.WriteAttribute("Name", PT.Name);
File.WriteAttribute("Synonym", PM.Synonym);
Für jedes Props aus PM.Props Cycle
File.WriteItemBeginning("Props");
File.WriteAttribute("Name", Props.Name);
File.WriteAttribute("Synonym", Props.Synonym);
File.WriteEndElement();
EndCycle;
File.WriteEndElement();
EndCycle;
//SaveItemEnd – „schließt“ den zuvor geöffneten Zweig mit WriteItemStart
File.WriteEndElement();
EndCycle;
File.WriteEndElement();
File.Close();
In diesem Artikel möchte ich eine Methode zum Schreiben und Lesen von XML-Dateien mithilfe der XmlSerializer-Klasse beschreiben. Diese Klasse befindet sich im System.Xml.Serialization-Namespace der System.Xml.dll-Assembly. Es ist schon vor langer Zeit aufgetaucht – sogar in den ersten Versionen von .NET. Ein Objekt dieser Klasse verfügt über zwei interessante Methoden: Serialize und Deserialize. In diesem Artikel geht es darum, wie man eine XML-Datei nahezu beliebiger Struktur liest oder schreibt, indem man sie mit einfachen Klassen in C# beschreibt. Um zu verstehen, dass die Verwendung dieser Methoden sehr praktisch ist, gebe ich ein Beispiel einer Klasse:
Öffentliche Klasse Item (public int id; public string name; public List Values; public bool CurrentStatus; ) Diese Klasse kann einfach in das folgende XML konvertiert werden:12.34ElementName> 56.78ElementName>CollectionName>RootElementName> Dazu reicht es aus, zwei Methoden zu implementieren, die eine Reihe von Serialisierungs- (SaveXml) und Deserialisierungsmethoden (LoadXml) kapseln: public static bool SaveXml(object obj, string filename) ( bool result = false; using ( StreamWriter write = new StreamWriter(filename)) ( try ( XmlSerializerNamespaces ns = new XmlSerializerNamespaces(); ns.Add("", ""); .Serialize(writer, obj, ns); result = true; ) Catch (Exception e) ( // Logging ) Finally (writer.Close(); ) ) return result; ) public static object LoadXml(Type type, string filename) ( object result = null ; using (StreamReader reader = new StreamReader(filename)) ( try ( XmlSerializer serializer = new (reader.Close( ); ) ) Ergebnis zurückgeben; ) Jetzt werde ich ein vollständiges Beispiel für die Verwendung der oben genannten Methoden geben: Item item = new Item(); item.id = 42; item.name = "Artikelname"; item.values = new List(); item.values.Add(12.34); item.values.Add(56.78); SaveXml(item, "d:\\obj.xml"); Item obj = LoadXml(typeof(Item), "d:\\obj.xml") as Item; Nun ein wenig zur Flexibilität dieser XML-Serialisierungsmethode. Die erste Frage ist, wie ein Klassenmitglied als Attribut eines Knotens serialisiert wird. Hängen Sie dazu einfach das Attribut an. Sie können dieses Attribut mit dem Parameter umbenennen: . Wenn wir ein Klassenmitglied als normalen Knoten speichern müssen, können wir nichts schreiben. Wenn wir jedoch den Knoten selbst umbenennen müssen, können wir die . In Bezug auf Objektsammlungen ist zu beachten, dass das Umbenennen von Sammlungsknoten genauso einfach ist wie das Umbenennen gewöhnlicher Elemente. Dazu werden vor der Collection die Attribute und eingefügt. Als Parameter dieser Attribute können Sie die Namen der Knoten übergeben, die die Sammlung selbst bzw. ihre Elemente speichern. Wenn wir ein Element nicht in XML speichern möchten, können wir es mit dem . markieren. Mit der beschriebenen Methode können Sie dem Programm sehr schnell „beibringen“, mit unterschiedlichem XML zu arbeiten. Und dafür müssen Sie nicht für jedes XML-Format einen separaten Code schreiben. Es reicht aus, das Format deklarativ als C#-Klasse mit den notwendigen Attributen zu beschreiben.
