Класс Page. Создание шаблона дизайна
Как известно, большинство сайтов имеют однотипную, общепринятую разметку страниц, неотъемлемой частью которой является верхний и нижний колонтитулы и, пожалуй, самая главная часть — тело страницы, хотя конечно, бывают и исключения. ASP .NET 2.x предлагает уникальный метод создания одинаковой разметки для страниц сайта – это использование, так называемых, эталонных страниц. Если вы работали с ранними версиями ASP(ASP, ASP .NET 1.x), то, наверное, помните, что постоянно приходилось копировать HTML-код страницы с элементами ASP. Конечно, использование включаемых файлов (include) в классическом ASP, и пользовательских элементов управления (*.ascx) в ASP .NET 1.x, значительно упрощало разработку Web-сайтов, но это не сравнится с тем, что предлагает ASP .NET 2.x.
Кто они, эти Эталонные страницы?И так, что же такое эталонная страница? Эталонная страница – это файл с расширением *.master, он практически ни чем не отличается от уже знакомых вам файлов aspx-страниц. Эталонная страница представляет собой контейнер для контента и может содержать html-разметку страницы, html-элементы, серверные элементы управления и пользовательские элементы управления. Другими словами, эталонная страница содержит разметку страницы, те же самые верхний и нижний колонтитул, меню навигации, в общем все, что фактически отображается на всех страницах сайта, а также эталонная страница содержит одно или более полей для подстановки контента (см. рис. 1). Сам контент при этом находится на страницах aspx, которые в свою очередь ссылаются на эталонную страницу. Таким образом, разработчику больше не придется дублировать разметку страниц, поскольку она будет находиться в одном файле.
Рис. 1. Эталонная страница.
Работа с эталонными страницамиКак я уже говорил, эталонная страница очень похожа на страницы aspx, но имеет ряд отличий. Так, вместо директивы @Page, эталонная страница имеет директиву @Master. Директива @Master имеет такой же набор параметров, как и @Page, наиболее часто применяются следующие параметры: Language – указывает язык, на котором пишется код; Debug – указывает на состояние режима отладки; Inherits – содержит имя класса отдельного кода; ClassName – задает имя класса, создаваемого при обработке страницы; EnabledTheming – определяет состояние использования тем; Src – задает имя исходного файла с классом отдельного кода.
Здесь стоит отметить, что указанные параметры в директиве @Master не наследуются дочерними страницами (страницами контента), а используются только в рамках эталонной страницы. Так например, аргумент Language у эталонной страницы может иметь значение C#, а у страниц контента — VB.
На эталонных страницах также можно использовать те же директивы, что и на страницах aspx, например @Register, @Import и т.д.
Каждая эталонная страница (их может быть несколько в одном проекте, в зависимости от структуры сайта и потребностей, например, для форума одна эталонная страница, для остальной части сайта – другая) должна иметь как минимум один элемент ContentPlaceHolder, который собственно и является контейнером для контента. Элемент ContentPlaceHolder обычно пустой, но он также может содержать контент, который будет отображаться по умолчанию, в случае, если на страницах aspx не будет контента. Сам контент находится в элементе Content на страницах aspx. Управляющий элемент Content является основным элементом страницы контента и работает только совместно с элементом ContentPlaceHolder.
Ссылка на эталонную страницу для страниц контента может находиться в директиве @Page в параметре MasterPageFile, где указывается путь к файлу эталонной страницы, например:
А также, ссылка на эталонную страницу может находится в файле web.config, в этом случает, эталонная страница будет применяться ко всем страницам aspx, находящимся в одной папке с web.config (либо ко всему приложению, если web.config находится в корневом каталоге приложения), например:
Помимо этого, эталонную страницу можно указать во время выполнения программы, для этого нужно в обработке события Page_PreInit изменить свойство MsterPageFile. Например:
Protected Sub Page_Init(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Init Me.MasterPageFile= "~/NewMasterPage.master" End Sub
Обратите внимание, данный код вызовет ошибку, если на странице aspx в директиве @Page будет указан аргумент MasterPageFile.
Следует также отметить, что сами эталонные страницы могут ссылаться на другие эталонные страницы, для этого нужно указать путь к эталонной странице в аргументе MasterPageFileдирективы @Master.
И так, пожалуй теории достаточно, перейдем к практическому использованию эталонных страниц. Для начала, сделаем простую эталонную страницу, назовем ее MasterPage.master:
Простой пример работы с эталонными страницами Этот шаблон дизайна будет на всех страницах контента Copyrght (c) Просто коопирайт
Обратите внимание на элемент ContentPlaceHolder. Наличие этого элемента в эталонной странице обязательно, как я уже говорил, он служит элементом-контейнером для контента.
Теперь, создадим несколько aspx страниц с контентом, которые будут ссылаться на нашу эталонную страницу. Первая страница, по сложившейся традиции и стандартам, будет назваться Default.aspx
Привет, это контент главной страницы!
Перейти на другую страницу
Обратите внимание на аргумент MasterPageFile в директиве @Page, который указывает на файл эталонной страницы, в нашем случае это файл MasterPage.master, который находится в корневом каталоге приложения.
Как видите, страница контента не содержит тэгов , , и , поскольку эти тэги уже есть в нашей эталонной странице. Обратите внимание на элемент Content, в частности на его параметр ContentPlaceHolderID – здесь указывает имя контейнера контента в эталонной странице, т.е. имя элемента ContentPlaceHolder, в который будет вставлен контент. В самом элементе Content содержится текст контента, помимо текста здесь могут содержаться любые допустимые элементы aspx-страниц.
Теперь создайте еще одну aspx-страницу, назовите ее Second:
А тут у нас контент второй страницы страницы!
Перейти на главную страницу
Теперь запустите проект и ASP .NET соединит эталонную страницу со страницей контента.
Доступ к свойствам эталонной страницыДоступ к объектной модели эталонной страницы возможен через свойство Master, однако если попытаться обратиться напрямую к эталонной странице, то произойдет ошибка. Это связано с тем, что эталонная страница представляет собой ссылку на объект эталонной страницы и предоставляет доступ только для открытых свойств и методов.
Для примера, разместите на эталонной странице элемент Label и назовите его lblTitle. Чтобы получить возможно изменять текст этого элемента, нужно создать соответствующие свойства в классе эталонной страницы:
Public Property MyTitle() As String Get MyTitle = lblTitle.Text End Get Set(ByVal value As String) lblTitle.Text = value End Set End Property
Теперь, вы можете динамически изменить, либо получить, текст в элементе lblTitle эталонной страницы, например, при обработке события загрузки aspx-страницы:
Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load CType(Master, MasterPage).MyTitle = "Привет!" End Sub
Вот собственно и все, если у вас возникнут какие либо вопросы, пишите, постараюсь ответить.
ASP.NET – один из компонентов.NET Framework. Перечислим кратко основные черты этой технологии. * Общеязыковая исполнительная среда CLR
* Библиотека классов.NET Framework
* Языки.NET(C#, VB.NET, J# и другие)
* ADO.NET
* ASP.NET
* Web-службы
* Промежуточный язык MSIL (Microsoft Intermediate Language). Это ассемблер для среды выполнения CLR.
ADO.NET – набор классов, предназначенных для доступа к базам данных Microsoft SQL Server, к источникам данных OLEDB и к файлам XML.
Разные части вашего проекта могут быть написаны на разных языках, это называется interoperability. Мы попробуем написать проект, где одна из страниц будет на Visual Basic, а другая на С#.
Компютерные языки бывают компилируемыми и интерпретируемыми. В процессе компиляции программы, написанной на компилируемом языке, создается выполняемый файл(В Windows – exe). Он выполняется быстро, но не может исполняться на другой платформе. Машина, на которой она выполняется, должна иметь похожую конфигурацию. Например, если программа использует dll, то эта библиотека должна быть установлена и на целевой машине. Интерпретируемые программы компилируются в момент выполнения, поэтому они работают медленнее, но не зависят от конкретной машины. В.NET Framework применяется двухэтапная компиляция, то есть первый этап – это компиляция в MSIL, а вторая – компиляция «Just-in-time» компилятором во время исполнения. JIT-компилятор оптимизирует код для той машины, на которой он исполняется. В ASP.NET страница компилируется в MSIL при первом обращении клиента к странице. Вместе с ней компилируются классы, которые она использует. Если вы используете Visual Studio 2005, можно не ожидать первого запроса, а принудительно скомпилировать все страницы вашего проекта. Это позволит выявить синтаксические и другие ошибки.
MSIL – это ассемблер, не зависящий от машины. Он может выполняться на любой машине, где установлена CLR. Проект Mono пытается перенести CLR на другие платформы, позволяя взаимодействовать серверам, работающим на разных платформах.
Вы можете ознакомиться с проектом на сайте http://mono-project.com
На странице http://go-mono.com/archive/xsp-0.10.html находится XSP - сервер ASP.NET, который может служить расширением сервера Apache – основного сервера *nix – систем.
Как работает ASP.NETКогда мы исталлируем.NET, в соответсвующих директориях C:WINDOWSMicrosoft.NETFramework помещается также файл aspnet_isapi.dll. Это – ISAPI-расширение, и предназначено оно для получения запросов, адресованных ASP.NET-приложениям (*.aspx *.asmx и т.д.), а также создания рабочих процессов aspnet_wp.exe, обратывающих запросы. Интернет-сервер – IIS или встроенный в WebMatrix или встроенный в Visual Studio Cassini – используют это расширение, когда им надо обработать обращение к страницам с расширением aspx.Этот модуль разбирает(parse) содержимое страниц aspx вместе с файлом отделенного кода и генерирует класс на языке страницы с объектом Page. Страница aspx отличается от обычной HTML-страницы наличием серверных элементов управления, которые описываются специальными тегами. Для понимания работы ASP.NET важно отметить, что каждому тегу элемента управления соответствует свой член класса страницы. Например,
< asp : Label ID = "Label1" runat = "server" >
преобразуется в
@ __ctrl = new global:: System . Web . UI . WebControls . Label ();
Основная задача объекта Page – посылка HTML-код в выходной поток. Этот класс компилируется в библиотеку.dll, которая загружается в процесс веб-сервера. Последующие запросы к странице также обрабатывает dll, если исходный код страницы не меняется. Все эти файлы можно найти в директории «Temporary ASP.NET Files» текущей версии.NET. Если мы работаем в среде разработки Visual Studio 2005 или VWD, для каждого проекта создается своя поддиректория.Типы страниц и папок проектаВ проект можно добавлять новые файлы через диалог New File. Если снять отметку с флажка “Place code in separate file”, Visual Studio создаст один файл, в котором будет и страница, и код для ее обработки(в стиле WebMatrix).
Все файлы помещаются в директорию проекта. И наоборот, все файлы, которые будут помещены в директорию проекта, станут его частью. Для веб-сайтов не существует специального файла.csproj, в котором перечислялись бы его составные части, как это было в предыдущих версиях Visual Studio. Структура решения(solution) описывается в текстовом файле.sln. В решение могут входить несколько веб-сайтов и библиотек.
В ASP.NET 2.0 имеются специальные поддиректории проекта для разных типов файлов. Например, в папке App_Code хранятся общедоступные классы, текстовые файлы и некоторые другие(DataSet, диаграмма классов). Файлы с расширениями.cs или.vb, попавшие туда, автоматически компилируются, когда запрашивается любая страница проекта. В App_Data содержатся источники данных, используемых в проекте – базы данных Access и Microsoft SQL, XML-файлы. К этой директории нельзя получить доступ извне, а только из самого приложения. В папке Themes хранятся темы проекта(лекция 13). Применение тем позволяет настроить единообразный внешний вид сайта и централизованно им управлять. В App_GlobalResources находятся ресурсы, например таблицы строк, которые можно создавать на разных языках. Язык ресурсов выбирается автоматически в зависимости от настроек браузера пользователя. В папке App_WebReferences находятся ссылки на используемые веб-сервисы.
Можно создавать собственные поддиректории проекта, например, для хранения картинок.
Проект на 2 языкахПроект Web-сайта состоит из страниц aspx и классов, которые используются на страницах(и, конечно, разнообразных ресурсов). Файлы с классами, к которым можно обратиться из разных страниц, помещают в специальную папку App_Code. При компиляции они помещаются в одну сборку – библиотеку.dll в формате portable executable. Совершенно неважно, на каком языке написан класс, если это язык.NET.Готовые скомпилированные сборки сторонних производителей тоже можно использовать в проекте. Их помещают в папку Bin. При этом их необходимо импортировать в проект.
Создайте новый проект. Добавьте в него файл, выбрав тип файла Class и язык Visual Basic. Среда сама предложит поместить его в папку Code. Назовем его CustomClass. У него будет очень простой код. Всего одна функция, которая добавляет слово Hello к имени, переданному в качестве параметра.
Imports Microsoft
.
VisualBasic
Public Class
CustomClass
Public Function
GetMessage
(ByVal name
As
String
) As
String
Return
"Hello, "
&
name
End
Function
End
Class
Добавьте в проект страницу CodeFolder_cs.aspx. Это страница написана на C#, но она создает класс, написанный на VB.NET.
<
script runat
=
"server"
>
void Button1_Click
(object sender
,
EventArgs e
)
{
CustomClass c
= new
CustomClass
();
Label1
.
Text
=
c
.
GetMessage
(TextBox1
.
Text
);
}
ASP.NET Inline Pages
Welcome to ASP.NET 2.0!
Enter Your Name:
На странице определена форма, напоминающая форму Windows-приложения. На ней имеется кнопка, нажатие на которую обрабатывается в функции Button1_Click. В ней создается класс и вызывается его функция GetMessage с параметром, который берется из элемента редактирования. Возвращаемое значение записывается в элемент Label1. В более простом варианте это выглядит так:
Label1 . Text = “Hello ” + TextBox1 . Text ;
Класс может быть написан на C#, а использоваться из страницы на Visual Basic.
using System
;
public class
CustomClass2
{
public
String GetMessage
(String input
) {
return
"Hello from C# "
+
input
;
}
}
Код страницы CodeFolder_vb
.
aspx
:
<
script runat
=
"server"
>
Sub Button1_Click
(ByVal sender
As
Object
,
ByVal e
As
System
.
EventArgs
)
Dim c
As New
CustomClass2
Label1
.
Text
=
c
.
GetMessage
(TextBox1
.
Text
)
End Sub
Однако поместить в директории App_Code можно только на одном языке. Если там будет находиться файлы на разных языках, проект не будет компилироваться. Для того, чтобы использовать два языка, необходимо создать поддиректорию, добавить ее в файле web.config и поместить в нее файлы на другом языке.
Регистрация в файле web.config:
<
configuration
>
<
system
.
web
>
...
<
compilation
>
<
codeSubDirectories
>
<
add directoryName
=
"VBCode"
/>
<
codeSubDirectories
>
<
add directoryName
=
"CSCode"
/>
...
Синтаскис объявления директив такой:
Можно объявить несколько директив одновременно:
В ASP.NET 2.0 существует 11 директив.
Директива Атрибуты Описание
@Assembly Name
Src Импортирует на страницу или в элемент управления сборку с заданным именем
@Control такие же, как у Page Применяется для задания свойств при создании собственных пользовательских элементов управления.
@Implements Interface Указывает, что класс данной страницы реализует данный интерфейс
@Import Namespace Импортирует пространство имен
@Master такие же, как у Page Применяется на страницах шаблона дизайна(Master page). Новая в ASP.NET 2.0
@MasterType TypeName
VirtualPath Дает строго типизированную ссылку на класс, содержащийся в шаблоне дизайна. Позволяет обращаться к свойствам этого класса.
@OutputCache Duration
Location
VaryByCustom
VaryByHeader
VaryByParam
VaryByControl Управляет кэшированием страницы или элемента управления. Подробнее описана в лекции 15.
@Page см. Ниже Атрибуты, относящиеся к данной странице. Употребляется только в файлах с расширением aspx
@PreviousPageType TypeName
VirtualPath Страница, с которой были отправлены данные, введенные пользователем. Новая в ASP.NET 2.0. Раньше страницы отправляли пост только самим себе.
@Reference Page
Control Страница или элемент управления, который нужно компилировать вместе с данной
@Register Assembly
Namespace
Src
TagName
TagPrefix Создает псевдонимы для пространств имен и пользовательских элементов управления
Пока что подробно рассмотрим 2 из них – Page и Import.
Директива PageДиректива Page позволяет установить свойства страницы, которые будут использованы во время компиляции. Эта директива используется чаще остальных, поэтому ее необходимо рассмотреть более подробно.Наиболее важные атрибуты директивы перечислены в таблице:
| AutoEventWireup | Автоматическая обработка событий страницы |
| Buffer | Управляет буферизацией страницы. По умолчанию буферизуется |
| ClassName | Позволяет назначать имя класса, сгенерированного данной страницей |
| CodeFile | Название файла с отделенным кодом для данной страницы |
| Culture | Устанавливает набор региональных параметров, т.е. язык, формат валюты, даты, чисел |
| Debug | Если true, на страницу выводится отладочная информация |
| Trace | Вывод трассировочной информации |
| EnableViewState | Сохранение состояния страницы. По умолчанию она сохраняется |
| EnableTheming | Позволяет включить или выключить поддержку тем оформления. По умолчанию включено |
| Inherits | Класс, от которого наследуется класс данной страницы в технологии отделенного кода |
| IsAsync | Показывает, обрабатывается ли страница асинхронно. |
| Language | Язык, используемый во внедренном коде |
| WarningLevel | Наибольший допустимый уровень предупреждений компилятора |
| CompilerOptions | Опции компилятора |
using System . XML ;
На странице aspx – директива Import
Для каждого пространства имен требуется отдельная директива Import.
Visual Studio.NET и VWD по умолчанию включают в страницу на C# наиболее часто используемые пространства имен. На страницу aspx импортировать эти пространства имен не требуется.
using System
;
using System
.
Data
;
using System
.
Configuration
;
using System
.
Collections
;
using System
.
Web
;
using System
.
Web
.
Security
;
using System
.
Web
.
UI
;
using System
.
Web
.
UI
.
WebControls
;
using System
.
Web
.
UI
.
WebControls
.
WebParts
;
using System
.
Web
.
UI
.
HtmlControls
;
Например, в пространстве имен System.Web.UI находится класс Page, без которого не может существовать ни одна страница ASP.NET, в System.Web - HttpRequest и HttpResponse.Программа просмотра классовКак же узнать, какие классы имеются в библиотеке классов.NET? Для этого предназначен Object Browser (Visual Studio 2005) и Class Browser WebMatrix. Чтобы открыть Object Browser в Visual Studio 2005 или VWD Express, выберите пункт меню View-> Object Browser. Если вы используете WebMatrix, то Class Browser находится в той же папке меню Windows, что и WebMatrix – All Programs->ASP.NET WebMatrix. В формате ASP.NET Class Browser включен в состав Framework SDK.
Все имеющиеся пространства имен показаны как узлы древовидной структуры. Нас интересует System.Web. Раскройте этот узел. Внутри оказались другие пространства имен. Раскройте System.Web.UI. Там находится большое количество классов, интерфейсов, делегатов, перечислений. Их можно узнать по иконкам. Например, иконка делегата похожа на чемодан.
Интерфейс
Событие
Перечисление
Выберите класс Page. В окошке справа появится список его методов, полей и событий. Если выбрать метод, в третьем окне под вторым появится его описание. Внутри класса находятся еще две папки – классов-прародителей(Base Classes) и классов-потомков. Все их тоже можно просмотреть. Object Browser показывает и классы текущего проекта. Если классы закомментирован тегами генерации документации XML, то эта информация тоже видна, например Summary, Parameters, Values, Returns.
Исследуя свойство IsPostBack, можно узнать, что оно имеет булевское значение, и предназначено только для чтения.
Проверка соответствия стандартамСуществуют разные стандарты HTML и XHTML. Более поздние стандарты предъявляют более строгие требования, например, XHTML 1.1 не разрешает пользоватьсяи другими простыми тегами без закрывающего слэша
. В то же время старые стандарты не поддерживают новые теги.
В заголовке HTTP-запроса указывается стандарт документа, Visual Studio 2005 во всех страницах указывает следующий стандарт:
Этот стандарт требует наличия атрибута xmlns в теге - ссылки на сайт с описанием стандарта.
< html xmlns = >
Многие страницы, сделанные для предыдущих версий ASP.NET, не имеют такого атрибута. В панели инстументов Html Source Editing также находится выпадающий список, в котором можно выбрать стандарт или версию браузер, для которого предназначена данная страница. Страница автоматически проверяется на соответствие этому стандарту.
Свойства страницы
Страница – это основа всего в Web-приложении.
Класс System.Web.UI.Page инкапсулирует функциональность, необходимую для создания и обработки страниц ASP.NET.
Каждая страница ASP.NET – это объект класса, который автоматически генерируется ядром ASP.NET. Класс наследуется от ассоциированного со страницей класса, если мы используем отделенный код, или прямо наследуется от System.Web.UI.Page, если код на C# встроен в страницу. Среда также создает конструктор по умолчанию.
Чтобы убедиться в этом, можем создать страницу “PageType.aspx”:
<
html xmlns
=
"http://www.w3.org/1999/xhtml"
>
<
head runat
=
"server"
>
<
title
>
Тип страницы
<
body
>
<
div
>
<
div
>
Вот результат:
Базовый тип данной страницы System.Web.UI.Page
Такая же страница, созданная по технологии разделения кода.
пишет результат
Тип данной страницы ASP.pagetype_aspx
Базовый тип данной страницы PageType
То, что PageType – наследник System.Web.UI.Page, прописано в файле отделенного кода:
public partial class PageType : System . Web . UI . Page
К текущему объекту страницы можно обращаться как к переменной Page. Page – это контейнер элементов управления данной страницы, поэтому содержит в себе коллекцию Controls. Если в теге присутствует атрибут runat = “server”, то в Page содержится и поле Header, через которое можно управлять заголовком страницы. Например, поменять название странице в заголовке браузера, назначить файл каскадных таблиц стилей.
<
script runat
=
"server"
>
protected
void Page_Init
(object sender
,
EventArgs e
)
{
HtmlLink myHtmlLink
= new
HtmlLink
();
myHtmlLink
.
Href
=
"printable.css"
;
myHtmlLink
.
Attributes
.
Add
("rel"
,
"stylesheet"
);
myHtmlLink
.
Attributes
.
Add
("type"
,
"text/css"
);
Page
.
Header
.
Controls
.
Add
(myHtmlLink
);
Page
.
Header
.
Title
=
"Новый заголовок"
;
}
protected
void Page_Load
(object sender
,
System
.
EventArgs e
)
{
Style bodyStyle
= new
Style
();
bodyStyle
.
ForeColor
=
System
.
Drawing
.
Color
.
Blue
;
bodyStyle
.
BackColor
=
System
.
Drawing
.
Color
.
Beige
;
Page
.
Header
.
StyleSheet
.
CreateStyleRule
(bodyStyle
,
null
,
"p"
);
}
Hello ASP.NET
Учитесь программировать на ASP.NET
В этом примере мы поменяли текст заголовка. Запустите эту страницу. В получившемся HTML-коде внутри тега стоит уже не «Untitled Page», а «Новый заголовок», который был установлен через Page.Header.Title. Был создан стиль для тега
Что отразилось таким образом:
<
style type
=
"text/css"
>
p
{
color
:
Blue
;
background
-
color
:
Beige
; }
Внешняя страница CSS была импортирована из файла.
< link href = "printable.css" rel = "stylesheet" type = "text/css" />< style type = "text/css" >
Если атрибут AutoEventWireup, который присутствует в заголовке страниц, генерируемых VS, установлен, то методы с префиксом Page_ автоматической назначаются обработчиками событий страницы.
У страницы есть два важных свойства - Response и Request. Свойство Response имеет тип HttpResponse. Response страницы можно воспринимать как выходной поток. Весь HTML код генерируемой страницы в принципе может быть выведен через запись в этот поток. Это был обычный способ работы разработчиков asp. Но в ASP.NET есть более удобные средства вывода данных с помощью серверных элементов управления. Response лучше использовать для записи Cookies, для задания различных параметров заголовка – управлять кэшированием, свойством Expires.
Вот пример из MSDN:
HttpCookie MyCookie
= new
HttpCookie
("LastVisit"
);
DateTime now
=
DateTime
.
Now
;
MyCookie
.
Value
=
now
.
ToString
();
MyCookie
.
Expires
=
now
.
AddHours
(1
);
Response
.
Cookies
.
Add
(MyCookie
);
Можно поменять кодовую страницу.
<
head runat
=
"server"
>
<
title
>
Русская кодировка
Функция Response.Redirect перенаправляет браузер на другую страницу.
Response . Redirect ("NavigationTarget.aspx?name=" + System . Web . HttpUtility . UrlEncode (Name . Text );
Здесь формируется командная строка с параметрами QueryString, которые целевая страница может прочитать.
Аналогично свойство Request – это запрос, переданный на сервер для вывода нужной страницы. Он имеет тип HttpRequest. В нем хранится все о клиенте, включая настройки его браузера, файлы-cookie и данные, введенные им в форму.
NameLabel . Text = Server . HtmlEncode (Request . QueryString [ "Name" ]);
События страницыРабота среды ASP.NET со страницей начинается с получения и обработки Web-сервером IIS запроса к данной странице и передачи этого запроса среде выполнения ASP.NET. Среда выполнения анализирует, нужно ли компилировать страницу или можно выдать в качестве ответа страницу из кэша.Затем начинается жизненный цикл страницы. Он начинается с этапа PreInit. После получения запроса среда выполнения загружает класс вызываемой страницы, устанавливает свойства класса страницы, выстраивает дерево элементов, заполняет свойства Request и Response и свойства UICulture и вызывает метод IHttpHandler.ProcessRequest. После этого среда выполнения проверяет, каким образом была вызвана эта страница, и если страница вызвана путем передачи данных с другой страницы, о чем будет рассказано далее, то среда выполнения устанавливает свойство PreviousPage.
На этом этапе устанавливается также свойство IsPostback объекта Page, которое позволяет узнать, в первый ли раз загружается форма или она должна формироваться как результат обработки данных, введенных пользователем.
В обработчиках событий страницы можно проверить это свойство:
if (!
Page
.
IsPostBack
)
{
// обрабатывать
}
Дальше происходит инициализация страницы – событие Init. Во времени инициализации страницы создаются дочерние пользовательские элементы управления и им установливаются свойства id. В это же время к странице применяются темы оформления. Если страница вызвана в результате постбэка, то на этом этапе данные, отправленные на сервер, еще не загружены в свойства элементов управления. Программист может инициализировать их свойства.
Если на странице существуют валидаторы(классы проверки данных, см. лекцию 5), то для них вызывается метод Validate(). Затем вызываются обработчики событий (при условии, что страница генерируется в ответ на действия пользователя).
В методе Render генерируется сам HTML-код выводимой страницы. При этом страница вызывает соответствующие методы дочерних элементов, те – методы своих дочерних элементов. В методе Render код выводится в Response.OutputStream. Сама страница тоже считается элементом управления – класс Page является наследником класса Control. Если на странице есть блоки отображения, они становятся частью функции отрисовки (rendering).
Наконец, страница выгружается из памяти сервера и происходит событие Unload.
Во время жизненного цикла страницы происходят различные события. Можно включить трассировку страницы, чтобы посмотреть порядок из возникновения.
Во время трассировки не выводится событие Unload, потому что оно происходит, когда весь код уже выведен. Во время обработки этого события нужно освободить ресурсы, например соединения с базами данных или открытые файлы.
Полный список событий страницы, которые можно переопределить в классе страницы:
* PreInit
* Init
* InitComplete
* PreLoad
* Load
* LoadComplete
* PreRender
* PreRenderComplete
* Unload
Для всех событий определены обработчики – виртуальные функции OnInit, OnLoad. Когда AutoEventWireup равно true, в классе автоматически объявляются функции-обработчики событий с префиксом Page - Page_Load, Page_Init и так далее. Одно из самых популярных событий – это Page_Load. Создавая новую страницу, Visual Studio создает обработчик этого события. Здесь можно изменить внешний вид элементов и создать новые. Можно установить AutoEventWireup в false. В таком случае надо писать перегруженные версии виртуальных функций.
protected
override void OnInit
(EventArgs e
)
{
}
Так можно добиться ускорения работы страницы.
Способы внедрения кода ASP.NET в страницу.
Есть три способа внедрить код на программном языке в страницу aspx.
Блок называется блоком объявления кода.
Тег похож на тот, которым вводятся скрипты JavaScript. Но с большим отличием – скрипт выполняется на сервере. Поэтому необходимо задавать атрибут runat="server". Атрибут language у него может принимать значения С#, VB, J#. В страницах с отделенным кодом можно писать и на C++. По умолчанию принимается значение языка Visual Basic, поэтому не надо забывать указывать язык, когда пишете на С#. Но нет необходимости это делать, если язык определен в директиве Page. Можно писать на разных языках в одном приложении, но нельзя смешивать разные языки на одной странице.
Внутри блока можно объявлять переменные, константы и функции. На самом деле в C# нет глобальных переменных, так что это будут члены класса страницы. Но они выглядят глобальными, потому что класс не описан программистом, его генерирует ASP.NET. Поэтому будем называть их переменными страницы.
Здесь можно переопределить виртуальные методы класса страницы. В блоке также можно объявлять классы, но они будут внутренними по отношению к классу страницы.
Блоки отображенияЛюбой код, внедренный с помощью , обрабатывается во время события Render как часть страницы.В теле блока допустимо объявлять переменные, тогда они будут локальными для того метода, в котором данный блок будет реализован, но нельзя объявлять методы или типы.
Такой стиль программирования был характерен для asp. Чаще всего в блоках отображения выводится HTML-код с помощью Response.Write.
является сокращением .
<
html
>
<
head
>
<
body
>
1 Строка HTML
<
br
/>
2 Строка HTML
<
br
/>
3 Строка HTML
<
br
/>
Более современный способ – использование серверных элементов управления. Они описаны в теле страницы подобно обычным элементам разметки, являются членами класса страницы. К ним возможно обращение через идентификатор. Например, вместо того, чтобы выводить текст через Response.Write, можно установить текст элемента управления, как в примере из первой лекции.
Объект любого класса создается с помощью синтаксиса «тег объекта»
< object id = "items" class= "System.Collections.ArrayList" runat = "server" />
Это эквивалентно описанию в классе страницы поля
System . Collections . ArrayList items ;
Еще один способ применяется для связывания с источниками данных и будет рассмотрен в 7 лекции.ЗаключениеТехнология ASP.NET построена на объектно-ориентированном событийно-управляемом подходе к созданию web-страницы. Классы, используемые для генерации web-страниц, являются частью библиотеки.NET Frameworks. Для многих из них существуют аналоги в Windows Forms, что сближает программирование настольных приложений с программированием web-приложений.
Знакомство с ASP.NET 2.0 Введение
Каждый раз, разрабатывая проект и создавая
Web-приложение, пользуются различными средствами для создания
архитектуры приложения, редактирования кода и публикации результатов
своего труда на Web-сервере. При этом для конечного пользователя
Web-приложение любой сложности остается набором HTML-страниц, каждая из
которых имеет свой уникальный URL. По большом счету, пользователю нет
дела до того на какой платформе или с использованием какой технологии
создано приложение. У пользователя есть цель, которую он хочет достичь и
универсальное средство, практически любой используемый им Web-браузер. В
этом заключено огромное преимущество приложений для Internet по
сравнению с приложениями для настольных систем – существование
общепринятого «языка общения», HTML кода. Для того, чтобы развернуть
Web-приложение достаточно установить его на сервер, после чего
приложение может быть доступно любому клиенту с установленным
Web-браузером. К сожалению, здесь тоже существует очевидная проблема в
обработке HTML кода браузерами разных производителей.
Задача разработчика заключается в том, чтобы создать приложение,
генерирующее HTML код, оптимальный для большинства браузеров, которыми
пользуется конечный пользователь. Каждая технология, используемая для
создания Web-приложения, позволяет генерировать HTML код, поэтому, в
конечном итоге, выбор технологии, на основе которой будет создано
Web-приложение, зависит лишь от удобства и скорости разработки и
простоты развертывания и поддержки конечного продукта.
Преимущество технологии ASP.NET перед остальными в высокой степени
абстракции, построенной над стандартным HTML кодом: использование
объектно-ориентированной парадигмы, поддержку нескольких языков
программирования, наличие универсального основания, содержащего тысячи
уже готовых для использования в проектах решений – Microsoft .NET
Framework.
При этом для разработки приложения может быть использована любая среда
разработки или даже текстовый редактор, позволяющий создавать,
редактировать и сохранять текстовые файлы. Если же разработчик желает
воспользоваться всей мощью Microsoft .NET Framework и ASP.NET и, при
этом, затратить как можно меньше усилий, то ему нужно воспользоваться
подходящей для его задач средой разработки. Одним из наиболее
эффективных средств создания Web-приложений ASP.NET является Microsoft
Visual Studio. Поддержка ASP.NET 2.0 включена в версию Visual Studio
2005.
В данной статье кратко
рассказывается о
большинстве новых возможностей ASP.NET 2.0, новой версии среды ASP.NET.
Далее в тексте считается, что читатель знаком с технологией ASP.NET 1.0
или ASP.NET 1.1. Если рассматриваемая тема выходит за
рамки статьи, то непосредственно в тексте располагается гиперссылка на
статью, содержащую подробную информацию. Также, в конце статьи
приводится список литературы в порядке изложения информации в данной
статье.
Microsoft .NET Framework и Visual Studio 2005
поддерживает несколько языков программирования, таких как Visual Basic,
Visual C#, Visual C++, Visual J#. Поскольку эти языки используют единую
среду выполнения CLR (Common
Language Runtime
) и соответствуют общим стандартам
CLS (Common
Language Specification)
, то сборка, созданная с применением
одного из.NET языков, может быть использована в проекте,
разрабатываемом на другом языке программирования, также, как если бы эта
сборка и приложение были написаны на одном и том же языке.
С выходом Microsoft .NET Framework 2.0
стало возможно использовать в одном и том же проекте разные языки
программирования. То, что Web-приложение ASP.NET может быть написано на
нескольких языках программирования, очень удобно, если уже есть
проверенные решения на одном из языков, а проект пишется с
использованием другого языка, либо, если в команде имеются разработчики,
использующие различные языки программирования. О том, как использовать
разные языки в одном проекте можно прочитать в
этой статье .
Технология разделения кода
Основа всего в Web-приложении – это страница.
Пользователь, пользуясь браузером, перемещается между страницами,
периодически возвращаясь к уже просмотренным ранее страницам, вводя
какие-то данные в HTML формы и получая некоторый результат. В ASP.NET
страница чаще всего представляет собой Web-форму, содержащую различные
элементы управления, реагирующую на события, создаваемые пользователем.
ASP.NET 1.x позволяет разделять код логики от кода представления, то
есть помещать код программной логики страницы в файл.cs или.vb,
отдельно от кода собственно страницы, размещаемом в.aspx файле. Эта
технология называется
Code-Behind . Таким образом, дизайн страницы может быть изменен не
затрагивая кода страницы, что позволяет разделить ответственность за
внешний вид и работу страницы между дизайнером и программистом. Для
этого в.aspx файле можно задать параметры директивы Page.
Но для поддержки редактирования с помощью Microsoft Visual Studio .NET в ASP.NET странице необходимо указать класс, соответствующей данной странице и файл, в котором находится код этого класса. Для этого директива Page преобразуется с использованием ключевых слов Codebenind и Inherits.
В ASP.NET 2.0 используется иной механизм разделения кода. В директиве Page при этом необходимо использовать другие ключевые слова: CodeFile и Inherits.
В этом случае код класса программной логики страницы будет размещен в файле указанном в атрибуте CodeFile. Надо отметить, что Visual Studio 2005 использует разделяемые классы (partial classes).
Public partial class Default: System.Web.UI.Page { protected void Page_Load(object sender, EventArgs e) { } }
Поэтому разработчик может поместить код класса в
нескольких файлах, но подобное рассредоточение кода делает приложение
весьма громоздким и трудным в поддержке и разработке.
Используемая в Visual Studio 2003 модель Code-Behind обладает
несколькими весьма существенными недостатками. Прежде всего, используя
Visual Studio разработчику необходимо компилировать проект перед
публикацией, поскольку ASP.NET компилирует страницы, только если указан
атрибут Src, не используемый Visual Studio. При этом, поскольку среда
ASP.NET обнаруживает изменение даты создания сборки, после каждой замены
старой сборки в каталоге bin происходит перезапуск домена приложения,
что выливается во временную «заторможенность» в работе приложения.
Visual Studio 2005 использует новые ключевые слова, поддерживаемые
средой выполнения ASP.NET 2.0, а среда выполнения, в свою очередь,
использует новую технику компиляции страниц. Это позволяет решить
проблему замены сборки на более новую.
Несмотря на это, Visual Studio 2005 по-прежнему позволяет отказаться от
разделения кода и поместить код программной логики в самом файле
страницы, и использовать теги . Более
того, по умолчанию Visual Studio создает именно страницы без разделения
кода.
Сравним действия, которые совершает ASP.NET 2.0 и
ASP.NET 1.0, когда пользователь запрашивает файл с расширением.aspx. В
ASP.NET 1.x среда выполнения анализирует директиву Page страницы,
осуществляет поиск соответствующего класса в сборке приложения, затем на
основании кода страницы создается класс, производный от класса
программной логики страницы. В случае если сборка отсутствует, то
осуществляется поиск файла программной логики, указанного в атрибуте Src
директивы Page. Если файл найден, то происходит компиляция сборки, если
нет, то ASP.NET выбрасывает исключение.
В ASP.NET 2.0 среда выполнения также анализирует директивы Page,
осуществляет поиск сборки соответствующей классу логики страницы, после
чего создается класс страницы. В отличие от ASP.NET 1.x, родительским
классом для класса страницы является System.Web.UI.Page, поскольку
создаваемый динамический класс является собственно классом страницы
(используются разделяемые классы для класса страницы и класса
программной логики), а не потомком класса программной логики. Поэтому,
если в ASP.NET 1.x класс Web-формы мог называться также как и сама
Web-форма.
… public class frmDefault: System.Web.UI.Page { protected void Page_Load(object sender, EventArgs e) { } }
В ASP.NET 2.0 это недопустимо, поскольку элемент
управления System.Web.UI.Form является элементом класса.
Основным преимуществом ASP.NET является то, что в случае отсутствия
сборки, необходимой для выполнения страницы, происходит компиляция
только файла программной логики страницы, без перекомпиляции всей
сборки. Поскольку существует динамическая компиляция, то необходимо
обеспечить возможность создавать код, общий для всех страниц приложения.
Для этой цели в ASP.NET 2.0 существуют специальные директории,
являющиеся дочерними директориями корневой директории приложения, одна
из которых App_Code, служит для хранения файлов, содержащих общий код
для всех страниц. При выполнении динамической компиляции, код из
директории App_Code компилируется и становится доступным для всех
страниц Web-приложения. При этом
Visual Studio
2005 поддерживает код, находящийся в директории
App_Code, поэтому работает подсветка синтаксиса и
IntelliSense.
Исследовать генерируемые средой выполнения
ASP.NET 2.0 файлы, и подробно разобраться в процессе компиляции можно
изучив содержимое директории:
%WINDIT%\Microsoft.NET\Framework\версия\Temporary ASP.NET
Files\имя_приложения, куда
ASP.NET 2.0
помещает динамически созданные сборки.
Либо, вызвав ошибку на
ASP.NET
странице
в режиме отладки выбрать ссылку
Show Complete Compilation Source.
Если же необходимо заренее скомпилировать проект, перед развертыванием на сервере в ASP.NET 2.0 существует возможность полной или частичной прекомпиляции Web-приложения. Подробнее о прекомпиляции можно прочесть в этой статье .
Изменения в структуре проекта Visual StudioВ версии Visual Studio 2005 больше нет файлов.csproj или.vbproj, которые раньше создавались для каждого из типов проектов ASP.NET. Вместо файлов проекта Visual Studio использует структуру директорий, таким образом, для того чтобы включить в проект существующий файл достаточно просто скопировать его в директорию проекта. Следует отметить, что если файл или директория удаляется из дерева файлов проекта в окне Solution Explorer, то файл или директория физически удаляются из файловой системы.
Страница ASP.NET 2.0 Директива @PageДля внесения новых возможностей в ASP.NET 2.0 было необходимо внести изменения и дополнения в класс страницы Page. Поскольку для установке свойств страницы в design-time используются атрибуты директивы Page, то здесь будут рассмотрены новые атрибуты, появившиеся для реализации механизмов персонализации, шаблонов дизайна, оформления и асинхронной работы станиц. Подробнее о назначении новых атрибутов можно узнать в части статьи, посвященной новым свойствам и методам класса Page.
Async
Указывает на то, какой из интерфейсов IHttpHandler или IHttpAsyncHandler реализует класс страницы. После установки этого атрибута в true, генерируемый динамически класс страницы будет реализовать от IHttpAsyncHandler, в противном случае класс будет реализовать IHttpHandler. Если класс страницы реализует IHttpAsyncHandler, то код страницы может выполнятся асинхронно до наступления нового события в жизненном цикле страницы PreRender, ко времени наступления которого происходит синхронизация и подготовка HTML-кода для отправки браузеру клиента.
AsyncTimeOut
Позволяет установить ограничение по времени, отведенное для выполнения асинхронных операций. По умолчанию этот параметр равен 45 секундам.
Culture
Устанавливает набор региональных параметров (Culture) , используемый для страницы.
EnableTheming
Позволяет включить или выключить поддержку тем оформления. По умолчанию включено.
MasterPageFile
Указывает путь к шаблону, который будет использован для создания кода этой страницы.
StyleSheetTheme
Позволяет установить идентификатор темы оформления, которая будет использоваться для изменения установленной темы оформления (в атрибуте Theme или в файле web.confg). Таким образом можно установить общую тему оформления для всего сайта, а с помощью атрибута StyleSheetTheme вносить некоторые изменения в общее оформление страницы и /или некоторых элементов управления, содержащихся на странице.
Theme
Указывает название темы оформления, которая будет использована для оформления кода данной страницы.
UI Culture
Устанавливает набор региональных параметров (Culture) , используемый для пользовательского интерфейса страницы.
Жизненный цикл страницыЖизненный цикл страницы ASP.NET начинается с
получения и обработки Web-сервером IIS запроса к данной странице и
передачи этого запроса среде выполнения ASP.NET. В момент получения
запроса, среда выполнения загружает
класс
вызываемой
страницы, устанавливает свойства
класса страницы, выстраивает дерево элементов, заполняет свойства
Request и
Response и вызывает метод
IHttpHandler.ProcessRequest.После этого среда
выполнения проверяет каким образом была вызвана эта страницы
и если
страница вызвана путем передачи данных с
другой страницы, о чем будет рассказано далее, то среда выполнения
устанавливает свойство
PreviousPage.
Стоит отметить также, что помимо рассмотренных ниже этапов
выполнения страницы существуют еще и этапы уровня приложения, не
специфичные для страницы. Подробно об этапах выполнения приложения
написано в
этой
статье .
| Запрос станицы | Запрос страницы осуществляетс ядо начала жизненноцо цикла страницы. Когда пользователь осуществляет запрос, среда выполнения ASP.NET устанавливает, необходимо ли осуществить компиляцию страницы и начать жизненный цикл, либо можно выдать в качестве ответа страницу из кеша, таким образом не выполняя страницы. |
| Начало жизненного цикла | На этом этапе происходит установка свойство Response и Request и свойства UICulture. Также, на этом этапе устанавливается, была ли эта страница запрошена в результате постбэка (отправления данных на сервер) и соответствующим образом устанавливается свойсто IsPostBack. |
| Инициализация страницы | Ко времени инициализации страницы все дочерние пользовательские элементы управления уже созданы и имеют установленный свойства UniqueID. В это же время к странице применяются темы оформления. Если страница вызвна в результате постбэка, то данные, отправленные на сервер, еще не загружены в свойства элементов управления, на этом этапе. | Если страница вызвана в результате постбэка, то на этом этапе устанавливаются свойства элементов управления, на основании информации о состоянии (ViewState и ControlState). |
| Валидация | Вызывается метод Validate() для всех, находящихся на странице валидаторов. |
| Обработка постбэка | Вызываются обработчики событий (при условии, что постбэк произошел). |
| Рендеринг | Сохраняется информация о состоянии, затем класс страницы вызывает соответствующие методы дочерних элементов управления для генерации HTML представления и передачи его в Response.OutputStream. |
| Выгрузка | Выгрузка происходит после того, как создано HTML представление для всей страницы. |
Во время прохождения этапов
жизненного цикла возникают события, подписавшись на которые, разработчик
может выполнять свой собственный код. Стоит упомянуть атрибут
AutoEventWireup, директивы
@Page:
если этот атрибут установлен в
true (значение по
умолчанию), то методы класса страницы, названные
Page_НазваниеСобытия,
автоматически становятся обработчиками соответствующих событий
жизненного цикла станицы.
Для того, чтобы проследить жизненный цикл страницы и
последовательность возникновения событий, можно установить атрибут
Trace директивы
@Page в
true, а атрибут
TraceMode
в
"SortByTime". Тогда в разделе
Trace
Information можно найти список произошедших событий
(колонка
Message). Например:
| aspx.page | Begin PreInit | ||
| aspx.page | End PreInit | 0.0364973314167865 | 0.036497 |
| aspx.page | Begin Init | 0.0379050459346291 | 0.001408 |
| aspx.page | End Init | 0.047693704143491 | 0.009789 |
| aspx.page | Begin InitComplete | 0.0477864508468221 | 0.000093 |
| aspx.page | End InitComplete | 0.0481875670270608 | 0.000401 |
| aspx.page | Begin PreLoad | 0.0489879732516718 | 0.000800 |
| aspx.page | End PreLoad | 0.0494462283607275 | 0.000458 |
| aspx.page | Begin Load | 0.0494924892194238 | 0.000046 |
| aspx.page | End Load | 0.0553441897381414 | 0.005852 |
| aspx.page | Begin LoadComplete | 0.0554711043059809 | 0.000127 |
| aspx.page | End LoadComplete | 0.055942153615399 | 0.000471 |
| aspx.page | Begin PreRender | 0.0561455634022874 | 0.000203 |
| aspx.page | End PreRender | 0.0618604874695332 | 0.005715 |
| aspx.page | Begin PreRenderComplete | 0.06269871008062 | 0.000838 |
| aspx.page | End PreRenderComplete | 0.0633259746265858 | 0.000627 |
| aspx.page | Begin SaveState | 0.080360541216174 | 0.017035 |
| aspx.page | End SaveState | 0.213795377788888 | 0.133435 |
| aspx.page | Begin SaveStateComplete | 0.213911298043872 | 0.000116 |
| aspx.page | End SaveStateComplete | 0.214385763389788 | 0.000474 |
| aspx.page | Begin Render | 0.214440078745078 | 0.000054 |
| aspx.page | End Render | 0.315044337228923 | 0.100604 |
Из всех событий жизненного цикла страницы, разработчик может
подписаться только на пять, помимо событий дочерних элементов
управления. Эти события:
PreInit, Init, Load, PreRender, Unload.
Рассмотрим варианты использования этих событий.
| PreInit |
Во время этого события можно использовать свойство IsPostBack, для того, чтобы определить вызвана ли эта страница в первый раз или в результате постбэка. В плане управления страницей разработчик может: создавать динамически элементы управления, динамически устанавливать шаблон дизайна или тему оформления, считывать или устанавливать свойства объекта Profile. Стоит особо отметить, что на данном этапе, если страница была вызвана в результате постбэка, свойства элементов управления еще не установлены. В случае, если разработчик самостоятельно установит свойства на этом этапе, на следующем установленный значения могут быть изменены. |
| Init | На этом этапе разработчик может считывать или инициализировать свойства элементов управления. |
| Load | На этом этапе разработчик может считывать или изменять свойства элементов управления. |
| PreRender | Последняя возможность внести изменения во внешний вид страницы. |
| Unload | Освобождение занятых ресурсов (закрытие
открытых соединений с базой данных, завершение работы с файлами
и т.п.)
Важно, что на этом этапе уже создано HTML представление страницы и попытка внести какие-либо изменения (например, вызвав метод Response.Write()), приведет к исключению. |
Для управления приведенными в предыдущем разделе событиями и получении информации о результатах их выполнения, у объекта Page в ASP.NET 2.0 появились следующие новые методы и свойства. Подробная информация по перечисленным ниже объектам и свойствам, а также их использовании последует далее в следующем разделе этой статьи.
EnableTheming
Свойство, позволяющее отключить поддержку тем оформления на странице, если применение темы нежелательно.
GetValidators
Метод, возвращающий коллекцию валидаторов данной страницы.
Header
Ссылка на объект HtmlHead, позволяющий контролировать содержимое раздела HTML страницы, при условии, что для элемента head установлен атрибут runat="server".
IsAsync
Свойство, указывающее на способ обработки страницы – синхронный или асинхронный.
IsCrossPagePostBack
Свойство, позволяющее определить была ли данная страница запрошена в ответ на отправку данных с другой страницы.
MasterPageFile
Свойство, содержащее имя файла шаблона страницы.
MaxPageStateFieldLength
Устанавливает максимальный размер одного поля, хранящего состояние, в байтах. Если этому свойству присвоено число, меньшее, чем размер информации о состоянии, которую необходимо сохранить, то будет создано несколько скрытых полей, объем данных в каждом не будет превышать значения MaxPageStateFieldLength.
PageAdapter
Свойство возвращает объект PageAdapter, управляющий генерацией HTML представления страницы. Конкретный PageAdapter устанавливается средой выполнения в зависимости от параметров Requets. Если выбран PageAdapter, то события жизненного цикла страницы замещаются событиями PaeAdapter.
SetFocus
Метод, позволяющий установить выделение на какой-либо из видимых на
странице элементов управления.
StyleSheetTheme, Theme
Смотрите выше описание новых атрибутов директивы @Page.
TestDeviceFilter
Метод, проверяющий является ли текущий браузер браузером указанного в качестве аргумента типа.
Title
Свойство, позволяющее получить и изменить заголовок страницы.
Использование новых объектов страницы ASP.NET 2.0 Объект ClientScriptManagerClientScriptManager предоставляющий методы для работы скодом сценариев, которые будут использоваться в клиентской части Web-приложения. Теперь все методы, которые в ASP.NET 1.x использовались для регистрации клиентских скриптов или скрытых полей принадлежат классу ClientScriptManager. Например, иногда бывает необходимо регистрировать клиентский сценарий динамически, в зависимости от каких-либо параметров. Например, при перезагрузке страницы форума нужно указать пользователю, что ему пришло новое личное сообщение. Это можно сделать как показано в нижеследующем примере.
Protected void Page_Load(object sender, EventArgs e) { if (CheckMail()) { string startupScript = "" + "if(confirm("Вам пришло новое сообщение. Прочесть?"))" + "window.navigate("/ReadMail.aspx");" + ""; ClientScript.RegisterStartupScript(this.GetType(), "MailAlertScript", startupScript); } }
Объект HtmlHeadДля каждой страницы ASP.NET, в HTML коде которой
присутствует тег автоматически создается
экземпляр объекта HtmlHead, позволяющий управлять заголовком страницы,
добавлять теги META и ссылки на каскадные таблицы стилей.
Раньше разработчику страницы ASP.NET 1.0 приходилось добавлять
специальное свойство или переменную в класс страницы или придумывать
какой-либо обходной путь для того, чтобы получить возможность управлять
заголовком и метаданными страницы. Например, так как это показано в
следующем примере.
С появлением объекта HtmlHead подобные ухищрения уходят в прошлое.
Page.Header.Title = "HtmlHead Test Page"; Page.Header.Metadata.Add("Author", "Gaidar Magdanurov"); Page.Header.Metadata.Add("E-Mail", "[email protected]");
Помимо этого, как и любой элемент, способный содержать вложенные элементы, HtmlHead позволяет добавлять произвольные элементы.
((Control)Page.Header).Controls.Add(new LiteralControl (""));
Управление страницей Установка выделения на элемент управленияИногда бывает необходимо, чтобы после загрузки страницы выделение было установлено на какой-то определенный элемент управления (например в поисковой форме логично установить фокус ввода на основное поле поиска), для этого можно задать значение атрибута defaultfocus тега form.
Выделением можно управлять программно, вызывая метод SetFocus, в качестве параметра передавая уникальный идентификатор этого элемента:
Protected void Page_Load(object sender, EventArgs e) { if(isPostBack) { SetFocus("txtLastName"); } else { SetFocus("txtFirstText"); } }
Обновление данных без перезагрузки страницы
В ASP.NET 2.0 стало возможным обновлять данные на
странице без отправки страницы на сервер и ее полного обновления. Это
стало возможно благодаря появлению клиентских сценариев с обратным
вызовом (callback scripts или клиентские коллбэки). После того, как
некоторое событие вызывает запрос к серверу, обновленные данные
передаются непосредственно в клиентский сценарий в качестве аргументов
функции.
Подобный способ обновления данных на странице удобно и выгодно
применять, когда для обновления всей информации требуется много ресурсов
и достаточно длительное время, при этом эти часть данных обновляется
часто, а остальные данные статичны. Тогда время на обновления данных,
например, одного пользовательского элемента, учитывая время запроса к
серверу, обработки и получения ответа, будет существенно ниже, чем время
обновления всей страницы.
Допустим, существует страница, на которой находится выпадающий
список. Когда пользователь выбирает некоторое значение из списка, в
некоторый элемент управления загружается значение, логически связанное с
выбранным из списка значением. При этом задача такова, что нельзя
хранить все данные на стороне клиента (возможно данных слишком много и
страница будет долго передаваться по сети, либо данные генерируются на
сервере не только в зависимости от выбранного пользователем элемента
выпадающего списка). В ASP.NET 1.x
для решения
этой задачи необходимо привязать к событию изменения значения в
выпадающем списке серверный метод. При этом список должен вызывать
отправку страницы на сервер при каждом изменении значения
(AutoPostBack="True").
Protected void ddStatic_SelectedIndexChanged(object sender, EventArgs e) { // На основании значения ddStatic.Items.Value // метод устанавливает свойства дригих элементов управления }
В ASP.NET 2.0, как уже было сказано выше, существует
возможность не обновлять всю страницу целиком. В данном случае разумно
обновить только необходимые данные, поскольку обновлять всю страницу
только для того, чтобы установить одно значение слишком расточительно.
Для реализации механизма обновления данных без перезагрузки страницы
необходимо создать клиентскую функцию обратного вызова, принимающую
переданные с сервера параметры, серверную функцию, принимающую параметры
от клиента и возвращающую клиенту значения на основании полученных
параметров и связать эти две функции. Мало того, механизм обратного
вызова в ASP.NET 2.0 позволяет возвращать результат асинхронно. Для
этого в интерфейсе ICallbackEventHandler определены два метода:
RaiseCallbackEvent, для получения параметров на сервере и
GetCallbackResult для возвращения результата клиенту. Для реализации
функциональности предыдущего примера в ASPX файле помещается следующий
код.
function UpdateText(result, context)
{
dSpan.innerText = result;
}
Класс страницы, использующей функции с обратным вызовом должен реализовывать интерфейс ICallbackEventHandler.
Public partial class ScriptCallback_aspx: System.Web.UI.Page, System.Web.UI.ICallbackEventHandler { }
Сигнатуры функций, поддерживающие обратный вызов выглядят следующим образом:
Public virtual void PrepareCallbackEvent(string Аргументы) public virtual string RenderCallbackResult() private string EventArgument = ""; public void PrepareCallbackEvent(string eventArgument) { EventArgument = eventArgument; } public string RenderCallbackResult() { return EventArgument; // значение типа string }
Последним шагом к поставленной цели является связывание серверной и клиентских функций.
Protected void Page_Load(object sender, EventArgs e) { // создаем ссылку на функцию обратного вызова string callbackFunction = Page.ClientScript.GetCallbackEventReference (this, "document.all["ddDynamic"].value", "UpdateText", "null"); // Привязываем сценарий к событию изменения значения выпадающего // списка ddDynamic.Attributes["onchange"] = String.Format("javascript:{0}", callbackFunction); }
Метод GetCallbackEventReference объекта
ClientScriptManager принимает в качестве параметров ссылку на объект
страницы, строку, указывающую на значение, которое необходимо передавать
на сервер при обратном вызове, имя метода на стороне клиента и
принимающего ответ сервера. Подробное описание можно получить в
документации MSDN или с помощью инструмента Visual Studio - Object
Browser.
Используя эту технологию можно создавать сложные методы обновления
данных страницы и позволяющие получить значительный выигрыш в
производительности, для этого достаточно разобраться в том, какой код
генерирует среда выполнения ASP.NET, реализуя эту функциональность.
// Список, вызывающий перезагрузку страницы // Список вызывающий метод с обратным вызовом
Стандартная функция doPostBack весьма проста и служит для сохранения данных о событии в скрытые поля формы.
Var theForm = document.forms["frmCallBack"]; function __doPostBack(eventTarget, eventArgument) { if (theForm.onsubmit == null || theForm.onsubmit()) { theForm.__EVENTTARGET.value = eventTarget; theForm.__EVENTARGUMENT.value = eventArgument; theForm.submit(); } }
При использовании функций с обратным вызовом механизм
значительно сложнее. Код функции WebForm_DoCallback гораздо больше, чем
doPostBack, поскольку эта функция определяет тип объектной модели
браузера, после чего загружает необходимый для передачи данных с модуль.
Например, для браузера поддерживающего DOM это будет Microsoft.XMLHTTP.
Посмотреть код различных клиентских функций, используемых средой
ASP.NET 2.0 можно сохранив страницу, поддерживающую функции с обратным
вызовом на жесткий диск и открыв в текстовом редакторе файл
WebResource.axd, ссылка на который имеется в HTML странице.
Более подробное описание возможностей и
области применения клиентских функций обратного вызова описано в
статье Дино Эспозито .
Существенное ограничением серверных форм в ASP.NET
1.0 – отсутствие возможности непосредственно передавать данные,
введенные в форме, другой странице. Чтобы отправить значения элементов
форму другой странице необходимо использовать простою HTML форму и в
атрибуте action указать путь к странице, которая должна получить данные.
При этом теряются преимущества использования серверных форм.
В ASP.NET 2.0 тег элемента управления может иметь дополнительный
атрибут PostBackUrl, позволяющий указать какой странице система должна
передать Web-форму, если отправление данных на сервер инициировано этим
элементом управления.
После щелчка по кнопке, браузер пользователя будет
переадресован на страницу crosspost.aspx, при этом вся информация об
элементах управления формы, с которой произошло отправление данных,
будет также передано.
Чтобы реализовать эту возможность, среда ASP.NET 2.0 осуществляет
проверку ASPX страниц на предмет наличия элементов управления с заданным
атрибутом PostBackUrl и, при наличии таковых, создает на странице
дополнительное скрытое поле __PREVIOUSPAGE, которое и содержит
информацию о состоянии элементов формы. Эта информация доступна
странице-получателю через свойство PreviousPage.
Void Page_Load(object sender, EventArgs e) { if (PreviousPage != null) { // Получаем объекты отправленной формы TextBox txtFirstName = (TextBox)PreviousPage.FindControl("txtFirstName"); TextBox txtLastName = (TextBox)PreviousPage.FindControl("txtLastName"); // Используем данные txtInfo.Text = "Добрый день, " + txtFirstName.Text + "!"; } }
На уровне HTML кода, отправка данных другой форме выглядит следующим образом.
Из чего можно заключить, что данные формы не направляются из браузера непосредственно странице CrossPage.aspx, а предварительно направляются все той же странице GetValues.aspx, которая содержит форму frmTest. Это необходимо для поддержки серверной проверки (validation) введенных данных с использованием элементов управления RequiredFieldValidation, RangeValidation и других. Ознакомиться с методом WebForm_DoPostBackWithOptions можно в файле WebResource.axd, упомянутом в предыдущем параграфе этой статьи.
Шаблоны дизайна страницЧто, прежде всего, отличает один Web-сайт от другого?
Для простого пользователя сети Интернет основное отличие заключается в
разнообразном дизайне странице. Прежде чем встретится с функциональными
возможностями Web-приложения, посетитель сайта оценивает, нравится ли
ему внешний вид страниц. Поэтому дизайн страниц является едва ли менее
важным, чем общая функциональность.
Задача разработчика писать код, а задача художника-дизайнера
заниматься внешним оформлением и версткой HTML кода страниц. При этом в
большинстве случаев необходимо обеспечить возможность параллельной
работы над кодом приложения и HTML шаблоном. С этим весьма успешно
справлялась технология разделения кода программной логики и HTML кода
страницы Code-Behind. Но, при этом, при работе над каждой страницей,
разработчику приходится, так или иначе, сталкиваться с разметкой
страницы.
Стоит заметить, что большинство современных Web-сайтов имеют сходный
внешний вид всех страниц и каждая страница имеет общие элементы дизайна.
В ASP.NET 1.x
общие элементы дизайна страниц
заключали в пользовательские элементы управления и включались в каждую
страницу, либо, наоборот, страницы преобразовывали в элементы
управления, используя одну страницу в качестве основы в которую
загружали элементы управления в зависимости от строки URL.
Подход в ASP.NET 2.0 близок ко второму из названных подходов, но
заключает в себе существенные преимущества. Разработчику больше нет
нужды преобразовывать страницы в пользовательские элементы управления,
что существенно упрощает разработку и отладку. А также существенно
упрощает работу дизайнера, поскольку его задача сводится лишь во
включении нескольких ASP.NET элементов в код страницы-шаблона. Для более
подробного сравнения технологии шаблонов ASP.NET 2.0
с существующими ранее техниками использования шаблонов
рекомендуется обратится к
статье Фрица Оньена .
Шаблон дизайна страниц (Master pages) представляет
собой обычную ASP.NET страницу, обладающую несколькими дополнительными
атрибутами и свойствами и содержащую один или несколько специальных
элементов управления ContentPlaceHolder. Для того чтобы преобразовать
обычную страницу в шаблон, достаточно заменить директиву Page на
директиву Master.
После этого необходимо вставить в разметку страницы серверные элементы
управления ContentPlaceHolder, в те части страницы, где будет
размещаться информация, не относящаяся к общему дизайну.
Моя домашняя страница
Время:
Также как и для обычной страницы, в файле программной
логики можно работать с имеющимися элементами управления, создавать и
добавлять новые, основываясь на параметрах запроса изменять страницу и
ее поведение. Таким образом, можно вынести логику создания внешнего
облика Web-приложения практически полностью в шаблон страницы.
Элемент управления ContentPlaceHolder позволяет определить
содержимое, которое будет использоваться в случае, если страница,
использующая шаблон, не переопределит содержимое элемента управления.
- Главная страница
- Оглавление
Работа с элементами управления страницы шаблона ничем не отличается от работы с элементами управления для обычной страницы. Таким же образом можно определить методы и свойства, которые будут доступны всем страницам использующим данный шаблон.
Protected void Page_Load(object sender, EventArgs e) { PageTime.InnerText = DateTime.Now.ToShortDateString(); } public string Title { get { return PageTitle.InnerText; } set { PageTitle.InnerText = value; } }
Создание страницыИспользование шаблонов дизайна налагает свои требования на страницы. Поскольку шаблон содержит элементы управления ContentPlaceHolder, то страница должна содержать элементы управления Content, содержащие код разметки и другие элементы управления, которые будут отображать на результирующей странице. На странице не должно быть каких-либо серверных элементов управления или кода разметки вне элементов управления Content.
- Страница 1
- Страница 2
- Страница 3
Также как и в случае с шаблоном, код логики страницы создается обычным образом. Единственное отличие в том, что страница не имеет собственных объектов вроде HeadControl, поэтому нужно использовать ссылку на страницу шаблона через свойство Master.
Protected void Page_Load(object sender, EventArgs e) { if (!Page.IsPostBack) Master.Page.Header.Title = "Домашняя страница"; } protected void btnShow_Click(object sender, EventArgs e) { PlaceHolder.Controls.Add(new LiteralControl(" alert("Добрый день, " + txtName.Text + ""); ")); Master.Page.Header.Title = "Добрый день, " + txtName.Text; }
Для того чтобы привязать страницу к шаблону используется атрибут MasterPageFile директивы Page. Если же необходимо привязать один и тот же шаблон ко всем страницам в директории, то нет необходимости указывать атрибут MasterPageFile для каждой страницы, достаточно задать базовый шаблон в файле web.config.
Кроме того, ASP.NET позволяет устанавливать тему оформления программным образом. Как было сказано выше, загрузка и связывание с шаблоном оформления происходит во время подготовки страницы к инициализации. Поэтому, если необходимо сменить шаблон оформления страницы, необходимо делать это в обработчике события PreInit.
Protected void Page_PreInit(object sender, EventArgs e) { Page.MasterPageFile = "AnotherMaster.master"; }
Обработка шаблонов средой ASP.NETВо время первого обращения к какой-либо странице,
ASP.NET осуществляет поиск и компиляцию сборок для всех шаблонов в
директории. Эта операция занимает некоторое время, зависящее от
количества страниц шаблонов в директории, но выполняется только один
раз. Поэтому, если в директории присутствуют не использующиеся шаблоны,
это не приводит к потерям производительности в процессе работы
приложения, единственное неудобство – дополнительное время, а компиляцию
ненужных сборок для неиспользуемых страниц.
При обращении к aspx файлу страницы с заданным шаблоном оформления
процесс компиляции почти ничем не отличается от обычного процесса
компиляции страницы, за исключением того, что создается класс шаблона
MasterPage ссылка на который доступна в свойстве Page.Master.
Затем страница проходит все те шаги, которые описаны выше в этой
статье, в результате чего генерируется HTML код, который отправляется
клиенту. В полученном браузером HTML коде уже нельзя определить, какая
часть кода задана в шаблоне оформления, а какая часть кода определена на
самой странице, поскольку элементы управления ContentPlaceHolder и
Content не имеют каких-либо HTML соответствий и не порождают
дополнительных тегов, кроме своего содержимого.
Домашняя страница
|
|
Время: 20.03.2005
Поскольку шаблон является подмножеством страницы, то допустимо создавать вложенные шаблоны, указывая для шаблона в директиве Master путь к другому шаблону с помощью атрибута MasterPageFile. Для этого необходимо в основном шаблоне определить элементы управления ContentPlaceHolder, а в «дочерних» шаблонах на ряду с ContentPlaceHolder элементами определить элементы управления Content для замещения содержимого элементов ContentPlaceHolder базового шаблона.
Использование разных шаблонов для разных браузеровЛюбому Web-разработчику хорошо известно, что разные
браузеры (например, Microsoft Internet Explorer, Netscape Navigator,
Mozilla FireFox и др.) по разному обрабатывают HTML код и, что особенно
важно, обладают несколько разными программируемыми моделями, что
усложняет создание клиентских сценариев.
Для разрешения этой проблемы существует два
основных метода, которые используются и в ASP.NET 1.x и в классическом
ASP. Первый заключается в том, что браузеру клиента отправляется
клиентский код, который, основываясь на типе и версии браузера,
выполняет некоторые действия. Второй состоит в перенаправлении браузера
пользователя на те страницы, которые специально оптимизированы под
конкретный браузер. ASP.NET упрощает создание подобных страниц,
поскольку среда выполнения генерирует HTML код для стандартных серверных
элементов управления основываясь на информации о браузере клиента. При
использовании шаблонов оформления, можно создать несколько шаблонов, для
каждого браузера и в директиве Page страницы указать, какой шаблон
использовать.
Список браузеров и используемые средой ASP.NET
свойства браузеров можно найти в директории
%WINDIT%\Microsoft.NET\Framework\версия\CONFIG\Browsers.
Для локализации приложений в ASP.NET 1.x разработчику часто приходилось писать код для определения региональных настроек пользователя. Этот код часто помещался в global.asax и его задачей стояла установка языка пользователя в качестве языка текущего процесса, путем создания объекта CultureInfo и присвоения его свойствам CurrentCulture и CurrentUICulture объекта CurrentThread :
Void Application_BeginRequest (Object sender, EventArgs e) { if (Request.UserLanguages.Length > 0) { CultureInfo UserCulture = CultureInfo.CreateSpecificCulture(Request.UserLanguages); Thread.CurrentThread.CurrentCulture = UserCulture; Thread.CurrentThread.CurrentUICulture = UserCulture; } }
В ASP.NET 2.0 существует возможность переложить определение региональных настроек пользователя на среду выполнения. Достаточно установить атрибуты Culture="auto" и UICulture="auto" директивы @Page , чтобы для страницы региональные настройки пользователя определялись автоматически. В случае. если необходимо достичь этого эффекта на всех страницах сайта, достаточно в файл web.config добавить следующую строку:
Выражения для локализации
ASP.NET 2.0 позволяет генерировать сборки с локальными ресурсами для каждой страницы и связывать элементы управления с данными, хранимыми в этих ресурсах с помощью выражений, размещаемых непосредственно в коде представления в ASPX файле. Для этого используется атрибут meta:resourcekey, значение которого анализируется во время выполнения страницы.
Select Language
Либо может быть использовано новое выражение :
Для того, чтобы таким же образом можно было локализовать статический текст, в ASP.NET 2.0 появился новый элемент управления Localize, позволяющий использовать указанные выше выражения локализации.
Text
Text
Подробнее и выражениях, генерации ресурсов и определении региональных настроек пользователя можно прочесть в этой статье .
ЗаключениеВ этой статье приведены лишь некоторые основные сведения о новшествах в технологии ASP.NET 2.0 по сравнению с ASP.NET 1.x . Особенности ASP.NET были очень описаны кратко и данная статья может служить отправной точной для изучению этой передовой технологии. Для более подробного описания упомянутых в статье технологий и новых возможностей, рекомендуется обратиться к списку дополнительной литературы. В статье не был затронут ряд важных нововведений - асинхронное выполнение кода, новые элементы управления, шифрование фрагментов файла web.config , новые механизмы доступа к данным и многое-многое другое. Все это является материалом, которому можно посвятить не одну книгу. По возможности автор постарается осветить эти нововведения в будущих статьях.
Шаблоны дизайна - это визуальное наследование страниц, впервые появившееся в ASP.NET 2.0. Вы можете создавать основу для любого количества страниц приложения. Шаблоны позволяют легче создавать и поддерживать приложения. Visual Studio 2005 включает поддержку создания и редактирования шаблонов страниц. Эта лекция рассматривает использование шаблонов страниц в приложении и начинается с объяснения их преимуществ.
Примечание: терминология в этой области не устоялась. В некоторых книгах используют выражение «эталонные страницы». Можно применять термин «главная страница», хотя его можно спутать с Default.aspx.
Зачем нужны шаблоны дизайна страниц?
Для простого пользователя отличие одного сайта от другого - в разнообразном дизайне страниц. Большинство веб-сайтов сегодня имеют узнаваемый дизайн, который достигается использованием одних и тех же элементов в тех же самых местах в разных страницах сайта. Поэтому дизайн страниц является едва ли менее важным, чем общая функциональность.
Например, взгляните на главную страницу сайта газеты «Комсомольская правда». Каждый день там появляются разные статьи, но оформление их остается единым. Это логотип газеты, верхние, правые, левые навигационные панели, рейтинг статей справа, формы для поиска, подписки и входа в почту. Внизу страницы находится юридическая информация.
Некоторые разработчики копируют и вставляют повторяющиеся элементы во всех страницах. Это неэффективно, если нужно изменить одну деталь в этих общих элементах, изменения придется вводить во всех страницах. Можно помещать повторяющиеся куски кода во включаемые файлы с помощью команды HTML include. Но так трудно увидеть окончательный вид страницы в среде разработки. В ASP.NET 1.1 стало возможным создавать пользовательские элементы управления. Можно создать такой элемент с нужным содержанием и помещать его на все страницы. Развитием этой идеи стало создание шаблонов страниц. Это тоже пользовательский элемент управления, только он находится не в странице, а вне ее.
Основы Master PagesС помощью шаблонов страниц вы определяете некоторое общее содержание и помещаете ее в страницу с расширением.master. Естественно, таких страниц в приложении может быть несколько. Этой шаблон могут использовать любое количество дочерних страниц, которые как и обычные страницы, имеют расширение aspx.
Начиная с этой лекции, будем разбирать проект, который Visual Studio 2005 создает по шаблону Personal Web Site Starter Kit. В нем показаны шаблоны страниц, темы и персонализация и навигация. Элементы управления навигации сосредоточены на странице шаблона Default.master. И это естественное решение, так как навигация нужна везде.
В страницу шаблона также включают общие заголовки и нижние колонтитулы.
Это единственный тип страниц, где возможно разместить специальные элементы управления ContentPlaceHolder. Они определяют места, в которое дочерние страницы данного мастера могут помещать свое собственное содержание. Когда ASP.NET получает запрос отобразить дочернюю страницу, она сливает ее код с кодом главной страницы, в результате генерируется HTML, в котором не видно никаких «швов».
Когда дочерняя страница редактируется в среде разработки, на вкладке Design видна полная страница вместе с элементами из шаблона, но они показаны серым цветом. Их редактировать нельзя. Можно редактировать то, что находится в элементах Content.
В диалоге Add New Item выберите тип страницы Master Page. Как и обычные страницы, их можно создавать с отделенным кодом или кодом, встроенным в страницу. Это никак не влияет на модель разделения кода дочерних+ страниц. Кроме того, главная и дочерняя страницы могут разрабатываться на разных языках.
Чтобы получить четкое разделение страницы на логические части, используют таблицы. Построим таблицу с 3 строками, где в верхней строке находится заголовок всех страниц, во второй произвольное содержание, она состоит из двух ячеек, в каждой из которых по одному ContentPlaceHolder. В нижнем ряду находится правовая информация. Таблица создается очень просто из меню Layout-Insert Table. Создайте таблицу 2 на 3. После этого объедините ячейки верхней и нижней строк, а в среднюю вставьте ContentPlaceHolder. Создайте содержание заголовка и подвала. Должна получиться подобная страница:
Привет!
|
||||||
Первое отличие этой страницы от обычной в том, что она начинается с директивы Master, а не Page. Класс мастер-страницы определен в файле MasterPage.master.cs.
| public partial class MasterPage: System.Web.UI.MasterPage { protected void Page_Load(object sender, EventArgs e) { } } |
Класс шаблона - наследник System.Web.UI.MasterPage, который в свою очередь наследует от System.Web.UI.UserControl.
В ней могут находиться любые элементы управления и HTML-код. В ней могут обрабатываться и события страницы. 2 элемента ContentPlaceHolder обозначают места, куда вставляется содержание страницы-наследницы.
Теперь нужно создать страницу содержания. Она создается как обычно, только отмечается флажок с надписью Select Master Page. Появляется диалог, в котором необходимо выбрать шаблон страницы.
Но и в этом случае назначение главной страницы в директиве Page имеет приоритет над назначением на уровне приложения. Установка web.config действует на тех страницах, в которых masterPageFile не указан, но определены элементы управления Content. Эта установка не действует на обычные aspx-страницы.
Шаблон можно назначить не всем страницам, а выборочно, например, расположенным в определенной папке приложения.
Элемент location вставляется в главный узел configuration. Здесь указано, что все страницы из папки Lections используют шаблонную страницу Lections.master.
На странице-наследнице шаблона могут быть только элементы типа Content, каждый из который соответствует одному элементу ContentPlaceHolder шаблона. Нельзя вставлять содержание вне этих элементов, иначе ASP.NET не сможет объединить главную страницу со страницей содержания. Идентификатор ContentPlaceHolder должен совпадать с атрибутом ContentPlaceHolderID соответствующего элемента Content.
Программа создала дочернюю страницу с 2 элементами управления Content. Если переключиться на вкладку Design, эти два элемента Content показаны в виде пустых прямоугольников, расположенных рядом друг с другом, так как в шаблоне они находятся в двух соседних ячейках таблицы. Директива Page отличается от обычной, кроме атрибута MasterPageFile, наличием атрибута Title. Так как теги , , наследуются из файла шаблона, это единственная возможность переопределить заголовок браузера. Заменим значение атрибута
Если посмотреть на результирующую страницу в браузере, увидим, что в заголовок браузера отразил изменение. В HTML-коде страницы записано
На самой странице отображается только содержание, заданное в странице шаблона.
Шаблон можно в любой момент отредактировать, и изменения отразятся на всех производных страницах. Например, добавим картинку перед текстом заголовка.
|
(Ее можно найти в установке.NET "Microsoft.NET\Framework\v2.0.xxx\ASP.NETWebAdminFiles\Images)
Дочерняя страница в браузере теперь выглядит так:
Есть еще один способ поменять заголовок браузера программно. У страницы, имеющей шаблон, есть свойство Master. Конечно, оно есть у всех страниц, но у обычных страниц оно равно Null. Через него можно обращаться ко всем свойствам главной страницы. Это свойство только для чтения.
В главной странице может быть определено содержание, которое будет отображаться по умолчанию. Оно помещается в элементах ContentPlaceHolder и наследуется всеми дочерними страницами. Если дочерняя страница не переопределит содержание по умолчанию, оно будет использоваться при ее отображении. Создадим элемент управления SiteMapPath, которым поместим в ContentPlaceHolder1.
На странице MainSchool.aspx он отображаться не будет, так как в ней определены оба элемента Content. Однако если в следующей странице определен только один из элементов Content:
|
Какой язык программирования Вы предпочитаете? asp:RadioButtonList ID="rblVoting" runat="server" DataSourceID="SqlDataSource1" DataTextField="variant" DataValueField="id"> |
Если посмотреть ее в браузере, увидим, что в ее левой части «хлебные крошки» отображаются.
Программное назначение мастер страницыВ странице содержания можно переназначить ее главную страницу программно. Для этого нужно присвоить нужное значение свойству Page.MasterPageFile. Шаблон поменяется независимо от того, какой шаблон был назначен в директиве @Page. Но если попробуете проделать это в функциях Page_Load или Page_Init, получите ошибку времени выполнения.
Это свойство можно изменить только во время обработки события Page_PreInit. Событие Page_PreInit - самая ранняя фаза жизненного цикла страницы, к которой можно получить доступ. Во время события Init главная и дочерняя страница уже сливаются в одну, поэтому уже поздно менять шаблон. По этой причине событие Page_PreInit единственное, в обработчике которого можно работать с главной страницей отдельно от страницы содержания.
Страницы шаблона могут иметь методы и свойства. Чтобы можно было обращаться к ним, нужно использовать директиву @MasterType. При этом становится доступен класс страницы шаблона дизайна через строго типизированную ссылку. Атрибут TypeName задает имя типа, а VirtualPath путь относительно корневого каталога веб-приложения к файлу шаблона.
Таким образом страница разрешает доступ извне к свойствам своих элементов.
| void Page_Load() { Master.FooterText = "This is a custom footer"; AdRotator ad = (AdRotator)Master.FindControl("MyAdRotator"); if (ad != null) { ad.BorderColor = System.Drawing.Color.Purple; ad.BorderWidth = 10; } } |
Шаблоны дизайна могут наследовать другие шаблоны. Например, сайт состоит из нескольких разделов. Все страницы сайта имеют общие элементы, и все страницы раздела имеют другие общие элементы. Сайт цветочного магазина состоит из разделов многолетних и однолетних цветов. Для них созданы шаблоны, которые наследуют общий шаблон сайта.
|
Perrenials
|
Страница, описывающая нарциссы, находится в разделе многолетних цветов и наследует шаблон SectionPerrenials.
| Daffodils bloom early in spring and welcome the growing season. |
Когда составная страница формируется на сервере, происходят события и страницы шаблона, и страницы содержания. Порядок этих событий полезно знать, если мы хотим программировать их обработчики.
Инициализация вложенных элементов управления главной страницы.
Инициализация вложенных элементов управления страницы содержания.
Инициализация самой главной страницы.
Инициализация страницы содержания.
Событие Page_LoadComplete страницы содержания
Событие LoadComplete было введено для того, чтобы можно было обратиться из страницы содержания к элементам главной страницы, созданным в ее Page_Load. Это нельзя сделать в обработчике Page_Load страницы содержания, так как она загружается до главной страницы.
Страницы шаблонов для конкретных платформВо многих случаях приложения разрабатываются для просмотра на разных видах контейнеров. Это могут быть различные браузеры или программы просмотра веб-сайтов на карманных компьютерах и мобильных телефонах.
Поэтому ASP.NET 2.0 позволяет в атрибуте MasterPageFile директивы Page определить разные страницы шаблона для конкретных контейнеров.
При создании приложений, в которых все страницы включают общие заголовки, подвалы и систему навигации жизнь могут облегчить шаблоны дизайна. Их легко применять и их можно изменять в любой момент, обновляя при этом все приложение.
ASP.NET Web pages provide the user interface for your Web applications. The topics in this section provide information on how ASP.NET Web pages work and how to create and program them.
In This SectionASP.NET Web Pages Overview
Provides general information on the structure of ASP.NET Web pages, how pages are processed by ASP.NET, and how ASP.NET pages render markup that conforms to XHTML standards.
ASP.NET Web Page Syntax Overview
Describes the basic markup elements that make up an ASP.NET page.
Programming ASP.NET Web Pages
Provides information on how to create event handlers in ASP.NET pages and how to work with client script.
ASP.NET Web Page Code Model
Provides an overview of the programming model inherent to all ASP.NET pages, which includes the single-page model, the code-behind model, and how to decide which model to use.
ASP.NET Page Class Overview
Describes the run time class that is generated and then compiled to represent a page, and provide a programmable object corresponding to that page.
Walkthrough: Creating a Basic Web Page in Visual Web Developer
Provides a tutorial on creating a simple ASP.NET Web page.
Walkthrough: Creating a Basic Web Page with Code Separation in Visual Web Developer
Provides a tutorial on creating a simple ASP.NET Web page using the code-behind programming model.
How to: Add ASP.NET Web Pages to a Web Site
Provides a procedure for adding new and existing ASP.NET Web pages to a Web site in Visual Studio.
Creating ASP.NET Web Sites
Provides information on how to create, customize, and manage an ASP.NET Web application (sometimes referred to as a Web site).
ASP.NET Web Server Controls Overview
Provides information about how ASP.NET Web server controls work, how to add them to ASP.NET pages, and how to program them.