Текст книги "Программирование мобильных устройств на платформе .NET Compact Framework"
Автор книги: Иво Салмре
Жанр:
Программирование
сообщить о нарушении
Текущая страница: 33 (всего у книги 69 страниц)
Многие приложения служат для того, чтобы предоставить пользователям возможность исследовать большие объемы динамических данных в сжатом виде. Эти данные могут храниться в локальном файле или базе данных или же динамически извлекаться из сети по мере необходимости.
Так, мобильное приложение для агентов по продаже недвижимости может открывать доступ к просмотру данных, охватывающих сотни или тысячи домов, организуя их в виде иерархического дерева навигация по узлам которого возможна при использовании мобильного телефона или PDA. В типичных случаях первоначальный вариант проекта, позволяющий решить эту задачу, может быть основан на загрузке в память всей структурной информации о списках выставленных на продажу домов и предоставлении пользователю возможности осуществлять навигацию по узлам иерархического дерева для нахождения объектов, которые могут представлять интерес. Когда пользователь выбирает конкретный объект недвижимости, приложение загружает для него в ответ на запрос такую детальную информацию, как фотографии, поэтажные планы, схему расположения улиц и рыночный статус.
Элемент управления TreeView может предложить вам богатое разнообразие способов иерархического представления информации о возможных объектах недвижимости, обеспечивающих возможность последовательной конкретизации выбора. Так, TreeView можно использовать для формирования иерархической структуры с тремя узлами верхнего уровня, которые являют собой различные способы сводного представления данных в соответствии с различными стратегиями принятия решений, которые пользователь может использовать в процессе навигации по узлам данных. Ниже приведены примеры трех возможных способов развертывания иерархических структур, которыми, в частности, может воспользоваться конечный пользователь.
■ Способ 1. Начните с просмотра данных, сгруппированных по районам (Neighbourhoods), а затем перейдите к просмотру данных, сгруппированных по ценам, чтобы определить, информация о домах какой стоимости должна быть отображена. Этому способу навигации соответствуют следующие переходы по иерархическим узлам TreeView: Neighbourhoods→Price→ListOfUnits.
■ Способ 2. Начните с группировки по ценам (Price), а затем перейдите к просмотру данных, сгруппированных по типам, и, наконец, по районам, в результате чего будет отображен соответствующий список домов. Этому способу навигации соответствуют следующие переходы по иерархическим узлам TreeView: Price→HouseType→Neighbourhood→ListOfUnits.
■ Способ 3. Начните с типов домов (HouseType), а затем последовательно перейдите к просмотру данных, сгруппированных по интервалам цен и районам. Этому способу навигации соответствуют следующие переходы по иерархическим узлам TreeView: HouseType→Price→Neighbourhood→ListOfUnits.
На рис. 11.2 показано, как может выглядеть навигация по узлам иерархии TreeView. Имеется три узла верхнего уровня: Neighbourhood, Price и House– Type У каждого родительского узла имеются подузлы, по которым пользователи могут переходить вглубь иерархии, получая, в конечном счете, множество объектов недвижимости, информацию о которых они хотят просмотреть.
Несмотря на всю полезность метафоры дерева для отбора домов на основании иерархических категорий, при ее использовании могут возникать проблемы, обусловленные заметным ростом количества узлов дерева даже при средних объемах данных. Простая иерархия, включающая 10 узлов типа Neighbourhood, каждый из которых включает по 4 узла типа HouseType, включающие каждый по 4 узла типа Price, каждый из которых, в свою очередь, включает по 6 узлов типа House. в сумме дает для нашего дерева 960 концевых узлов, или листьев.
Это число следовало бы дополнительно умножить на количество способов навигации, которые мы хотим использовать:
960 для навигации по схеме Neighbourhoods→HouseType→Price→ListOfUnits
960 для навигации по схеме Price→Neighbourhoods→HouseType→ListOfUnits
960 для навигации по схеме HouseTypeOPrice→Neighbourhood→ListOfUnits
Рис. 11.2. Простой пример того, как может выглядеть иерархия узлов элемента управления TreeView для задачи поиска объектов недвижимости
Если мы решим заранее заполнить данными элемент управления TreeView, не дожидаясь, какую навигационную схему изберет пользователь, то нам, в конечном счете, придется задействовать огромное количество узлов дерева, большинство из которых не будут посещены пользователем во время сеансов работы с приложением. Создание таких членов TreeView занимает много времени, а каждый из отдельных узлов TreeView сам по себе потребляет системные ресурсы. Несомненно, хранение тысяч элементарных узлов иерархии TreeView приведет к ухудшению производительности приложения. Если исходить из того, что не все из описанных отдельных узлов будут посещены пользователем, то можно значительно повысить производительность, используя более разумный подход. Чего нам хотелось бы – так это сохранить метафору пользовательского интерфейса TreeView, но избежать создания сотен или тысяч узлов, которые так никогда и не будут посещены. Способ, позволяющий это реализовать, состоит в том, чтобы создавать нужные узлы TreeView лишь тогда, когда становится ясным, что пользователь собирается их посетить. Этого можно добиться, используя некий "умный" код, который 1) заполняет элемент управления TreeView информацией лишь до той точки, до которой он перед этим был развернут, и 2) обрабатывает событие, указывающее на ожидаемое развертывание определенного узла элемента управления TreeView, который, таким образом, должен быть заполнен достоверными данными. Это позволяет сэкономить время и ресурсы, которые иначе пришлось бы расходовать мобильному приложению для заполнения информацией огромного количества узлов, и, в конечном счете, делает приложение более привлекательным с точки зрения конечного пользователя.
Возможны и более сложные подходы, например, заблаговременное продвижение на одну ступень вглубь иерархического дерева TreeView и предварительное заполнение узлов информацией; благодаря этому условия работы пользователя с приложением еще более улучшаются. Многообразие возможностей подхода, который вы решите применить для того, чтобы, используя разумные оценки, отложить выполнение части операций на более позднее время, ограничивается лишь объемом работы по проектированию и реализации ваших идей.
.NET Compact Framework: не все поддерживаемые обработчики прерываний предоставляются конструктором форм Visual Studio .NET
Платформа .NET Compact Framework поддерживает подмножество управляющих событий платформы .NET Compact Framework, ориентированной на настольные компьютеры. Следует отметить, что одно лишь наличие в .NET Compact Framework сигнатуры какого-либо события еще не является гарантией того, что это событие может быть возбуждено во время выполнения. Могут существовать специфические условия совместимости или причины, связанные со свойствами объектного наследования, в силу которых определение события необходимо было связать с элементом управления, но само событие запускаться во время выполнения в .NET Compact Framework не будет. Единственный способ прояснения подобных ситуаций состоит в том, чтобы подключить событие к элементу управления и посмотреть, будет ли оно запущено во время выполнения. Эта ситуация дополнительно осложняется тем фактом, что не все события, поддерживаемые платформой .NET Compact Framework, отражаются в графической среде проектирования Visual Studio .NET. Среди поддерживаемых событий имеются и такие, которые не фигурируют в списке событий C# в панели свойств или в выпадающем списке событий Visual Basic .NET в редакторе кода.
События, отображаемые в среде проектирования, должны поддерживаться платформой .NET Compact Framework, но имеется ряд дополнительных событий, которые .NET Compact Framework поддерживает, но не отображает. Причиной такого поведения явилась недостаточная координация работ над этим проектом: группа, работающая над средствами проектирования, и группа, работающая над средой выполнения, не смогли идеально организовать взаимодействие между собой! (Надеюсь, что в процессе дальнейшего усовершенствования платформы подобная ситуация уже не повторится.) Большинство обычных событий отображаются в окне конструктора форм, но некоторые специфические события могут требовать подключения их к форме вручную. Сделать это несложно, но для этого надо хотя бы немного знать о том, как осуществляется подключение обработчиков событий.
Если вы хотите использовать событие, которое поддерживается в .NET Compact Framework, но не предлагается в качестве доступного в среде проектирования Visual Studio .NET, вам придется вручную вставить одну строку кода в функцию InitializeComponent() формы, содержащей данный элемент управления. Функцию InitializeComponent() вы найдете в обычно скрытом или свернутом разделе "Windows Form Designer-Generated Code" редактора кода класса.
Добавление обработчика событий BeforeExpand в элемент управления TreeView иллюстрирует приведенный ниже фрагмент кода:
#region Windows Form Designer generated code
private void InitializeComponent()
… строки кода для других элементов управления …
//
// treeView1
//
this.treeView1.ImageIndex = -1;
this.treeView1.Location = new System.Drawing.Point(72, 48);
this.treeView1.Name = "treeView1";
this.treeView1.SelectedImageIndex = -1;
this.treeView1.Size = new System.Drawing.Size(168, 176);
this.treeView1.TabIndex = 0;
//ОДНОСТРОЧНЫЙ КОД ДЛЯ ПОДКЛЮЧЕНИЯ СОБЫТИЯ, КОТОРЫЙ ВЫ ДОЛЖНЫ ВСТАВИТЬ
this.treeView1.BeforeExpand += new.System.Windows.Forms.TreeViewCancelEventHandler(this.TreeView1BeforeExpand);
… строки кода для других элементов управления …Представленный выше код подключает обработчик события BeforeExpand элемента управления treeView1. Функция обработчика события должна иметь специальную сигнатуру. В данном случае она имеет следующий вид:
private void TreeView1BeforeExpand(object sender, System.Windows.Forms.TreeViewCancelEventArgs e) {}Неплохим способом обеспечения автоматической генерации обоих вышеприведенных фрагментов кода является использование проекта Windows Application для настольных компьютеров. В Visual Studio .NET проекты для настольных компьютеров поддерживают графический способ создания и подключения всех поддерживаемых обработчиков прерываний. Сгенерированный при этом код вы далее можете скопировать и вставить в соответствующие части своего проекта .NET Compact Framework.
Заслуживает рассмотрения и слегка видоизмененный вариант описанной выше стратегии. Поскольку конструктор форм автоматически вставляет и удаляет код внутри функции InitializeComponent(), существует вероятность того, что он добавит свой код поверх добавленного вами кода. Чтобы этого избежать, может оказаться целесообразным создать собственную функцию (например, MyInitializeComponent()), чтобы вставить в нее свой код, выполняющий все действия по инициализации, и вызвать эту функцию в коде конструктора формы сразу же после вызова InitializeComponent(). Благодаря этому вы сможете быть уверены в том, что ваш код не будет случайно удален конструктором форм.
Пример: заполнение элемента управления TreeView данными по требованию
На рис. 11.3 представлен пример простого приложения с элементами управления TreeView (treeview1) и Button (button1). Щелчок на кнопке во время выполнения приложения устанавливает или сбрасывает состояние элемента управления TreeView. После установки состояния элемента управления TreeView щелчком на кнопке он предоставляет три узла верхнего уровня, которые можно динамически заполнять данными. Этими узлами являются узлы Neighbourhoods, Price и HouseType.
Рис. 11.3. Выполнение приложения, динамически заполняющего данными элемент управления TreeView, на эмуляторе Pocket PC
Чтобы сократить размер кода и не усложнять пример, в листинг 11.2 включен лишь код, обеспечивающий динамическое заполнение данными узла Neighbourhoods. Щелчки на других узлах будут приводить при первом щелчке к отображению окна сообщений MessageBox, информирующего о том, что для динамического заполнения данного узла данными вы должны добавить собственный код.
В листинге 11.2 содержится код, который должен быть вставлен в класс Form для данного примера. Для создания приложения необходимо выполнить следующие действия:
1. Начните новый проект Smart Device в Visual Studio .NET и выберите в качестве целевой платформы Pocket PC.
2. Добавьте в форму Form в окне конструктора элементы управления TreeView и Button.
3. Дважды щелкните на кнопке Button в окне конструктора форм; в результате этого будет создан и подключен к кнопке приведенный ниже обработчик событий button1_Click.
4. Введите приведенный ниже код button1_Click, ответственный за заполнение данными элемента управления TreeView.
5. Введите оставшуюся часть приведенного ниже кода, включая константы, определения которых содержатся перед кодом обработчика прерываний button1_Click.
6. Вручную подключите обработчик событий для события BeforeExpand элемента управления TreeView, о чем говорилось в разделе выше.
7. Скомпилируйте пример и запустите его на выполнение.
Листинг 11.2. Динамическое заполнение данными элемента управления TreeView
//Фиктивный текст для размещения в заполнителях дочерних узлов
const string dummy_node = "_dummynode";
//Метка, которую мы будем использовать для обозначения узла
const string node_needToBePopulated = "_populateMe";
//Текст, который мы будем использовать для наших узлов высшего уровня
const string nodeText_Neighborhoods = "Neighborhoods";
const string nodeText_Prices = "Prices";
const string nodeText_HouseType = "HouseTypes";
//–
//Обработчик события щелчка для кнопки
//
//Настраивает наш элемент управления TreeView для отображения процесса
//последовательного заполнения дерева
//–
private void button1_Click(object sender, System.EventArgs e) {
TreeNode tnNewNode;
//Отключить обновление интерфейса до тех пор, пока дерево
//не будет заполнено
treeView1.BeginUpdate();
//Избавиться от устаревших данных
treeView1.Nodes.Clear();
//–
//Узел "Neighborhoods"
//–
//Добавить узел "Neighborhoods" верхнего уровня.
tnNewNode = treeView1.Nodes.Add("Neighborhoods");
//Установить для узла метку, указывающую на то, что узел
//будет заполняться динамически
tnNewNode.Tag = node_needToBePopulated;
//Этот фиктивный дочерний узел существует лишь для того, чтобы
//узел имел, по крайней мере, один дочерний узел и поэтому
//был расширяемым.
tnNewNode.Nodes.Add(dummy_node);
//–
//Узел "Price"
//–
tnNewNode = treeView1.Nodes.Add("Price");
//Установить для узла метку, указывающую на то, что узел
//будет заполняться динамически
tnNewNode.Tag = node_needToBePopulated;
//Этот фиктивный дочерний узел существует лишь для того, чтобы
//узел имел, по крайней мере, один дочерний узел и поэтому
//был расширяемым.
tnNewNode.Nodes.Add(dummy_node);
//–
//Узел "HouseType"
//–
tnNewNode = treeView1.Nodes.Add("HouseType");
//Установить для узла метку, указывающую на то, что узел
//будет заполняться динамически
tnNewNode.Tag = node_needToBePopulated;
//Этот фиктивный дочерний узел существует лишь для того, чтобы
//узел имел, по крайней мере, один дочерний узел и поэтому
//был расширяемым.
tnNewNode.Nodes.Add(dummy_node);
//Восстанавливаем обновление интерфейса
treeView1.EndUpdate();
}
//–
//Обработчик событий BeforeExpand для нашего элемента управления TreeView
//ПРИМЕЧАНИЕ: Этот обработчик событий необходимо будет
// вручную подключить к функции InitializeComponent()
// формы.
//
//Вызывается при запросе пользователем расширения узла, у которого имеется,
//по крайней мере, один дочерний узел. Этот вызов осуществляется до
//отображения дочерних узлов данного узла и дает нам возможность
//динамически заполнить данными элемент управления TreeView.
//–
private void TreeView1BeforeExpand (object sender, System.Windows.Forms.TreeViewCancelEventArgs e) {
//Получить узел, который будет расширяться
System.Windows.Forms.TreeNode tnExpanding;
tnExpanding = e.Node;
//Если узел не отмечен как "нуждающийся в заполнении данными",
//то он устраивает нас в том виде, "как он есть".
if (tnExpanding.Tag !=(object) node_needToBePopulated) {
return; //Разрешить беспрепятственное продолжение выполнение
}
//–
//Требуется динамическое заполнение дерева данными.
//Мы знаем, что узел должен быть заполнен данными; определить,
//что это за узел
//–
if (tnExpanding.Text == nodeText Neighborhoods) {
PopulateTreeViewNeighborhoods(tnExpanding);
return; //добавление элементов закончено!
} else {
//Проверить другие возможности для узлов дерева, которые мы должны
//добавить.
System.Windows.Forms.MessageBox.Show("НЕ СДЕЛАНО: Добавьте код для динамического заполнения этого узла");
//Снять отметку с этого узла, чтобы мы не могли вновь выполнить
//этот код
tnExpanding.Tag = "";
}
}
//–
//Эта функция вызывается для динамического добавления дочерних узлов
//в узел "Neighborhood"
//–
void PopulateTreeViewNeighborhoods(TreeNode tnAddTo) {
TreeView tvControl;
tvControl = tnAddTo.TreeView;
tvControl.BeginUpdate();
//Очистить имеющийся фиктивный узел
tnAddTo.Nodes.Clear();
//Объявить четыре узла, которые мы хотим сделать дочерними узлами
//того узла, который был передан.
TreeNode[] newNeighborhoodNodes;
newNeighborhoodNodes = new TreeNode[4];
newNeighborhoodNodes[0] = new TreeNode("Capitol Hill");
newNeighborhoodNodes[1] = new TreeNode("Chelsea");
newNeighborhoodNodes[2] = new TreeNode("Downtown");
newNeighborhoodNodes[3] = new TreeNode("South Bay");
//Добавить дочерние узлы в элемент управления
TreeView tnAddTo.Nodes.AddRange(newNeighborhoodNodes);
tvControl.EndUpdate();
}
Приведенный код демонстрирует, что, проявив немного изобретательности и написав совсем небольшой объем дополнительного кода, можно отложить заполнение сложного пользовательского интерфейса данными до тех пор, пока они не понадобятся пользователю. Независимо от того, работаете ли вы в .NET Compact Framework или в любой другой среде выполнения для мобильных устройств, откладывание заполнения данными расширяемых элементов управления пользовательских интерфейсов до того момента, когда возникнет действительная необходимость в них, является чрезвычайно мощным методом.
Будьте внимательны, когда работаете с кодом, управляемым событиямиЗначительная часть кода современных пользовательских интерфейсов ответственна за реагирование на события, генерируемые каркасом приложения. Знание того, какие события следует обрабатывать, как часто запускаются события и в каких случаях на них целесообразно не реагировать, имеет очень большое значение для создания эффективно функционирующих программных кодов пользовательского интерфейса.
Довольно часто причина низкой производительности приложения кроется в том, что события, генерируемые кодом, ошибочно обрабатываются так, как если бы они были сгенерированы в результате действий пользователя.
Пример: демонстрация возбуждения события, заключающегося в изменении содержимого текстового окна в результате установки значения свойства .Text
В листинге 11.3 содержится код, который необходимо вставить в класс Form. Для создания приложения потребуется выполнить следующие действия:
1. Начните новый проект Smart Device в Visual Studio .NET, выбрав в качестве целевой платформы Pocket PC.
2. Добавьте в форму Form элементы управления TextBox, Label, ListBox и Button.
3. Дважды щелкните на кнопке Button в окне конструктора форм; в результате этого будет создан и подключен к кнопке приведенный ниже обработчик событий button1_Click. Введите соответствующий код из листинга 11.3, который будет реагировать на это событие.
4. Дважды щелкните на элементе управления TextBox в окне конструктора форм; в результате этого будет создан и подключен к текстовому окну приведенный ниже обработчик событий textBoxl_TextChanged. Введите соответствующий код из листинга 11.3, который будет реагировать на это событие.
5. Скомпилируйте пример и запустите его на выполнение.
6. Введите текст в текстовое поле; обратите внимание, что каждое нажатие клавиши приводит к выполнению приведенного ниже кода обработки события textBox1_TextChanged.
7. Щелкните на кнопке Button; обратите внимание, что это также приводит к выполнению приведенного ниже кода обработки события textBox1_TextChanged.
НА ЗАМЕТКУ
При выполнении приложения на платформе .NET Compact Framework 1.1 в случае установки значения свойства Text элемента управления TextBox программным путем событие TextChanged в действительности запускается дважды.
Выполнение того же кода на настольном компьютере сопровождается только однократным запуском указанного события. Вероятно, поведение последующих версий NET Compact Framework будет изменено таким образом, чтобы оно совпадало с поведением .NET Framework (однократный запуск события). События – коварная вещь. Будьте очень внимательны в своих предположениях относительно того как и когда запускаются события.
Листинг 11.3. Запуск обработчика событий при изменении содержимого элемента TextBox программным путем
int m_eventTriggerCount;
private void textBox1_TextChanged(object sender, System.EventArgs e) {
m_eventTriggerCount++;
//Обновить надпись для отображения количества событий
label1.Text = "Events: #" + m_eventTriggerCount.ToString();
//Внести каждое событие в список
listBox1.Items.Add(m_eventTriggerCount.ToString() + textBox1.Text);
}
private void button1_Click(object sender, System.EventArgs e) {
//Запускает событие TextChanged так же,
//как если бы текст был введен пользователем
textBox1.Text = "Hello World";
}
Как видно из листинга 11.3, программная установка свойства Text элемента управления TextBox запускает тот же код обработки событий, который запускался бы при вводе текста пользователем. В зависимости от того, какие допущения вами сделаны, результаты могут как совпадать, так и не совпадать с ожидаемыми. Программисты часто пишут коды, предназначенные для заполнения пользовательских интерфейсов данными после их извлечения из внешнего источника. При этом устанавливаются свойства Checked переключателей RadioButton и флажков CheckBox, заполняются значения текстовых полей TextBox, заполняются элементами списки ListBox и ComboBox и так далее. Во многих случаях программисты предполагают, что выполнение всех этих установочных действий не приводит к запуску событий пользовательского интерфейса. Обычно в намерения программиста не входит, чтобы эти события запускались, поскольку пользовательский интерфейс всего лишь подготавливается к тому, чтобы пользователь мог им воспользоваться. Очень часто программисты, которые разрабатывают приложение, хотят, чтобы код обработки событий приложения запускался лишь тогда, когда происходит внешнее событие, например, поступает сигнал таймера, пользователь выполняет щелчок на кнопке или вводит текст в элемент управления и тому подобное.
Не позволяйте событиям заставать вас врасплох
Сложность работы с кодами, управляемыми событиями, связана с тем, что невозможно заранее знать, когда именно будет вызван код того или иного обработчика события. Просматривая исходный код приложения, вы можете точно сказать, когда вызываются библиотечные функции или другие части кода приложения, но ничто не укажет вам на то, когда именно среда выполнения запустит событие. По этой причине большинство разработчиков просто делают относительно этого некоторые предположения, которые даже не удосуживаются тщательно проверять. Кроме того, по мере увеличения объема приложения за счет дальнейшего добавления пользовательского кода и соответствующего усложнения его внутренней структуры в нем появляется все больше кода, предназначенного для генерации и обработки событий пользовательского интерфейса; из-за этого также могут возникать весьма тонкие взаимодействия, обнаружить которые простым просмотром исходного текста кода очень трудно. Так, код, реагирующий на выбор элемента в списке ListBox, может запускать код, инициирующий обновление свойств элементов управления CheckBox и TextBox, как показано в приведенном ниже примере:
textboxUserName.Text = selectedRecord.Username;
checkboxDeliverPackageToHomeAddress.Checked = selectedRecord.DeliverToHome;
Этот код кажется простым, но если с элементами управления CheckBox или TextBox связаны события, то они могут запускаться и в свою очередь запускать код приложения, который изначально предназначался только для обработки действий пользователя. В свою очередь, этот код может изменять другие элементы пользовательского интерфейса, что вызовет появление каскада событий, запуск которых вовсе не входил в намерения разработчика приложения.
Ниже описаны три эффективных способа, позволяющие не допустить, чтобы ваше приложение оказалось застигнутым врасплох непредвиденными событиями.
1. В процеcce разработки кода снабжайте его средствами контроля (мониторинга) выполнения приложения. Подсчет количества запусков событий относится к операциям с низкими накладными расходами; для этого требуется всего лишь последовательно увеличивать на единицу значение целой переменной. С точки зрения диагностики вам также может пригодиться ведение и периодическое изучение упорядоченного списка возникающих событий. Включение соответствующих средств в код можно организовать с помощью условной компиляции приложения. Целесообразно периодически анализировать поведение приложения на протяжении всего цикла разработки и изучать ту информацию, которую вам предоставляет его версия, в которой предусмотрены средства контроля выполнения приложения. Эти средства совсем не сложны в реализации, но являются чрезвычайно эффективным вспомогательным инструментом разработчика.
2. Используйте хорошо продуманную модель состояний, которая определяет, когда события должны запускать код, а когда из них должен осуществляться немедленный выход. Весьма распространены ситуации, в которых наступление события приводит к непредусмотренному запуску кода при заполнении данными пользовательского интерфейса приложения. В подобных случаях нашим намерением является введение данных в пользовательский интерфейс, а не ответ на события, запускаемые этой операцией. Простым выходом из таких ситуаций является установка флажка на уровне формы, означающая следующее: "В данный момент обновляется пользовательский интерфейс, поэтому из обработчиков событий должен осуществляться немедленный выход, не сопровождающийся выполнением какой-либо обработки". В первой строке программного кода каждого из обработчиков событий должна выполняться проверка состояния этого флажка, и если он установлен, то должен осуществляться немедленный выход из обработчика.
3. Время от времени размещайте точки останова в каждом из обработчиков событий приложения и исследуйте цепочки обрабатываемых событий. Для выяснения того, какие виды обработки событий и в каком порядке выполняются, полезно периодически организовывать пошаговое отслеживание выполнения событий, запускаемых в пользовательском интерфейсе. Не исключено, что таким способом вам удастся обнаружить непредусмотренные каскады событий, инициируемых обновлением пользовательского интерфейса кодом приложения; может также оказаться, что выполняется излишняя обработка, требующая больших накладных расходов. Хорошим примером кода, который следует выявлять и исключать из своего приложения, является код обработки событий, инициирующий выполнение многочисленных операций считывания и записи данных с использованием базы данных.
Концепция кода, управляемого событиями, является необычайно плодотворной, однако, как и в случае любой другой абстракции, при этом теряется низкоуровневая картина того, что происходит. Вы имеете право говорить о том, что поведение приложения вам понятно, лишь в том случае, если хорошо представляете себе, в каком порядке и с какой частотой запускаются события, заставляющие выполняться код вашего приложения. С этим могут быть связаны не только проблемы производительности, но и проблемы надежности приложений. Поэтому стоит не пожалеть времени и составить для себя надежную и подробную картину того, где и когда именно в вашем приложении запускаются события.
На рис. 11.4 и в листинге 11.4 представлен пример приложения, демонстрирующий использование как средств контроля выполнения кода, так и модели состояний для того, чтобы избежать выполнения кода обработки событий пользовательского интерфейса в тех случаях, когда эти события связаны с обновлением пользовательского интерфейса. Для создания данного примера приложения необходимо выполнить следующие действия:
Пример приложения Pocket PC, демонстрирующий работу средств контроля запуска событий
Рис. 11.4. Пример приложения Pocket PC, демонстрирующий работу средств контроля запуска событий
1. Начните новый проект Smart Device в Visual Studio .NET, выбрав в качестве целевой платформы Pocket PC.
2. Добавьте в форму Form элементы управления TextBox, RadioButton, ListBox и Button (на рис. 11.4 показано, как должна выглядеть форма).
3. Дважды щелкните на кнопке Button в окне конструктора форм. В результате этого будет создан и подключен к кнопке приведенный ниже обработчик событий button1_Click. Введите соответствующий код из листинга 11.4, который будет реагировать на это событие.
4. Дважды щелкните на элементе управления TextBox в окне конструктора форм. В результате этого будет создан и подключен к текстовому окну приведенный ниже обработчик событий textBox1_TextChanged. Введите соответствующий код из листинга 11.4, который будет реагировать на это событие.
5. Дважды щелкните на элементе управления RadioButton1 в окне конструктора форм. В результате этого будет создан и подключен к переключателю приведенный ниже обработчик событий radioButton1_Click. Введите соответствующий код из листинга 11.4, который будет реагировать на это событие.
6. Измените имя второй кнопки с button2 на buttonShowEventLog и дважды щелкните на кнопке Button в окне конструктора форм. В результате этого будет создан и подключен к кнопке приведенный ниже обработчик событий buttonShowEventLog_Click. Введите соответствующий код из листинга 11.4, который будет реагировать на это событие
7. Введите оставшуюся часть приведенного ниже кода, включая операторы #if и #endif и переменные уровня класса.
8. В самом начале файла класса формы Form добавьте оператор #define EVENTINSTRUMENTATION. Это позволит вам использовать условную компиляцию кода.
