Начини за обработка на xml в c. Как да отворите XML документ - функции за работа с XML файлове. Създаване на XML елемент с дъщерни елементи
Разширяем език за маркиране (XML). Те всъщност са само текстови файлове, които използват персонализирани тагове, за да опишат структурата и други функции на документа.
Какво е XML
XMLе език за маркиране, създаден от World Wide Web Consortium (W3C) за дефиниране на синтаксис на кодиране за документи, които могат да бъдат прочетени от хора и машини. Той прави това с етикети, които определят структурата на документа, както и как документът да се съхранява и транспортира.
Най-лесният начин да го сравните е с друг език за маркиране, с който може да сте запознати, the хипертекстово маркиране(HTML), използван за кодиране на уеб страници. HTML използва предварително дефиниран набор от знаци за маркиране (кратки кодове), които описват формата на съдържанието на уеб страница.
Разликата между XML обаче е, че е разширяем. XML няма предварително дефиниран език за маркиране като HTML. Вместо това XML позволява на потребителите да създават свои собствени знаци за маркиране, за да опишат съдържание, образувайки неограничен и самодефиниращ се набор от знаци.
По същество HTML е език, който се фокусира върху представянето на съдържание, докато XML е специален език за описание на данни, използван за съхраняване на данни.
XML често се използва като основа за други формати на документи, които са стотици. Ето няколко, които може да искате да знаете:
- RSS и ATOM описват как приложенията трябва да обработват емисии.
- Microsoft .NET използва XML за своите конфигурационни файлове.
- Microsoft Office използва XML като основа за структурата на документа.
Така че, ако имате XML файл, той не ви казва непременно за какво приложение е. Не е нужно обаче да се притеснявате за това, освен ако не разработвате XML файлове.
Как да отворите XML файл
Има няколко начина за директно отваряне на XML файл. Можете да ги отваряте и редактирате с всеки текстов редактор, да ги разглеждате с всеки уеб браузър или да използвате уебсайт, който ви позволява да ги преглеждате, редактирате и дори да ги конвертирате в други формати.
Използвайте текстов редактор, когато работите редовно с XML
Тъй като XML файловете са само обикновени текстови файлове, те могат да бъдат отворени с всеки текстов редактор. Въпреки това, много текстови редактори, като Notepad, просто не са проектирани да показват XML файлове в правилната им структура. Това може да бъде полезно за бързо запознаване със съдържанието на XML файл. Но има по-удобни инструменти за работа с тях.
Използване на уеб браузър за преглед на XML файл
Ако не е необходимо да редактирате XML файла, а просто трябва да видите съдържанието, вашият браузър може да се справи със задачата. Нещо повече, вашият уеб браузър най-вероятно вече е настроен като стандартен XML визуализатор. Така че двукратното щракване върху XML файл трябва да го отвори в браузър.
Ако не, можете да щракнете с десния бутон върху файла, за да намерите опции за отварянето му с всяко друго приложение. Просто изберете вашия уеб браузър от списъка с програми.
Когато файлът се отвори, трябва да видите добре структурирани данни. Не е толкова красив като цветния изглед, който получавате в Notepad++, но е много по-добър от notepad.
Използване на онлайн редактора за XML файлове
Ако искате да редактирате произволен XML файл и не искате да изтеглите нов текстов редактор, или трябва конвертирате xml файл в друг формат, има няколко прилични онлайн XML редактора, достъпни безплатно.
TutorialsPoint.com , XMLGrid.net и CodeBeautify.org – позволяват ви да преглеждате и редактирате XML файлове. След като редактирането приключи, можете да качите модифицирания XML файл или дори да го конвертирате в друг формат.
Нека използваме CodeBeautify.org като пример. Страницата е разделена на три раздела. Отляво е XML файлът, с който работите. В средата ще намерите няколко функции. Вдясно ще видите резултатите от някои от опциите, от които можете да избирате.
Например, в изображението по-долу нашият пълен XML файл е отляво, а панелът с резултати показва дървовиден изглед, защото щракнахме върху бутона Tree View в средата.
Използвайте бутона Преглед, за да заредите XML файл от вашия компютър, или бутона Зареждане на URL, за да извлечете XML от интернет източник
Бутонът за дървовиден изглед показва данните в добре форматирана дървовидна структура в панела с резултати, като всички тагове са маркирани в оранжево, а атрибутите са вдясно от таговете.
Beatify показва вашите данни по спретнат, лесен за четене начин.
Бутонът Minify показва вашите данни, използвайки най-малко интервали. Тази функция ще постави всяка отделна част от данните на един ред. Това ще бъде полезно, когато се опитвате да направите файла по-малък, което ще спести малко място.
И накрая, можете да използвате бутона XML към JSON, за да конвертирате XML във формат JSON, и бутона Експортиране в CSV, за да запазите данните като файл със стойности, разделени със запетая, или бутона Изтегляне, за да изтеглите всички промени, които сте направили в нов XML файл..
Вероятно сте чували за XML и има много причини да го използвате във вашата организация. Но какво точно е XML? Тази статия обяснява какво е XML и как работи.
В тази статия
Маркиране, маркиране и тагове
За да разберете XML, е полезно да запомните как можете да етикетирате данни. Документите са създавани от хората в продължение на много векове и през цялото това време хората са си правили бележки в тях. Например, учителите често маркират работата на учениците, за да посочат необходимостта от преместване на абзаци, по-ясно изречение, коригиране на правописни грешки и т. н. Маркирането на документ може да определи структурата, значението и външния вид на информацията. Ако някога сте използвали корекции в Microsoft Office Word, тогава сте запознати с компютъризирания формуляр за анотация.
В света на информационните технологии терминът "маркиране" се превърна в термин "маркиране". Маркирането използва кодове, наречени тагове (или понякога токени), за да дефинира структурата, визуалния облик и - в случая на XML - значението на данните.
HTML текстът на тази статия е добър пример за използването на компютърно маркиране. Ако щракнете с десния бутон върху тази страница в Microsoft Internet Explorer и изберете Вижте HTML кода, ще видите четим текст и HTML тагове като
И
. В HTML и XML документи етикетите са лесни за разпознаване, защото са оградени в ъглови скоби. В изходния код на тази статия HTML таговете изпълняват много функции, като дефиниране на началото и края на всеки параграф (
...
) и местоположението на чертежите.Отличителни черти на XML
Документите във формат HTML и XML съдържат данни, затворени в тагове, но дотук приликите между двата езика свършват. В HTML формат таговете определят представянето на данните – местоположението на заглавията, началото на абзаца и т.н. В XML формат таговете определят структурата и значението на данните – какво представляват те.
Когато се описва структурата и значението на данните, става възможно повторното им използване по няколко начина. Например, ако имате блок от данни за продажби, където всеки елемент е ясно дефиниран, можете да заредите само необходимите елементи в отчета за продажбите и да прехвърлите останалите данни в счетоводната база данни. С други думи, можете да използвате една система, за да генерирате данни и да ги маркирате в XML формат и след това да обработвате тези данни във всяка друга система, независимо от клиентската платформа или операционна система. Тази оперативна съвместимост прави XML гръбнака на една от най-популярните технологии за обмен на данни.
Когато работите, имайте предвид следното:
HTML не може да се използва вместо XML. XML данните обаче могат да бъдат обвити в HTML тагове и показани на уеб страници.
Функциите на HTML са ограничени до предварително дефиниран набор от етикети, общи за всички потребители.
XML правилата ви позволяват да създавате всякакви етикети, необходими за описание на данните и тяхната структура. Да приемем, че трябва да съхранявате и споделяте информация за домашни любимци. За да направите това, можете да създадете следния XML код:
Както можете да видите, XML таговете показват ясно какви данни разглеждате. Например, ясно е, че това са данни за котка и можете лесно да определите нейното име, възраст и т. н. С възможността за създаване на тагове, които дефинират почти всяка структура от данни, XML е разширим.
Но не бъркайте таговете в този пример с таговете в HTML файла. Например, ако XML текстът по-горе бъде поставен в HTML файл и отворен в браузър, резултатите ще изглеждат така:
Izzy Siamese 6 да не Izz138bod Колин Уилкокс
Уеб браузърът ще игнорира XML таговете и ще покаже само данните.
Добре оформени данни
Вероятно сте чували някой в ИТ да говори за „добре оформен“ XML файл. Добре оформеният XML файл трябва да следва много строги правила. Ако не спазва тези правила, XML не работи. Например в предишния пример всеки начален таг има съответен краен таг, така че този пример следва едно от правилата за добре оформен XML файл. Ако премахнете някой таг от файла и се опитате да го отворите в някоя от програмите на Office, ще получите съобщение за грешка и няма да можете да използвате такъв файл.
Не е необходимо да знаете правилата за създаване на добре оформен XML файл (въпреки че са лесни за разбиране), но не забравяйте, че само добре оформени XML данни могат да се използват в други приложения и системи. Ако XML файлът не се отвори, вероятно е неправилно форматиран.
XML е независим от платформата, което означава, че всяка програма, създадена да използва XML, може да чете и обработва XML данни, независимо от хардуера или операционната система. Например с правилните XML тагове можете да използвате десктоп програма за отваряне и обработка на данни, получени от мейнфрейма. И независимо от това кой е създал XML данните, е възможно да се работи с данните в различни приложения на Office. Благодарение на своята оперативна съвместимост XML се превърна в една от най-популярните технологии за обмен на данни между бази данни и потребителски компютри.
В допълнение към добре оформените маркирани данни, XML системите обикновено използват два допълнителни компонента: схеми и трансформации. Следващите раздели описват как работят.
Схема
Не се плашете от термина "схема". Схемата е просто XML файл, съдържащ правила за съдържанието на XML файл с данни. Файловете със схеми обикновено имат разширение .xsd, докато файловете с XML данни използват разширение .xml.
Схемите позволяват на програмите да проверяват данните. Те формират структурата на данните и ги правят разбираеми за създателя и другите хора. Например, ако потребителят въведе невалидни данни, като например текст в поле за дата, програмата може да подкани потребителя да ги коригира. Ако данните в XML файла съответстват на правилата в схемата, можете да използвате всяка програма, която поддържа XML, за да го прочетете, интерпретирате и обработите. Например, както е показано на фигурата по-долу, Excel може да валидира данните
Схемите могат да бъдат сложни и е невъзможно да се обясни как да се създадат в тази статия. (Също така е вероятно вашата организация да има ИТ персонал, който знае как да направи това.) Въпреки това е полезно да знаете как изглеждат диаграмите. Следващата схема дефинира правилата за набор от тагове
Не се притеснявайте, ако примерът няма смисъл. Просто обърнете внимание на следното:
Вградените елементи в примерната схема се наричат декларации. Ако са необходими допълнителни подробности за животното, като неговия цвят или специални характеристики, ИТ отделът ще добави подходящи декларации към схемата. XML системата може да се променя с развитието на нуждите на бизнеса.
Декларациите са мощен начин за контрол на структурата на данните. Например реклама
Ако данните в XML файла отговарят на правилата на схемата, тогава данните се считат за валидни. Процесът на проверка дали даден XML файл с данни отговаря на правилата на схемата се нарича (достатъчно логично) валидиране. Голямо предимство на използването на схеми е, че те могат да предотвратят повреда на данните. Схемите също така улесняват намирането на повредени данни, защото когато възникне такъв проблем, обработката на XML файла се спира.
Трансформации
Както беше обсъдено по-горе, XML също позволява ефективно използване и повторно използване на данни. Механизмът за повторно използване на данни се нарича XSLT трансформация (или просто трансформация).
Вие (или вашият ИТ отдел) можете също да използвате трансформации за обмен на данни между бек-енд системи, като например между бази данни. Да приемем, че база данни A съдържа данни за продажби в таблица, която е полезна за отдела по продажбите. База данни B съхранява данни за приходите и разходите в таблица, специално предназначена за счетоводство. База данни B може да използва трансформация, за да вземе данни от база данни A и да ги постави в подходящите таблици.
Комбинацията от файл с данни, схема и трансформация формира основната XML система. Следващата фигура показва работата на такива системи. Файлът с данни се проверява спрямо правилата на схемата и след това се изпраща по всякакъв подходящ начин за трансформация. В този случай трансформацията поставя данните в таблица на уеб страницата.
Следващият пример показва трансформация, която зарежда данни
Име
Порода
Възраст
променен
Без нокти
Разрешително
Собственик
Този пример показва как може да изглежда текстът на един от типовете трансформация, но не забравяйте, че можете да се ограничите до ясно описание на това, от което се нуждаете от данните, и това описание може да бъде направено на вашия собствен език. Например, можете да отидете в ИТ отдела и да кажете, че трябва да отпечатате данни за продажбите за определени региони за последните две години и че тази информация трябва да изглежда така и така. След това специалистите от отдела могат да напишат (или модифицират) трансформацията, за да изпълнят вашата заявка.
Microsoft и все по-голям брой други компании създават трансформации за различни задачи, които правят използването на XML още по-удобно. В бъдеще най-вероятно ще бъде възможно да изтеглите преобразуване, което отговаря на вашите нужди с малко или никакво персонализиране. Това означава, че с времето използването на XML ще става все по-евтино.
XML в системата Microsoft Office
Професионалните издания на Office предоставят подобрена поддръжка за XML. Започвайки с 2007 Microsoft Office System, Microsoft Office използва файлови формати, базирани на XML, като DOCX, XLSX и PPTX. Тъй като XML съхранява данни в текстов формат, а не в собствен двоичен формат, клиентите могат да дефинират свои собствени схеми и да използват вашите данни по много начини, без да се налага да плащат възнаграждения. За повече информация относно новите формати вижте Open XML формати и разширения на имена на файлове. По-долу са изброени други предимства.
Всичко това е страхотно, но какво ще стане, ако имате XML данни без схема? Зависи коя програма на Office използвате. Например, когато отворите XML файл без схема в Excel, той приема, че схемата съществува и ви позволява да заредите данните в XML таблица. Можете да използвате XML списъци и таблици за сортиране, филтриране и изчисляване на данни.
Активирайте XML инструменти в Office
По подразбиране разделът Разработчик не се показва. Трябва да се добави към лентата, за да се използват XML командите в Office.
В предишната статия бяха описани общи понятия, свързани с XML. В тази статия ще научим как да извършваме основни действия, свързани с промяна, добавяне, търсене в XML файл.
XML файл, който се използва за примера.
xml dom
В момента нашият файл съдържа следната структура:
Връзката между възлите в XML DOM, основни моменти:
1. Всеки възел в DOM дървото има родителски ParentNode. В нашия пример гаражът е родител и на двата елемента car, а двата елемента car на свой ред са родители на елементите модел и година.
Как да получа родителския xml елемент на колата?
Console.WriteLine(elmRoot["car"].ParentNode.Name); //Резултат: гараж
2. Родител може да има деца на ChildNodes. Например за гаражен възел и двата автомобилни елемента са деца. Елементите на колата също имат деца на модел и година.
ChildNodes, е колекция, която съхранява всички дъщерни xml елементи, за да получите достъп до желания елемент, трябва да посочите неговия индекс. (Индексът винаги започва от нула!)
Например: как да получа първия дъщерен елемент?
ElmRoot.ChildNodes;
3. Както в обикновения живот, едно дете може да се роди като първото FirstChild или последното LastChild.
Ако вземем елемента кола като пример, тогава
FirstChild е модел LastChild е година
4. От своя страна също има връзки между детските елементи, те могат да бъдат братя или сестри, ако направим паралели с реалния живот.
Едно дете може да има, например, брат Previous Sibling и следващ брат Next Sibling
Console.WriteLine(elmRoot.ChildNodes.FirstChild.NextSibling.Name); //Резултат: година Console.WriteLine(elmRoot.ChildNodes. LastChild.PreviousSibling.Name); //Резултат: модел
Ако елементът не бъде намерен, тогава се хвърля изключение: NullReferenceException, така че когато работите с xml, винаги използвайте блокове try catch.
Console.WriteLine(elmRoot.ChildNodes.LastChild.NextSibling.Name); Console.WriteLine(elmRoot.ChildNodes.FirstChild.PreviousSibling.Name);
LastChild е NextSibling;
FirstChild е PreviousSibling;
Използвайки методите, описани по-горе, можете лесно да навигирате до желания възел и да получите всяка стойност, от която се нуждаете.
Как да получа стойността на xml елемент?
Стойността на xml елемента може да бъде получена с помощта на свойството InnerText, например:
Console.WriteLine(elmRoot["car"].FirstChild.InnerText); //Резултат: mazda
Друг начин да получите същата стойност на xml елемент:
Console.WriteLine(elmRoot.FirstChild.FirstChild.InnerText); //Резултат: mazda
Последователността на движение през DOM дървото:
Гараж -> автомобил -> модел -> Mazda
Вземете годината:
ElmRoot["car"].LastChild.InnerText; //Резултат: 2007г
Последователност:
Гараж -> кола -> година -> 2007г
Друг пример: 3 начина да получите същия резултат.
Console.WriteLine(elmRoot.LastChild.FirstChild.InnerText); Console.WriteLine(elmRoot["car"].NextSibling.FirstChild.InnerText); Console.WriteLine(elmRoot.ChildNodes.Item(1).FirstChild.InnerText); //Резултат: BMW
Ако искате да получите годината за елемент със стойност Mazda:
Console.WriteLine(elmRoot.FirstChild.LastChild.InnerText); //Резултат: 2007г
За BMW (два начина, получавате същия резултат)
Console.WriteLine(elmRoot.ChildNodes.Item(1).ChildNodes.Item(1).InnerText); Console.WriteLine(elmRoot.ChildNodes.ChildNodes.InnerText); //Резултат: 2009г
Как да промените стойностите на xml елемент?
Ползване на имота InnerText()можете както да получите, така и да промените стойността на xml елемента, например да промените годината.
//Задайте нова стойност elmRoot.FirstChild.LastChild.InnerText = "2010"; //Изведете новата стойност на екрана на конзолата Console.WriteLine(elmRoot.FirstChild.ChildNodes.Item(1).InnerText); //Резултат: 2010г
В същото време трябва да запомните, че всички промени се извършват с виртуален xml файл, ако отворите физически файл, ще видите, че годината 2007 все още е посочена в него.
За да влязат в сила промените, трябва да използвате метода Save, например:
ElmRoot.Save("xml име на файл или поток");
Сега информацията ще бъде променена във "физическия" xml файл.
Как да получа броя на дъщерните елементи?
Console.WriteLine(elmRoot.FirstChild.ChildNodes.Count);гараж -> колата съдържа 2 деца: модел и година
Console.WriteLine(elmRoot.FirstChild.FirstChild.ChildNodes.Count);
гараж -> кола -> модел съдържа 1 xml дъщерен елемент.
Достъп до дъщерни елементи
по индекс
ElmRoot.ChildNodes.Name; elmRoot.ChildNodes.Name; //Резултат: кола
С примка
Foreach (XmlNode кимване в elmRoot.ChildNodes) ( Console.WriteLine(nod.Name); ) //Резултат: кола, кола
Как да получа името на xml елемент?
elmRoot.Name; //Резултат: гаражСъздаване на нов XML елемент
Нека създадем нов елемент в нашия XML документ, за да го разграничим от другите два (кола), нека го наречем автобус.
Когато създаваме нов елемент, ще използваме препоръката от сайта msdn и ще използваме метода CreateElement вместо стандартния нов XmlElement.
XmlElement elm = xmlDoc.CreateElement("автобус");
Създаване и добавяне на нов xml елемент
Нека създадем нов xml елемент с име "BUS".
XmlElement elmRoot = xmlDoc.DocumentElement; Console.WriteLine(elmRoot.ChildNodes.Count); //кола, кола XmlElement elmNew = xmlDoc.CreateElement("автобус"); elmRoot.AppendChild(elmNew); Console.WriteLine(elmRoot.ChildNodes.Count); //3 кола, кола, автобус xmlDoc.Save("име на xml файл");
Обяснение:
1. Първо, получаваме основния елемент, към който ще прикрепим нови елементи.
2. Като тест отпечатайте текущия брой деца на елемента гараж: 2 (кола и кола)
3. Създайте нов елемент BUS
4. Използване на метода AppendChildдобавете нов елемент към дървото
5. Нека отново да използваме отметката и да покажем текущия брой елементи за елемента гараж, сега има 3 от тях: кола, кола, автобус.
6. За да могат промените да засегнат физическия файл, ние запазваме
В самия XML файл новият елемент ще изглежда така:
Как да добавя нов xml елемент?
Задача: създайте нов XML елемент и добавете малко текстово съдържание към него, като например годината на издаване.
String strFilename = @"C:\lessons\Auto.xml"; XmlDocument xmlDoc = нов XmlDocument(); xmlDoc.Load(strFilename); XmlElement elmRoot = xmlDoc.DocumentElement; XmlElement elmNew = xmlDoc.CreateElement("автобус"); XmlText new_txt = xmlDoc.CreateTextNode("2006"); elmRoot.AppendChild(elmNew); elmRoot.LastChild.AppendChild(new_txt); Console.WriteLine(elmRoot.ChildNodes.Name); //bus Console.WriteLine(elmRoot.ChildNodes.LastChild.InnerText); //2006 Console.Read();
В XML файл:
За яснота
А сега нека създадем възел "автобус" със същата архитектура като колата, тоест да добавим възли: модел, година и малко текстово съдържание.
Създаване на XML елемент с дъщерни елементи
низ strFilename = @"C:\lessons\Auto.xml"; //създаване на нов xml документ в паметта XmlDocument xmlDoc = нов XmlDocument(); //зареждане на xml файла в паметта xmlDoc.Load(strFilename); //Вземете основния елемент XmlElement elmRoot = xmlDoc.DocumentElement; //Създаване на 3 елемента: автобус, модел, година XmlElement elmBUS = xmlDoc.CreateElement("bus"); XmlElement elmModel = xmlDoc.CreateElement("модел"); XmlElement elmYear = xmlDoc.CreateElement("година"); //Задайте стойности за елементи: модел, година XmlText year_txt = xmlDoc.CreateTextNode("2006"); //XmlText mod_txt = xmlDoc.CreateTextNode("liaz"); add else //Добавяне на два дъщерни елемента към елемента bus: модел и година elmBUS.AppendChild(elmModel); elmBUS.AppendChild(elmYear); //Добавяне на стойности към възлите на модела и годината elmModel.InnerText = "liaz"; elmYear.AppendChild(year_txt); //Добавяне на нова шина на xml елемент към дървото elmRoot.AppendChild(elmBUS); //Проверете дали всичко е добавено правилно Console.WriteLine(elmRoot.ChildNodes.FirstChild.InnerText); Console.WriteLine(elmRoot.LastChild.LastChild.InnerText); //Ако всичко е наред, използвайте метода за запис xmlDoc.Save("xml име на файл");Резултат:
Как можете да съкратите този код? Например, както следва:
String PathXmlFile = @"C:\lessons\Auto.xml"; XmlDocument xmlDoc = нов XmlDocument(); xmlDoc.Load(PathXmlFile); XmlElement elmRoot = xmlDoc.DocumentElement; XmlElement elmBUS = xmlDoc.CreateElement("автобус"); XmlElement elmModel = xmlDoc.CreateElement("модел"); XmlElement elmYear = xmlDoc.CreateElement("година"); //Добавяне на стойности към възлите на модела и годината elmModel.InnerText = "liaz"; elmYear.InnerText = "2006"; elmBUS.AppendChild(elmModel); elmBUS.AppendChild(elmYear); elmRoot.AppendChild(elmBUS); //Ако всичко е правилно, извикайте метода за запазване xmlDoc.Save("име на xml файл");
Нека съкратим кода още малко, за това ще използваме свойството InnerXml:
XmlDocument xmlDoc = нов XmlDocument(); xmlDoc.Load(PathXmlFile); XmlElement elmXML = xmlDoc.CreateElement("автобус"); низ txt="
Резултат
Вземете списък с елементи с GetElementByTagName
GetElementByTagName връща XmlNodeList, който съдържа всички наследствени елементи, принадлежащи на посочения елемент, например трябва да получим всички модели автомобили, които се съхраняват в гаража:
XmlDocument xmlDoc = нов XmlDocument(); xmlDoc.Load(strFilename); XmlNodeList modelName = xmlDoc.GetElementsByTagName("модел"); foreach (XmlNode възел в modelName) ( Console.WriteLine(node.InnerText); ) //Резултат: mazda, bmw, liaz
Рефериране с индекс:
String PathXmlFile = @"C:\lessons\Auto.xml"; XmlDocument xmlDoc = нов XmlDocument(); xmlDoc.Load(PathXmlFile); XmlNodeList modelName = xmlDoc.GetElementsByTagName("модел"); Console.WriteLine(modelName.InnerText); //Резултат: liaz
Как мога да променя текстовото съдържание на новосъздадения елемент "bus" с помощта на метода GetElementByTagName?
String PathXmlFile = @"C:\lessons\Auto.xml"; XmlDocument xmlDoc = нов XmlDocument(); xmlDoc.Load(PathXmlFile); XmlNodeList modelName = xmlDoc.GetElementsByTagName("модел"); Console.WriteLine(modelName.InnerText); //Получаване на стойност: liaz
Или можете да промените името liaz на Ikarus
Console.WriteLine(modelName.InnerText = "Ikarus");
Измина доста време, откакто обещах да говоря за работата с XML данни при разработването на .NET приложения. Обещанията трябва да се спазват. Моля, имайте предвид, че тази статия не е предназначена за професионални .NET разработчици, а за тези, които все още нямат значителен опит в създаването на .NET приложения.
Защо трябва да работим с XML?
Ако все още нямате много добра представа какво е XML, тогава препоръчвам да прочетете статията „XML е истински и за дълго време“ в „KV“ № 2007. За да спестите място за по-важни неща, самият XML формат няма да бъде анализиран тук.
Преди да започнете да се запознавате с програмния код, трябва да отговорите на един основен въпрос: защо изобщо да включвате XML поддръжка във вашето приложение? Мисля, че мнозина си зададоха този въпрос по отношение на много технологии и не всички бяха включени в приложенията след отговора. Въпреки това, нещата са малко по-различни с XML и има реални причини да използвате този формат в много ситуации.
Основното предимство на XML е, че като текстов формат по природа, той все пак идеално ви позволява да съхранявате и предавате всякакви данни. Тъй като този формат е текстов, проблемът с неговата междуплатформена природа се решава сам по себе си и проблемът с предаването на XML данни е също толкова лесно решен (както например се прави в SOAP). Освен това можете лесно да промените формата за предаване или съхранение чрез добавяне на нови атрибути и да не се притеснявате много за съвместимостта с предишни версии на формата, тъй като приложенията, използващи старата версия, ще могат да четат това, от което се нуждаят, без да обръщат внимание на новите тагове или атрибути.. Много приложения използват XML-базирани файлови формати, много комуникационни протоколи също са XML-базирани и списъкът на двете продължава да расте.
Разбира се, от друга страна, XML не е много икономичен, тъй като, както веднъж правилно отбеляза един от посетителите на форума Computer News, XML документите често се състоят от 10% данни и 90% тагове. Това обаче вече до голяма степен зависи от това какви етикети избирате. Можеш да пишеш
Така че в способни ръце XML е мощно и удобно нещо и поради повсеместното разпространение на този формат не можете да стигнете доникъде от него. Така че нека да преминем към писане на програмен код.
За програмиране ще използваме основния език на платформата .NET – C#. За да могат възможно най-много читатели да се упражняват с горния програмен код за себе си, ще използвам първата версия на C # и .NET Framework "a.
Записване на данни
Първо, нека поговорим за писане на данни, защото, знаете ли, за да прочетете нещо отнякъде, първо трябва да напишете нещо някъде. И щом се занимаваме с програмиране, тогава не е подходящо да създаваме XML данни с "дръжки". Затова нека първо се заемем с писането на данни в XML.
За да започнете, създайте нов проект в Visual Studio, #Develop или C# Builder и добавете System.Xml към списъка с импортирани пространства от имена.
Специален клас XmlTextWriter е отговорен за писането на XML данни в .NET Framework, което ви позволява да записвате XML данни в произволен поток.Тоест, ние, най-общо казано, можем да ги напишем с него във файл и в база данни, и изпратете на някого по интернет, но засега ще запишем всичко във файл. Можете да пренасочите изхода, като промените конструктора на обект (т.е. не предавате името на файла и неговото кодиране по време на инициализацията, а обект, който е поток от данни Мисля, че малко изпреварвам, нека първо да разгледаме кода, отговорен за записването на данни в нашия XML файл.
String FileName = "c:\\demo.xml"; XmlTextWriter xml = нов XmlTextWriter(Име на файл, System.Text.Encoding.Unicode); xml.Formatting = Форматиране.Отстъп; xml.WriteStartDocument(); xml.WriteStartElement("основен елемент"); за (int i = 0; i< 10; i++) { xml.WriteStartElement("subelement"); xml.WriteAttributeString("attrib1", "value1"); xml.WriteAttributeString("attrib2", i.ToString()); for (int j = 0; j < 10; j++){ xml.WriteStartElement("subsubelement"); xml.WriteAttributeString("attr", j.ToString()); xml.WriteEndElement(); } xml.WriteEndElement(); } xml.WriteEndElement(); xml.WriteEndDocument(); xml.Close();
Първият ред, мисля, е съвсем ясен - това е просто запис на името на файла, в който ще запазим данните. След това създаваме обект от типа XmlTextWriter (нарича се, както можете да видите, xml) и с него ще извършваме всички по-нататъшни операции. Обърнете внимание, че когато конструираме обекта, ние също така определяме кодирането, в което ще бъде написан XML: в нашия пример това е Unicode. Следващият ред, най-общо казано, не е задължителен, но той ще направи нашия XML документ, както се казва, четим от човека, тоест ще добави необходимите отстъпи и ще го раздели на редове. Без това целият документ би бил написан на един ред, което, макар и да спестява място, го прави практически неподходящ за ръчно редактиране.
Писането на документа започва с извикване на метода WriteStartDocument () на нашия xml обект. Редът след него добавя коренния елемент "rootelement" към нашия XML документ (припомнете си, че за XML документи коренният елемент трябва да присъства в един екземпляр). След това в цикъл добавяме още десет елемента, които не носят никакъв семантичен товар към нашия XML документ, за всеки от които задаваме два атрибута и още десет поделемента. Моля, обърнете внимание, че можем да добавим число към низ без изрично преобразуване на данните, но ако числото трябва изцяло да формира низ, то трябва да бъде преобразувано изрично чрез метода ToString(). Също така имайте предвид, че трябва изрично да затворим всеки от елементите на нашия XML документ, а след това и целия документ.
След като нашият XML документ е написан успешно, нека видим как можем да четем данни от него.
Четене на данни
Добавете компонент listBox към формуляра на вашето приложение (освен ако, разбира се, не е конзолен), за да можете да проследите резултата от четенето на XML файла. Е, ако вашата програма е конзола, тогава можете лесно да пренасочите изхода към конзолата.
Както обикновено, първо ще се запознаем с програмния код, а след това ще видим какво точно прави този код.
XmlTextReader xml = нов XmlTextReader(Име на файл); xml.WhitespaceHandling = WhitespaceHandling.None; int i = 0; while (xml.Read())( if ((xml.NodeType == XmlNodeType.Element) & (xml.Name == "поделемент")) ( listBox1.Items.Add("поделемент " + i + " намерен") ; i++; listBox1.Items.Add(" " + xml.GetAttribute("attrib1")); listBox1.Items.Add(" " + xml.GetAttribute("attrib2")); докато (xml.Read()&( xml.Name == "подподелемент"))( listBox1.Items.Add(" " + xml.GetAttribute("attr")); ) ) ) xml.Close();
За четене, както може би сте забелязали, ние използваме друг клас, а именно XmlTextReader. Той е в същото пространство от имена като класа, който използвахме за запис на данните. В първия ред създаваме екземпляр на XmlTextReader с име xml (тук предполагаме, че променливата FileName вече е дефинирана от нас по-рано).За да пропуснем празни редове, ако такива се появят по някакъв неразбираем начин в нашия новосъздаден XML файл, използваме следващия ред в кодовия фрагмент по-горе. Променливата i се използва за преброяване на броя на елементите "поделемент", намерени в XML файла, от който се четат данни.
Следва цикълът на директно четене на данни от файла. Методът Read() чете следващия елемент от XML документа и след прочитането му проверяваме какво точно сме прочели. Ако това наистина е „поделемент“, тогава добавяме информация за прочетения елемент към listBox1, увеличаваме променлива, съдържаща броя на прочетените елементи, и след това прочитаме атрибутите на елемента. След като прочетем атрибутите, ние организираме отделен цикъл за четене на поделементите "subsubelement" (имайте предвид, че не се нуждаем от отделен XmlTextReader за това) и атрибутите на тези поделементи. Както преди, ние въвеждаме цялата прочетена информация в listBox1 за контрол правилното четене.
Когато четете XML файлове, по същия начин, както когато ги пишете, когато конструирате XmlTextReader "a, можете да посочите като параметър потока, от който ще се извърши четенето, и тогава ще бъде възможно да се чете не само от файлове, но също и от други източници, примери за които вече дадох по-горе. Трябва да се отбележи една полезна функция на класа XmlTextReader: когато чете, той не зарежда целия четим XML документ в паметта, така че е удобно да се използва за анализиране големи XML документи (например XML бази данни).
Зад сцената
Като цяло примерът, който току-що анализирахме, е твърде прост за реални проекти. В наши дни, когато се четат XML документи, като правило те се валидират с помощта на DTD, XML Schema или Relax NG. Валидирането е проверка дали маркирането на XML документ отговаря на някакъв стандарт, описан във външен файл. Валидирането е необходимо, така че проверката на документа да не е твърдо включена в алгоритъма на програмата, но може да се променя произволно при промяна на формата на данните, без да се актуализира програмният код, който чете или записва данни. За съжаление сега няма да имаме време да анализираме валидирането, тъй като, както разбирате, обемът на вестникарска статия има определени ограничения.
Друг интересен и полезен практически момент по отношение на работата с XML данни е трансформацията на XSL данни. Тази трансформация се прилага към данните, когато се показват на HTML страници и всъщност е просто прилагане на определен шаблон на уеб страница към XML файл с някои данни. Тъй като лъвският дял от текущото използване на XML данни по един или друг начин попада в световната мрежа, би било много, много добре да се обмислят XSL трансформации.
Така че, мисля, че тази статия ще има продължение - но, разбира се, само ако вие самите (т.е. читателите на Computer News) попитате за това във форума или в писмо до моя имейл адрес. Засега относно използването на XML в .NET приложения, може би това е всичко. Надяваме се, че тази информация ще ви бъде полезна.
