Книга: C# для профессионалов. Том II

Программное соединение событий в C#

Одним из наиболее мощных свойств .NET является возможность создания динамических форм для приложений Windows. Известные и раньше, сегодня они очень легко создаются в .NET. Это позволяет получать объекты, производные из System.Windows.Forms.Control, непосредственно во время выполнения, и использовать их точно таким же образом, как если бы они были созданы проектировщиком форм. Динамические элементы управления могут использоваться для настройки интерфейса пользователя приложения в зависимости от некоторой информации о среде выполнения, например административной утилиты базы данных, где кнопка динамически добавляется в утилиту для каждой таблицы, содержащейся в базе данных. Немного сложным моментом этой темы является соединение обработчиков событий с элементами управления. В этой статье показано, как динамически создавать элементы управления в C# и соединять методы с событиями элементов управления.

Давайте создадим новый проект Visual C# — Windows Application и назовем его DynamicButtons.

Прежде всего необходимо скомпоновать базовую форму, которая выглядит следующим образом:

Пусть кнопка будет называться cmdCreateButtons, а текстовое поле — txtLog. Убедитесь, что в txtLog свойство Multiline задано как True, а свойство ScrollBars — как Vertical.

Когда будет нажата cmdCreateButtons, мы добавим к форме шесть кнопок, расположенных в пустом пространстве справа от txtLog. В то время как обработчики событий конфигурируются для новых кнопок, определим какая кнопка инициирует вызов. Здесь нужно, чтобы все кнопки имели дополнительные целые свойства с именем ID, которые при создании пронумерованы от 1 до 6.

Одной из отличительных черт .NET, к которой разработчикам VB необходимо привыкнуть, является идея наследования существующих классов из Framework (Среды разработки) и их расширение. Эта техника является очень эффективной. В данном случае необходимо создать новый класс с именем DynamicButton и наследовать его из System.Windows.Forms.Button. Это означает, что наш новый класс будет обладать всей функциональностью обычного элемента управления Button, но при этом иметь и другие свойства, которые нам понадобятся, в частности новое свойство с именем DynamicID. Так как этот класс является производным из Button, он выполняет все действия, присущие элементу управления кнопки, т. е. реагирует на нажатия, может быть помещен в форму и т.д.

Более того, действительно важный аспект наследования состоит в том, что любой знающий, как использовать Button, способен также применять DynamicButton. Однако необязательно знать, как использовать расширенную функциональность, по большей части ее можно применять как обычную кнопку. Вы также вправе вывести свои собственные классы из DynamicButton и добавить свою собственную функциональность. Итак, создадим новый класс с именем DynamicButton и добавим следующий код:

namespace DynamicButton {
 using System;
 public class DynamicButton : System.Windows.Forms.Button {
  public int DynamicId;
  public DynamicButton() {
  }
 }
}

Теперь есть новый класс, который ведет себя так же, как кнопка, но имеет целое свойство с именем DynamicId.

Фактически мы хотим добавить кнопке функциональность, в частности предоставить ID везде, где создается кнопка, и задать текст по умолчанию для отражения этого ID:

public DynamicButton(int newId) {
 // задать ID ...
 DynamicId = newId;
 // задать изображение ...
 Text = "Dynamic Button " + DynamicId;
}

Далее можно перейти к cозданию кнопок

Чтобы создать кнопки, добавим код обработчика для кнопки cmdCreateButtons. Это относительно простой код, но выглядит немного великоватым, так как нам необходимо самостоятельно управлять компоновкой новых кнопок для отслеживания координат кнопки при ее добавлении.

Первая часть обработчика задает цикл:

protected void cmdCreateButtons_Click (object sender, System.EventArgs e) {
 // определить, где должны располагаться новые кнопки ...
 int spacing = 8;
 int у = txtLog.Top;
 int width = this.Width - txtLog.Right - (3 * spacing);
 int height = 25;
 // цикл создания новыx кнопок
 int n = 0;
 for (n = 0; n < 6; n++) {

Здесь задано, что высота кнопки равна 25 и у начинается в той же точке, что и вершина txtLog. Мы также задали, что spacing равно 8, это значение используется для разделения кнопок.

Чтобы создать кнопку, делаем так:

  // создать новую кнопку ...
  DynamicButton newButton = new DynamicButton(n);

Отметим, как значение n передается в конструктор в качестве DynamicId кнопки. Следующим шагом является позиционирование кнопки на форме:

  newButton.Left = txtLog.Right + spacing;
  newButton.Top = y;
  newButton.Width = width;
  newButton.Height = height;

Сложность здесь заключается в определении ширины кнопки. Мы хотим, чтобы она находилась на одинаковом расстоянии между правым краем txtLog и правым краем самой формы.

Наконец, мы добавляем кнопку в массив элементов управления и перемещаем у вниз в положение следующей кнопки:

  // добавление кнопки в форму ...
  this.Controls.Add(newButton);
  // следующая ...
  у += (height + spacing);
 }
}

