C# Web. Занятие 05.

Темы лекции: ASP.NET. Web Forms. Часть 1.
Практическое задание: ASP.NET. Web Forms.
Тренер: Игорь Шкулипа, к.т.н.
Разработка Веб-приложений на платформе
Microsoft .NET Framework.
Занятие 5

http://www.slideshare.net/IgorShkulipa 2
ASP.NET
ASP.NET(Active Server Pages) — технология создания веб-приложений
и веб-сервисов от компании Майкрософт. Она является составной
частью платформы Microsoft .NET и развитием более старой технологии
Microsoft ASP.
Когда платформа ASP.NET была выпущена впервые, от предыдущих
продуктов Microsoft и конкурирующих платформ ее отличали семь
ключевых фактов:
• ASP.NET интегрируется с .NET Framework
• Код ASP.NET компилируется, а не интерпретируется
• В ASP.NET поддерживается множество языков
программирования
• ASP.NET обслуживается средой CLR
• Автоматическое управление памятью и сборкой мусора
• Безопасность типов
• Метаданные
• Обработка ошибок
• Многопоточностъ

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

• HTML- и веб-элементы управления
• На момент создания ASP.NET существовало два типа мышления. Одних
разработчиков ASP.NET больше интересовали серверные элементы
управления, которые бы в точности соответствовали
существующему набору элементов управления HTML. Такой
подход позволяет создавать интерфейсы для веб-страниц ASP.NET в
редакторах HTML и предоставляет быстрый путь для миграции
существующих страниц ASP.
Однако другие разработчики ASP.NET видели будущее в другом — в
многофункциональных серверных элементах управления,
которые бы не просто имитировали отдельные дескрипторы HTML. Эти
элементы управления могли бы визуализировать свой интерфейс из
десятков отдельных элементов HTML и при этом все равно
предоставлять программистам простой объектный интерфейс для
работы и позволять им использовать программируемые меню,
календари, списки данных, средства проверки данных и т.д.
После некоторых размышлений в Microsoft решили обеспечить обе
этих модели. Кроме серверных элементов управления HTML в ASP NET
еще предлагаются и так называемые веб-элементы управления,
которые предоставляют более высокий уровень абстракции и больше
функциональных возможностей.

• ASP.NET поддерживает все браузеры
• Одним из самых больших испытаний для разработчиков веб-
приложений является необходимость в обеспечении
поддержки множества различных браузеров. В разных
браузерах, версиях и конфигурациях технологии HTML, CSS и
JavaScript поддерживаются по-разному. Разработчики веб-
приложений должны выбирать, визуализировать содержимое
в соответствии с наименьшими общими характеристиками или
добавлять фрагменты для принятия во внимание
специфических особенностей популярных браузеров.
В ASP.NET эта проблема решена удивительно
интеллектуальным способом. Хотя внутри страницы ASP.NET
можно извлечь информацию о браузере клиента и его
возможностях, в действительности в ASP.NET рекомендуется
игнорировать такой подход и пользоваться развитым
комплектом серверных веб-элементов управления.

Модель ASP.NET

Динамический пользовательский интерфейс
Несомненно, модель элементов управления облегчает извлечение
информации о форме. Еще более примечательно то, что она упрощает
жизнь при необходимости добавления информации к странице. Почти
все свойства веб-элемента управления можно читать и устанавливать.
Это означает, что, например, свойство текстового поля Text можно
установить так же просто, как и прочитать его.
HTML
<asp:Label ID="Label1" runat="server"></asp:Label>
C#
Label1.Text = "Welcome " + txtFirstName.Text + " " + txtLastName.Text;
Label1.ForeColor = Color.Red;

Динамический пользовательский интерфейс
Этот код обладает несколькими преимуществами:
• Во-первых, его намного легче написать (причем без ошибок). В данном
примере экономия незначительна, однако она становятся весьма
существенной, если принимать во внимание полную страницу ASP.NET, на
которой необходимо динамически изменять сложные блоки HTML,
содержащие ссылки, изображения и стили.
• Во-вторых, основанный на элементах управления код также намного
легче разместить внутри страницы. Вы можете написать код ASP.NET
независимо от того, где происходит соответствующее действие. С другой
стороны, в случае классической ASP вам придется позаботиться о
расположении содержимого на странице и соответствующем размещении
кода блоков сценариев. Если страница содержит динамические области, она
может превратиться в путаницу из блоков сценариев, не связанных между
собой и не упорядоченных.
• Третим преимуществом модели элементов управления является способ
сокрытия низкоуровневых подробностей HTML. Это не только дает
возможность писать код без изучения всех индивидуальных особенностей
HTML, но также позволяет страницам поддерживать более широкий
диапазон браузеров. Поскольку элемент управления визуализирует себя
сам, он обладает способностью адаптировать свой вывод с целью
поддержки различных браузеров, усовершенствованных клиентских свойств
или даже других стандартов, связанных с HTML, наподобие XHTML или WML.
По существу код уже не привязан непосредственно к стандарту HTML.

