Перейти к содержимому

Runat server что это

  • автор:

Типы серверных элементов управления

Серверные элементы управления ASP.NET являются неотъемлемой частью архитектуры ASP.NET. По сути, серверные элементы управления представляют собой классы в среде .NET Framework, представляющие визуальные элементы веб-формы. Некоторые из этих классов являются относительно простыми и отображаются на определенные HTML-дескрипторы. Другие элементы управления намного более абстрактны и реализуют более сложное представление нескольких элементов HTML.

ASP.NET предлагает множество серверных элементов управления, которые делятся на несколько категорий:

Серверные элементы управления HTML

Это классы, в которых содержатся стандартные HTML-элементы. За исключением атрибута runat=»server» объявление серверных элементов управления HTML ничем не отличается от объявления других элементов управления. Двумя наиболее яркими представителями серверных элементов управления являются HtmlAnchor (представляющий дескриптор ) и HtmlSelect (представляющий дескриптор ).

Однако в принципе в серверный элемент управления может быть преобразован любой дескриптор. Если соответствующего напрямую класса нет, ASP.NET будет просто использовать класс HtmlGenericControl. Чтобы преобразовать обычный элемент HTML в серверный элемент управления, нужно всего лишь добавить к дескриптору этого элемента атрибут runat=»server».

Веб-элементы управления

Эти классы дублируют функции базовых HTML-элементов, но обладают более согласованным и значащим набором свойств и методов, которые упрощают их объявление и доступ к ним. В качестве примеров можно назвать элементы управления HyperLink, ListBox и Button. Более того, несколько других типов элементов управления ASP.NET (такие как многофункциональные элементы управления и элементы управления проверкой достоверности) часто считаются особыми типами веб-элементов управления. В Visual Studio вы найдете базовые элементы управления на вкладке Standard (Стандартные) в окне Toolbox (Панель инструментов).

Многофункциональные элементы управления

Эти усовершенствованные элементы управления могут генерировать большой объем HTML-разметки и даже клиентский JavaScript-код для создания интерфейса. В качестве примеров можно назвать элементы управления Calendar, AdRotator и TreeView. В Visual Studio многие многофункциональные элементы управления доступны на вкладке Standard (Стандартные) в окне Toolbox.

Элементы управления проверкой достоверности

Этот набор элементов управления позволяет быстро проверять достоверность связанного элемента управления ввода на предмет соблюдения нескольких стандартных или пользовательских правил. Например, вы можете указать, что ввод не может быть пустым, что это должно быть число, что оно не должно превышать определенное значение, и т.п.

Если проверка достоверности не проходит, вы можете предотвратить обработку страницы или позволить этим элементам управления отображать сообщения об ошибках на странице. В Visual Studio эти элементы управления можно найти на вкладке Validation (Проверка достоверности) в окне Toolbox.

Элементы управления данными

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

Элементы управления навигацией

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

Элементы управления входом в систему

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

Элементы управления Web Parts

Этот набор элементов управления поддерживает Web Parts — модель ASP NET для построения компонентных, легко конфигурируемых веб-порталов.

Элементы управления ASP.NET AJAX

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

Элементы управления ASP.NET Dynamic Data

Эти элементы управления поддерживают компонент ASP.NET Dynamic Data, который позволяет создавать управляемые данными веб-сайты за счет построения гибких шаблонов, а не написания утомительного кода.

Иерархия серверных элементов управления

Все серверные элементы управления унаследованы от базового класса Control из пространства имен System.Web.UI. Это верно при использовании серверных элементов управления HTML, применении веб-элементов управления или создании собственных специальных элементов управления. Это также относится к классу Page, от которого происходят все формы.

На рисунке ниже показаны основные ветви этой цепочки наследования:

Наследование серверных элементов управления

Поскольку все элементы управления происходят от базового класса Control, у вас имеется базовый общий знаменатель, который можно использовать для манипулирования элементом управления на странице, даже если определенный тип элемента управления неизвестен. (Например, этот прием можно применять для циклического прохода по всем элементам управления страницы и сокрытия каждого из них установкой свойства Visible равным false.) В следующей таблице перечислены наиболее часто используемые члены класса Control:

Свойства и методы класса Control