В результате будет получено изображение:

Кнопки созданы, но пока они ничего не делают. Для того чтобы они работали, необходимо присоединить обработчики событий.

В .NET существует небольшое различие в способах использования термина делегат. Делегат определяется с помощью ключевого слова Delegate, описывающего сигнатуру метода, который будет использоваться в делегате. Сигнатура метода включает комбинацию параметров и возвращаемый тип. Поэтому метод, который получает один параметр Object и возвращает String, будет иметь сигнатуру, отличную от сигнатуры метода, получающего параметр Hashtable и возвращающего String.

Это выглядит запутанным, потому что вызываемый метод также называется делегатом. В этой статье делегат будет означать определение делегата с помощью ключевого слова Delegate. Делегируемый метод будет обозначать метод, который реализуется в результате вызова делегата.

Для присоединения обработчика событий необходимо создать делегируемый метод со следующей сигнатурой:

void DelegateMethod(Object sender, System.EventArgs e)

Здесь важно то, что имя создаваемого метода является полностью произвольным, т.е. метод может иметь любое имя, какое мы захотим использовать. До тех пор пока создается метод, который не имеет возвращаемого значения, но получает System.Object, а затем объект System.EventArgs,— все будет нормально. Как можно понять, порядок параметров влияет на сигнатуру метода. Если изменить порядок параметров, метод не будет иметь требуемую сигнатуру для делегируемого метода.

Все обработчики событий в множестве элементов управления Windows.Forms соответствуют этой модели, значит, возможно создание достаточно мощных обработчиков событий. Можно было бы при желании сделать так, чтобы каждое событие каждого элемента управления на форме проходило через один и тот же делегируемый метод. Фактически делегируемый метод вызывается для любого объекта из любого другого объекта. Поэтому элемент управления кнопки объекта формы, называемого MyDialog, может вызывать метод для объекта формы, называемого MyDialogOwner.

Параметр sender предоставляет ссылку на элемент управления, который порождает событие. Чтобы добраться до свойства DynamicId, необходимо преобразовать его в тип DynamicButton. Параметр е определяет некоторые специальные аргументы события. Мы не собираемся это здесь рассматривать, но для некоторых событий в данных аргументах содержится дополнительная информация о том, что вызывает событие. Вот обработчик нажатия кнопки:

// DynamicButton_Click ...
protected void DynamicButton_Click(object sender, System.EventArgs e) {
 // преобразовать sender в button ...
 DynamicButton button = (DynamicButton)sender;
 // msgbox ...
 AddToLog("Clicked" + button.DynamicId);
}

В этом методе нет ничего необычного. Соединим его с событием Click нашей динамической кнопки. Непосредственно перед тем как вызывать Controls.Add, можно добавить обработчик:

// соединить обработчик ...
newButton.Click += new System.EventHandler(this.DynamicButton_Click);
// добавить кнопку к форме ...
this.Controls.Add(newButton);

Теперь, когда возникает связанное с кнопкой событие Click, рабочая среда Framework просматривает список делегированных методов, соединенных с этим событием, инициируя каждый из них по очереди.

Важная деталь — в .NET события могут иметь более одного обработчика. Это означает, что если создать другой делегированный метод, соединить его с помощью нового экземпляра System.EventHandler, то оба метода будут вызываться в момент порождения события. Конечно, методы не вызываются одновременно, так как фактически получится мультипоточное приложение, а это не то, что хотелось бы случайно получить.

Мы не определили, как выглядит наша функция AddToLog,— сделаем это сейчас:

// AddToLog — обновляет представление журнала ...
private void AddToLog(String buf) {
 // обновляет элемент управления журнала ...
 txtLog.Text = (buf + "rn" + txtLog.Text);
}

Теперь давайте попробуем выполнить приложение и понажимать на кнопки:

Обработчики, которые отвечают на другие события в DynamicButton, могут быть добавлены аналогичным образом. Прежде всего для каждого из них создается метод:

// DynamicButton_Enter ...
protected void DynamicButton_Enter(object sender, System.EventArgs e) {
 // преобразовать sender в button ...
 DynamicButton button = (DynamicButton)sender;
 // msgbox ...
 AddToLog("Enter " + button.DynamicId);
}
// DynamicButton_Leave ...
protected void DynamicButton_Leave(object sender, System.EventArgs e) {
 // преобразовать sender в button ...
 DynamicButton button = (DynamicButton)sender;
 // msgbox ...
 AddToLog("Left " + button.DynamicId);
}

Затем можно добавить обработчики для каждого из них:

// соединить обработчик
newButton.Click +=
 new System.EventHandler(this.DynamicButton_Click);
newButton.MouseEnter +=
 new System.EventHandler(this.DynamicButton_Enter);
newButton.MouseLeave +=
 new System.EventHandler(this.DynamicButton_Leave);

Теперь, если снова выполнить приложение, в журнал будут добавляться сообщения по мере перемещения по кнопкам.

Оглавление книги