Модель событий ASP.NET
ASP.NET предлагает управляемую событиями модель обработки (event-
driven model). В этой модели разработчик сначала добавляет в веб-
форму элементы управления, а затем решает, на какие события он
хочет реагировать. Каждый обработчик событий представляет собой
отдельный метод, благодаря чему код страниц выглядит аккуратно и
организованно.
Эта модель не является новой, но до появления ASP.NET она применялась
исключительно в области программирования оконных
пользовательских интерфейсов для многофункциональных клиентских
приложений.

Модель событий ASP.NET
1. При первом запуске страницы ASP.NET создает объекты этой страницы и ее
элементов управления. Далее выполняется код инициализации, после чего
страница преобразуется в HTML и возвращается клиенту, а созданные объекты
удаляются из памяти сервера.
1. На каком-то этапе пользователь выполняет действие, инициирующее
обратную отправку данных, например, щелкает на кнопке. Тогда страница
отправляется серверу вместе со всеми данными формы.
1. ASP.NET перехватывает эту возвращаемую страницу и снова воссоздает ее
объекты, возвращая их в то состояние, в котором они находились тогда, когда
эта страница в последний раз отправлялась клиенту.
1. Далее ASP.NET проверяет, какая именно операция привела к обратной
отправке данных, и генерирует соответствующие события (например,
Button.Click), на которые разработчик может предусмотреть в своем коде
определенную реакцию.
1. Затем, выполняется код разработчика, например, выполняется какая-то
серверная операция, а затем изменяются объекты элементов управления так,
чтобы они отображали уже новую информацию.
1. Измененная страница преобразуется в HTML и возвращается клиенту.
Объекты страницы удаляются из памяти. В случае если происходит еще одна
обратная отправка данных, ASP.NET повторяет действия, перечисленные в
пунктах 2-4.

Автоматическая обратная отправка данных
Разработчики Windows-приложений уже давно привыкли иметь дело с
полнофункциональной моделью событий, позволяющей коду
реагировать на перемещения мыши, нажатия клавиш клавиатуры и
мгновенные взаимодействия элементов управления. Но в ASP.NET
действия клиента происходят на стороне клиента, а серверная
обработка осуществляется на веб-сервере. Это означает, что
ответ на событие всегда влечет за собой определенные накладные
расходы. Поэтому быстро генерируемые события (вроде событий
перемещения курсора мыши) в мире ASP.NET являются совершенно
непрактичными.
Чтобы добиться в пользовательском интерфейсе определенного эффекта,
для обработки быстрых событий вроде перемещений курсора мыши
можно создать клиентский сценарий JavaScript. Или, что даже лучше,
можно воспользоваться специальным элементом управления ASP.NET
со встроенными возможностями подобного рода, например, одним из
элементов ASP.NET AJAX. Однако код бизнес-логики должен
обязательно выполняться только в безопасной многофункциональной
среде сервера.

Автоматическая обратная отправка данных
Чтобы использовать автоматическую обратную отправку, понадобится
установить свойство AutoPostBack веб-элемента управления в true
(по умолчанию это свойство устанавливается в false, что гарантирует
оптимальную производительность в случаях, когда не требуется
реагировать ни на какие события изменения). После этого ASP.NET
использует клиентские возможности JavaScript для устранения
пробела между клиентским и серверным кодом.
В частности, происходит следующее: в случае создания веб-страницы с
одним или более веб-элементами управления, для которых
настраивается AutoPostBack, ASP.NET добавляет в визуализируемую
HTML-страницу JavaScript-функцию по имени ____doPostBack(). При
вызове эта функция инициирует обратную отправку, отправляя
страницу обратно веб-серверу со всеми данными формы.
Помимо этого, ASP.NET также добавляет два скрытых поля ввода, которые
функция ____doPostBack() использует для передачи обратно серверу
определенной информации. Этой информацией является
идентификатор элемента управления, который инициировал событие,
и другие значимые сведения.