Свойство или метод Описание
ClientID Возвращает идентификатор элемента, который является уникальным именем, созданным ASP.NET при построении экземпляра страницы
Controls Возвращает коллекцию дочерних элементов управления. Коллекция Page.Controls может применяться для извлечения высокоуровневой коллекции элементов управления на странице. Каждый элемент управления в коллекции Controls может содержать собственные дочерние элементы управления, которые, в свою очередь, могут содержать еще какие-то элементы управления, и т.д.
EnableViewState Возвращает или устанавливает булевское значение, указывающее на то, должен ли элемент управления поддерживать свое состояние с помощью обратных отправок родительской страницы. По умолчанию имеет значение true
ID Возвращает или устанавливает идентификатор элемента управления. На практике это имя, с помощью которого вы можете получить доступ к элементу управления из серверных сценариев или класса отделенного кода
Page Возвращает ссылку на объект страницы, в которой содержится элемент управления
Parent Возвращает ссылку на родителя элемента управления, которым может быть страница или другой контейнерный элемент управления
Visible Возвращает или устанавливает булевское значение, указывающее на то, нужно ли генерировать элемент управления. Если равно false, то элемент управления не просто делается невидимым для клиента, но даже не генерируется соответствующий HTML-дескриптор
DataBind() Связывает элемент управления и все дочерние элементы управления с определенным источником данных или выражением
FindControl() Ищет дочерний элемент управления с определенным именем в текущем элементе управления и всех содержащихся в нем элементах. Если дочерний элемент найден, метод возвращает ссылку на общий тип Control, который затем можно привести к соответствующему типу
HasControls() Возвращает булевское значение, указывающее на наличие у элемента управления дочерних элементов управления. Чтобы содержать дочерние элементы, элемент управления должен быть дескриптором контейнера (например, )
RenderControl() Записывает вывод HTML для элемента управления на основе его текущего состояния. Этот метод не вызывается напрямую; вместо этого ASP.NET вызывает его при генерации страницы

ASP.NET элементов управления сервера

В этой статье представлены ASP.NET сервера, такие как серверные элементы управления HTML, веб-серверные элементы управления, элементы управления list и т. д.

Исходная версия продукта: ASP.NET
Исходный номер базы знаний: 306459

В этой статье содержатся ссылки на следующие пространства имен платформа .NET Framework классов Майкрософт:

  • System.Web.UI.HtmlControls.HtmlControl
  • System.Web.UI.WebControls.WebControl

Серверные элементы управления в ASP.NET page framework

Платформа ASP.NET содержит ряд встроенных серверных элементов управления, предназначенных для предоставления более структурированной модели программирования для Интернета. Эти элементы управления предоставляют следующие функции:

  • Автоматическое управление состоянием.
  • Простой доступ к значениям объекта без использования Request объекта.
  • Возможность реагировать на события в серверном коде для создания более структурированных приложений.
  • Распространенный подход к созданию пользовательских интерфейсов для веб-страниц.
  • Выходные данные автоматически настраиваются в зависимости от возможностей браузера.

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

Элементы управления сервером HTML

Элементы управления сервера HTML — это элементы HTML, включаемые в атрибут runat=server . Элементы управления сервера HTML имеют те же выходные данные HTML и те же свойства, что и соответствующие htmL-теги. Кроме того, элементы управления сервером HTML обеспечивают автоматическое управление состоянием и события на стороне сервера. Элементы управления сервером HTML предоставляют следующие преимущества:

  • Элементы управления HTML-сервера сопоставляются с соответствующими HTML-тегами.
  • При компиляции ASP.NET в сборку компилируются элементы управления HTML-сервера runat=server с атрибутом.
  • Большинство элементов управления включают OnServerEvent событие для наиболее часто используемого элемента управления. Например, элемент управления имеет OnServerClick событие.
  • HTML-теги, которые не реализованы как определенные элементы управления HTML-сервера, по-прежнему можно использовать на стороне сервера. однако они добавляются в сборку как HtmlGenericControl .
  • При повторной ASP.NET страницы htmL-сервер сохраняет свои значения.

Базовый System.Web.UI.HtmlControls.HtmlControl класс содержит все общие свойства. Элементы управления сервера HTML являются производными от этого класса.

Чтобы использовать серверный элемент управления HTML, используйте следующий синтаксис (который использует элемент управления HtmlInputText в качестве примера):

