Метод GetObjectData() вызывается форматером автоматически при выполнении сериализации. Реализация данного метода подразумевает заполнение объекта SerializationInfo набором данных вида «ключ-значение», которые (обычно) соответствуют полям сохраняемого объекта. Класс SerializationInfo содержит несколько перегруженных версий метода AddValue(), а также свойства для указания имени типа, имени сборки и т.п. Фрагмент определения класса SerializationInfo приведен ниже:
public sealed class SerializationInfo {
public SerializationInfo(Type type,
IFormatterConverter converter);
public string AssemblyName { get; set; }
public string FullTypeName { get; set; }
public int MemberCount { get; }
public void AddValue(string name, short value);
public void AddValue(string name, UInt16 value);
public void AddValue(string name, int value);
. . .
}
Если тип реализовывает интерфейс ISerializable, то он должен также содержать специальный конструктор:
[Serializable]
class SomeClass : ISerializable {
// Конструктор с такой сигнатурой необходим,
// чтобы CLR смогла восстановить состояние объекта
private SomeClass(SerializationInfo si,
StreamingContext ctx) { . . . }
. . .
}
Обратите внимание: конструктор объявлен с модификатором private. Первый параметр конструктора – это объект класса SerializationInfo. Второй параметр имеет тип StreamingContext. Наиболее часто используемым элементом данного класса является свойство State из перечисления StreamingContextStates.
Для иллюстрации использования интерфейса ISerializable предположим, что у нас определен класс с двумя текстовыми полями. Далее, пусть требуется сохранять эти поля в верхнем регистре, а считывать в нижнем регистре. Вот код, который выполняет требуемую сериализацию (не забудьте подключить пространство имен System.Runtime.Serialization):
[Serializable]
class MyStringData : ISerializable {
public string dataItemOne, dataItemTwo;
public MyStringData(){}
private MyStringData(SerializationInfo si,
StreamingContext ctx) {
// Получаем значения из потока и преобразовываем их
Как видим, в конструкторе типа сериализованные значения извлекаются при помощи метода GetString(). В классе SerializationInfo существуют аналогичные методы для других типов данных.
Во второй версии .NET Framework для поддержки собственных форматов сериализации существует ряд атрибутов: [OnSerializing], [OnSerialized], [OnDeserializing], [OnDeserialized]. Этими атрибутами помечаются методы класса. Механизм сериализации будет автоматически вызывать помеченный метод в требуемый момент. Метод, который помечается одним из вышеуказанных атрибутов, должен принимать в качестве параметра объект класса StreamingContext и не возвращать значений.
Для иллюстрации пользовательской сериализации с применением атрибутов рассмотрим класс MoreData, который при сериализации ведет себя аналогично классу MyStringData.
[Serializable]
class MoreData {
public string dataItemOne, dataItemTwo;
// Если метод помечен атрибутом [OnSerializing], то он
XML – это способ записи структурированных данных. Под «структурированными данными» обычно подразумевают такие объекты, как электронные таблицы, адресные книги, конфигурационные параметры. XML-данные содержатся в документе, в роли которого может выступать файл, поток или другое хранилище информации, способное поддерживать текстовый формат.
Любой XML-документ строится по определенным правилам. XML-данные состоят из набора элементов. Каждый элемент определяется при помощи имени и открывающего и закрывающего тэга. Открывающий тэг элемента записывается в форме <имя_элемента>, закрывающий тэг – в форме </имя_элемента>. Между открывающим и закрывающим тэгами размещается содержимое элемента. Приведем пример простейшего элемента:
<name>This is a text</name>
Элемент может содержать вложенные элементы с другими именами, но в XML-документе всегда должен быть единственный элемент, называемый корневым, никакая часть которого не входит в содержимое любого другого элемента.
<Group>
<student>
<name>
Ivanov
</name>
</student>
<student>
<name>
Petrov
</name>
<ball>
4.0
</ball>
</student>
</Group>
В приведенном примере XML-документ содержит корневой элемент с именем Group, который, в свою очередь, содержит два элемента с именем student. Обратите внимание на разное количество вложенных элементов у первого и второго «студентов» (это допустимо).
Имена тегов элементов чувствительны к регистру! Элементы, задаваемые открывающим и закрывающим тегами, должны быть правильно вложены друг в друга. Следующий пример не является правильным:
<text>
<bold><italic>XML</bold></italic>
</text>
Элемент без содержимого может быть записан в специальной форме: <name/>.
Имена элементов могут содержать буквы, цифры, дефисы (-), символы подчеркивания (_), двоеточия (:) и точки (.), однако начинаться они могут только с буквы или символа подчеркивания. Двоеточие может быть использовано только в специальных случаях, когда оно разделяет так называемое пространство имен. Имена элементов, начинающиеся с xml, вне зависимости от комбинации регистров букв в этом выражении зарезервированы для нужд стандарта.
Элемент может иметь ни одного, один или несколько атрибутов. Правила на имена атрибутов накладываются такие же, как и на имена элементов. Имена атрибутов отделяются от их значений знаком =. Значение атрибута заключается в апострофы или в двойные кавычки. Если апостроф или двойные кавычки присутствуют в значении атрибута, то используются те из них, которые не встречаются в этом значении. Приведем пример элементов с атрибутами:
<elements-with-attributes>
<el _ok = "yes"/>
<one attr = "a value"/>
<several first = "1" second = "2" third = "333"/>
<apos_quote case1 = "John's"
case2 = 'He said: "Hello, world!" '/>
</elements-with-attributes>
Символы < и & не могут быть использованы в тексте, так как они используются в разметке XML-документа. Если эти символы необходимы, следует использовать < вместо < и & вместо &. Символы >, ", и ' также могут быть заменены >, " и ', соответственно.
XML-документ может содержать комментарии, записываемые в обрамлении <!-- и -->. В тексте комментариев не должна содержаться последовательность из двух знаков дефиса:
<!-- Group 252001 list -->
<Group>
<student>
<name>
Ivanov
</name>
</student>
</Group>
Документ может содержать инструкции по обработке (PI), несущие информацию для приложений. Инструкции по обработке записываются в обрамлении <? и ?>.
<example>
<?perl lower-to-upper-case ?>
<?web-server add-header = "university" ?>
<text>Some text</text>
</example>
Секция CDATA используется для того, чтобы обозначить части документа, которые не должны восприниматься как разметка. Секция CDATA начинается со строки <![CDATA[ и заканчивается строкой ]]>. Внутри самой секции не должна присутствовать строка ]]>.
<example>
<![CDATA[ <aaa>bb&cc<<<]]>
</example>
XML-документ может, но не обязан начинаться с XML-декларации, определяющей используемую версию XML:
<?xml version="1.0"?>
Декларация может содержать необязательный атрибут, указывающий кодировку XML-документа:
<?xml version="1.0" encoding="UTF-16"?>
Если XML-документ оформлен по описанным выше правилам, то он называется хорошо оформленным XML-документом. Если хорошо оформленный документ удовлетворяет некой схеме, задающей структуру и содержание, то документ называется правильно оформленным. Существует несколько способов для описания приемлемых схем документов. Один из способов – использование блоков определения типа документа (document type definitions, DTD). Современным способом считается использование языка XML Schema Definitions (XSD), который сам основан на XML.
Описание XSD может потребовать нескольких лекций, поэтому просто приведем пример файла students.xsd на этом языке:
Данная схема описывает правильные документы, которые должны содержать корневой элемент Students, элемент Students должен содержать один или несколько элементов student, а элемент student должен содержать один элемент name, один элемент year и может содержать элемент ball. Также определен порядок и тип элементов, и наличие необязательного атрибута Department у элемента student.
Существует большое количество разнообразного программного обеспечения для работы с XML-схемами, в частности, для создания схем и проверки соответствия XML-документа некоторой схеме. Упомянем такие программы как XMLSPY и утилиту Xsd.exe, которая входит в состав .NET SDK.
2.9. РАБОТА С XML-документами В .NET FRAMEWORK
Рассмотрим вопросы, связанные с чтением и записью XML-документов. Для этих целей предназначен набор классов из пространства имен System.Xml. Упомянем такие классы, как XmlDocument, XmlTextReader, XmlTextWriter, XmlValidatingReader.
Класс XmlReader – это абстрактный класс, предназначенный для чтения xml-данных из потока. В .NET Framework существуют три класса, построенных на основе XmlReader: XmlTextReader (разбор xml-данных на основе текстового потока), XmlNodeReader (разбор XML из набора объектов XmlNode) и XmlValidatingReader (при чтении производится проверка документа с использованием DTD и/или Shema).
Обычно для простого чтения XML достаточно класса XmlTextReader. Конструктор класса может быть вызван в различных формах. В следующем примере предполагается читать данные из файла Students.xml:
XmlTextReader tr = new XmlTextReader("Students.xml");
Объект класса XmlTextReader может быть построен на основе потоков:
XmlTextReader tr = new XmlTextReader(
new TextReader(
new FileStream("Students.xml",
FileMode.Open)));
Как видим, XmlTextReader может извлекать данные из любых потоков, включая сетевые потоки и потоки, связанные с базами данных. XML-данные можно извлекать и из потоков, сконструированных на основе строк:
string xmlContent =
"<book>" +
" <title>Чук и Гек</title>" +
" <author>Аркадий Гайдар</author>" +
"</book>";
XmlTextReader tr = new XmlTextReader(
new StringReader(xmlContent));
После создания объект XmlTextReader извлекает xml-конструкции из потока при помощи метода Read(). Тип текущей конструкции (элемент, атрибут) можно узнать, используя свойство NodeType, значениями которого являются элементы перечисления XmlNodeType. С конструкцией можно работать, используя различные свойства, такие как Name (возвращает имя элемента или атрибута), Value (возвращает данные элемента) и так далее.
В таблице 16 приведены все возможные значения перечисления XmlNodeType.
Таблица 16
Значения перечисления XmlNodeType
Значение
Пример
Attribute
Department="Informatics"
CDATA
<![CDATA["This is character data"]]>
Comment
<!-- This is a comment -->
Document
<Students>
DocumentType
<!DOCTYPE Students SYSTEM " Students.dtd">
Element
<student>
EndElement
</student>
Entity
<!ENTITY filename "Strats.xml">
EntityReference
<
Notation
<!NOTATION GIF89a SYSTEM "gif">
ProcessingInstruction
<?perl lower-to-upper-case ?>
Text
Petrov
Whitespace
<Make/>\r\n<Model/>
XmlDeclaration
<?xml version="1.0"?>
Дадим некоторые комментарии. Значения DocumentType, Entity, EntityReference и Notation связаны с блоком определения типа документа (document type definition, DTD). Напомним, что при помощи подобного блока, который может являться частью XML-документа, задается приемлемая схема документа. Значение Whitespace представляет пустое (вернее, не обрабатываемое) пространство между тэгами.
Следующий пример демонстрирует разбор xml-файла и вывод разобранных конструкций на экран:
using System;
using System.Xml;
class XmlFun {
static void Main() {
XmlTextReader rdr = new XmlTextReader("Students.xml");
// Разбираем файл и выводим на консоль каждый элемент
while(rdr.Read()) {
// Реагируем в зависимости от NodeType
// Не все значения NodeType отслеживаются!!!
switch(rdr.NodeType) {
case XmlNodeType.Element:
Console.Write("<{0}>", rdr.Name);
break;
case XmlNodeType.Text:
Console.Write(rdr.Value);
break;
case XmlNodeType.CDATA:
Console.Write("<![CDATA[{0}]]>", rdr.Value);
break;
case XmlNodeType.Comment:
Console.Write("<!--{0}-->", rdr.Value);
break;
case XmlNodeType.XmlDeclaration:
Console.Write("<?xml version='1.0'?>");
break;
case XmlNodeType.EndElement:
Console.Write("</{0}>", rdr.Name);
break;
}
}
}
}
Набор методов класса XmlTextReader вида MoveXXX(), таких как MoveToNextElement(), может использоваться для извлечения соответствующей конструкции из потока. Методы используются для перехода к следующей конструкции, вернуться к просмотренным конструкциям нельзя.
Подобно тому, как класс XmlReader является абстрактным классом для чтения xml-данных из потока, класс XmlWriter – это абстрактный класс для создания xml-данных. Подчеркнем, что xml-данные всегда могут быть созданы при помощи простой строки и затем записаны в любой поток:
Однако такой подход не лишен недостатков: возрастает вероятность неправильного формирования структуры XML-документа из-за элементарных ошибок программиста. Класс XmlWriter предоставляет более «помехоустойчивый» способ генерации XML-документа. В следующем примере создается документ, содержание которого соответствует xmlContent:
using System;
using System.Xml;
class XmlFun {
static void Main() {
string message = "Hello, dude!";
XmlTextWriter xw = new XmlTextWriter("greetings.xml",
System.Text.Encoding.UTF8);
xw.Formatting = Formatting.Indented;
xw.Indentation = 2;
xw.WriteStartDocument();
xw.WriteStartElement("greeting");
xw.WriteString(message);
xw.WriteEndElement();
xw.WriteEndDocument();
xw.Flush();
}
}
Класс XmlDocument представляет XML-документ в виде дерева узлов-элементов. Каждый узел является экземпляром класса XmlNode, который содержит методы и свойства для навигации по дереву, чтения и записи информации узла и другие.
Пусть имеется следующий файл Students.xml:
<?xml version="1.0" encoding="UTF-8"?>
<Students>
<student Department="Informatics">
<name>Ivanov</name>
<year>1980</year>
</student>
<student>
<name>Petrov</name>
<year>1980</year>
<ball>5.0</ball>
</student>
<student Department="Informatics">
<name>Sidorova</name>
<year>1981</year>
<ball>4.5</ball>
</student>
</Students>
Следующий код создает объект класса XmlDocument, и этот объект загружается информацией из файла Students.xml:
XmlDocument doc = new XmlDocument();
doc.Load("Students.xml");
Метод Load() считывает документ и разбирает его в памяти на элементы. Если документ не является правильно форматированным, генерируется исключение XmlException.
За успешным вызовом метода Load() обычно следует обращение к свойству DocumentElement объекта, представляющего документ. Данное свойство возвращает ссылку на объект класса XmlNode. Этот объект позволяет обнаружить у элемента дочерние элементы (свойство HasChildNodes) и получить к ним доступ, используя свойство ChildNodes, являющееся коллекцией типа XmlNodeList. Комбинация свойств HasChildNodes и ChildNodes позволяет использовать при обработке XML-документов рекурсивный подход:
Приведенный код не выводит значения атрибутов элемента. Свойство ChildNodes не включает атрибуты. Все атрибуты элемента хранятся в свойстве Attributes и представлены типом XmlAttribute. Следующий фрагмент кода позволяет обработать атрибуты элемента:
У объекта класса XmlNode имеются свойства NodeType, Name и Value. Следует иметь в виду, что обращаться к Name и Value нужно в зависимости от значения NodeType. У элементов (XmlNodeType.Element) нет Value, но определено Name. У текста (XmlNodeType.Text) определено Name, но нет Value. У атрибутов определены и Name, и Value.
Для того чтобы получить определенный узел или набор узлов, нет необходимости итеративно просматривать весь XML-документ. Для этих целей можно использовать методы класса XmlDocument такие как GetElementsByTagName(), SelectNodes(), SelectSingleNode().
При помощи класса XmlDocument можно не только читать, но и создавать XML-документы. В следующем примере загружается файл Students.xml, удаляется его первый элемент (первый студент), добавляется еще один элемент, описывающий студента, и результат сохраняется в файл Students_new.xml.
using System;
using System.Xml;
class XmlWork {
static void Main() {
XmlDocument doc = new XmlDocument();
// Загружаем информацию из файла
doc.Load("Students.xml");
// Создаем необходимые элементы
XmlNode student = doc.CreateElement("student");
XmlNode name = doc.CreateElement("name");
XmlNode year = doc.CreateElement("year");
XmlNode ball = doc.CreateElement("ball");
// Создаем текстовое наполнение элементов
XmlNode text1 = doc.CreateTextNode("Mr. Zorg");
XmlNode text2 = doc.CreateTextNode("1990");
XmlNode text3 = doc.CreateTextNode("4.7");
// Связываем элементы и текстовое наполнение
name.AppendChild(text1);
year.AppendChild(text2);
ball.AppendChild(text3);
// Связываем элементы в одну структуру
student.AppendChild(name);
student.AppendChild(year);
student.AppendChild(ball);
// Получаем корневой элемент документа
XmlNode root = doc.DocumentElement;
// Удаляем первый дочерний элемент
root.RemoveChild(root.FirstChild);
// Добавляем сконструированный нами элемент
root.AppendChild(student);
// Сохраняем все в файл
doc.Save("Students_new.xml");
}
}
Другие методы класса XmlDocument, которые могут быть полезны при модификации XML-документа, это методы PrependChild(), InsertBefore(), InsertAfter(), RemoveAll(), ReplaceChild(). Для конструирования элемента можно использовать свойство XmlNode.InnerText, которое должно содержать подходящую строку, представляющую содержимое элемента:
XmlNode student = doc.CreateElement("student");
student.InnerText = "<name>Mr. Zorg</name>" +
"<year>1990</year>" +
"<ball>4.7</ball>";
Класс XmlValidatingReader позволяет производить проверку допустимости XML-документов заданной XSD-схеме или описанию DTD. Объект класса XmlValidatingReader присоединяется к объекту XmlTextReader (или XmlNodeReader, если нужно проверить лишь часть документа). При чтении документа и возникновении ошибки допустимости генерируется событие ValidationEventHandler, с передачей информации о позиции ошибки в документе. Далее рассмотрен пример использования класса XmlValidatingReader.
// Создаем ридер для некого XML-документа
XmlTextReader xtr = new XmlTextReader("Students.xml");
// Объект XmlValidatingReader порождаем на основе ридера
XmlValidatingReader xvr = new XmlValidatingReader(xtr);
// Задаем тип проверки допустимости.
// В данном случае --- XSD-схема
xvr.ValidationType = ValidationType.Schema;
// Так как эта схема не храниться в самом XML-документе,
// необходимо присоединить ее к XmlValidatingReader.
// Создем коллекцию схем (правда, из одного элемента)
XmlSchemaCollection xsc = new XmlSchemaCollection();
xsc.Add("","data.xsd");
// Добавляем коллекцию к XmlValidatingReader
xvr.Schemas.Add(xsc);
// Назначаем обработчик события на ошибки
xvr.ValidationEventHandler +=
new ValidationEventHandler(ValidationError);
Хотя класс XmlValidatingReader предназначен для работы с XmlTextReader, следующий код демонстрирует, как использовать его с XmlDocument.
XmlDocument doc = new XmlDocument();
XmlTextReader tr = new XmlTextReader("Sample.xml");
XmlValidatingReader reader = new XmlValidatingReader(tr);
doc.Load(reader);
В пространстве имен System.Xml.XPath определен класс XPathNavigator. Этот класс используется для перемещения по XML-документу или для запроса содержимого документа с помощью выражения XPath. Объект класса XPathNavigator создается вызовом метода CreateNavigator() у объектов классов XmlDocument, XPathDocument, XmlDataDocument. Методы класса XPathNavigator позволяют перемещаться по XML-документу, либо делая выборки узлов (группа методов Select()) либо получая очередной элемент, атрибут и т.д. (группа методов MoveToXXX()). Если производится выборка узлов, то они доступны через итератор XPathNodeIterator.
// Считываем XML-файл при помощи объекта XPathDocument
XPathDocument document = new XPathDocument("books.xml");
Классы, предназначенные для поддержки многопоточного программирования, сосредоточены в пространстве имен System.Threading. В среде .NET каждый поток представлен объектом класса System.Threading.Thread. Для организации собственного потока необходимо создать объект указанного класса. Класс Thread имеет единственный конструктор:
public Thread(ThreadStart start);
В качестве параметра конструктор принимает делегат типа ThreadStart, который должен ссылаться на пользовательский метод, выполняемый в потоке.
public delegate void ThreadStart();
Следует учесть, что создание потока не подразумевает его автоматического запуска. Для запуска потока требуется вызвать у объекта метод Start().
Продемонстрируем создание и запуск потоков на простейшем примере. Программа содержит два потока, каждый из которых в бесконечном цикле выводит данные на консоль:
using System;
using System.Threading; //Необходимо для работы с потоками
class MainClass {
// Эта функция будет выполняться в отдельном потоке
public static void DoSomeWork() {
while (true) {
Console.WriteLine("The second thread");
// Создаем видимость работы
for (int i = 0; i < 1000000; i++){ i++; }
}
}
public static void Main() {
// Создали объект потока
Thread th = new Thread(new ThreadStart(DoSomeWork));
// Запустили поток
th.Start();
// Создаем видимость работы
while (true) {
Console.WriteLine("The first thread");
for (int i = 0; i < 1000000; i++){ i++; }
}
}
}
Рассмотрим работу с членами класса Thread подробнее. Любой поток характеризуется приоритетом выполнения, который влияет на количество квантов процессорного времени, выделяемых потоку. Для работы с приоритетами класс Thread содержит свойство Priority, доступное для чтения и записи. Значением свойства являются элементы перечисления ThreadPriority: Lowest, BelowNormal, Normal, AboveNormal, Highest:
// Создали объект потока
Thread th = new Thread(new ThreadStart(DoSomeWork));
