Прайс-лист

Процессоры

Видеокарты

Жесткие диски

Это только небольшая часть того, что можно делать с помощью XSL.

Программная обработка XML в C#

Для обработки текста XML заранее известного формата совсем не сложно написать собственный обработчик (parser). Однако существуют стандартные средства работы с XML.

Способы работы с XML можно разделить на две больших группы:

1) Объектные модели документа

В этих обработчиках документ загружается в память в виде набора объектов, с помощью методов котоырх можно получать доступ к данным в XML-документе. Самой известной из таких моделей является DOM (Document Object Model), в которой XML-документ представляется в виде дерева.

Объектные модели удобны, когда нужно обеспечивать произвольный доступ к узлам в XML-документе, использовать сложные фильтры, создавать новые XML-документы в памяти.

2) Синтаксические анализаторы, последовательно обрабатывающие документы

Обработчики этой группы последовательно обходят тэги XML-текста, считывают данные и выполняют необходимые действия. Для такой обработки XML-файлов существует стандарт SAX (Simple API for XML).

Такой способ обработки документов удобен для извлечения неболших фрагментов информации из документа, при обработке больших документов (поскольку не нужно полностью загружать документ в память) и когда нужно иметь возможность остановить обработки документа в случае ошибки.

В C# классы для работы с XML находятся в пространстве имен System.Xml

Последовательное чтение Xml файла удобно производить с помощью XmlTextReader. Рассмотрим пример чтения и записи файла этими способами.

public class XPriceListItem

{

string _category;

public string Category

{

get { return _category; }

set { _category = value; }

}

string _name;

public string Name

{

get { return _name; }

set { _name = value; }

}

decimal _price;

public decimal Price

{

get { return _price; }

set { _price = value; }

}

public XPriceListItem(XmlReader r)

{

if (r.LocalName == "Item")

{

_category = r.GetAttribute("Category");

// Читаем открывающий тэг Item

r.ReadStartElement();

// Читаем название товара как строку

_name = r.ReadElementString();

// А цену, как число

_price = r.ReadElementContentAsDecimal();

// Читаем закрывающий тэг Item

r.ReadEndElement();

}

}

public void Save(XmlWriter w)

{

w.WriteStartElement("Item");

w.WriteAttributeString("Category", _category);

w.WriteElementString("Product", _name);

// Используем InvariantInfo, чтобы разделитель был всегда точка

w.WriteElementString("Price", _price.ToString(NumberFormatInfo.InvariantInfo));

w.WriteEndElement();

}

}

class XPriceList : List<XPriceListItem>

{

public void Load(string filename)

{

// Создаем читателя для чтения из xml-файла

XmlTextReader r = new XmlTextReader(filename);

// Игнорируем пробелы и символы табуляции

r.WhitespaceHandling = WhitespaceHandling.None;

Load(r);

r.Close();

}

public void Save(string filename)

{

// Создаем писателя для записи в xml-файл

XmlTextWriter w = new XmlTextWriter(filename, Encoding.Unicode);

// Указываем, что нужно делать отступы и переносы на новую строку

// иначе весь xml будет одной строкой

w.Formatting = Formatting.Indented;

Save(w);

w.Close();

}

void Load(XmlReader r)

{

// Читаем <PriceList>

r.ReadStartElement("PriceList");

// Читаем элементы, пока не дойдем до закрывающего тэга

while (r.LocalName != "PriceList")

{

this.Add(new XPriceListItem(r));

}

}

void Save(XmlWriter w)

{

// Пишем первый тэг - где указывается версия xml и

w.WriteStartDocument();

// Указываем связь с таблицей стилей

w.WriteProcessingInstruction("xml-stylesheet", "type=\"text/xsl\" href=\"price2.xsl\"");

w.WriteStartElement("PriceList");

// Поэлементно пишем

foreach (XPriceListItem item in this)

{

item.Save(w);

}

w.WriteEndDocument();

}

}

class Program

{

static void PrintPriceItems(XmlNodeList nl)

{

XmlNode n;

for (int i = 0; i < nl.Count; i++)

{

n = nl[i];

// Распечатываем значение категории и дочерних узлов

Console.Write(n.Attributes["Category"].Value + " ");

Console.Write(n.ChildNodes[0].InnerText + ", ");

Console.WriteLine(n.ChildNodes[1].InnerText + "$");

}

}

static void Main(string[] args)

{

// Загружаем прайс-лист из одного файла

XPriceList p = new XPriceList();

p.Load("price.xml");

// И сохраняем в другом

p.Save("price2.xml");

// Загружаем что получилось другим способом

// Создаем Xml-документ

XmlDocument xmlDoc = new XmlDocument();

// Загружаем документ из файла

xmlDoc.Load("price2.xml");

// Получаем все дочерние узлы для узла PriceList

XmlNodeList zItems = xmlDoc["PriceList"].ChildNodes;

Console.WriteLine("Весь документ");

PrintPriceItems(zItems);

Console.ReadLine();

// Находящийся в памяти документ можно изменять,

// вызывая соответствующие методы

// Сохранить xmlDoc можно просто вызывав метод xmlDoc

// Открываем получившийся файл

Process.Start("price2.xml");

}

}