Дополнительные сведения об отдельных элементах управления HTML-сервера, доступных в ASP.NET, см. на следующих веб-сайтах:

  • Элемент управления HtmlAnchor
  • Элемент управления HtmlButton
  • Элемент управления HtmlForm
  • Элемент управления HtmlImage
  • Элемент управления HtmlInputButton
  • Элемент управления HtmlInputCheckBox
  • Элемент управления HtmlInputFile
  • Элемент управления HtmlInputHidden
  • Элемент управления HtmlInputImage
  • Элемент управления HtmlInputRadioButton
  • Элемент управления HtmlInputText
  • Элемент управления HtmlSelect
  • Элемент управления HtmlTable
  • Элемент управления HtmlTableCell
  • Элемент управления HtmlTableCell
  • Элемент управления HtmlTextArea

Элементы управления веб-сервера

Веб-элементы управления похожи на серверные элементы управления HTML, такие как Button, TextBox и Hyperlink, за исключением того, что веб-элементы управления имеют стандартизированный набор имен свойств. Веб-серверные элементы управления предоставляют следующие преимущества:

  • Упростите для производителей и разработчиков создание средств или приложений, которые автоматически создают пользовательский интерфейс.
  • Упростите процесс создания интерактивных веб-форм, что требует меньше знаний о работе элементов управления HTML и позволяет уменьшить вероятность ошибок.

Базовый System.Web.UI.WebControls.WebControl класс содержит все общие свойства. Большинство элементов управления веб-сервера являются производными от этого класса.

Чтобы использовать элемент управления веб-сервера, используйте следующий синтаксис (в качестве примера используется элемент управления TextBox):

Элементы управления веб-сервера можно разделить на четыре категории:

  • Основные веб-элементы управления
  • Элементы управления проверкой
  • Элементы управления «Список»
  • Расширенные элементы управления

Базовые веб-элементы управления

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

Дополнительные сведения об отдельных веб-элементах управления, доступных в ASP.NET, см. на следующих веб-сайтах:

  • Элемент управления «Веб-сервер кнопки»
  • CheckBox Web Server Control
  • Элемент управления веб-сервера HyperLink
  • Элемент управления «Веб-сервер изображений»
  • Элемент управления веб-сервера ImageButton
  • Элемент управления «Метка веб-сервера»
  • Элемент управления веб-сервера LinkButton
  • Литеральный элемент управления веб-сервера
  • Панель управления веб-сервером
  • Элемент управления PlaceHolder Web Server
  • Элемент управления веб-сервера RadioButton
  • Элемент управления «Веб-сервер таблиц»
  • Элемент управления веб-сервера TableCell
  • Элемент управления TableRow Web Server
  • Элемент управления textBox Web Server

Элементы управления проверкой

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

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

Проверка на стороне клиента перехватывает ошибки перед завершением операции обратной передачи. Таким образом, если на одной странице есть сочетания элементов управления проверки на стороне клиента и сервера, проверка на стороне сервера будет замещена в случае сбоя проверки на стороне клиента. Дополнительные сведения об отдельных элементах управления проверкой, доступных в ASP.NET, см. на следующих веб-сайтах:

  • Элемент управления RequiredFieldValidator
  • Элемент управления RangeValidator
  • Элемент управления CompareValidator
  • Элемент управления RegularExpressionValidator
  • Элемент управления CustomValidator
  • Элемент управления ValidationSummary

Список элементов управления

Элементы управления списками — это специальные веб-серверные элементы управления, поддерживающие привязку к коллекциям. Элементы управления списком можно использовать для отображения строк данных в настраиваемом формате шаблона. Все элементы управления списками предоставляют свойства DataSource и DataMember, которые используются для привязки к коллекциям.

Элементы управления списками могут быть привязаны только к коллекциям, поддерживающих интерфейсы IEnumerable, ICollection или IListSource. Например, пример страницы .NET для Visual C# выглядит следующим образом:

Пример страницы .NET в Visual Basic выглядит следующим образом:

Выходные данные будут выглядеть следующим образом:

Дополнительные сведения об отдельных элементах управления списками, доступных в ASP.NET, см. на следующих веб-сайтах:

  • Элемент управления ListBox Web Server
  • Элемент управления веб-сервера CheckBoxList
  • Элемент управления веб-сервера RadioButtonList
  • Элемент управления веб-сервера repeater
  • Элемент управления веб-сервера DataList
  • Элемент управления веб-сервера DataGrid
  • Элемент управления веб-сервера DropDownList

Полнофункциональные элементы управления

Помимо предыдущих элементов управления, платформа ASP.NET предоставляет несколько элементов управления для конкретных задач, называемых расширенными элементами управления. Полнофункциональные элементы управления создаются с несколькими элементами HTML и содержат широкие функциональные возможности. Примерами полнофункциональных элементов управления являются элемент управления «Календарь» и элемент управления AdRotator.