Состояние представления
Последним компонентом в модели ASP.NET является механизм состояния
представления (view state). Этот механизм решает еще одну проблему,
которая возникает из-за того, что HTTP не поддерживает состояний —
утрату информации об изменениях.
Каждый раз, когда страница отправляется обратно серверу, ASP.NET
получает все данные, которые пользователь ввел в любом из
содержащихся в дескрипторе <form> элементов управления <input>.
После этого ASP.NET загружает веб-страницу в исходном состоянии
(на основе схемы компоновки и параметров по умолчанию, которые
были указаны в файле .aspx) и настраивает ее в соответствии с этими
новыми данными.
Проблема состоит в том, что в динамической веб-форме код может
изменять намного больше деталей. Например, он может программно
изменять цвет заголовка, редактировать фрагмент статического
текста, скрывать или отображать панель с элементами управления или
даже привязывать целую таблицу данных к сетке. Все эти действия
подразумевают изменение исходного состояния страницы. Однако ни
одно из них не отражается в пересылаемых данных формы. А это
означает, что после каждой обратной отправки данных эта
информация будет утрачиваться.

Для устранения этого ограничения в ASP.NET имеется свой
интегрированный механизм сериализации состояния.
Этот механизм работает так:
• После завершения выполнения кода страницы (и непосредственно
перед генерацией и отправкой клиенту окончательного документа
HTML) ASP.NET изучает свойства всех представленных на этой
странице элементов управления.
• Если хоть какое-то из этих свойств изменилось по сравнению с тем,
каким оно было в исходном состоянии, ASP.NET делает
соответствующую заметку в коллекции "имя-значение".
• Потом ASP.NET берет всю собранную информацию и сериализирует
ее в строку формата Base64 (который гарантирует отсутствие
специальных символов, являющихся недопустимыми в HTML),
• А затем вставляет эту строку в раздел <form> страницы как новое
скрытое поле.

При следующей обратной отправке данной страницы, ASP.NET выполняет
перечисленные ниже действия:
1. Воссоздает объект страницы и ее элементов управления на основе
значений по умолчанию (указанных в файле .aspx), в результате чего
страница оказывается в том же состоянии, в котором была, когда
запрашивалась впервые.
1. Выполняет десериализацию информации о состоянии и обновляет все
элементы управления. В результате страница возвращается в состояние, в
котором находилась перед последней отправкой клиенту.
1. Напоследок производится настройка страницы в соответствии с
отправленными данными формы. Например, если пользователь ввел
новый текст в текстовом поле или же сделал новый выбор в окне списка,
эта информация разместится в коллекции Form и используется ASP.NET для
постройки соответствующих элементов управления. После этого страница
отображает текущее состояние при ее просмотре пользователем.
1. Теперь в действие вступает ваш код обработки событий. ASP.NET
генерирует соответствующие события, и код может реагировать изменением
страницы, переходом на новую страницу или же выполнением какой-то
другой операции.

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

• Инициализация структуры страницы
На этом этапе ASP.NET создает страницу. Генерируются все элементы
управления, определенные в дескрипторах внутри веб-страницы
.aspx. Более того, если страница запрашивается не впервые (иначе
говоря, если это обратная отправка), ASP.NET десериализирует
информацию о состоянии представления и применяет ее ко всем
элементам управления.
На этом этапе запускается событие Page.Init. Однако это событие
редко обрабатывается веб-страницей, поскольку еще слишком рано
выполнять инициализацию страницы. Причина в том, что объекты
элементов управления еще не созданы, а информация о состоянии
представления пока не загружена.
• Инициализация кода пользователя
На этом этапе запускается событие Page.Load. Большинство веб-
страниц обрабатывают это событие для выполнения любой
необходимой инициализации, подобной заполнению динамических
текстовых полей или конфигурирования элементов управления.
Событие Page.Load запускается всегда, независимо от того,
запрашивается страница впервые или же как часть обратной
отправки. К счастью, ASP.NET позволяет программистам различать
события первой загрузки страницы и все последующие загрузки.

• Проверка достоверности
В состав ASP.NET входят специальные элементы управления, которые
могут автоматически проверять другие элементы управления,
принимающие вводимые пользователем данные, и отображать
сообщения об ошибках. Эти элементы управления вступают в игру
после того, как загрузится страница, но перед тем как произойдет
какое-то другое событие. Однако они по большей части являются
самодостаточными, а это означает, что реагировать на генерируемые
ими события проверки не нужно. Вместо этого можно в другом
обработчике событий проверить, является ли действительной вся
страница (с помощью свойства Page.IsValid).
• Обработка событий
На этом этапе страница является уже полностью загруженной и
проверенной. Поэтому ASP.NET запускает все события, которые
успели произойти с момента последней обратной отправки данных.

