Scrierea datelor în xml. Scrieți și citiți cu ușurință XML folosind XmlSerializer

- pagini web binecunoscute, care sunt, de asemenea, un analog al XML-ului cu verificări slabe.

XML Reader/Writer Objects, FastInfoset, HTML extind capabilitățile de citire a fișierelor text cu procesarea încorporată a etichetelor de marcare.

Ele sunt, de asemenea, utilizate pentru obiectele DOMBuilder/DOMRecord (vezi mai jos) ca surse de date.

Fișierele XML 1C conțin informații text, adică sunt fișiere text. Obiectele 1C XML Reader și 1C Write XML sunt un „supliment” care facilitează lucrul cu etichete XML într-un fișier 1C.

Obiectele ReadingFastInfoset 1C și WritingFastInfoset 1C, ReadingHTML 1C și WritingHTML 1C sunt complet similare cu ReadingXML 1C și WritingXML 1C și servesc pentru a funcționa în același mod cu alte formate.

Fișier XML 1C folosit în exemple

Director>

Text valueProps>
Director>
Configurare>

Exemplul 1: Citirea fișier XML 1C în arborele de valori folosind XML Reading 1C

//deschideți fișierul XML 1C pentru citire folosind ReadingXML 1C
Fișier = New ReadXML();
File.OpenFile("D:\ConfigurationStructure.xml");

//pregătește arborele de valori
//fiecare ramură XML poate avea un nume, atribute și valoare
dzXML = NewValueTree();
dzXML.Columns.Add(„Nume”);
dzXML.Columns.Add(„Valoare”);
dzXML.Columns.Add(„Atribute”);

//deoarece un șir XML poate avea mai multe atribute, le vom scrie în tabelul cu valori
//fiecare atribut are un nume și o valoare
tAtribute = New ValueTable();
tAttribute.Columns.Add(„Nume”);
tAttribute.Columns.Add(„Valoare”);

//nivelul de imbricare ne va ajuta să înțelegem când trebuie să adăugăm o ramură imbricată și când trebuie să urcăm un nivel
Nesting Level = 0;
//linia curentă este o linie arborescentă, se va schimba pe măsură ce cuibărirea crește
CurrentRow = Nedefinit;
//citirea fișierului XML 1C nu se face linie cu linie, ci conform structurii; când fișierul se termină, citirea va returna FALSE
While File.Read() Loop

//ne interesează trei tipuri de noduri - începutul elementului, textul (valoarea elementului) și sfârșitul elementului (pentru a reveni la nivelul superior)
Dacă File.NodeType = XMLNodeType.ElementStart Atunci

Nivel de cuib = Nivel de cuib + 1;

//dacă aceasta este prima linie, apoi adăugați-o chiar în vârful arborelui și salvați doar numele
Dacă CurrentRow = Nedefinit, atunci
CurrentRow = dXML.Rows.Add();
CurrentLine.Name = File.Name;
Continua;
In caz contrar
//linii imbricate
CurrentRow = CurrentRow.Rows.Add();
CurrentLine.Name = File.Name; //salvează numele

//are acest element XML atribute?
Dacă File.NumberAttributes() > 0 Atunci
//dacă da, copiați tabelul gol pregătit pentru a salva atributele
tAttributesNode = tAttributes.Copy();
// parcurge numărul de atribute ale acestui element
Pentru cont = 0 după fișier.Număr de atribute()-1 ciclu
//pentru fiecare atribut, amintiți-vă numele și valoarea
Rând = tNodeAttributes.Add();
Line.Name = File.AttributeName(Sch);
Row.Value = File.AttributeValue(Ac);
EndCycle;
//salvează tabelul de atribute al elementului în linia curentă
CurrentRow.Attributes = tNodeAttributes;
endIf;
endIf;

ElseIf File.NodeType = XMLNodeType.EndElement Atunci
//la începutul elementului creștem nivelul de imbricare, la sfârșitul elementului îl micșorăm
Nesting Level = Nesting Level - 1;
//return linia curentă cu un nivel în sus
CurrentRow = CurrentRow.Parent;

ElseIf File.NodeType = XMLNodeType.Text Atunci
//dacă elementul are o valoare, salvați-o
CurrentRow.Value = File.Value;

endIf;

EndCycle;

File.Close();

Exemplul 2. Înregistrarea unui fișier XML 1C utilizând obiectul 1C Record XML

//creați un fișier Record XML 1C
Fișier = NewWriteXML();
File.OpenFile ("D:\ConfigurationStructure.xml", "UTF-8");
File.WriteElementStart("Configurare");

//utilizați metadate pentru a parcurge toate directoarele (pentru mai multe detalii, consultați „Lucrul cu metadate”)
Pentru fiecare Director din Metadate.Ciclul Directoarelor