Дополнительные сведения об отдельных полнофункциональных элементах управления, доступных в ASP.NET, см. на следующих веб-сайтах:

  • Элемент управления веб-сервера AdRotator
  • Элемент управления «Веб-сервер календаря»
  • Элемент управления XML Web Server

Пользовательские элементы управления

Часто может потребоваться повторно использовать пользовательский интерфейс веб-формы без необходимости писать дополнительный код. ASP.NET это можно сделать, преобразуя веб-формы в пользовательские элементы управления. Пользовательские элементы управления, которые имеют расширение ASCX-файла, можно использовать несколько раз в одной веб-форме.

Чтобы преобразовать веб-форму в пользовательский элемент управления, выполните следующие действия.

  1. Удалите все теги , и теги.
  2. Если директива @ Page отображается на странице, измените ее на @ Control .
  3. Включите className атрибут в директиву @ Control , чтобы пользовательский элемент управления был строго типизирован при создании его экземпляра.
  4. Присвойте элементу управления описательное имя файла и измените расширение файла с ASPX на ASCX.

Дополнительные сведения об пользовательских элементах управления см. в веб-формы User Controls.

пользовательские элементы управления

Помимо встроенных веб-элементов управления, ASP.NET также позволяет создавать собственные пользовательские элементы управления. Если вы столкнулись с одним из следующих сценариев, может оказаться полезным разработать пользовательские элементы управления.

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

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

  • Разработка ASP.NET серверных элементов управления
  • Разработка пользовательских элементов управления: основные понятия
  • Разработка составного элемента управления

Обратная связь

Были ли сведения на этой странице полезными?

Элементы управления HTML

В следующих разделах вы узнаете о серверных элементах управления HTML, определенных в пространстве имен System.Web.UI.HtmlControls. В целом существует около двух десятков отдельных классов серверных элементов управления HTML. Они разбиты на отдельные категории на основе того, являются они элементами управления вводом (в этом случае они унаследованы от HtmlInputControl) или же могут содержать другие элементы управления (тогда они являются производными от HtmlContainerControl).

На рисунке ниже показана иерархия наследования:

Серверные элементы управления HTML

Класс HtmlControl

Все серверные элементы управления HTML являются производными от базового класса HtmlControl. Ниже перечислены свойства, добавленные классом HtmlControl к базовому классу Control:

Свойства класса HtmlControl

Свойство Описание
Attributes Позволяет читать и добавлять атрибуты дескриптора элемента управления. Эту коллекцию можно использовать для добавления атрибутов, не предоставляемых определенными свойствами. (Например, можно добавить атрибут onFocus к текстовому полю и указать какой-то JavaScript-код для настройки того, что будет происходить в результате передачи фокуса текстовому полю.)
Disabled Возвращает или устанавливает состояние доступности элемента управления. При значении true элемент управления становится неактивным
Style Возвращает коллекцию применяемых к элементу управления атрибутов CSS. В веб-странице значение этого свойства имеет вид разделенного точками с запятой списка атрибутов стиль:значение. В Visual Studio указать такое значение можно, щелкнув правой кнопкой мыши на элементе управления в режиме визуального конструктора и выбрав в контекстном меню пункт New Style (Новый стиль)
TagName Возвращает имя дескриптора элемента управления, например, a, img и т.п.

Класс HtmlContainerControl

Любой HTML-дескриптор, который имеет открывающий и закрывающий дескрипторы, может содержать другое содержимое либо элементы управления HTML. В качестве примера можно привести дескриптор ссылки, который обычно заключает текст или изображение в пару .. .. Многие другие HTML-дескрипторы также работают как контейнеры, включая все, начиная с (форматирует блок или содержимое) и заканчивая скромным дескриптором (выделяет текст полужирным начертанием). Эти дескрипторы не отображаются на определенные классы элементов управления HTML, но все же могут использоваться с атрибутом runat=»server». В этом случае вы взаимодействуете с ними через класс HtmlGenericControl, который, в свою очередь, является производным от HtmlContainerControl.

Для поддержки включения класс HtmlContainerControl добавляет два свойства:

InnerHtml

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

InnerText

Возвращает или устанавливает текст внутри открывающего и закрывающего дескрипторов. При использовании этого свойства все символы, интерпретируемые как специальный синтаксис HTML (вроде угловой скобки <), автоматически заменяются эквивалентными HTML-сущностями.