• В конце своего жизненного цикла страница преобразуется в HTML-
разметку.
После этого начинается реальная очистка и запускается событие
Page.Unload. В этот момент объекты страницы все еще доступны, но
окончательная HTML-разметка уже сгенерирована и не может быть
изменена.
У .NET Framework имеется служба сборки мусора, периодически
запускаемая для освобождения памяти, занятой объектами, на
которые уже нет ссылок. Неуправляемые ресурсы должны
освобождаться явно на этапе очистки или, что лучше, перед
ним. Когда сборщик мусора уничтожает страницу, запускается
событие Page.Disposed. На этом жизненный цикл веб-страницы
завершен.

Структура страницы
Для визуализации страницы веб-форме необходимо взаимодействовать со
всеми входящими в ее состав элементами управления. По сути, веб-
форма сначала визуализируется сама, а затем просит все элементы
управления на странице тоже визуализироваться. Каждый из этих
элементов управления, в свою очередь, может содержать дочерние
элементы управления, причем все они также самостоятельно отвечают
за код визуализации.
По мере того, как элементы управления визуализируются, страница
собирает генерируемую HTML-разметку в завершенную страницу. На
первый взгляд этот процесс может показаться немного сложным, но он
предоставляет поразительную мощность и гибкость при создании
развитых интерфейсов веб-страниц.
При первом создании страницы (в ответ на HTTP-запрос) ASP.NET
инспектирует файл .aspx. Для каждого обнаруживаемого там элемента
с атрибутом runat="server" ASP.NET создает и настраивает объект
элемента управления, после чего добавляет этот элемент управления в
виде дочернего элемента управления страницы. Просмотреть все
дочерние элементы управления страницы можно в коллекции
Page.Controls.

Класс Page
Все веб-формы, фактически, являются экземплярами класса Page из
ASP.NET, который находится в пространстве имен System.Web.UI.
Наследование от Page также еще предоставляет коду доступ к
следующим полезным свойствам:
• Session
• Application
• Cache
• Request
• Response
• Server
• User
• Trace
Многие из этих свойств соответствуют внутренним объектам, которые
можно было использовать в классических веб-страницах.

Объекты Session, Application и Cache
• Объект Session является экземпляром класса
System.Web.SessionState.HttpSessionState. Он предназначен для
хранения любого типа пользовательских данных, который должен постоянно
существовать между запросами веб-страниц. Объект Session предоставляет
словарный доступ к набору пар "имя-значение", представляющему
пользовательские данные для этого сеанса. Состояние сеанса часто
применяется для обслуживания информации наподобие имени и
идентификатора пользователя, покупательской тележки либо других
элементов, удаляемых, когда пользователь уже не посещает страницы веб-
сайта.
• Объект Application является экземпляром класса
System.Web.HttpApplicationState. Подобно объекту Session, он тоже
представляет собой словарь данных типа "имя-значение". Однако эти данные
являются глобальными для всего приложения.
• Объект Cache, является экземпляром класса System.Web.Caching.Cache.
В нем также хранится глобальная информация, но он предлагает более
масштабируемый механизм хранения, поскольку ASP.NET может удалять
объекты в случае нехватки памяти сервера. Как и другие наборы состояний,
это, по сути, коллекция объектов "имя-значение", однако здесь для каждого
элемента можно также устанавливать специализированные политики
истечения срока и определять зависимости.

Объект Request
Объект Request является экземпляром класса
System.Web.HttpRequest. Этот объект представляет значения и
свойства HTTP-запроса, который привел к загрузке страницы. В нем
содержатся все параметры, касающиеся URL, а также все остальные
данные, которые были отправлены клиентом.
Свойство Описание
AnonymousID Уникальным образом идентифицирует текущего
пользователя, если был включен анонимный доступ.
ApplicationPath и
PhysicalApplicationPath
ApplicationPath извлекает информацию о месте
размещения виртуального каталога приложения
ASP.NET (URL-адрес), a PhysicalPath — о месте
размещения его "реального" каталога
Browser
Предоставляет ссылку на объект
HttpBrowserCapabilities, в котором содержатся
свойства, описывающие различные функциональные
возможности браузера
ClientCertificate
Объект HttpClientCertificate, предоставляющий
сертификат безопасности для текущего запроса, если
таковой существует
Cookies Предоставляет коллекцию cookie-наборов,
отправляемых с этим запросом