XPath

XPath используется для обращения к элементам внутри XML-документа. Выражения XPath используются в других технологиях XML для обращения к узлам (например, при указании уникальных значений в XSD). В C# с помощью xpath можно получать набор узлов из XML документа.

// Получаем все дочерние узлы для узла PriceList (все тэги Item)

// XmlNodeList items = zXmlDoc.SelectNodes(@"/PriceList/Item");

Console.WriteLine();

Console.WriteLine("Все тэги второго уровня");

PrintPriceItems(xmlDoc.SelectNodes(@"//Item"));

Console.ReadLine();

Console.WriteLine();

Console.WriteLine("Все процессоры");

PrintPriceItems(xmlDoc.SelectNodes(@"//Item[@Category='Процессоры']"));

Console.ReadLine();

// Получаем все узлы Item с ценой < 200

Console.WriteLine();

Console.WriteLine("Товары с ценой < 200");

PrintPriceItems(xmlDoc.SelectNodes(@"//Item[Price < 200.0]"));

Console.ReadLine();

Схемы XSD

Схемы XSD (XML Schema Definition) определяют ограничения на формат XML файла. Сама схема XSD также является xml-файлом специального формата. XSD описывают структуру документа, а также другие ограничения – уникальность полей, типы данных используемые в значениях и т.д. Для примера с прайсом XSD схема будет выглядеть так:

<?xml version="1.0" encoding="windows-1251"?>

<xs:schema id="price" targetNamespace="urn:price-schema" elementFormDefault="qualified" xmlns="urn:price-schema" xmlns:mstns="urn:price-schema" xmlns:xs="http://www.w3.org/2001/XMLSchema">

<xs:element name="PriceList">

<xs:complexType>

<!--PriceList содержит последовательность тэгов Item кол-вом от 1 до бесконечности-->

<xs:sequence minOccurs="1" maxOccurs="unbounded">

<xs:element name="Item">

<xs:complexType>

<xs:sequence>

<xs:element name="Product" type="xs:string"/>

<xs:element name="Price" type="xs:decimal"/>

</xs:sequence>

<!-- Поле Category должно быть заполнено-->

<xs:attribute name="Category" type="xs:string" use="required" />

</xs:complexType>

</xs:element>

</xs:sequence>

</xs:complexType>

<!-- Поле Product во всех позициях прайса должно быть уникальным

для указания элементов используется XPath-->

<xs:unique name="ItemUnique">

<xs:selector xpath="mstns:Item" />

<xs:field xpath="mstns:Product" />

</xs:unique>

</xs:element>

</xs:schema>

Чтобы связать документ со схемой, в корневом тэге XML-документа нужно указать пространство имен.

<PriceList xmlns="urn:price-schema">

Такой атрибут тэга означает, что будет использоваться пространство имен urn:price-schema. Вообще, пространства имен используются, чтобы обеспечить уникальность тэгов с помощью префиксов.

Для того, чтобы проверить документ на соответствие схеме, в C# используется проверяющий (validating) reader.

// Создаем обычный reader

XmlTextReader r = new XmlTextReader(@"price.xml");

// Игнорируем пробелы и символы табуляции

r.WhitespaceHandling = WhitespaceHandling.None;

try

{

// Создаем проверяющий reader

XmlValidatingReader v = new XmlValidatingReader(r);

// Указываем для него схему

v.Schemas.Add("urn:price-schema", "price.xsd");

...

}

// Отлавливаем ошибки несоответствия схеме XSD

catch (Exception ex)

{

Console.WriteLine("Несоответствие схеме: " + ex.Message);

}

Для загрузки документа в виде объектной модели, также используется проверяющий reader. На этом примере также будет продемонстрирован альтернативный способ проверки ошибок соответствия схеме – через обработчик событий.

public void ValidationError(object Sender, ValidationEventArgs e)

{

Console.WriteLine("Несоответствие схеме: " + e.Message);

}

public void DocumentValidatingReader()

{

// Создаем проверяющий reader

XmlTextReader r = new XmlTextReader("price.xml");

XmlValidatingReader v = new XmlValidatingReader(zReader);

zValidatingReader.Schemas.Add("urn:price-schema", "price.xsd");

// Альтернативный способ обработки ошибок несоответствия схеме

// обработчик событий

v.ValidationEventHandler += new ValidationEventHandler(ValidationError);

// Создаем документ, читая его с помощью проверяющего reader'а

XmlDocument zXmlDoc = new XmlDocument();

zXmlDoc.Load(r);

// ...

}