//WriteStartofElement - deschide o nouă ramură [subordonată].
File.WriteElementStart("Director");
//WriteAttribute - scrie un atribut într-o ramură deschisă anterior
File.WriteAttribute("Nume", Director.Nume);
File.WriteAttribute("Synonym", Directory.Synonym);

//folosind metadate, parcurgem toate detaliile directorului
Pentru fiecare Props din Directory.Props Cycle

EndCycle;

//folosește metadate pentru a parcurge toate părțile tabulare ale directorului
Pentru fiecare PM din Director.Părți tabelare ale ciclului
File.WriteElementStart("TabularPart");
File.WriteAttribute("Nume", PM.Nume);
File.WriteAttribute("Synonym", PM.Synonym);

Pentru fiecare Props din PM.Props Cycle
File.WriteElementStart("Recuzită");
File.WriteAttribute("Nume", Atribute.Nume);
File.WriteAttribute("Sinonim", Atribute.Synonym);
File.WriteEndElement();
EndCycle;

File.WriteEndElement();
EndCycle;

//WriteEndElement - „închide” ramura deschisă anterior folosind WriteBeginElement
File.WriteEndElement();
EndCycle;

File.WriteEndElement();
File.Close();

În acest articol vreau să descriu o metodă de scriere și citire a fișierelor XML folosind clasa XmlSerializer. Această clasă se află în spațiul de nume System.Xml.Serialization al ansamblului System.Xml.dll. A apărut cu destul de mult timp în urmă - în primele versiuni de .NET. Obiectul acestei clase are două metode interesante - Serialize și Deserialize. Acest articol este despre cum să citiți sau să scrieți un fișier XML cu aproape orice structură, descriindu-l cu clase simple în C#. Pentru a înțelege că utilizarea acestor metode este foarte convenabilă, voi da un exemplu de clasă:

Clasa publică Item ( public int id; nume public șir; valori public List; public bool CurrentStatus; ) Această clasă poate fi convertită cu ușurință în următorul XML:12.34 Element_Name> 56.78 Element_Name> Collection_Name> Root_Element_Name> Pentru a face acest lucru, este suficient să implementați două metode care încapsulează corpul metodelor de serializare (SaveXml) și deserializare (LoadXml): public static bool SaveXml(object obj, string filename) rezultat = fals; folosind ( StreamWriter writer = new StreamWriter(nume fișier)) ( try ( XmlSerializerNamespaces ns = nou XmlSerializerNamespaces(); ns.Add("", ""); XmlSerializer serializer = nou XmlSerializer(obj.GetType()); serializer.Serialize(writer, obj, ns); rezultat = true; ) catch (Excepție e) ( // Logging ) finally ( writer.Close(); ) ) returnează rezultat; ) obiect static public LoadXml(Tip tip, șir nume fișier ) ( rezultatul obiectului = nul ; folosind ( StreamReader reader = new StreamReader (nume fișier)) ( încercați ( XmlSerializer serializer = nou XmlSerializer (tip); rezultat = serializer.Deserialize (cititor); ) catch (Excepție e) ( // Înregistrare ) în final ( reader.Close( ); ) ) returnează rezultatul; ) Acum voi da un exemplu complet de utilizare a metodelor de mai sus: Item item = new Item(); item.id = 42; item.name = „Numele articolului”; item.values = listă nouă (); item.values.Add(12.34); item.values.Add(56,78); SaveXml(articol, „d:\\obj.xml”); Item obj = LoadXml(typeof(Item), "d:\\obj.xml") ca Item; Acum, puțin despre flexibilitatea acestei metode de serializare XML. Prima întrebare este cum să serializeze un membru al clasei ca atribut de nod. Pentru a face acest lucru, atașați-i atributul. Puteți redenumi acest atribut utilizând parametrul: . Dacă trebuie să salvăm un membru al clasei ca nod obișnuit, atunci nu trebuie să scriem nimic. Deși, dacă trebuie să redenumim nodul în sine, putem introduce fișierul . În ceea ce privește colecțiile de obiecte, trebuie menționat că redenumirea nodurilor de colecție este la fel de simplă ca și redenumirea elementelor obișnuite. Pentru a face acest lucru, atributele și sunt inserate înaintea colecției. Ca parametru pentru aceste atribute, puteți trece numele nodurilor în care vor fi stocate colecția în sine și, respectiv, elementele acesteia. Dacă nu dorim să salvăm un element în XML, îl putem marca cu . Metoda descrisă vă permite să „învățați” foarte rapid programul cum să lucreze cu diferite XML. Și acest lucru nu este necesar pentru toată lumea format XML scrie cod separat. Este suficient să descrieți declarativ formatul sub forma unei clase C# cu atributele necesare.