FilePath и
CurrentExecutionFilePa
th
Возвращают реальный путь к файлу (относительно сервера)
для выполняемой в данный момент страницы.
Form Представляет коллекцию переменных формы, обратно
отправляемых странице.
Headers и
ServerVariables
Предоставляют словарную коллекцию HTTP-заголовков и
серверных переменных с индексацией по имени. Эти
коллекции по большей части состоят из низкоуровневой
информации, которая отправлялась браузером вместе с
веб-запросом.
IsAuthenticated и
IsSecureConnection
Возвращают true в случае успешной аутентификации
пользователя и подключения пользователя по протоколу
защищенных сокетов (Secure Sockets Layer — SSL)
IsLocal Возвращает true, если пользователь запрашивает страницу
с локального компьютера
QueryString Предоставляет параметры, переданные в строке запроса
Url и UrlReferrer
Выдают объект Uri, представляющий текущий адрес
страницы и страницу, с которой переходит пользователь
(предыдущую страницу, содержащую ссылку на данную
страницу)
UserAgent Строка, представляющая тип браузера. Internet Explorer
предоставляет для этого свойства значение MSIE.

UserHostAddress и
UserHostName
Извлекают информацию об IP-адресе и DNS-имени
удаленного клиента. К этой информации также можно
получать доступ и через коллекцию ServerVariables. Однако
из-за трансляции сетевых адресов (Network Address
Translation — NAT) она не всегда бывает значимой. В
зависимости от способа подключения к Интернету, многие
клиенты могут использовать совместно один и тот же IP-
адрес (например, IP-адрес шлюзового компьютера). Помимо
этого, IP-адрес также еще может и меняться после
выполнения нескольких запросов
UserLanguages
Предоставляет отсортированный строковый массив, в
котором перечислены языковые предпочтения клиента.
Может быть полезно при создании многоязычных страниц

Объект Response
Объект Response является экземпляром класса
System.Web.HttpResponse и представляет ответ веб-сервера на
запрос клиента. При классической ASP-разработке объект Response
был единственным способом программной отправки HTML-текста
клиенту.
Теперь серверные элементы управления содержат вложенные объектно-
ориентированные методы для выполнения визуализации самих себя.
От разработчика требуется всего лишь установить значения их
свойств. Поэтому объект Response уже не играет такой центральной
роли, как раньше.

Перемещение между страницами
Самой важной функцией класса HttpResponse является предоставление
небольшого набора методов, которые позволяют переходить с одной
страницы на другую. Наиболее универсальным из них является метод
Redirect(), который позволяет перенаправлять пользователя на
другую страницу.
// Перенаправление к файлу в текущем каталоге.
Response.Redirect("PageFlow.aspx");
// Перенаправление на другой веб-сайт.
Response.Redirect("http://www.google.com");

Объект Server
Объект Server является экземпляром класса System.Web.HttpServerUtility
и предоставляет вспомогательные методы и свойства.
Метод или свойство Описание
MachineName
Свойство, представляющее имя компьютера, на котором
запускается страница. Это имя веб-сервера,
используемого компьютером с целью его
идентификации для остальной части сети
GetLastError() Извлекает объект исключения для самой поздней
ошибки (или ссылку null, если таковая не существует).
HtmlEncode() и
HtmlDecode()
Заменяет обычную строку строкой допустимых символов
HTML (и наоборот)
UrlEncode() и
UrlDecode()
Заменяет обычную строку строкой допустимых символов
URL (и наоборот)
MapPath()
Возвращает физический путь к файлу, соответствующий
определенному виртуальному пути к файлу на веб-
сервере.
Transfer()
Передает выполнение другой веб-странице в текущем
приложении. Этот метод похож на Response.Redirect(),
но работает быстрее. Не может применяться для
перемещения пользователя на сайт, расположенный на
другом веб-сервере, или же на страницу, отличную от
ASP.NET (такую как HTML или ASP)