Поскольку для связи с XSD мы использовали пространство имен, то для использования XPath необходимо его указать.

// Создаем Xml-документ

XmlDocument zXmlDoc = new XmlDocument();

// Загружаем документ из файла

zXmlDoc.Load("price.xml");

// Поскольку мы используем xsd с помощью пространства имен,

// то нужно указать префикс для используемого пространства

XmlNamespaceManager nm = new XmlNamespaceManager(zXmlDoc.NameTable);

nm.AddNamespace("ps", "urn:price-schema");

XmlNodeList items = zXmlDoc.SelectNodes(@"//ps:Item[ps:Price<200]", nm);

Сериализация в XML

.NET содержит специальные классы, автоматизирующие сохранение объектов в XML

Немного изменим классы из предыдущих примеров:

public class XPriceListItem

{

string _category;

// С помощью XmlAttribute можно указать что, свойство Category должно

// быть вынесено в атрибут xml-тега

// Аналогично можно управлять сериализацией с помощью других атрибутов

[XmlAttribute("Category")]

public string Category

{

get { return _category; }

set { _category = value; }

}

string _name;

public string Name

{

get { return _name; }

set { _name = value; }

}

decimal _price;

public decimal Price

{

get { return _price; }

set { _price = value; }

}

public XPriceListItem(string category, string name, decimal price)

{

_category = category;

_name = name;

_price = price;

}

// Пустой конструктор необходим при десериализации

public XPriceListItem()

{

_category = "";

_name = "";

_price = 0;

}

public override string ToString()

{

StringBuilder sb = new StringBuilder();

sb.Append(_category);

sb.Append(" ");

sb.Append(_name);

sb.Append(" ");

sb.Append(_price);

return sb.ToString();

}

}

public class XPriceList : List<XPriceListItem>

{

}

class Program

{

static XPriceList FillPriceList()

{

XPriceList pl = new XPriceList();

pl.Add(new XPriceListItem("Процессор", "Core 2 Duo 2.0 Ghz", 100));

pl.Add(new XPriceListItem("Процессор", "Core 2 Duo 2.2 Ghz", 120));

pl.Add(new XPriceListItem("Процессор", "Athlon X2 4000+", 40));

pl.Add(new XPriceListItem("Видеокарта", "GeForce 8800 512Mb", 400));

pl.Add(new XPriceListItem("Жесткий диск", "OCZ Summit 250Gb SSD (MLC)", 900));

return pl;

}

static void Main(string[] args)

{

XPriceList priceList = FillPriceList();

XmlSerializer s = new XmlSerializer(typeof(XPriceList));

Console.WriteLine("Сохранение xml в файле...");

using (FileStream fs = new FileStream("price.xml", FileMode.Create))

{

s.Serialize(fs, priceList);

}

Console.WriteLine("Сохранили");

Console.WriteLine();

XPriceList readPriceList = null;

Console.WriteLine("Читаем то, что сохранили");

using (FileStream fs = new FileStream("price.xml", FileMode.Open))

{

readPriceList = (XPriceList)s.Deserialize(fs);

}

foreach (XPriceListItem plItem in readPriceList)

{

Console.WriteLine(plItem.ToString());

}

Console.ReadLine();

}

}

В результате получится вот такой файл:

<?xml version="1.0"?>

<ArrayOfXPriceListItem xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">

<XPriceListItem Category="Процессор">

<Name>Core 2 Duo 2.0 Ghz</Name>

<Price>100</Price>

</XPriceListItem>

<XPriceListItem Category="Процессор">

<Name>Core 2 Duo 2.2 Ghz</Name>

<Price>120</Price>

</XPriceListItem>

<XPriceListItem Category="Процессор">

<Name>Athlon X2 4000+</Name>

<Price>40</Price>

</XPriceListItem>

<XPriceListItem Category="Видеокарта">

<Name>GeForce 8800 512Mb</Name>

<Price>400</Price>

</XPriceListItem>

<XPriceListItem Category="Жесткий диск">

<Name>OCZ Summit 250Gb SSD (MLC)</Name>

<Price>900</Price>

</XPriceListItem>

</ArrayOfXPriceListItem>

Теория компиляции. Введение в компиляцию

Компилятор – это программа, которая считывает текст программы, написанный на одном языке – исходном, и транслирует (переводит) его в эквивалентный текст на другом языке – целевом.

Компиляция состоит из двух частей: анализа и синтеза. Анализ – это разбиение исходной программы на составные части и создание ее промежуточного представления. Синтез – конструирование требуемой целевой программы из промежуточного представления.

Многие программные инструменты, работающие с исходными программами, сначала выполняют определенный вид анализа. Рассмотрим примеры таких инструментов.