ASP.NET Web Forms – это механизм, который работает на базе общей среды исполнения ASP.NET и встроен в поставку ASP.NET начиная с самой первой версии. Механизм веб-форм предполагает построение веб-приложений аналогично настольным приложениям.
Как известно, результат работы веб-приложения – это код HTML, который передается клиенту. Обычно HTML-код страницы веб-приложения содержит различные элементы, которые позволяют управлять процессом работы приложения – например, кнопки, поля ввода, переключатели и т.д. Эти элементы управления можно описать на языке HTML. Например, можно создать небольшую форму на языке HTML, как показано ниже.
При попытке открыть подобный HTML-код в браузере можно увидеть следующую несложную форму.
Рисунок 4.1 - Пример Web-формы
После того, как в поля ввода ввести какие-либо значения и нажать кнопку отправки информации на сервер, браузером будет сгенерирован HTTP-запрос методом POST, в котором тело запроса будет содержать строку вида:
FirstName=Ivan&LastName=Petrov&CS=on
Как видно, в теле запроса содержатся параметры, которые присутствуют на форме – строки и флажки. Несмотря на тип каждого параметра, все они передаются в виде строкового значения. Например, состояние флажка "C#" передается как "CS=ON". Поэтому для считывания состояния этого элемента управления можно использовать следующий код.
Из этого примера видно, что значения элементов на форме нетипизированны. Это означает, что какой бы смысл не содержался в элементе управления (строка, число, флаг, переключатель и т.д.), при обработке этого элемента мы всегда вынуждены иметь дело со строками.
Подход ASP.NET Web Forms для решения этой проблемы предлагает ввести понятие элемента управления в структуру страницы. Элемент управления ASP.NET Web Forms – это объект.NET Framework, который является наследником базового класса Control и который реализует в себе логику какого-либо элемента на странице. При этом этот объект берет на себя обязательства по генерации собственного HTML-представления, обработке параметров HTTP-запроса и другие операции, связанные с этим элементом. Таким образом, можно сказать, что элемент управления ASP.NET Web Forms является аналогом элемента управления настольного приложения. Платформа ASP.NET уже содержит ряд стандартных, наиболее часто используемых элементов управления, таких как кнопка, поле ввода, переключатели и т.д. Предыдущий пример можно переписать следующим образом.
Как видно, вместо стандартного описания элементов HTML используются объекты ASP.NET. Эти объекты отличает наличие префикса "asp" в названии тега, а также атрибута "runat="server"", который говорит среде исполнения о том, что этот тег является серверным элементом управления. При обращении к веб-форме с таким описанием мы получим аналогичное представление.
Рисунок 4.2 - ASP.NET Web Forms
Отличие такой формы от приведенной ранее состоит в том, что в этом случае каждый элемент управления является объектом.NET Framework, который содержит все необходимые типизированные свойства. Поэтому в данном случае состояние флажка можно получить, используя следующий код.
Как видно из этого примера, у элемента управления CheckBox доступно свойство Checked, которое имеет тип bool. В данном случае не требуется всегда работать со строками, поскольку каждый элемент управления содержит типизированные свойства.
ASP.NET Web Forms содержит уже достаточно большое количество различных элементов управления, которые содержат готовую логику. Эти элементы управления можно использовать в своих приложениях. Однако, если функциональных возможностей этих элементов управления окажется недостаточно, то есть возможность разработать собственный элемент управления, который будет содержать всю необходимую логику.
Для отправки данных на сервере в рамках веб-формы используется механизм обратного вызова - Postback. При обратном вызове выполняется обращение к веб-серверу в виде HTTP-запроса методом POST, в составе которого передаются данные серверу.
Таким образом, ASP.NET Web Forms – это инструментарий, который встроен в общую платформуASP.NET и который позволяет создать собственные веб-формы в составе веб-приложения. Идеология ASP.NET Web Forms строится на основе концепции элементов управления. Элемент управления ASP.NET Web Forms – это объект.NET Framework, который отвечает за обработку входящих параметров и генерацию собственного HTML-представления.
Абстрагирование на уровне элементов управления позволяет задавать внутри элементов управления сложную логику и при этом генерировать сколько угодно сложный HTML-код. Например, давайте рассмотрим элемент управления Calendar.
Элемент управления Calendar представляет собой сложный объект, который выполняет работу по генерации кода HTML на странице в зависимости от выбранной даты. Для размещения этого элемента управления на форме используется несложный код разметки страниц ASP.NET (.aspx).
После запуска приложения и отображения данной страницы, в браузере можно увидеть полноценный календарь. При этом элемент управления генерирует ссылки на управление календарем – для переключения года и месяца, а также для выбора даты(рис.4.3).
Как видно, за небольшим определением календаря в странице ASPX скрывается достаточно сложная логика по генерации и управлению календарем. Если проанализировать объем сгенерированного кода HTML, то можно увидеть, что он располагается более чем на 200 строках и содержит определение таблицы для размещения календаря.
Рисунок 4.3 – Элемент управления Calendar
В общем случае элементы страницы ASP.NET Web Forms могут генерировать еще более сложный HTML-код. Таким образом, разработчик веб-приложения может абстрагироваться от громоздкого написания кода на языке HTML и выстраивать логику веб-приложения, используя подобные "строительные блоки".
С точки зрения программного кода, подобные элементы управления имеют свою объектную модель. Например, приведенный выше элемент управления Calendar имеет ряд свойств, методов и событий для управления поведением элемента управления из программного кода страницы. Все эти элементы можно использовать в программном коде, описывающем логику веб-приложения. Например, можно определить поведение элемента управления следующим образом.
Все элементы управления ASP.NET Web Forms имеют аналогичные свойства, методы и события для управления. Используя их можно воздействовать на элементы управления, размещенные на странице, а также получать информацию из элемента управления.
Таким образом, построение страниц в веб-приложениях на основе ASP.NET Web Forms, как правило, сводится к размещению на странице набора элементов управления для задания определенной функциональности и настройке взаимодействия этих элементов управления на уровне страницы. Зачастую разработчики приложений в этом случае не создают HTML-код отдельных частей страницы, а эту работу выполняют элементы управления. В случае, если какого-либо элемента управления нет в стандартной поставкеASP.NET или функциональности существующих элементов управления недостаточно, то можно использовать наработки других разработчиков или создать собственный элемент управления. Создание собственного элемента управления позволяет повторно использовать код, который разработан один раз. Это означает, что можно создать элемент управления и использовать его в различных проектах многократно. Более того, можно передать элемент управления другим разработчикам
Все элементы управления размещаются на страницах ASP.NET Web Forms. Страница ASP.NET Web Forms представляется объектом Page и является контейнером для элементов управления. Страница управляет генерацией HTML-кода, который в результате будет передан клиенту. При этом объект Page содержит набор методов, свойств и событий для управления поведением страницы. Следующий пример, использует свойство страницы Title, а также подписывается на ряд событий страницы.
Также можно использовать другие свойства и события объекта Page для получения информации от страницы, а также управлять поведением страницы используя методы объекта Page.
Таким образом, можно сделать вывод, что разработка веб-приложений с использованием ASP.NET Web Forms в большей степени абстрагируется на объектах, которые являются составными частями страницы. При этом управление поведением и внешним видом страницы ASP.NET осуществляется посредством методов, свойств и событий таких объектов.
Результатом работы веб-приложения является HTML-код страницы. Для генерации HTML-кода в страницах ASP.NET Web Forms в основном используются специальные объекты.NET–элементы управления. Такие элементы управления содержат набор свойств и методов для управления состоянием этих объектов. Все элементы управления размещаются в контейнере – странице ASP.NET. Для определения поведения всей страницы в целом разрабатывается код, который настраивает взаимодействие элементов управления на странице.
Модель зворотного виклику
Платформа ASP.NET Web Forms, по аналогии с разработкой настольных приложений, содержит модель событий, которые генерируются каждый раз при обработке страницы. Элементы страницы также содержат ряд событий, которые можно использовать для построения своего приложения. Однако, нужно четко понимать, что при работе веб-приложения код страницы генерируется на сервере, а отображается на клиенте. Поэтому необходим механизм, который, например, при нажатии кнопки на клиентской стороне уведомит об этом сервер для того, чтобы последний мог сгенерировать событие и обработать его. По этой причине, при нажатии на кнопку, страница формирует HTTP-запрос к серверу и отправляет данные с помощью метода POST на сервер. В этом случае сервер может понять, что форма инициировала взаимодействие с ним и сгенерировать и обработать нужную последовательность действий.
При выполнении указанных действий, пользователь в момент нажатия на кнопку увидит процесс загрузки той же самой страницы заново. При этом, возможно, часть данных на странице будет обновлена. Фактически, при выполнении подобных действий страница будет перезагружена "сама на себя". Этот процесс можно представить схематически следующим образом(рис 4.4).
Рисунок 4.4 – Процесс обработки события элемента управления
Процесс отправки данных на эту же страницу и обработки данных на сервере называется моделью обратного вызова (postback).
Для того, чтобы описанный выше процесс смог выполнятся, страница в ASP.NET Web Forms представляет собой большую HTML-форму. Это учитывается при генерации исходного HTML-кода страницы, и все элементы страницы заключены в тег <form>.
Эта форма всегда указывает на саму себя и использует метод POST. Использование именно этого HTTP-метода обусловлено тем, что в этом случае все данные будут отправлены на сервер в теле HTTP-запроса, что удобно при наличии большого количества элементов управления на странице. Страница ASP.NET Web Forms не может содержать еще дополнительные HTML-формы – все взаимодействия с сервером выполняются в рамках приведенной выше формы.
Для выполнения обратного вызова в составе страницы присутствуют дополнительные элементы – скрытые поля "__EVENTTARGET" и "__EVENTARGUMENT", а также функция на языке JavaScript "__doPostBack".
Скрытые поля на странице предназначены для указания источника обратного вызова и его аргументов. В качестве источника вызова обычно выступает элемент управления, который инициировал обратный вызов, например, кнопка. Функция JavaScript "__doPostBack" предназначена для осуществления обратного вызова. Как видно из исходного HTML-кода страницы, эта функция присваивает скрытым полям необходимые значения и выполняет отправку формы на сервер. Поскольку HTML-форма содержит все элементы страницы, включая указанные выше скрытые поля, они также будут переданы серверу для обработки. Анализируя состояние этих полей, сервер может определить, какой именно элемент управления осуществил обратный вызов.
При генерации страницы на стороне сервера можно определить, в каком режиме происходит загрузка страницы – это может быть первое обращение к странице или обратный вызов страницы, когда страница перезагружается после взаимодействия пользователя с элементами управления. Для этих целей базовый класс Page содержит свойство IsPostBack. Можно воспользоваться этим свойством и несколько изменить логику, выполняемую при обработке страницы. Например, при первом обращении к странице можно обратиться к базе данных, получить данные и отобразить на странице, а при обратном вызове не делать этого – нужные данные уже будут содержаться на странице в поле ViewState.
4.3 Сторінкові директиви в ASP.NET Web Forms
ASP.NET поддерживает множество команд, называемых директивами, которые можно поместить в файл.aspx. Страничные директивы размещают между символами <% …….%> и они должны быть расположены в начале.aspx файла. С помощью директив можно контролировать поведение страницы, можно считать их языком, на котором программист общается с компилятором, указывая ему, как обрабатывать данную страницу.
Директивы страницы служат для конфигурирования среды выполнения. Имя директивы чувствительно к регистру
Например, использование директивы @ Page может выглядеть следующим образом:
<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" %>
Рассмотрим директивы ASP.NET и их возможные параметры (атрибуты).
Директива @Page файлов.aspx
Основные атрибуты директивы @Page приведены в таблице 4.1:
Таблица 4.1 - Основные атрибуты директивы @Page
| Атрибут | Описание |
| AutoEventWireup | Автоматическая обработка событий страницы, установить true |
| CompilerOptions | Опции компилятора |
| ClassName | Назначает имя класса, сгенерированного данной страницей |
| CodeFile | Название файла, описывающего класс данной страницы, с отделенным кодом для страницы |
| Debug | Если true, то на страницу выводится отладочная информация |
| ErrorPage | Задаёт URL, куда в случае необработанного исключения будет перенаправлен браузер. |
| Trace | Вывод трассировочной информации |
| EnableViewState | Сохранение состояния представления страницы (в кодировке BASE64). По умолчанию – true. |
| EnableViewStateMac | Если true(по умолчанию), то к состоянию представления страницы добавляется зашифрованная аутентификационная подпись на основе кода машины (из файла machine.config), чтобы убедиться, что состояние представления не было изменено на стороне клиента. |
| ViewStateEncryptionMode | Указывает должно ли быть зашифровано состояние представления страницы (Auto – по умолчанию, Always, Never). При Auto состояниеViewState шифруется, если хотя бы один элемент управления на странице запросит это. Может устанавливаться и в web.config – <pages ViewStateEncryptionMode="Always" /> |
| Inherits | Указывает класс Page (System.Web.UI.Page), от которого наследуется класс данной страницы в технологии отделенного кода. По умолчанию _Default |
| Async | Устанавливает страницу как синхронный или асинхронный (false по умолчанию) обработчик. |
| Language | Язык, используемый во внедренном коде. |
| OutputCache | Кэширование вывода страницы. |
Директива @Assembly
Директива @Assembly подключает сторонние (дополнительные пользовательские) сборки к текущей странице в виде.dll или.cs файлов.
Для того чтобы связать сборку со страницей в приложении, необходимо включить в файл страницы одну из двух следующих директив:
<%@ Assembly Name = имя_файла_сборки_из_bin.dll %>
<%@ Assembly Src = путь_к_исходнику_файла_сборки.cs %>
По умолчанию в файле web.config строка <add assembly=”*” /> связывает с приложением (со всеми компилируемыми классами страниц) все сборки из папки bin. Если вы не хотите, чтобы с приложением автоматически связывались все сборки, найденные в bin, то данную строку следует удалить.
Для того, чтобы связать конкретную сборку с приложением, во-первых, необходимо поместить её в корневую папку bin и во-вторых, добавить в файл web.config строки:
<system.web>
<compilation>
<assemblies>
<add assembly = ” список полных имён классов в сборке ”
…
Директива @Import
Директива @Import связывает со страницей пространство имён. Это аналог оператора using
Например, если Вы не хотите создавать в файле страницы новый экземпляр класса ADO.NET DataSet, то можно при помощи директивы @Import импортировать пространство имён System.Data, что даст возможность выполнить оператор типа
DataSet ds = new DataSet();
иначе, каждый раз придётся задавать уточнённое имя класса
System.Data DataSet ds = new System.Data DataSet();
В данном примере импорт пространства имён реализуется очень просто:
<%@ Import namespace = System.Data %>
Такой импорт позволяет использовать короткие имена классов и предполагает наличие сборки, содержащей код.dll соответствующего класса, которая присоединена к текущей странице. Обычно, имена сборок и пространства имён (классов) совпадают.
Директива @ Reference
Директива @Reference устанавливает динамическую связь (взаимодействие) в пределах одного проекта между текущей страницей и заданной страницей или пользовательским элементом управления, где описаны нужные дополнительные классы.
Например,
<%@ Reference page = виртуальный_путь_к_странице_.aspx %>
<%@ Reference control = виртуальный_путь_к_элементу_.ascx %>
Во время компиляции в сборку текущего файла классы и пользовательские элементы управления, указанные в @Reference, становятся доступными.
Директива @Control
Идентифицирует страницу пользовательского элемента управления –.ascx
4.4 Серверні елементи управління
Элементы управления являются одним из наиболее важных элементов концепции ASP.NET Web Forms. По сути, элементы управления ASP.NET Web Forms представляют собой объекты.NET Framework, которые являются наследниками общего базового класса Control или WebControl. Обычно элементы управления содержат в себе некоторую логику и имеют алгоритм генерации HTML-кода для содержимого этого элемента управления. Если рассмотреть иерархию наследования для типичного элемента управления, то можно убедиться в этом. Например, иерархия наследования для элемента управления Calendar выглядит следующим образом.
Рисунок 4.5 – Иерархия наследования для элемента управления Calendar
Обычно элементы управления генерируют свое HTML-представление на стороне сервера при обращении к странице. Вся логика элементов управления зачастую также находится на сервере. Поэтому иногда такие элементы управления называют серверными элементами управления. Однако в некоторых случаях элементы управления могут содержать некоторую логику также и на стороне клиента. Для этого они размещают программный код на языке JavaScript в составе страницы и при взаимодействии пользователя с элементами управления запускают этот код. Например, валидаторы - элементы управления для проверки введенных пользователем значений, используют клиентский код JavaScript для проверки введенных значений – если они введены некорректно, то на сервер ничего не отправляется; если корректно – отправляются и проверяются серверным кодом также.
В составе Visual Studio уже содержится обширный набор стандартных элементов управления, которые можно использовать в своих приложениях. В зависимости от их применимости их можно разделить на несколько категорий:
