Работа с XML в.NET-приложениях. Чем работать с XML - обзор онлайн-сервисов и xml редакторов
Представляем вашему вниманию новый курс от команды The Codeby - "Тестирование Веб-Приложений на проникновение с нуля". Общая теория, подготовка рабочего окружения, пассивный фаззинг и фингерпринт, Активный фаззинг, Уязвимости, Пост-эксплуатация, Инструментальные средства, Social Engeneering и многое другое.
XML DOM 2
В предыдущей статье были описаны общие понятия касающиеся XML. В этой статье научимся выполнять основные действия, связанные с изменением, добавлением, поиском в XML файле.
XML файл, который используется для примера.
xml dom
В данный момент, наш файл содержит следующую структуру:
Взаимоотношение между узлами в XML DOM , основные моменты:
1. Любой узел в DOM дереве имеет родителя ParentNode . В нашем примере garage является родителем для обоих элементов car, а оба элемента car, являются в свою очередь родителями для элементов: model и year.
Как получить родителя для xml элемента car?
Console.WriteLine(elmRoot["car"].ParentNode.Name); //Результат: garage
2. У родителя могут быть дети ChildNodes. Например, для узла garage детьми являются оба элемента car. У элементов car, тоже есть дети model и year.
ChildNodes , представляет собой коллекцию, которая хранит все дочерние xml элементы, чтобы обратиться к нужному элементу, нужно указать его индекс. (Индекс всегда начинается с нуля!)
Например: как получить первый дочерний элемент?
ElmRoot.ChildNodes;
3. Как и в обычной жизни ребенок может родиться первым FirstChild, или последним LastChild.
Если взять для примера элемент car, то
FirstChild - это model LastChild - это year
4. В свою очередь между дочерними элементами тоже существуют связи, они могут быть братьями или сестрами, если проводить параллели с реальной жизнью.
У ребенка может быть к примеру брат Previous Sibling и следующий брат Next Sibling
Console.WriteLine(elmRoot.ChildNodes.FirstChild.NextSibling.Name); //Результат: year Console.WriteLine(elmRoot.ChildNodes. LastChild.PreviousSibling.Name); //Результат: model
Если элемент не найден, то тогда возникает исключение: 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 дереву:
Garage -> car -> model -> Мазда
Получаем год:
ElmRoot["car"].LastChild.InnerText; //Результат: 2007
Последовательность:
Garage -> car -> year -> 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);garage -> car содержит 2 ребенка: model и year
Console.WriteLine(elmRoot.FirstChild.FirstChild.ChildNodes.Count);
garage -> car -> model содержит 1 дочерний xml элемент.
Обращение к дочерним элементам
по индексу
ElmRoot.ChildNodes.Name; elmRoot.ChildNodes.Name; //Результат: car
С помощью цикла
Foreach (XmlNode nod in elmRoot.ChildNodes) { Console.WriteLine(nod.Name); } //Результат: car, car
Как получить имя xml элемента?
elmRoot.Name; //Результат: garageСоздание нового XML элемента
Создадим новый элемент в нашем XML документе, чтобы он отличался от двух других (car) назовём его автобус (bus).
При создании нового элемента воспользуемся рекомендацией с сайта msdn и вместо стандартного new XmlElement воспользуемся методом CreateElement.
XmlElement elm = xmlDoc.CreateElement("bus");
Создание и добавление нового xml элемента
Создадим новый xml элемент по имени «BUS».
XmlElement elmRoot = xmlDoc.DocumentElement; Console.WriteLine(elmRoot.ChildNodes.Count); //car, car XmlElement elmNew = xmlDoc.CreateElement("bus"); elmRoot.AppendChild(elmNew); Console.WriteLine(elmRoot.ChildNodes.Count); //3 car, car, bus xmlDoc.Save("имя xml файла");Пояснение:
1. Сначала получаем root-элемент к которому будем крепить новые элементы.
2. В качестве проверки выведем текущее количество дочерних элементов у элемента garage: 2 (car и car)
3. Создаем новый элемент BUS
4. При помощи метода AppendChild добавляем новый элемент в дерево
5. Снова воспользуемся проверкой и выведем текущее количество элементов у элемента garage, теперь их стало 3: car, car, bus.
6. Чтобы изменения затронули физический файл, сохраняемся
В самом XML файле новый элемент будет выглядеть так:
Как добавить новый xml элемент?
Задача: создать новый XML элемент и добавить в него какое-нибудь текстовое содержимое, например год выпуска.
String strFilename = @"C:\lessons\Auto.xml"; XmlDocument xmlDoc = new XmlDocument(); xmlDoc.Load(strFilename); XmlElement elmRoot = xmlDoc.DocumentElement; XmlElement elmNew = xmlDoc.CreateElement("bus"); 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 файле:
Для наглядности
А теперь создадим узел «bus», с такой же архитектурой, как и car, то есть добавим узлы: model, year и какое-нибудь текстовое содержимое.
Создание XML элемента с дочерними элементами
string strFilename = @"C:\lessons\Auto.xml"; //создаем новый xml документ в памяти XmlDocument xmlDoc = new XmlDocument(); //загружаем xml файл в память xmlDoc.Load(strFilename); //Получаем root-элемент XmlElement elmRoot = xmlDoc.DocumentElement; //Создаём 3 элемента: bus, model, year XmlElement elmBUS = xmlDoc.CreateElement("bus"); XmlElement elmModel = xmlDoc.CreateElement("model"); XmlElement elmYear = xmlDoc.CreateElement("year"); //Устанавливаем значения для элементов: model, year XmlText year_txt = xmlDoc.CreateTextNode("2006"); //XmlText mod_txt = xmlDoc.CreateTextNode("liaz"); добавим иначе //К элементу bus добавляем два дочерних элемента: model и year elmBUS.AppendChild(elmModel); elmBUS.AppendChild(elmYear); //Добавляем значения узлам model и year elmModel.InnerText = "liaz"; elmYear.AppendChild(year_txt); //Добавляем в дерево новый xml элемент bus elmRoot.AppendChild(elmBUS); //Проверяем, всё ли добавлено, как надо Console.WriteLine(elmRoot.ChildNodes.FirstChild.InnerText); Console.WriteLine(elmRoot.LastChild.LastChild.InnerText); //Если всё в порядке, то используем метод Save xmlDoc.Save("имя xml файла");Результат:
Как можно сократить, данный код? Например, следующим образом:
String PathXmlFile = @"C:\lessons\Auto.xml"; XmlDocument xmlDoc = new XmlDocument(); xmlDoc.Load(PathXmlFile); XmlElement elmRoot = xmlDoc.DocumentElement; XmlElement elmBUS = xmlDoc.CreateElement("bus"); XmlElement elmModel = xmlDoc.CreateElement("model"); XmlElement elmYear = xmlDoc.CreateElement("year"); //Добавляем значения узлам model и year elmModel.InnerText = "liaz"; elmYear.InnerText = "2006"; elmBUS.AppendChild(elmModel); elmBUS.AppendChild(elmYear); elmRoot.AppendChild(elmBUS); //Если всё верно, то вызываем метод Save xmlDoc.Save("имя xml файла");
Ещё немного сократим код, для этого воспользуемся свойством InnerXml:
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(PathXmlFile);
XmlElement elmXML = xmlDoc.CreateElement("bus");
string txt = "
Результат
Получить список элементов при помощи GetElementByTagName
GetElementByTagName возвращает XmlNodeList , в котором содержаться все элементы потомки, принадлежащие указному элементу, например, нам нужно получить все модели машин, которые хранятся в гараже:
XmlDocument xmlDoc = new XmlDocument(); xmlDoc.Load(strFilename); XmlNodeList modelName = xmlDoc.GetElementsByTagName("model"); foreach (XmlNode node in modelName) { Console.WriteLine(node.InnerText); } //Результат: mazda, bmw, liaz
Обращение при помощи индекса:
String PathXmlFile = @"C:\lessons\Auto.xml"; XmlDocument xmlDoc = new XmlDocument(); xmlDoc.Load(PathXmlFile); XmlNodeList modelName = xmlDoc.GetElementsByTagName("model"); Console.WriteLine(modelName.InnerText); //Результат: liaz
Как изменить текстовое содержимое, у только что созданного элемента «bus», при помощи метода GetElementByTagName?
String PathXmlFile = @"C:\lessons\Auto.xml"; XmlDocument xmlDoc = new XmlDocument(); xmlDoc.Load(PathXmlFile); XmlNodeList modelName = xmlDoc.GetElementsByTagName("model"); Console.WriteLine(modelName.InnerText); //Получили значение: liaz
Либо можно изменить имя liaz на Ikarus
Console.WriteLine(modelName.InnerText = "Ikarus");
Уже довольно много времени прошло с тех пор, как я пообещал рассказать о работе с данными в формате XML при разработке.NET-приложений. Обещания надо выполнять. Прошу только учесть, что эта статья ориентирована не на профессиональных.NET-разработчиков, а на тех, кто ещё не имеет существенного опыта создания.NET-приложений.
Зачем нам работать с XML?
Если вы ещё не очень хорошо представляете себе, что такое XML, то рекомендую прочитать статью "XML - это всерьёз и надолго" в "КВ" № за 2007-й год. Чтобы сэкономить место для более важных вещей, здесь сам формат XML разбираться не будет.
Перед тем, как начинать знакомиться с программным кодом, нужно ответить на один принципиальный вопрос: зачем вообще включать поддержку XML в своё приложение? Думаю, что многие задавали себе этот вопрос относительно многих технологий, и не все после ответа были включены в приложения. Впрочем, с XML дело обстоит несколько иначе, и существуют реальные поводы использовать этот формат во многих ситуациях.
Главное преимущество XML в том, что, будучи по природе текстовым форматом, он, тем не менее, прекрасно позволяет хранить и передавать любые данные. Поскольку этот формат текстовый, то сама собой решается проблема его кросс-платформенности, и точно так же легко решается проблема передачи XML-данных (как это, например, сделано в SOAP). Кроме того, можно без проблем изменять формат передачи или хранения данных, добавляя новые атрибуты и не сильно беспокоясь о совместимости с предыдущими версиями формата, поскольку приложения, использующие старую версию, смогут прочитать то, что им надо, не обращая внимания на новые теги или атрибуты. Многие приложения используют основанные на XML файловые форматы, многие протоколы передачи данных тоже основаны на XML, и списки тех и других продолжают расти.
Конечно, с другой стороны, XML не
очень экономичен, потому что, как
когда-то верно заметил один из
посетителей форума
"Компьютерных вестей", часто
XML-документы состоят на 10% из данных
и на 90% из тегов. Впрочем, это уже в
значительной степени зависит от
того, какие вы сами выберете теги.
Можно написать
Так что в умелых руках XML - вещь мощная и удобная, а из-за повсеместной распространённости этого формата от него и вовсе никуда не денешься. Поэтому давайте перейдём уже к написанию программного кода.
Для программирования мы будем использовать основной язык платформы.NET - C#. Для того, чтобы как можно больше читателей могли сами поупражняться с приведенным программным кодом, я буду использовать первую версию C# и.NET Framework"а.
Запись данных
Сначала поговорим о записи данных, поскольку, сами понимаете, чтобы что-то откуда-то считывать, нужно сначала что-то куда-то и записать. А коль скоро мы с вами занялись программированием, то создавать XML-данные "ручками" нам с вами не пристало. Поэтому давайте сначала займёмся записью данных в XML.
Для начала создайте новый проект в Visual Studio, #Develop"е или C# Builder"е, и в список импортируемых namespace"ов добавьте System.Xml.
За запись XML-данных в.NET Framework"е отвечает специальный класс XmlTextWriter, который позволяет записывать XML-данные в произвольный поток. То есть, мы, вообще говоря, можем записать их с его помощью и в файл, и в базу данных, и отправить кому-то через Интернет, однако сейчас мы будем писать всё именно в файл. Вы можете перенаправить вывод, изменив конструктор объекта (т.е. передав при инициализации не имя файла и его кодировку, а объект, являющийся потоком данных). Впрочем, я, кажется, уже стал забегать немного вперёд. Давайте сначала познакомимся с кодом, ответственным за запись данных в наш с вами XML-файл.
String FileName = "c:\\demo.xml"; XmlTextWriter xml = new XmlTextWriter(FileName, System.Text.Encoding.Unicode); xml.Formatting = Formatting.Indented; xml.WriteStartDocument(); xml.WriteStartElement("rootelement"); for (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-документ, что называется, human readable, то есть добавит нужные отступы и разобьёт его на строки. Без этого весь документ был бы записан одной строкой, что, хотя и экономит место, но делает его практически непригодным для ручного редактирования.
Начинается запись документа с вызова метода WriteStartDocument() нашего объекта xml. Следующая за ней строчка добавляет корневой элемент "rootelement" в наш XML-документ (напомню, для XML-документов корневой элемент должен присутствовать в единственном экземпляре). Далее мы в цикле добавляем ещё десять не несущих никакой смысловой нагрузки элементов в наш с вами XML-документ, для каждого из которых устанавливаем два атрибута и ещё по десять подэлементов. Обратите внимание, что мы можем добавлять к строке число без явной конвертации данных, а вот если число должно целиком образовывать строку, то его нужно преобразовывать явно методом ToString(). Также обратите внимание, что мы должны явно закрывать каждый из элементов нашего XML-документа, а также потом и весь документ целиком.
Теперь, когда наш XML-документ успешно записан, давайте посмотрим, каким образом можно считать из него данные.
Чтение данных
Добавьте на форму вашего приложения (если, конечно, оно у вас не консольное) компонент listBox для того, чтобы можно было следить за результатом чтения XML-файла. Ну а если ваша программа консольная , то вы с лёгкостью сможете перенаправить вывод на консоль.
Как обычно, сначала ознакомимся с кодом программы, а потом уже будем смотреть, что именно этот код делает.
XmlTextReader xml = new XmlTextReader(FileName); xml.WhitespaceHandling = WhitespaceHandling.None; int i = 0; while (xml.Read()){ if ((xml.NodeType == XmlNodeType.Element) & (xml.Name == "subelement")) { listBox1.Items.Add("subelement " + i + " found"); i++; listBox1.Items.Add(" " + xml.GetAttribute("attrib1")); listBox1.Items.Add(" " + xml.GetAttribute("attrib2")); while (xml.Read()&(xml.Name == "subsubelement")){ listBox1.Items.Add(" " + xml.GetAttribute("attr")); } } } xml.Close();
Для чтения, как вы могли заметить, мы используем уже другой класс, а именно - XmlTextReader. Он находится в том же пространстве имён, что и класс, который мы использовали для записи данных. В первой строчке мы создаём экземпляр XmlTextReader"а, имеющий имя xml (здесь мы предполагаем, что переменная FileName уже определена нами ранее). Чтобы пропускать пустые строки, ежели такие неким непостижимым образом возникнут в нашем только что созданном XML-файле, мы используем следующую строку в приведенном фрагменте кода. Переменная i используется для подсчёта количества найденных элементов "subelement" в XML-файле, из которого производится считывание данных.
Дальше идёт цикл непосредственного чтения данных из файла. Метод Read() считывает следующий элемент XML-документа, и после его считывания мы проверяем, что именно мы считали. Если это действительно элемент "subelement", то мы добавляем информацию о считанном элементе в listBox1, инкрементируем переменную, содержащую количество считанных элементов, а затем считываем атрибуты элемента. После чтения атрибутов мы организуем отдельный цикл для чтения подэлементов "subsubelement" (обратите внимание, что для этого нам не требуется отдельного XmlTextReader"а) и атрибутов этих подэлементов. Как и ранее, все считанные сведения мы заносим в listBox1, чтобы контролировать правильность чтения.
При чтении XML-файлов, точно так же, как и при их записи, при конструировании XmlTextReader"а можно указать в качестве параметра поток, из которого будет производиться чтение, и тогда читать можно будет не только из файлов, но также и из других источников, примеры которых я уже приводил выше. Следует отметить одну полезную особенность класса XmlTextReader: при чтении он не загружает в память весь читаемый XML-документ, поэтому с его помощью удобно проводить разбор больших XML-документов (например, XML баз данных).
За кадром
В общем-то, пример, который мы с вами только что разобрали, чересчур прост для реальных проектов. В наше время при чтении XML-документов, как правило, применяется их валидация с помощью DTD, XML Schema или Relax NG. Валидация - это проверка соответствия разметки XML-документа некоторому стандарту, описываемому во внешнем файле. Валидация нужна для того, чтобы проверка документа не была жёстко зашита в алгоритм программы, а могла изменяться произвольным образом при изменении в формате данных без обновления считывающего или записывающего данные программного кода. К сожалению, сейчас мы с вами уже разобрать валидацию не успеем, поскольку, как вы сами понимаете, объём газетной статьи имеет определённые ограничения.
Ещё один интересный и полезный практический момент, касающийся работы с XML-данными, - это XSL-преобразование данных. Это преобразование применяется к данным при их отображении на HTML-страницах и, фактически, просто является применением определённого шаблона web-страницы к XML-файлу с какими-либо данными. Поскольку львиная доля теперешнего использования XML-данных так или иначе приходится на World Wide Web, то и XSL-преобразования рассмотреть было бы очень и очень неплохо.
Так что, думаю, у этой статьи будет продолжение - но, конечно, только в том случае, если вы сами (то есть читатели "Компьютерных вестей") об этом попросите на форуме или в письме на мой электронный почтовый адрес. Пока же об использовании XML в.NET-приложениях, пожалуй, всё. Надеюсь, что эта информация будет полезной для вас.
Работа с данными в формате XML в приложениях ASP.NET 2.0, объект XmlDataDocument и элемент управления XML
Этот модуль посвящен тому, как можно работать с данными в формате XML из приложений ASP.NET.
XML расшифровывается как Extensible Markup Language (расширяемый язык разметки), хотя сам XML - это не язык. XML - набор правил, используемых для создания своих языков разметки. Например, представим себе, что у нас существуют такие данные о сотруднике:
Эти данные, конечно, можно представить как угодно: в виде таблицы в реляционной базе данных, в виде таблицы Excel или HTML, в виде таблицы в документе Word или в виде текстового документа ASCII, в виде файла *.csv и т.п. Если мы представим их в формате придуманного нами XML-совместимого языка разметки ABML (Address Book Markup Language), то они будут выглядеть так:
Немного о том, как расшифровать этот код. Первые две строки - это пролог (использовать его, в принципе, необязательно, но очень рекомендуется). Строка
называется объявлением XML (XML Declaration) и говорит о том, что этот файл соответствует спецификации XML 1.0, принятой в качестве рекомендации World Wide Web Consortium 10 февраля 1998 года. Строка
называется определением типа документа (Document Type Definition) и говорит о том, что структура языка, которому соответствует этот документ, описана в файле abml.dtd (можно использовать и внутренние DTD, когда описание языка находится прямо в документе). Сейчас для описания структуры XML-совместимых языков чаще используются не DTD, а XML Schema - к ним проще обращаться и они обеспечивают больше возможностей, в частности, при описании различных типов данных. Эта же строка с использованием XML Schema может выглядеть так:
в зависимости от того, где лежит сама Schema - описание данного языка - в файле abml.xml или на Web-сервере (корпоративное хранилище схем от Microsoft - BizTalk Server).
Пример XML Schema для нашего языка может выглядеть так:
XML – это формализованный набор правил для «разметки» документа – то есть выделения его логической структуры. То, что находится внутри любого документа, совместимого с форматом XML, можно разбить на две категории: разметку и само содержание. Вся информация о разметки должна начинаться либо с символа амперсанда (&), либо с символа левой угловой скобки (<). В XML существует шесть типов информации разметки: элементы, атрибуты, комментарии, инструкции обработки, ссылки на сущности и разделы CDATA.
· Элементы (elements) – это наиболее распространенный тип информации о разметке. Элемент выделяет логическую составную часть документа. Обычный документ состоит из открывающих и закрывающих тегов, которые могут окружать содержимое, другой элемент, или и то, и другое вместе. Теги с названиями элемента заключаются в угловые скобки. Вот пример элемента:
· Атрибуты (attributes) состоят из пары имя атрибута/значение атрибута и применяются к элементам. Атрибуты положено помещать после имени элемента в открывающем теге. Например, атрибутами являются ширина и высота:
· Комментарии (comments) – это любой текст, который будет игнорироваться процессором XML. Пример:
· Инструкции обработки (processing instructions) используются для передачи информации приложению, обрабатывающему документ XML. Синтаксис инструкции обработки выглядит так:
· Ссылки на сущности (entity references) используются для того, чтобы помещать в документ зарезервированные символы или зарезервированные слова. К примеру, нам надо вставить в документ левую угловую скобку (<), которая является зарезервированным символом XML. Просто так вставить в текст документа мы ее не сможем: приложение, работающее с документом, решит, что она относится к разметке. Поэтому нам необходимо использовать сочетание символов <. lt означает less than (меньше чем), а амперсанд (&) и точка с запятой (;) выделяют ссылку на сущность.
· Раздел CDATA (CDATA section) – это часть текста, которая не обрабатывается, как остальные части документа XML, а передаваться приложению напрямую. Это средство может пригодиться, например, при передаче приложению какого-либо кода.
Синтаксические принципы XML:
· Документы XML состоят из символов Unicode (Unicode – это 16-битный набор символов, который позволяет отображать документы на любых языках).
· XML чувствителен к регистру. Теги и в нем – это разные теги.
· Пустое пространство (whitespace) – это невидимые символы, такие, как пробел (ASCII 32), символ табуляции (ASCII 9), символы возврата каретки (ASCII 13) и символы перевода строки (ASCII 10). Пустое пространство игнорируется внутри тегов, но сохраняется в символьных данных (то есть между открывающим и закрывающим тегами). Пустое пространство в символьных данных передается обрабатывающему приложению.
· Многие компоненты XML должны иметь имена (наиболее наглядный пример – элементы и атрибуты). Правила именования XML выглядят следующим образом: имя XML должно начинаться с буквы или подчеркивания, за которым следует любое количество букв, цифр, дефисов, подчеркиваний или точек, например:
Мой_Уникальный_Идентификатор_Тега-123 2_Это_имя_является_неверным
· Имя компонента XML не может начинаться с символов xml (как в верхнем, так и в нижнем регистре). Такие имена зарезервированы создателями спецификации для служебных целей.
· Символьные значения должны быть помещены в одинарные или двойные кавычки.
· В XML должен строго соблюдаться порядок вложенности тегов.
· Любому открывающему тегу в XML должен соответствовать закрывающий тег.
· Пустой тег в XML записывается как открывающий тег, перед правой угловой скобкой в котором стоит прямой слеш (/).
· В документе XML может быть только один корневой элемент.
В чем преимущества размещения данных в XML перед традиционными двоичными форматами? Почему в настоящее время большинство крупных производителей программного обеспечения либо уже полностью перешли на работу с данными в XML-совместимом формате (например, Micrоsoft Office 2003), либо планируют перейти в ближайшем будущем? Главная причина - данные в XML очень легко передавать между самыми разными приложениями и их очень легко преобразовывать. Дополнительные моменты, связанные с преимуществами XML:
- Независимый формат данных - данные в формате XML можно открывать в любом XML-совместимом (точнее, совместимым с конкретной схемой) приложении. Пример: на любом предприятии документы хранятся в самых разных форматах - форматах разных версий Word, текстовых, HTML, PDF и т.п. Проблем из-за этого возникает очень много, радикально решаются при помощи XML.
- Общий принцип - один источник данных (документ XML), много представлений. Наглядно можно продемонстрировать на примере Web-сайта, к которому нужно обращаться из разных броузеров и через WAP.
- Гораздо более простая передача данных "сквозь" приложения. Примеры - прохождение документов через цепочку поставщиков, или прохождение данных между разнородными программными продуктами на одном предприятии (что необходимо очень часто).
- Улучшенные возможности поиска данных. Во-первых, нет необходимости обращаться к документам разных двоичных форматов, во-вторых, иерархическая структура документов XML облегчает поиск.
- Более простая разработка приложений - нет необходимости реализовывать в приложениях поддержку большого количества разных двоичных форматов данных.
- Данные в текстовом формате (стандарт XML - Unicode) проще, чем двоичные, хранить на различных платформах и безопаснее (с точки зрения отсутствия вредоносного двоичного кода) передавать в сетях. Целое направление в разработке приложений - XML Web-службы.
Well -formed XML - такой код XML , который соответствует требованиям синтаксиса этого языка (например, каждому открывающему тегу соответствует закрывающий тег). Valid XML - корректный с точки зрения логической структуры этого языка (например, элементы правильно вложены друг в друга), определенной в DTD или XML Schema .
Немного по терминологии XML, которая будет использоваться в этом курсе:
·
XSD
- XML
Schema
Definition
, обычно используемое в VS
.NET
описание структуры документа XML. Обычно она размещается в файлах с расширением *.xsd. Внутри схемы используются специальные теги
xmlns:od="urn:schemas-microsoft-com:officedata">
Чтобы внутри схемы определить строковый элемент Last Name, который может встречаться в документе 0 или больше раз, можно, например, использовать следующий тег:
type="string">
· для описания преобразований XML -совместимых документов используются документы на специальном языке программирования XSLT (eXtensible Stylesheet Language Transform). Сам этот язык, конечно, также является XML -совместимым. В XSLT используется три типа документов:
o документ-источник (source document). Этот документ XML "подается на вход" для преобразования. В нашем случае этот может быть такой документ:
xml-stylesheet type="text/xsl" href="Employees1.xsl "?>
o документ таблицы стилей XSLT (XSLT style sheet document) - XML-совместимый документ, в котором описываются правила проведения трансформаций. В нашем случае пример этого документа может быть таким:
xmlns:xsl="http://www.w3.org/1999/XSL/Transform "
version="1.0 ">
o документ - результат преобразований. Например, при применении нашего преобразования имя сотрудника будет помечено красным, а его должность - синим.
· XPath - специальный язык, который можно использовать для навигации по дереву элементов XML . При использовании объектной модели XPath документ XML представляется в виде дерева узлов. Информация содержится в свойствах этих узлов.
· DOM (Document Object Model ) - представление дерева документа XML в оперативной памяти. DOM позволяет выполнять навигацию по документу XML и редактировать его. Стандартные свойства, методы и события DOM определены в документе, принятом W3C. В ASP.NET при помощи DOM можно создать документ XML и отправить его в броузер пользователю. Другой вариант - клиентский скрипт создает при помощи DOM документ XML на клиенте и передает его на Web-сервер.
· XQuery - это специализированный язык запросов к информации, которая хранится в документах XML . Работа XQuery во многом основана на XPath.
Надо сказать, что XML - это стандартный формат для работы с данными в ADO.NET. Про формат XML и как его можно использовать с DataSet - ниже.
Возможности использования XML при работе с DataSet такие:
· DataSet могут сериализовать данные в формате XML. Схема DataSet (включая таблицы, столбцы, типы данных и ограничения) определяется при этом в XML Schema (файл.xsd ).
· обмен данными из DataSet с удаленными клиентами предписывается производить в формате XML;
· XML можно использовать для синхронизации и преобразования данных в DataSet.
Еще немного про взаимодействие XML и DataSet:
· можно не только создавать XML Schema на основе DataSet (о чем говорилось выше, это делается при помощи метода WriteXmlSchema ), но и наоборот - генерировать DataSet на основе информации их XML Schema (для этого - метод ReadXmlSchema ). Есть возможность сгенерировать DataSet даже без схемы - просто на основе документа XML. Для этой цели предназначен метод InferXmlSchema.
· для объекта DataSet предусмотрен метод ReadXML , который позволяет считать текстовый документ XML (поток текстовых данных XML ) в DataSet . Другой метод, WriteXML , позволяет сохранять содержимое DataSet в XML-совместимом формате. Такая возможность позволяет очень просто организовывать обмен данными между различными приложениями и платформами.
· вы можете создать представление XML (объект XmlDataDocument ) на основе информации из DataSet . Получается, что с информацией в DataSet можно работать двумя способами: обычными реляционными (с самим DataSet) и XML-методами. Оба представления автоматически синхронизируются (при внесении изменений через любое представление).
· вы можете применять преобразования XSLT к данным, которые хранятся в DataSet .
Теперь - о том, как все это выглядит на практике.
Dim ds As New DataSet()
ds.ReadXml(Server.MapPath("filename.xml"))
Метод MapPath для специального объекта Server позволяет преобразовать виртуальный путь к файлу в Web-приложении в физический путь.
Будет ли сгенерирована структура DataSet автоматически из файла XML или она останется прежней, зависит от того, была ли она уже сформирована в этом DataSet и от того, был ли указан необязательный параметр метода ReadXml XmlReadMode.
Dim ds As New DataSet()
Dim da As New SqlDataAdapter(_
"select * from Authors", conn)
da.Fill(ds)
ds.WriteXml(Server.MapPath("filename.xml"))
Есть еще два метода, которые позволяют получить из DataSet данные в формате XML и положить их в строковую переменную. Это методы GetXml и GetXmlSchema. Пример может выглядеть так:
Dim strXmlDS As String = ds . GetXml ()
В DataSet часто помещаются объекты DataTable , связанные между собой отношениями DataRelation (то есть таблицы с Primary и Foreign key). При экспорте в XML информация из родительской таблицы может быть дополнена информацией из подчиненной таблицы. Записи из подчиненной таблицы будут выглядеть как вложенные элементы для записей из главной. Чтобы реализовать такую возможность, необходимо для объекта DataRelation в DataSet для свойства Nested установить значение True (по умолчанию False).
предположим, мы просто экспортируем данные без использования этого свойства:
Dim ds As New DataSet()
’fill the DataSet
...
Dim parentCol As DataColumn = _
ds.Tables("Publishers").Columns("pub_id")
Dim childCol As DataColumn = _
ds.Tables("Titles").Columns("pub_id")
ds.Relations.Add(dr)
ds.WriteXml(Server.MapPath("PubTitlesNotNested.xml"), _
XmlWriteMode.IgnoreSchema)
Код XML получается такой:
а теперь используем устанавливаем свойство Nested для объекта DataRelation в True:
Dim dr As New DataRelation _
("TitlePublishers", parentCol, childCol)
dr.Nested = True
ds.Relations.Add(dr)
ds.WriteXML(Server.MapPath("PubTitlesNested.xml"), _
XmlWriteMode . IgnoreSchema )
Код XML получается уже совсем другой. В каждый элемент типа Pub вложены элементы Titles, выпущенные этим издательством:
XmlDataDocument - это XML -представление данных в DataSet в оперативной памяти. XmlDataDocument неразрывно связан с DataSet . Любые изменения, внесенные в XmlDataDocument , немедленно отражаются в DataSet и наоборот. Ниже будет рассказано о приемах работы с XmlDataDocument.
DataSet - это реляционное представление данных, а XmlDataDocument - иерархическое. Применение XmlDataDocument очень удобно, поскольку работать с данными в формате XML только через DataSet бывает сложно. Например, если загрузить данные из файла XML в DataSet, а затем выгрузить обратно, то вполне может получиться так, что файл будет неузнаваем: будет потеряно форматирование, вполне возможно - порядок элементов, возможно, элементы, которые были проигнорированы из-за несоответствия со схемой, определенной для DataSet.
В XmlDataDocument можно положить документ XML напрямую, а можно создать его на основе DataSet. Код для первого варианта может выглядеть так:
Dim objXmlDataDoc As New XmlDataDocument()
objXmlDataDoc.Load(Server.MapPath("file.xml"))
или так:
objXmlDataDoc.DataSet.ReadXml(Server.MapPath("file.xml"))
Разницы никакой не будет.
А можно вначале создать DataSet, заполнить его данными, а затем на основе его создать XmlDataDocument:
Dim ds As New DataSet()
’fill in ds
...
Dim objXmlDataDoc As New XmlDataDocument(ds)
После того, как объект XmlDataDocument создан, с ним можно выполнять различные действия:
· привязывать к DataGrid и другим элементам управления:
dg.DataSource = objXmlDataDoc.DataSet
· получать нужную строку (она возвращается в виде объекта XmlElement):
Dim elem As XmlElement
elem = objXmlDataDoc.GetElementFromRow _
(ds.Tables(0).Rows(1))
· использовать полный набор свойств и методов DOM. Эти свойства и методы XmlDataDocument наследует от объекта XmlDocument
· применять преобразования XSLT (для этой цели используются объекты XslTransform ).
Подробнее о преобразованиях средствами XSLT:
XSLT позволяет преобразовать исходный документ XML в другой документ, отличающийся по формату и структуре. Например, при помощи XSLT документ XML можно преобразовать к код HTML для отображения в Web-приложении. В ASP.NET для выполнения преобразований XSLT используется класс XslTransform .
Как выглядит работа с ним?
· для проведения преобразований вначале нужно создать DataSet и соответствующий ему XmlDataDocument :
Dim ds As New DataSet()
’fill in DataSet
...
Dim xmlDoc As New XmlDataDocument(ds)
· следующее действие - создаем объект XslTransform:
Dim xslTran As New XslTransform()
· используем метод Load этого объекта, чтобы загрузить в него преобразование:
xslTran.Load(Server.MapPath("PubTitles.xsl"))
· создаем объект XmlTextWriter (он будет использован для вывода результатов преобразования):
Dim writer As New XmlTextWriter _
(Server.MapPath("PubTitles_output.html"), _
System.Text.Encoding.UTF8)
· выполняем само преобразование при помощи метода Tr ansform объекта XslTransform . У этого метода - несколько вариантов. Один из вариантов его применения может выглядеть так:
xslTran.Transform(xmlDoc, Nothing, writer)
· закрываем объект Writer:
writer.Close()
Для работы с XML на Web -форме можно обойтись и совсем без объекта DataSet (и элементов управления, предназначенных для отображения данных из реляционного источника). Вместо этого можно использовать элемент управления XML Web Server Control . Он позволяет выводить на Web-странице сами документы XML или результаты их преобразований. Код XML можно передавать этому элементу управления разными способами:
· напрямую открывать их с диска (через свойство DocumentSource ). В этом случае (если вы не применили преобразования XSLT) документ XML будет выведен на форму "как есть":
XML Example
TransformSource="MyStyle.xsl" runat="server" />
· открывать их как объекты и передавать их этому элементу управления (через свойство Document ). В нашем случае XML Web Server Control называется Xml1 :
Private Sub Page_Load(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles MyBase.Load
Dim xmlDoc As System.Xml.XmlDocument = _
New System.Xml.XmlDocument()
xmlDoc.Load(Server.MapPath("MySource.xml"))
Dim xslTran As System.Xml.Xsl.XslTransform = _
New System.Xml.Xsl.XslTransform()
xslTran.Load(Server.MapPath("MyStyle.xsl"))
Xml1.Document = xmlDoc
Xml1.Transform = xslTran
End Sub
· просто программным образом генерировать код XML и передавать этот код XML Web Server Control (через свойство DocumentContent )
· вообще напрямую вписать код XML в тег XML Web Server Control:
· выполнить преобразование и передать ему результаты преобразования
Пример, который иллюстрирует все эти возможности, представлен ниже:
Document="XmlDocument object to display"
DocumentContent="String of XML"
DocumentSource="Path to XML Document"
Transform="XslTransform object"
TransformSource="Path to XSL Transform Document"
runat =" server ">
Добавить XML Web Server Control на Web -форму можно просто перетаскиванием этого элемента управления из ToolBox или программно:
< asp : Xml id =" xmlCtl " runat =" server " />
XmlCtl . Document . Save (Server . MapPath (" xmlResult . xml "))
Язык - не сын, а отец мысли.
Оскар Уайльд
Аббревиатура XML расшифровывается как Extensible Markup Language, в переводе «расширяемый язык разметки». Как и язык HTML, он является подмножеством SGML (Standard General Markup Language) - «дедушки» языков разметки. Мы уже не раз сталкивались с форматом XML. Таков формат конфигурационных файлов, файла описания объектных источников данных.
XML - это универсальный, независящий от платформы стандарт описания информациии, который можно использовать для представления иерархических данных и унификации передаваемой информации. Без его знания невозможно понимание SOAP и следовательно, веб-сервисов. XML стал де-факто стандартом передачи данных в сети Интернет. Стандарт XML и связанных с ним форматов определяется консорциумом W3C(World Wide Web Consortium). Например, мы создаем aspx страницы в формате XHTML - переходном между HTML и XML, стандарт которого тоже определен W3C. Стандарт XHTML налагает более строгие правила на правильное формирование документа, аналогичные правилам XML.
Давайте поймем главное отличие XML от HTML. XML создан для описания данных и фокусируется на том, что именно они из себя представляют. HTML создан для демонстрации данных и фокусируется на том, как данные выглядят. Если в традиционном HTML понятия «представление» и «визуализация» часто смешиваются, то при работе с XML мы четко разделяем эти понятия. Теги XML не предопределены создателями языка, в отличие от тегов HTML. Каждый автор документа сам определяет собственные теги.
Стандарт требует, чтобы программа, которая обрабатывает XML-документ, должна остановить работу, если обнаружила ошибку. А если браузер обнаружит непонятный тег в HTML, или отсутствие закрывающего тега, он это просто игнорирует.
В начале XML-документа обязательно появляется его декларация, или пролог. В нем указывается версия стандарта XML, которому он соответствует.
является ошибкой в XML.
У тегов могут быть атрибуты. Значения атрибутов должны быть заключены в кавычки. Порядок атрибутов значения не имеет. Между открывающим и закрывающими тегами может находится текст. В XML сохраняются все пробелы, находящиеся в тексте. Если текста нет, можно применить сокращенную форму записи. Пример тега XML:
| |
Это краткая форма тега
| |
Вам это ничего не напоминает? Правила описания элементов ASP.NET точно такие же.
Существует атрибут xmlns, который определяет пространство имен. Значением его может быть любое уникальное имя. Существует договоренность использовать URL, так как они уникальны. Пространства имен имеют смысл, аналогичный их применению в.NET Framework - чтобы не смешивать одинаковые имена, используемые разными разработчиками. Название пространства имен отделяется от имени двоеточием.
XML-файлы представляют иерархическую информацию, которую можно представить в виде дерева с одним корнем.
Документы XML, удовлетворяющие всем требованиям синтаксиса, называют правильными (well-formed). Для описания данных XML использует DTD (Document Type Definition) - определение типа документа. Если файл соответствует DTD, он считается действительным (valid) .
Браузеры IE 6.0, FireFox 1.5 отображают XML-файлы с выделением синтаксиса. Родительские узлы можно раскрывать и закрывать. Например, в закрытом виде корневой узел файла BirthDay.xml выглядит так:
Среды разработки Visual Studio и VWD Express проверяют правильность xml-документов прямо во время редактирования.
AdRotator
Элемент управления AdRotator позволяет показывать рекламные баннеры и автоматически заменять их на другие. Сами баннеры описаны в файле XML или другом источнике данных. Реклама обновляется каждый раз при обновлении страницы. В свойстве AdvertismentFile задается имя XML-файла. Скелет XML-файла таков.
|
|
Внутри узла Advertisements располагаются узлы
У этих узлов имеются 5 атрибутов, все они необязательны.
Пример файла AdvertismentFile, он называется ads.xml.
|
|
На страницу помещен элемент управления. Его свойство AdvertisementFile указывает на этот файл.
| |
Если установлено свойство Keyword, то элемент управления показывает только ту рекламу, которая соответствует его содержанию. Так как его можно менять динамически, можно подстраивать рекламу под нужды пользователя. Keyword должен встречаться хотя бы раз в файле объявлений, иначе вместо рекламы будет пустой прямоугольник.
В предыдущих версиях ASP.NET можно было работать только с файлами XML. Теперь можно использовать любой источник данных, связавшись с элементом управления-источником данных. В таком случае необходимо указать как минимум 3 поля источника в свойствах ImageUrlField, NavigateUrlField и AlternateTextField.
| |
Файлы преобразования документа
Известно, что для форматирования HTML-файлов часто используются CSS (Cascading Stylesheets), хотя это необязательно, так как браузеры соотносят со всеми тегами определенный внешний вид. Элемент
Задает параграф, - полужирный шрифт - браузер знает, как их показывать.
Поскольку XML не использует изначально заданные теги, их значение может быть каким угодно:
|
Чтобы внести в выходной поток XSLT-преобразования каждый XML-элемент, применяется тег XSL xsl:for-each. Элемент:for-each определяет местоположение элементов в XML-документе и повторяет шаблон для каждого из них.
Данные можно отсортировать с помощью тега xsl:sort, который должен находиться внутри элемента xsl:for-each:
Окончательный вид файла трансформации:
Известные цитаты
|
Если хотите увидеть результат преобразования документа в браузере, включите после XML-декларации объявление
| , |
или выберите в меню XML пункт Show XML Output и определите файл преобразования.
Тот же самый XML-документ можно преобразовать с помощью другого XSL-файла:
Мастера Афоризма |
В результате будет выводиться цитаты, разделенные горизонтальной линией.
Файлы определения схемы документа
Согласно современному стандарту, валидный документ должен соответствовать связанному с ним файлу XSD (XML Schema Definition) - файлу определения схемы XML, который определяет конкретный язык, то есть описывает, какие элементы и типы могут появляться в документе. Схемы XSD призваны заменить DTD (Document Type Definition), разница между ними заключается в том, что файлы XSD сами тоже используют синтаксис XML. Схемы XSD позволяют определить, какие теги разрешены, обязательны они или нет, могут ли повторяться в документе и так далее. Таким образом, XML описывает данные, а XSD - структуру этих данных, или метаданные. В терминах программирования, XSD - описание типов, в то время как в XML-файле описаны объекты этих типов. По адресу http://www.w3.org/TR/2003/WD-xmlschema-11-req-20030121/ находится рабочий проект стандарта XSD 1.1.
Файл описания схемы начинается с описания префикса пространства имен, который включается затем во все элементы этого файла. Адрес http://tempuri.org предназначается для задания URI для пространств имен ASP.NET .
Например, это определение задает, что элемент "Author" строкового типа, должен появляться один и только один и раз, и если он не указан, то принимает значение "Пушкин".
| |
Параметр maxOccurs="unbounded" указывает, что элемент может встречаться любое количество раз.
Параметр ref позволяет ссылаться на уже описанный в данном файле глобальный элемент или атрибут, чтобы избежать повторного описания одних и тех же элементов.
- определить простые и сложные типы.
В XSD есть предопределенные типы - примерно такие же, как в.NET. Во время работы приложения они преобразуются в типы.NET. На их основании можно строить сложные типы, похожие на структуры языков программирования. Сложный тип состоит из последовательности описаний элементов. Определим сложный тип
| |
Тег
Тег
В следующем примере определен простой тип, вложенный в определение элемента MyValue.
- Добавлять новые группы и группы атрибутов.
В определении сложного типа могут фигурировать атрибуты. Предположим, мы хотим построить схему такого файла:
Атрибуты могут быть только простых типов.
- Добавлять аннотации.
Аннотации позволяют вставлять описание существующих элементов, таким образом в файл добавляется документация.
| |
Редактировать XSD-файлы в Visual Studio 2005 можно и через исходный код, и с помощью дизайнера. Для XML-документа можно автоматически сгенерировать соответсвующую ему схему. В окне свойств XML-документа можно задать как файл схемы, так и файл преобразования. В таком случае студия автоматически проверяет файл на соответствие схеме, и даже IntelliSense подставляет теги из этого файла.
Класс XmlReader
С помощью класса XmlReader можно быстрее, чем другими методами, получить данные из XML-документов.
XmlReader - это абстрактный класс. Чтобы начать чтение, в статический метод Create передается объект класса XmlReaderSettings. Эта функция подсчитывает число узлов в документе.
| using System.Xml; using System.IO; private int CountNodes(string xmlFile) { int NodesCount=0; XmlReaderSettings settings = new XmlReaderSettings(); settings.IgnoreWhitespace = true; settings.IgnoreComments = true; using (XmlReader reader = XmlReader.Create(xmlFile, settings)) { while (reader.Read()) { if (reader.NodeType == XmlNodeType.Element) { NodesCount++; } } } return NodesCount; } |
Класс XmlReader позволяет извлекать из документа классы CLR. Пусть у нас есть меню ресторана.
Напишем функцию, которая посчитает сумму цен и количества калорий в меню.
| protected void Page_Load(object sender, EventArgs e) { int ItemsCount = 0; decimal DishesTotal = 0; UInt16 CaloriesTotal = 0; XmlReaderSettings settings = new XmlReaderSettings(); settings.IgnoreWhitespace = true; NameTable nt = new NameTable(); object food = nt.Add("food"); object price = nt.Add("price"); object calories = nt.Add("calories"); settings.NameTable = nt; string MenuFile = Path.Combine(Request.PhysicalApplicationPath, "menu.xml"); using (XmlReader reader = XmlReader.Create(MenuFile, settings)) { while (reader.Read()) { if (reader.NodeType == XmlNodeType.Element && food.Equals(reader.LocalName)) { ItemsCount++; } if (reader.NodeType == XmlNodeType.Element && price.Equals(reader.LocalName)) { DishesTotal += (UInt16)reader.ReadElementContentAsDecimal(); } if (reader.NodeType == XmlNodeType.Element && calories.Equals(reader.LocalName)) { CaloriesTotal += (UInt16)reader.ReadElementContentAsInt(); } } } Response.Write(String.Format("Вы заказали {0} блюда на сумму {1:C}, {2} калорий", ItemsCount, DishesTotal, CaloriesTotal)); } |
Класс XPathDocument
Класс обеспечивает чтение и хранение в памяти XML-документов для трансформаций с помощью XSL. По документу можно перемещаться в любом направлении и получать произвольный доступ к любому элементу, используя выражения XPath.
Возьмем XML-документ "Quotes.xml"и файл трансформации XSL "Quotes.xsl". В выходной поток страницы будет направлен результат преобразования XML-документа.
| <% XPathDocument doc = new XPathDocument(Server.MapPath("App_Data\\Quotes.xml")); XslCompiledTransform xsl = new XslCompiledTransform(); xsl.Load(Server.MapPath("App_Data\\Quotes.xsl")); xsl.Transform(doc, null, Response.OutputStream); %> |
Благодаря тому, что в файле трансформации определены табличные теги, на странице появится таблица с нужной информацией.
Элемент управления XML
Элемент управления XML предоставляет способ преобразовать XML-документ, используя таблицу стилей XSL. Свойство DocumentSource позволяют задать XML-файл, в котором находятся данные, TransformSource - файл трансформации XSLT.
В предыдущем примере того же результата можно достичь, если поставить на странице элемент управления XML.
| |
XMLDataSource
Элемент -источник данных XMLDataSource обеспечивает простой способ подключения XML-документов как источников данных к элементам, отображающим информацию. Также можно задать запрос XPath для того, чтобы отфильтровать данные. Как и SqlDataSource, он позволяет редактировать, удалять, добавлять записи данных. Для этого нужно получить доступ к находящемуся в нем объекту XmlDataDocument с помощью вызова метода GetXmlDocument. После редактирования документ сохраняется с помощью метода Save.
В отличие от табличных данных в СУБД, данные в XML-файлах иерархичны, поэтому XMLDataSource удобно привязывать к иерархичным элементам управления, например Menu.
Синтаксис привязки к данным XML
Так как в приложениях XML-данные используются все чаще и чаще, был введен метод привязки данных, полученных из XMLDataSource.
Эти методы работают так же, как Bind и Eval, которые обсуждались в 7 лекции.
Применим этот синтаксис в элементе DataList, который получает данные из источника данных XmlDataSource:
Заключение
В этой лекции мы рассмотрели работу с данными типа XML. XML предоставляет универсальный способ для описания и обмена структурированной информацией, независимо от приложений и разработчиков. На этом завершили рассмотрение работы с источниками данных.
В первой статье в блоге .NET «Работаем с XML » в комментариях народ потребовал статьи LINQ to XML. Что же, попробуем раскрыть принципы работы этой новой технологии от Microsoft.
Создадим базу для ведения каталога аудиозаписей. База будет состоять из треков:
- Название
- Исполнитель
- Альбом
- Продолжительность
Для начала создадим консольное приложение (я пишу свои проекты на C#, но суть в общем-то понятна будет всем) и подключим необходимое пространство имен
Using System.Xml.Linq;
Создание файлов XML
Создадим XML файл нашей базы содержащий несколько тестовых записей уже при помощи LINQ:
//задаем путь к нашему рабочему файлу XML string fileName = "base.xml"; //счетчик для номера композиции int trackId = 1; //Создание вложенными конструкторами. XDocument doc = new XDocument(new XElement("library", new XElement("track", new XAttribute("id", trackId++), new XAttribute("genre", "Rap"), new XAttribute("time", "3:24"), new XElement("name", "Who We Be RMX (feat. 2Pac)"), new XElement("artist", "DMX"), new XElement("album", "")), new XElement("track", new XAttribute("id", trackId++), new XAttribute("genre", "Rap"), new XAttribute("time", "5:06"), new XElement("name", "Angel (ft. Regina Bell)"), new XElement("artist", "DMX"), new XElement("album", "...And Then There Was X")), new XElement("track", new XAttribute("id", trackId++), new XAttribute("genre", "Break Beat"), new XAttribute("time", "6:16"), new XElement("name", "Dreaming Your Dreams"), new XElement("artist", "Hybrid"), new XElement("album", "Wide Angle")), new XElement("track", new XAttribute("id", trackId++), new XAttribute("genre", "Break Beat"), new XAttribute("time", "9:38"), new XElement("name", "Finished Symphony"), new XElement("artist", "Hybrid"), new XElement("album", "Wide Angle")))); //сохраняем наш документ doc.Save(fileName);
Теперь в папке с нашей программой после запуска появится XML файл следующего содержания:
Для создания подобного файла средствами XmlDocument кода понадобилось где-то раза в 2 больше. В коде выше мы воспользовались конструктором класса XDocument, который принимает в качестве параметра перечень дочерних элементов, которыми мы изначально хотим инициализировать документ. Используемый конструктор XElement принимает в качестве параметра имя элемента, который мы создаем, а так же перечень инициализирующих элементов. Удобно то, что мы в этих элементах можем задавать как новые XElement, так и XAttribute. Последние отрендретятся в наш файл как атрибуты самостоятельно. Если вам не нравится использоваться такую вложенность конструкторов и вы считаете такой код громоздким, то можно переписать в более традиционный вариант. Код ниже даст на выходе аналогичный XML файл:
XDocument doc = new XDocument();
XElement library = new XElement("library");
doc.Add(library);
//создаем элемент "track"
XElement track = new XElement("track");
//добавляем необходимые атрибуты
track.Add(new XAttribute("id", 1));
track.Add(new XAttribute("genre", "Rap"));
track.Add(new XAttribute("time", "3:24"));
//создаем элемент "name"
XElement name = new XElement("name");
name.Value = "Who We Be RMX (feat. 2Pac)";
track.Add(name);
//создаем элемент "artist"
XElement artist = new XElement("artist");
artist.Value = "DMX";
track.Add(artist);
//Для разнообразия распарсим элемент "album"
string albumData = "
Естественно выбирать необходимый способ нужно по ситуации.
Чтение данных из файла
//задаем путь к нашему рабочему файлу XML string fileName = "base.xml"; //читаем данные из файла XDocument doc = XDocument.Load(fileName); //проходим по каждому элементу в найшей library //(этот элемент сразу доступен через свойство doc.Root) foreach (XElement el in doc.Root.Elements()) { //Выводим имя элемента и значение аттрибута id Console.WriteLine("{0} {1}", el.Name, el.Attribute("id").Value); Console.WriteLine(" Attributes:"); //выводим в цикле все аттрибуты, заодно смотрим как они себя преобразуют в строку foreach (XAttribute attr in el.Attributes()) Console.WriteLine(" {0}", attr); Console.WriteLine(" Elements:"); //выводим в цикле названия всех дочерних элементов и их значения foreach (XElement element in el.Elements()) Console.WriteLine(" {0}: {1}", element.Name, element.Value); }
Здесь в коде, думаю, ничего сложного нету и приведены комментарии. После запуска нашей программый в консоли отобразится следующий результат:
Track 1 Attributes: id="1" genre="Rap" time="3:24" Elements: name: Who We Be RMX (feat. 2Pac) artist: DMX album: The Dogz Mixtape: Who"s Next?! track 2 Attributes: id="2" genre="Rap" time="5:06" Elements: name: Angel (ft. Regina Bell) artist: DMX album: ...And Then There Was X track 3 Attributes: id="3" genre="Break Beat" time="6:16" Elements: name: Dreaming Your Dreams artist: Hybrid album: Wide Angle track 4 Attributes: id="4" genre="Break Beat" time="9:38" Elements: name: Finished Symphony artist: Hybrid album: Wide Angle
Изменение данных
Попробуем пройтись по всем узлам library и увеличить аттрибут Id элемента track на 1.
(дальше писать объявление пути к файлу и результат вывода в консоль я приводить не буду, чтобы не перегружать лишней информацией статью, все компилировал, все работает:))
:
//Получаем первый дочерний узел из library XNode node = doc.Root.FirstNode; while (node != null) { //проверяем, что текущий узел - это элемент if (node.NodeType == System.Xml.XmlNodeType.Element) { XElement el = (XElement)node; //получаем значение аттрибута id и преобразуем его в Int32 int id = Int32.Parse(el.Attribute("id").Value); //увеличиваем счетчик на единицу и присваиваем значение обратно id++; el.Attribute("id").Value = id.ToString(); } //переходим к следующему узлу node = node.NextNode; } doc.Save(fileName);
Теперь попробуем это сделать более правильным способом для наших задач:
Foreach (XElement el in doc.Root.Elements("track")) { int id = Int32.Parse(el.Attribute("id").Value); el.SetAttributeValue("id", --id); } doc.Save(fileName);
Как видим – этот способ нам подошел больше.
Добавление новой записи
Добавим новый трек в нашу библиотеку, а заодно вычислим средствами LINQ следующий уникальный Id для трека:
Int maxId = doc.Root.Elements("track").Max(t => Int32.Parse(t.Attribute("id").Value)); XElement track = new XElement("track", new XAttribute("id", ++maxId), new XAttribute("genre", "Break Beat"), new XAttribute("time", "5:35"), new XElement("name", "Higher Than A Skyscraper"), new XElement("artist", "Hybrid"), new XElement("album", "Morning Sci-Fi")); doc.Root.Add(track); doc.Save(fileName);
Вот таким подним запросом ко всем элементам вычисляется максимальное значение аттрибута id у треков. При добавлении полученное максимальное значение инкрементируем. Само же добавление элемента сводится к вызову метода Add. Обратите внимание, что добавляем элементы в Root, так как иначе нарушим структуру XML документа, объявив там 2 корневых элемента. Так же не забывайте сохранять ваш документ на диск, так как до момента сохранения никакие изменения в нашем XDocument не отразятся в XML файле.
Удаление элементов
Попробуем удалить все элементы исполнителя DMX:
IEnumerable
В этом примере мы вначале выбрали все треки у который дочерний элемент artst удовлетворяет критерии, а потом в цикле удалили эти элементы. Важен вызов в конце выборки ToList(). Этим самым мы фиксируем в отдельном участке памяти все элементы, которые хотим удалить. Если же мы надумаем удалять из набора записей, по которому проходим непосредственно в цикле, мы получим удаление первого элемента и последующий NullReferenceException. Так что важно помнить об этом.
По совету xaoccps удалять можно и более простым способом:
IEnumerable
В этом случае приводить к списку наш полученный результат вызовом функции ToList() не нужно. Почему этот способ не использовал изначально описал в
