В распоряжении разработчика ASP.Net имеются две технологии компонентного программирования: "заказные" компоненты (Web Custom Controls) и пользовательские компоненты (Web User Controls). В документации достаточно подробно описаны преимущества и недостатки тех и других. Стоит отметить, что по некоторым позициям пользовательские компоненты уступают "заказным" компонентам, однако простота их создания во многих случаях позволяет закрыть глаза на мелкие недостатки, а возможность визуальной компоновки делает разработку пользовательских компонентов быстрой и приятной.

Есть, однако, у пользовательских компонентов один недостаток, который может затруднять их полноценное использование в контексте сложных интерактивных форм ввода, - эти компоненты работают практически полностью под управлением исполняющего ядра ASP.Net, что не позволяет работать с ними как с полноценными объектами. В документации описана возможность управления компонентом из страницы, но это управление одностороннее. Термин "одностороннее управление" в данном контексте означает, что инициатором каких-либо действий выступает WEB-форма, на которой установлен компонент, т.е. только из методов формы можно установить значения свойств компонента и/или вызвать какие-либо его целевые методы, но никак не наоборот.

Формально класс System.UI.WebControls.Control, от которого наследуются пользовательские компоненты, имеет свойство Page, которое можно было бы использовать для доступа к странице-владельцу, например, так:

	HttpRequest request = Page.Request;

Для того чтобы тоньше прочувствовать проблему, представим себе какую-нибудь практическую ситуацию, где может потребоваться управление формой "от компонента".

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

• 0 записей - работник в базе не найден;
• 1 запись - работник в базе найден;
• несколько записей - найдено несколько человек, например, однофамильцы.

1. работник в базе не найден - информацию о человеке необходимо добавить в базу данных, т.е. нужно отобразить на форме компонент ввода дополнительных данных о человеке (например, год и место рождения, адрес жительства и пр.) для записи в БД
2. работник в базе найден - на форме нужно отобразить компонент для вывода детальной информации о человеке;
3. найдено несколько человек - на форме нужно отобразить компонент для выбора конкретного человека.

Примечание: этот пример представляет собой фрагмент функциональности формы оформления приказов в системе учета персонала.

Ключевой момент здесь - некоторые компоненты должны выполнить на сервере какие-то действия, и затем содержащая их страница должна перекомпоноваться.

Итак, возможные решения:

• наследовать форму-владельца не от System.UI.WebControls.Page, а от своего класса;
• определить интерфейсы взаимодействия главной страницы со своими компонентами и, соответственно, реализовать их в форме-владельце;
• использовать делегаты, подключаемые к компоненту в форме-владельце;
• генерировать в компонентах специальные события, а в форме-владельце подключать соответствующие обработчики.

Наследование формы от своего класса

public abstract class BasePage : System.UI.WebControls.Page {
  public virtual abstract void DoSearchModuleAction(int recordCount);
}
public class MyPage : BasePage {
  public override void DoSearchModuleAction(int recordCount) { 
    // здесь выполняется реальная работа
  }
}
public class SeachModule : System.UI.WebControls.Control {
  private void Button1_Click() {
    if (Page is BasePage) 
      ((BasePage) Page).DoSearchModuleAction(Search());
  }
  private int Search() {
    return 0;
  }
} 

Этот вариант имеет следующие недостатки:

• если потребуется, чтобы некоторая форма содержала компонент, но не предоставляла ему "обратной связи", в классе этой формы все равно придется прописывать все методы управления, хотя бы и пустые;
• если в ходе разработки появится новый компонент, придется переписывать базовый класс и, соответственно, ВСЕХ его наследников;
• невозможно разместить компонент в компоненте, т.к. компонент-владелец наследуется от System.UI.WebControls.Control, а не от System.UI.WebControls.Page и, соответственно, не может быть наследован от BasePage.

Определение целевых интерфейсов

Выше в качестве примера был приведен код, иллюстрирующий вызов метода DoSearchModuleAction страницы-владельца из обработчика нажатия кнопки в компоненте SeachModule. Ключевая строка:

    if (Page is BasePage) ...

public interface IBasePage {
  void DoSearchModuleAction(int recordCount);
}
public class MyPage : System.UI.WebControls.Page, IbasePage {
  public void IBasePage.DoSearchModuleAction(int recordCount) { 
    // здесь выполняется реальная работа
  }
}
public class SeachModule : System.UI.WebControls.Control {
  private void Button1_Click() {
    if (Page is IBasePage) 
      ((IBasePage) Page).DoSearchModuleAction(Search());
  }
  private int Search() {
    return 0;
  }
} 

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