Класс HtmlInputControl

Элементы управления вводом HTML обеспечивают взаимодействие с пользователем. К ним относятся знакомые графические элементы управления — флажки, текстовые поля, кнопки и окна со списком. Все эти элементы управления генерируются с помощью дескриптора . Атрибут type указывает тип элемента управления вводом, как в (текстовое поле), (кнопка Submit (Отправить)), (элементы управления для загрузки файла).

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

Type

Предоставляет тип HtmlInputControl. Например, если это свойство установлено в text (текст), HtmlInputControl является текстовым полем для ввода данных.

Value

Извлекает либо устанавливает значение, связанное с элементом управления вводом. Значение, ассоциированное с элементом управления, зависит от типа элемента управления. Например, в текстовом поле это свойство хранит текст, введенный в элементе управления. Для кнопок оно соответствует тексту кнопки.

Классы серверных элементов управления HTML

В таблице ниже перечислены все доступные серверные элементы управления HTML и специфичные свойства и события, которые каждый элемент добавляет к базовому классу. Как упоминалось ранее, объявление серверных элементов управления HTML на странице дает тот же эффект, что и указание атрибута runat=»server» в обычных статических HTML-дескрипторах. Именно этот атрибут позволяет ASP.NET обрабатывать их и транслировать в экземпляры соответствующего класса .NET. По этой причине серверные элементы управления HTML являются хорошим выбором при преобразовании существующей HTML- или ASP-страницы в веб-форму ASP.NET.

Классы серверных элементов управления HTML

Объявление дескриптора Класс .NET Специфичные члены
HtmlAnchor HRef, Target, Title, Name, событие ServerClick
HtmlButton CausesValidation, ValidationGroup, событие ServerClick
HtmlForm Enctype, Method, Target, DefaultButton, DefaultFocus
HtmlImage Align, Alt, Border, Height, Src, Width
HtmlInputButton Type, Value, CausesValidation, ValidationGroup, событие ServerClick
HtmlInputReset Type, Value
HtmlInputSubmit Type, Value, CausesValidation, ValidationGroup, событие ServerClick
HtmlInputCheckBox Checked, Type, Value, событие ServerClick
HtmlInputFile Accept, MaxLength, PostedFile, Size, Type, Value
HtmlInputHidden Type, Value, событие ServerChange
HtmlInputImage Align, Alt, Border, Src, Type, Value, CausesValidation, ValidationGroup, событие ServerClick
HtmlInputRadioButton Checked, Type, Value, событие ServerChange
HtmlInputText MaxLength, Type, Value, событие ServerChange
HtmlInputPassword MaxLength, Type, Value, событие ServerChange
HtmlSelect Multiple, SelectedIndex, Size, Value, DataSource, DataTextField, DataValueField, Items (коллекция), событие ServerChange
HtmlTableCell Align, BgColor, BorderColor, ColSpan, Height, NoWrap, RowSpan, VAlign, Width
HtmlTableRow Align, BgColor, BorderColor, Height, VAlign, Cells (коллекция)
HtmlTextArea Cols, Rows, Value, событие ServerChange
,

HtmlTable Align, BgColor, Border, BorderColor, CellPadding, Cellspacing, Height, Width, Rows (коллекция)
Любой другой дескриптор HTML с атрибутом runat=»server» HtmlGenericControl Отсутствуют

В этой таблице не были упомянуты три специализированных элемента управления HTML — HtmlHead, HtmlMeta и HtmlTitle, предоставляющие серверный доступ к части веб-страницы . С использованием этих элементов управления можно динамически устанавливать заголовок, метаданные и связанные таблицы стилей для страницы.

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

Установка атрибутов стилей и других свойств

В следующем примере демонстрируются варианты настройки стандартного элемента управления HtmlInputText (который представляет дескриптор ). Для чтения или установки текущего текста в текстовом поле применяется свойство Value. Чтобы сконфигурировать стили, необходимо с помощью коллекции Style добавить новые атрибуты стиля CSS. И, наконец, если нужно установить другие атрибуты, не представленные никакими свойствами, следует использовать коллекцию Attributes.

В предлагаемом примере коллекция Attributes применяется для ассоциирования с клиентским событием onfocus элемента управления простого кода JavaScript (отображающего окно предупреждения с текущим значением текстового поля):