Объекты User и Trace
• Объект User
Объект User представляет информацию о пользователе, запрашивающем
веб-сервер, и позволяет проверить принадлежность этого пользователя
к роли.
Объект User реализует интерфейс
System.Security.Principal.IPrincipal. Определенный класс зависит от
используемого типа аутентификации. Например, пользователя можно
аутентифицировать на основе информации об учетной записи Windows с
использованием IIS или же с помощью специальной базы данных и
выделенной страницы входа в систему. Однако важно понимать, что
объект User предоставляет полезную информацию только в том случае,
если веб-приложение выполняет какую-то разновидность
аутентификации, которая ограничивает доступ анонимных
пользователей.
• Объект Trace
Объект Trace является универсальным-объектом трассировки и
экземпляром класса System.Web.TraceContext. Он позволяет
записывать информацию в журнал на уровне страниц. Этот журнал
содержит подробную информацию о синхронизации, чтобы вы не только
могли видеть объект Trace для отладки, но и использовать его для
мониторинга производительности и синхронизации.

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

• Веб-элементы управления
Эти классы дублируют функции базовых HTML-элементов, но обладают
более согласованным и значащим набором свойств и методов, которые
упрощают их объявление и доступ к ним. В качестве примеров можно
назвать элементы управления HyperLink, ListBox и Button.
• Многофункциональные элементы управления
Эти усовершенствованные элементы управления могут генерировать
большой объем HTML-разметки и даже клиентский JavaScript-код для
создания интерфейса. В качестве примеров можно назвать элементы
управления Calendar, AdRotator и TreeView.

• Элементы управления проверкой достоверности
Этот набор элементов управления позволяет быстро проверять
достоверность связанного элемента управления ввода на предмет
соблюдения нескольких стандартных или пользовательских правил. В
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, который позволяет создавать управляемые данными веб-сайты
за счет построения гибких шаблонов, а не написания утомительного
кода.

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

Серверные элементы управления
Ссылка на раздел MSDN

Мастер-страницы
Мастер-страницы (главные страницы) ASP.NET позволяют создавать
последовательную структуру страниц в приложении. Одна мастер-
страницы определяет вид, наполнение и стандартное поведение для
всех страниц (или группы страниц) приложения. Затем можно
создавать отдельные страницы содержимого, включающие
содержимое, которое необходимо отобразить. Когда пользователи
запрашивают страницу содержимого, выходная страница представляет
собой сочетание структуры мастер-страницы и содержимого со
страницы содержимого.
Мастер-страница представляет собой файл ASP.NET с расширением
MASTER (например MySite.master) с предопределенной структурой,
которая может включать статический текст, элементы HTML и
серверные элементы управления. Мастер-страница идентифицируется
по особой директиве @ Master, которая заменяет директиву @ Page,
используемую для обычных страниц ASPX. :
<%@ Master Language="C#" %>

Страницы содержимого
Содержимое для элементов управления — "местозаполнителей" на
главной странице определяется путем создания отдельных страниц
содержимого, которыми являются страницы ASP.NET (ASPX-файлы и
файлы с выделенным кодом), связанные с определенной мастер-
страницей.
Связывание осуществляется в директиве @Page страницы содержимого
путем включения атрибута MasterPageFile, указывающего на
используемую главную страницу. Например, страница содержимого
может иметь следующую директиву @Page, связывающую ее со
страницей Master1.master:
<%@ Page Language="C#"
MasterPageFile="~/MasterPages/Master1.master"
Title="Content Page"%>
На странице содержимого содержимое создается путем добавления
элементов управления Content и сопоставления их с элементами
управления ContentPlaceHolder на мастер-странице.

Страницы содержимого

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

Поведение мастер-страниц во время выполнения
Во время выполнения главные страницы обрабатываются в следующей
последовательности:
• Пользователи отправляют запрос на страницу путем ввода
URL-адреса страницы содержимого.
• Когда страница извлекается, происходит чтение директивы
@Page. Если директива ссылается на мастер-страницу, также
выполняется чтение мастер-страницы. При первом запросе на эти
страницы выполняется компиляция обеих страниц.
• Мастер-страница с обновленным содержимым объединяется с
деревом управления страницы содержимого.
• Содержимое отдельных элементов управления Content
объединяется с соответствующим элементом управления
ContentPlaceHolder на главной странице.
• Получившаяся в результате объединения страница
отображается в веб-обозревателе.

Создание проекта ASP.NET

Проект ASP.NET

Редактор кода

Мастер-страница

Сайт с мастер-страницей и без

Страница с постбеком и без

Лабораторная работа №5.
Выполнить задание Лабораторной работы №1 с использованием Microsoft
ASP.NET Web Forms.

C# Web. Занятие 05.

More Related Content

What's hot (14)

Viewers also liked (20)

Similar to C# Web. Занятие 05. (20)

More from Igor Shkulipa (20)

C# Web. Занятие 05.