Тем не менее, и в этом варианте можно найти некоторые недостатки:

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

Использование делегатов

Передать управление форме-владельцу можно следующим образом:

public delegate void SearchModuleDelegate(int recordCount);
public class MyPage : System.UI.WebControls.Page {
  protected SeachModule SeachModule1;
  public void PageLoad() {
    // подключение делегата к компоненту
    SeachModule1.Action = new SearchModuleDelegate(DoSearchModuleAction);
  }
  private void DoSearchModuleAction(int recordCount) {
    // здесь выполняется реальная работа
  }
}
public class SeachModule : System.UI.WebControls.Control {
  public SearchModuleDelegate Action = null;
  private void Button1_Click() {
    if (Action != null) Action(Search()); 
  }
  private int Search() {
    return 0;
  }
} 

Некоторые пояснения:

• в качестве делегата выступает приватный метод DoSearchModuleAction; в общем случае может использоваться не только метод экземпляра класса формы, но и статический метод формы или даже метод другого класса;
• подключение делегата к компоненту выполняется в методе PageLoad формы-владельца.

Интересная возможность, присущая делегатам, - подключать несколько делегатов:

delegate void D(int x);
class C {
  public static void M1(int i) { /* ... */ }
  public static void M2(int i) { /* ... */ }
}
class Test {
  static void Main() { 
    D cd1 = new D(C.M1);  // M1
    D cd2 = new D(C.M2);  // M2
    D cd3 = cd1 + cd2;    // M1 + M2
    D cd4 = cd3 + cd1;    // M1 + M2 + M1
    D cd5 = cd4 + cd3;    // M1 + M2 + M1 + M1 + M2
  }
}

Примечание: Пример взят из раздела 15.1 спецификации языка C#.

Генерация событий

Использование событий мало чем отличается от рассмотренного выше варианта, т.к. обработчики событий представляют собой не что иное, как стандартизованные (по типу возвращаемого значения и набору параметров) делегаты:

public delegate void SearchEventHandler(object sender, SearchEventArgs e);
public class SearchEventArgs : System.EventArgs {
  public readonly int RecordCount;
  public SearchEventArgs(int recordCount) : base() {
    RecordCount = recordCount;
  }
}
public class MyPage : System.UI.WebControls.Page {
  protected SeachModule SeachModule1;
  public void PageLoad() {
    // подключение обработчика события к компоненту
    SeachModule1.Action += new SearchEventHandler(DoSearchModuleAction);
  }
  private void DoSearchModuleAction(object sender, SearchEventArgs e) {
    // здесь выполняется реальная работа
  }
}
public class SeachModule : System.UI.WebControls.Control {
  public event SearchEventHandler Action;
  private void Button1_Click() {
    if (Action != null) Action(this, new SearchEventArgs(Search())); 
  }
  private int Search() {
    return 0;
  }
} 

• обработчик события представляет собой делегат SearchEventHandler; для обработчиков событий: тип возвращаемого значения void, параметр sender - объект, сгенерировавший событие, параметр e - аргументы события;
• для передачи в событии специфических данных создается класс аргументов события SearchEventArgs, наследованный от System.EventArgs;
• подключение делегата к компоненту выполняется в методе PageLoad формы-владельца; при этом используется специальный синтаксис подключения обработчика - оператор +=
• точка подключения обработчика события Action в компоненте описывается с использованием ключевого слова event; в результате вне класса SeachModule можно использовать только операторы += и -=, что исключает, например, случайное обнуление.

public class MyPage : System.UI.WebControls.Page {
  protected SeachModule SeachModule1;
  public void PageLoad() {
    // подключение обработчика события к компоненту
    SeachModule1.Action += new EventHandler(DoSearchModuleAction);
  }
  private void DoSearchModuleAction(object sender, EventArgs e) {
    int recordCount = (sender is SeachModule)
 ? ((SeachModule) sender).RecordCount : -1;
    // TODO: add code to interpret recordCount
  }
}
public class SeachModule : System.UI.WebControls.Control {
  public event EventHandler Action;
  private int recordCount = -1;
  private void Button1_Click() {
    if (Action != null) {
      recordCount = Search(); 
      Action(this, null);
    }
  }
  private int Search() {
    // TODO: add code to search person
    return 0;
  }
  public int RecordCount {
    get {
      return recordCount;
    }
  }
} 

Выводы

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

Использование механизма наследования для реализации взаимодействия компонентов и форм не рекомендуется.