protected void Page_Load(object sender, EventArgs e) < // Выполнить инициализацию, только если страница запрашивается впервые. // После этого данная информация отслеживается в состоянии представления if (!IsPostBack) < // Установить атрибуты стиля для настройки внешнего вида страницы TextBox1.Style["font-size"] = "20px"; TextBox1.Style["color"] = "red"; // Использовать немного отличающийся, но эквивалентный // синтаксис для установки атрибута стиля TextBox1.Style.Add("background-color", "lightyellow"); // Установить текст, отображаемый по умолчанию TextBox1.Value ; // Установить другие нестандартные атрибуты. TextBox1.Attributes["onfocus"] = "alert(TextBox1.value);"; >>

Если запросить эту страницу, для текстового поля возвращается следующий HTML-код:

Атрибут стиля CSS может также содержать информацию, которая не была явно установлена в коде. Например, если изменить размер элемента управления вводом в визуальном конструкторе Visual Studio, к используемому стилю будут добавлены свойства высоты (height) и ширины (width). Эти детали затем появятся и в окончательном HTML-коде.

На рисунке показано, как будет выглядеть приведенная страница при наведении фокуса на текстовое поле:

Тестирование серверных элементов управления HTML

Описанный процесс взаимодействия, по сути, выглядит одинаково для всех серверных элементов управления HTML. Свойства стилей и атрибуты всегда устанавливаются одинаково. Единственное отличие состоит в том, что некоторые элементы управления предоставляют дополнительные свойства. Например, элемент управления HtmlAnchor предоставляет свойство HRef, позволяющее устанавливать целевую страницу для ссылки.

Программное создание серверных элементов управления

Иногда невозможно знать наперед, сколько текстовых полей, переключателей, строк таблиц или других элементов управления понадобится, поскольку это может зависеть от других факторов, таких как количество записей, хранимых в базе данных, или пользовательский ввод. ASP.NET предлагает решение этой проблемы — вы можете просто создать экземпляры необходимых серверных элементов управления HTML, установить их свойства с помощью объектно-ориентированного подхода, использованного в предыдущем примере, а затем добавить их в коллекцию Controls страницы-контейнера.

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

protected void Page_Load(object sender, EventArgs e) < // Создать новый объект HtmlTable HtmlTable table1 = new HtmlTable(); // Установить свойства форматирования таблицы table1.Border = 1; table1.CellPadding = 3; table1.CellSpacing = 3; table1.BorderColor = "red"; // Начать добавлять содержимое в таблицу HtmlTableRow row; HtmlTableCell cell; for (int i=1; iCell: " + j.ToString(); // Добавить ячейку в текущую строку row.Cells.Add(cell); > // Добавить строку в таблицу table1.Rows.Add(row); > // Добавить таблицу внутрь страницы this.Controls.Add(table1); >

Этот пример содержит два вложенных цикла. Во внешнем цикле создаются строки, а во внутреннем — отдельные ячейки для каждой строки, которые затем добавляются в коллекцию Cells текущей строки. По окончании внутреннего цикла код добавляет всю строку в коллекцию Rows таблицы. Последнее действие выполняется по завершении внешнего цикла. На этом этапе код добавляет готовую таблицу в коллекцию Controls страницы.

Компиляция страниц ASP.NET: генерация кода

Сейчас пришла пора разобраться с тем, что происходит с кодом от момента написания ASPX/ASCX- разметки и CS-кода до момента их физического выполнения в виде некоторого скомпилированного кода на сервере.

Генерация полного исходного кода

Начнём с простой, и, в принципе, известной особенности ASP.NET 2.0: частичной компиляции страниц. Как мы знаем, частичные (partial) классы — это синтаксический сахар для разнесения исходного кода класса в несколько разных файлов. Это особенно удобно, когда одна часть кода класса генерируется автоматически некоторой утилитой, а другая — пишется вручную программистом. Так как модифицировать автогенерённый код — очень плохая практика (ведь последующая перегенерация уничтожит все такие изменения), в таких случаях утилита генерирует классы как частичные, и программист может спокойно добавить нужный функционал «рядом», в соседнем файле, не затрагиваемом перегенерацией.
Именно так и поступает среда ASP.NET, когда сталкивается с парой ASPX (или ASCX,ASHX,ASAX) + CS. Пусть есть пара описаний — ASPX-страница с серверным кодом и элементом управления и её файл отделённого кода:

SomePage.aspx:

SomePage.aspx.cs:

  1. using System ;
  2. using System.Web ;
  3. using System.Web.UI ;
  4. using System.Web.UI.WebControls ;
  5. public partial class SomePage : Page
  7. protected void Page_PreRender ( object sender, EventArgs e )
  9. lblHello. Text = «Hello from code» ;
  10. >
  11. >

Рассмотрим, как данная страница превращается в код.

Здесь ASP.NET генерирует целых два класса. Во-первых, генерируется partial class SomePage, в котором определёны защищённые члены для элементов управления (в нашем случае Label lblHello) и два свойства для доступа к пользовательским типизированным объектам Profile и ApplicationInstance (в данном примере их типы не переопределялись и совпадают со стандартными), а также представлен тот серверный код, что мы видели в теге

App_Web_ogjttwiz.0.cs:

  1. public partial class SomePage : System. Web . SessionState . IRequiresSessionState
  2. protected global :: System. Web . UI . WebControls . Label lblHello ;
  3. protected void Page_Load ( object sender, EventArgs e )
  5. lblHello. ForeColor = System. Drawing . Color . Red ;
  6. >
  7. protected System. Web . Profile . DefaultProfile Profile
  8. get
  9. return ( ( System. Web . Profile . DefaultProfile ) ( this . Context . Profile ) ) ;
  10. >
  11. >
  12. protected System. Web . HttpApplication ApplicationInstance
  13. get
  14. return ( ( System. Web . HttpApplication ) ( this . Context . ApplicationInstance ) ) ;
  15. >
  16. >
  17. >

После этого генерируется собственно класс страницы, который уже будет обрабатывать наш физический запрос. Замечу, что его ASP.NET помещает в тот же временный файл кода, в котором мы видели и предыдущий класс.

App_Web_ogjttwiz.0.cs (продолжение):

  1. namespace ASP
  2. .
  3. [ System . Runtime . CompilerServices . CompilerGlobalScopeAttribute ( ) ]
  4. public class somepage_aspx : global :: SomePage , System. Web . IHttpHandler
  5. private static bool @__initialized ;
  6. private static object @__fileDependencies ;
  7. [ System. Diagnostics . DebuggerNonUserCodeAttribute ( ) ]
  8. public somepage_aspx ( )
  9. string [ ] dependencies ;
  10. ( this ) . AppRelativeVirtualPath = «~/SomePage.aspx» ;
  11. if ( ( global :: ASP . somepage_aspx .@__initialized == false ) )
  12. dependencies = new string [ 2 ] ;
  13. dependencies [ 0 ] = «~/SomePage.aspx» ;
  14. dependencies [ 1 ] = «~/SomePage.aspx.cs» ;
  15. global :: ASP . somepage_aspx .@__fileDependencies = this . GetWrappedFileDependencies ( dependencies ) ;
  16. global :: ASP . somepage_aspx .@__initialized = true ;
  17. >
  18. this . Server . ScriptTimeout = 30000000 ;
  19. >
  20. [ System. Diagnostics . DebuggerNonUserCodeAttribute ( ) ]
  21. protected override void FrameworkInitialize ( )
  22. base . FrameworkInitialize ( ) ;
  23. this . @__BuildControlTree ( this ) ;
  24. this . AddWrappedFileDependencies ( global :: ASP . somepage_aspx .@__fileDependencies ) ;
  25. >
  26. [ System. Diagnostics . DebuggerNonUserCodeAttribute ( ) ]
  27. private void @__BuildControlTree ( somepage_aspx @__ctrl )
  28. this . InitializeCulture ( ) ;
  29. System. Web . UI . IParserAccessor @__parser = ( ( System. Web . UI . IParserAccessor ) ( @__ctrl ) ) ;
  30. @__parser. AddParsedSubObject ( new System. Web . UI . LiteralControl ( @»
  32. SomePage
  33. » ) ) ;
  34. global :: System. Web . UI . WebControls . Label @__ctrl2 ;
  35. @__ctrl2 = this . @__BuildControllblHello ( ) ;
  36. @__parser. AddParsedSubObject ( @__ctrl2 ) ;
  37. @__parser. AddParsedSubObject ( new System. Web . UI . LiteralControl ( «» ) ) ;
  38. >
  39. [ System. Diagnostics . DebuggerNonUserCodeAttribute ( ) ]
  40. private global :: System. Web . UI . WebControls . Label @__BuildControllblHello ( )
  41. global :: System. Web . UI . WebControls . Label @__ctrl ;
  42. @__ctrl = new global :: System. Web . UI . WebControls . Label ( ) ;
  43. this . lblError = @__ctrl ;
  44. @__ctrl. ApplyStyleSheetSkin ( this ) ;
  45. @__ctrl. ID = «lblHello» ;
  46. @__ctrl. EnableViewState = false ;
  47. return @__ctrl ;
  48. >
  49. .
  50. >
  51. >

Этот класс по умолчанию имеет имя somepage_aspx, но это можно изменить установкой атрибута ClassName у директивы Page, вот так:

Как видно здесь, для генерации первого из классов (public partial class SomePage) используется атрибут CodeFile и Inherits, причём они должны быть согласованы (то есть, в файле, указанном в CodeFile, должен находиться класс с именем, как в атрибуте Inherits). После этого создаётся второй класс с именем, взятом из атрибута ClassName (или по умолчанию — <Значение_Inherits_lowercase>_aspx)
Во втором классе (именно он является окончательным классом страницы) мы видим код, отвечающий за генерацию дерева элементов управления страницы, и код, отвечающий за инициализацию инфраструктуры компиляции и кэширования скомпилированных страниц в виде сборок .dll.
Разберем его по частям.

  1. public somepage_aspx ( )
  2. string [ ] dependencies ;
  3. ( this ) . AppRelativeVirtualPath = «~/SomePage.aspx» ;
  4. if ( ( global :: ASP . somepage_aspx .@__initialized == false ) )
  5. dependencies = new string [ 2 ] ;
  6. dependencies [ 0 ] = «~/SomePage.aspx» ;
  7. dependencies [ 1 ] = «~/SomePage.aspx.cs» ;
  8. global :: ASP . somepage_aspx .@__fileDependencies = this . GetWrappedFileDependencies ( dependencies ) ;
  9. global :: ASP . somepage_aspx .@__initialized = true ;
  10. >
  11. this . Server . ScriptTimeout = 30000000 ;
  12. >

Конструктор somepage_aspx инициализирует текущий виртуальный путь для страницы, так как сама инфраструктура ASP.NET не отвечает за это (надо иметь в виду этот факт при разработке собственных пользовательских классов-наследников страницы, обходящий стандартный путь компиляции).
После этого заявляется, что скомпилированная версия данного класса (в виде dll) должна быть перекомпилирована при изменении следующих исходных файлов: ~/SomePage.aspx и ~/SomePage.aspx.cs. Данная информация будет ниже передана инфраструктуре (а именно — стандартному провайдеру пути), который, в свою очередь, будет предоставлять её провайдеру компиляции при необходимости.

Генерацией дерева элементов управления занимается метод @__BuildControlTree, в котором производится поочёредный вызов методов вида @__BuildControl():

  1. [ System. Diagnostics . DebuggerNonUserCodeAttribute ( ) ]
  2. private void @__BuildControlTree ( somepage_aspx @__ctrl )
  3. this . InitializeCulture ( ) ;
  4. System. Web . UI . IParserAccessor @__parser = ( ( System. Web . UI . IParserAccessor ) ( @__ctrl ) ) ;
  5. @__parser. AddParsedSubObject ( new System. Web . UI . LiteralControl ( @»
  7. SomePage
  8. » ) ) ;
  9. global :: System. Web . UI . WebControls . Label @__ctrl2 ;
  10. @__ctrl2 = this . @__BuildControllblHello ( ) ;
  11. @__parser. AddParsedSubObject ( @__ctrl2 ) ;
  12. @__parser. AddParsedSubObject ( new System. Web . UI . LiteralControl ( «» ) ) ;
  13. >

В нашем случае контрол всего один — это lblHello. Помимо создания объекта для него, в объектное дерево страницы добавляются текстовые фрагменты, обрамляющие наш контрол. В итоге, каждая строчка разметки оказывается добавленной в объектное дерево страницы, либо как LiteralControl, либо как типизированный серверный элемент управления.

Итого

Полученный класс реализует интерфейс IHttpHandler, и после отработки фабрики страниц созданный ею экземпляр этого класса обрабатывает запрос вида http://url/SomePage.aspx — после чего начинается всем хорошо известный жизненный цикл ASP.NET.

В дальнейшем, вероятно, напишу подробнее про провайдеры, упоминавшиеся здесь: компиляции и виртуального пути.

Похожие публикации:
  1. Centos 7 сколько места на диске
  2. Mikrotik как узнать ip на интерфейсе
  3. Как найти скорость через высоту
  4. Что такое сэмпл в программировании

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *