Поделиться через

Клиентский сценарий на веб-страницах ASP.NET

  • Статья

Обновлен: Ноябрь 2007

Веб-приложения ASP.NET не ограничены серверными инструментами и языками. В веб-страницы ASP.NET можно включать ECMAScript (JavaScript или JScript) для создания эффективных веб-приложений. В ASP.NET доступны разнообразные возможности для поддержки клиентских сценариев.

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

Альтернативное решение — воспользоваться преимуществами функций AJAX, предоставляемых ASP.NET. Реализация AJAX в ASP.NET представляет собой законченную инфраструктуру, включающую:

  • Объектно-ориентированное программирование в JavaScript.

  • Асинхронная обратная передача.

  • Веб-службы приложений для проверки подлинности и работы с профилями.

  • Серверные элементы управления, которые управляют клиентским сценарием с помощью расширенных функций отладки и трассировки.

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

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

  • Сценарии

  • Включение пользовательских клиентских сценариев в страницы ASP.NET

  • Расширение JavaScript возможностями AJAX ASP.NET

  • Серверные элементы управления ASP.NET, зависящие от клиентских сценариев

  • Добавление событий клиентскиз сценариев к серверным элементам управления ASP.NET

  • Обращение к серверным элементам управления из клиентского сценария

  • Вызов клиентских событий щелчка для серверных элементов управления

  • Взаимодействие между клиентским сценарием и серверным кодом

  • Создание компонентов клиентских сценариев

  • Добавление клиентской функциональности серверным элементам управления

Сценарии

Используйте клиентские сценарии, если требуется:

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

  • Добавление на веб-страницы ASP.NET функциональных возможностей AJAX позволит:

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

    • Обновлять и управлять пользовательским интерфейсом без необходимости выполнения обратной передачи серверу.

    • Организовать код в виде клиентских компонентов. Клиентские компоненты — это объекты многократного использования, которые инкапсулируют JavaScript и основу которых составляет Microsoft AJAX (библиотека). Также клиентские компоненты могут управляться серверными элементами управления или связываться с существующими серверными элементами для дополнения клиентской функциональности.

Включение пользовательских клиентских сценариев в страницы ASP.NET

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

Существует несколько возможностей включения клиентских сценариев в страницы ASP.NET:

  • Можно включить клиентский сценарий статически в блок script, содержащий код сценария или использующий атрибут include для ссылки на файл JavaScript (с расширением JS). Используйте этот метод для вставки блоков сценария или файлов JavaScript, содержащих клиентский сценарий, динамическое создание которого не требуется и который не использует дополнительные функции AJAX (эти функции предоставляет Microsoft AJAX (библиотека)).

  • Можно динамически создавать и добавлять клиентские сценарии на веб-страницу ASP.NET с помощью класса ClientScriptManager. Используйте этот метод, если требуется создавать сценарии, которые зависят от данных, доступных только во время выполнения.

  • Если планируется использовать возможности AJAX ASP.NET, можно управлять файлами клиентских сценариев с помощью серверного элемента управления ScriptManager. Серверный элемент управления ScriptManager также гарантирует, что Microsoft AJAX (библиотека) загружается в обозреватель перед выполнением сценариев. Дополнительные сведения см. в разделе Общие сведения о ASP.NET AJAX.

Включение статических блоков клиентских сценариев

Можно добавлять блоки script на страницу ASP.NET так же, как и на любую HTML-страницу. Клиентский сценарий может реализовывать обработку событий, например события страницы onload. Когда страница ASP.NET выполняется в обозревателе, элементы разметки страницы являются доступными из клиентского сценария. HTML-элементы вызывают соответствующие обработчики клиентских событий.

3hc29e2a.alert_note(ru-ru,VS.90).gifПримечание.

Можно обращаться к серверным элементам управления ASP.NET из клиентского сценария. Дополнительные сведения см. ниже в подразделе Обращение из клиентского сценария к серверным элементам управления.

Веб-страница ASP.NET также имеет доступ к файлу сценария с помощью атрибута src тега <script>, как показано в следующем примере:

<script type="text/javascript" src="MyScript.js"></script>

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

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

Динамическое создание клиентских сценариев

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

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

  • RegisterClientScriptBlock, который вставляет блок сценария в верхнюю часть отображаемой страницы.

  • RegisterStartupScript, который вставляет блок сценария в конец отображаемой страницы.

В следующем примере показано добавление динамически генерируемого клиентского сценария на страницу. Код проверяет, установлен ли флажок с именем checkDisplayCount. Если установлен, то выполняются следующие задачи:

  • Создается функция клиентского сценария, которая использует элемент span для отображения количества знаков в элементе управления TextBox с именем TextBox1.

  • Клиентское событие добавляется к элементу управления TextBox.

  • Создается элемент span.

В коде предполагается, что страница содержит флажок с именем checkDisplayCount, свойство которого AutoPostBack установлено в true, и элемент управления PlaceHolder с именем PlaceHolder1.

Protected Sub Page_Load(ByVal sender As Object, _
        ByVal e As System.EventArgs)
    If checkDisplayCount.Checked Then
        Dim scriptText As String = ""
        scriptText &= "function DisplayCharCount(){"
        scriptText &= "   getElementByID("spanCounter").innerText = " & _
            "document.forms[0].TextBox1.value.length"
        scriptText &= "}"
        ClientScriptManager.RegisterClientScriptBlock(Me.GetType(), _
            "CounterScript", scriptText, True)
        TextBox1.Attributes.Add("onkeyup", "DisplayCharCount()")
        Dim spanLiteral As New LiteralControl()
        spanLiteral.Text = "<span id=""spanCounter""></span>"
        PlaceHolder1.Controls.Add(spanLiteral)
    End If
End Sub

void Page_Load(object sender, EventArgs e)
{
    if(checkDisplayCount.Checked)
    {
        String scriptText = "";
        scriptText += "function DisplayCharCount(){";
        scriptText += "   spanCounter.innerText = " + 
            " document.forms[0].TextBox1.value.length";
        scriptText += "}";
        ClientScriptManager.RegisterClientScriptBlock(this.GetType(), 
           "CounterScript", scriptText, true);
        TextBox1.Attributes.Add("onkeyup", "DisplayCharCount()");
        LiteralControl spanLiteral = new 
            LiteralControl("<span id=\"spanCounter\"></span>");
        PlaceHolder1.Controls.Add(spanLiteral);
    }
}

Дополнительные сведения см. в разделе Пошаговое руководство. Добавление клиентского сценария динамически на веб-страницы ASP.NET.

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

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

Добавление клиентского сценария с помощью элемента управления ScriptManager

Если используется AJAX ASP.NET, элемент управления ScriptManager предоставляет возможность добавления файлов сценария на страницу — статических файлов сценариев, хранящихся на диске (с расширением JS), и файлов сценария, внедренных в качестве ресурсов в сборку. Файлы сценариев в этом элементе управления можно указать декларативно. Кроме того, методы регистрации элемента управления ScriptManager позволяют программно управлять существующими файлами клиентских сценариев и использовать сценарии для поддержки частичного обновления страницы.

Общие сведения об элементе управления ScriptManager см. в разделе Общие сведения об элементе управления ScriptManager. Сведения о том, как внедрить файл JavaScript в качестве ресурса в сборку и как использовать его на веб-странице, см. в разделе Пошаговое руководство. Внедрение в сборку файла JavaScript в качестве ресурса.

3hc29e2a.alert_note(ru-ru,VS.90).gifПримечание.

При использовании клиентских (но не серверных) возможностей AJAX ASP.NET применяйте методы класса ClientScriptManager для вставки сценариев на веб-страницу ASP.NET. Например, если не используются функции локализации для сценариев или элемент управления UpdatePanel, то элемент управления ScriptManager не требуется. Поэтому нельзя вызвать его методы для вставки клиентского сценария на страницу. Использование методов класса ClientScriptManager, как правило, более эффективно, чем использование методов элемента управления ScriptManager. Это объясняется тем, что методы класса ClientScriptManager не требуют дополнительной обработки для серверных функций, поддерживаемых элементом управления ScriptManager. Если необходимо создать сценарий клиента динамически (а не управлять существующим сценарием), используйте класс ClientScriptManager для вставки клиентского сценария на страницу. Например, используйте класс ClientScriptManager, если требуется создать клиентский сценарий программными средствами на основе сведений, доступ к которым невозможен в случае статического файла сценария.

Расширение JavaScript возможностями AJAX ASP.NET

ASP.NET поддерживает инфраструктуру AJAX, что позволяет использовать клиентские сценарии для добавления расширенных функциональных возможностей к веб-странице. К ним относятся асинхронные обратные передачи, быстрореагирующий пользовательский интерфейс и т.д. Функциональные возможности AJAX реализует Microsoft AJAX (библиотека). Она содержит клиентские сценарии, использующие не зависящие от обозревателя технологии ECMAScript (JavaScript) и динамического HTML (DHTML). Функциональность AJAX интегрирована с платформой серверной разработки ASP.NET.

Microsoft AJAX (библиотека), объектно-ориентированные возможности и расширения объектов JavaScript обеспечивают следующие возможности для создания клиентских сценариев:

  • Пространства имен

  • Наследование

  • Интерфейсы

  • Перечисления

  • Отражение

  • Вспомогательные средства отладки

  • Трассировка

  • Обработка типизированных исключений

  • Вспомогательные методы для работы со строками и массивами.

    3hc29e2a.alert_note(ru-ru,VS.90).gifПримечание.

    Microsoft AJAX (библиотека) может использоваться даже в том случае, если не планируется использовать серверные возможности AJAX ASP.NET.

Дополнительные сведения о том, как Microsoft AJAX (библиотека) расширяет возможности JavaScript, см. в следующих разделах:

Совместимость возможностей AJAX с обозревателями

Microsoft AJAX (библиотека) предоставляет достаточный уровень совместимости сценариев AJAX для работы с наиболее распространенными обозревателями (включая Microsoft Internet Explorer, Mozilla Firefox и Apple Safari). Это позволяет создавать сценарии, не зависящие от того, в каком из поддерживаемых обозревателей они будут выполняться. Дополнительные сведения см. в разделе Общие сведения о ASP.NET AJAX.

Серверные элементы управления ASP.NET, зависящие от клиентского сценария

Функциональность некоторых серверных элементов управления ASP.NET зависит от клиентских сценариев. Например, элемент управления LinkButton требует, чтобы клиентский сценарий поддерживал обратную передачу. Клиентский сценарий, необходимый для серверных веб-элементов управления ASP.NET, добавляется автоматически на страницу при ее отображении. Клиентский сценарий, генерируемый для этих элементов управления, не зависит от каких-либо клиентских сценариев, создаваемых разработчиком.

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

Добавление событий клиентского сценария к серверным элементам управления ASP.NET

Элементы управления ASP.NET отображаются на странице как HTML-элементы. (Какими именно HTML-элементами представляется элемент управления, определяется языком разметки для страницы — HTML, XHTML или другим языком.) Поэтому можно добавлять клиентский сценарий обработки событий для элементов управления, как и для любых HTML-элементов на странице. Однако в некоторых случаях необходимо знать, каким именно образом интерпретируется элемент управления и какие атрибуты элемент управления резервирует для себя.

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

Декларативное добавление обработчиков клиентских событий

В разметке для серверных элементов управления ASP.NET значения свойств устанавливаются с помощью атрибутов. Например, чтобы установить свойство Text элемента управления TextBox, можно создать следующую разметку:

<asp:textbox id="TextBox1" runat="server" text="Sample Text" />
3hc29e2a.alert_security(ru-ru,VS.90).gifПримечание о безопасности.

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

Если добавить атрибут, который не отображается на какое-либо свойство элемента управления, ASP.NET во время обработки сервером проигнорирует этот атрибут. Он передается без изменений как часть разметки, генерируемой элементом управления для обозревателя. Например, элемент управления TextBox не имеет свойства с именем onkeyup. Поэтому, если включить атрибут onkeyup в разметку для элемента управления TextBox, этот атрибут будет передан в обозреватель. Такое поведение позволяет добавлять привязку событий к серверным элементам управления путем объявления их в разметке. Например, следующая разметка для элемента управления TextBox интерпретируется таким образом, что при каждом нажатии клавиши в текстовом поле текущая длина текста будет отображаться в HTML-элементе span с именем spanCounter:

<asp:textbox id="TextBox1" runat="server" text="Sample Text" 
  onkeyup="spanCounter.innerText=this.value.length;" />

Другой способ — вызов событием метода, который определен в клиентском сценарии в другом месте страницы:

<asp:textbox id="TextBox1" runat="server" text="Sample Text" 
  onkeyup="DisplayCount(this);" />

Обратите внимание, что язык, используемый для серверного кода (Visual Basic или C#), не влияет на клиентский сценарий, который всегда записывается на ECMAScript (JavaScript или JScript).

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

Добавление атрибутов в серверный код

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

Обращение к серверным элементам управления из клиентского сценария

При отображении серверного элемента управления ASP.NEP свойство ClientID элемента управления интерпретируется на странице как атрибуты id и name конечного элемента. (Значение свойства ClientID автоматически генерируется из свойства ID.) Например, можно создать следующий серверный элемент управления ASP.NET:

<asp:textbox id="TextBox1" runat="server" text="Sample Text" />

Свойство ClientID имеет значение TextBox1, и конечный HTML-элемент в обозревателе будет выглядеть следующим образом:

<input name="TextBox1" type="text" value="Sample Text" id="TextBox1" />
3hc29e2a.alert_note(ru-ru,VS.90).gifПримечание.

Элемент form интерпретирует только атрибут ID, но не атрибут name.

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

var tb1 = document.getElementById("TextBox1");
tb1.value = "New value";

В следующем примере предполагается, что у элемента form атрибут id имеет значение form1.

document.form1.TextBox1.value = "New value";

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

Доступ к элементам управления, находящимся внутри других элементов управления

Некоторые элементы управления отображают на странице дочерние элементы управления. К таким элементам относятся элементы управления списками данных, например ListView, GridView, DetailsView, FormView, DataList и Repeater, а также пользовательские элементы управления и веб-части.

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

Например, пусть в элементе управления DataList создано свойство ItemTemplate, а в шаблон добавлен элемент управления CheckBox, идентификатор которого установлен в checkEnabled. При интерпретации элемента DataList, для каждого элемента данных создается новый элемент управления checkEnabled. Отображаемая страница не должна содержать несколько экземпляров элементов с именем checkEnabled. Поэтому элемент управления DataList создает уникальный идентификатор для каждого из дочерних элементов управления.

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

  • Свойство UniqueID элемента управления отображается на атрибут name.

  • Свойство ClientID элемента управления отображается на атрибут id.

Свойства ClientID и UniqueID основаны на исходном свойстве ID, дополненном данными, гарантирующими уникальность в пределах страницы. В клиентском сценарии доступно свойство ClientID (атрибут id в сопоставленном элементе).

Если отобразить страницу, содержащую контейнер именования, в обозревателе, можно открыть исходный код страницы и просмотреть уникальные идентификаторы, сгенерированные как атрибуты name и id для дочерних элементов контейнера именования. Однако не рекомендуется использовать непосредственное обращение к элементам с помощью идентификаторов, содержащихся в исходном коде, потому что формула, используемая для генерации уникальных идентификаторов для дочерних элементов управления, может измениться. Вместо этого в серверном коде получайте значение свойства ClientID дочернего элемента управления и используйте его для обращения к дочернему элементу управления. Например, пусть на странице динамически создан клиентский сценарий. Если клиентский сценарий обращается к дочернему элементу управления, получите свойство ClientID дочернего элемента управления и используйте его в динамическом сценарии.

Вызов клиентских событий щелчка для серверных элементов управления

Как было отмечено ранее, можно добавить клиентское событие щелчка в большинство серверных элементов управления ASP.NET путем добавления атрибута onclick в разметку элемента управления. Однако некоторые элементы управления резервируют атрибут onclick для привязки к серверному событию. Это относится к элементам управления Button, LinkButton и ImageButton. В этих элементах управления для добавления обработчика клиентского сценария к элементу управления нельзя использовать атрибут onclick декларативно.

Можно добавить клиентский сценарий обработчика для события щелчка двумя способами:

  • Присвойте свойству OnClientClick элемента управления сценарий, подлежащий выполнению. При интерпретации элемента управления «Кнопка» значение OnClientClick отображается на атрибут onclick.

  • Добавьте атрибут onclick программно, вызвав метод Add коллекции Attributes элемента управления.

    3hc29e2a.alert_note(ru-ru,VS.90).gifПримечание.

    Нельзя программно добавить атрибут onclick к серверному элементу управления, если этот элемент управления уже использует onclick в своей функциональности, как например, LinkButton.

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

<asp:button id="Button1" 
  runat="server" 
  OnClientClick="return confirm('Ok to post?')" 
  onclick="Button1_Click" 
  Text="Click!" />

Взаимодействие между клиентским сценарием и серверным кодом

Кроме использования стандартных обратных передач, веб-страницы ASP.NET могут организовывать взаимодействие между клиентским сценарием и серверным кодом несколькими способами. Такие серверные элементы управления с поддержкой AJAX в ASP.NET, как UpdatePanel, автоматизируют задачи асинхронного частичного обновления страницы. Кроме того, AJAX ASP.NET поддерживает вызов веб-служб в асинхронном режиме.

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

Вызов серверного кода непосредственно из клиентского сценария

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

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

  • Используйте серверный элемент управления ASP.NET UpdatePanel. Этот элемент управления является частью функциональности AJAX в ASP.NET. Он позволяет задать область страницы, которая будет обновлена при частичном обновлении страницы. При использовании элемента управления UpdatePanel не требуется писать какой-либо клиентский сценарий для вызова асинхронных частичных обновлений страницы. Дополнительные сведения см. в разделах Общие сведения о частичной отрисовке страниц и Общие сведения об элементе управления UpdatePanel.

  • Используйте средства AJAX ASP.NET, обеспечивающие взаимодействие с веб-службами, для создания клиентского сценария, вызывающего метод веб-сервера. Этот подход аналогичен процедуре создания собственного клиентского сценария ответной передачи для вызова метода веб-сервера. Однако Microsoft AJAX (библиотека) выполняет необходимые действия для вызова серверного метода и является высоконадежной библиотекой клиентских сценариев для создания и обработки вызовов. Дополнительные сведения см. в разделе Веб-службы в ASP.NET AJAX.

  • Реализовать обратный вызов клиента. В этом случае создается клиентский код, который посылает запрос и обрабатывает результат. Наиболее распространенный подход — создание в клиентском сценарии вызывающей функции и функции обратного вызова, которая вызывается, когда сервер возвращает результаты. Дополнительные сведения см. в разделе Программная реализация обратных вызовов клиента без обратной передачи в веб-страницы ASP.NET.

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

Совместное использование данных с помощью элемента управления HiddenField

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

Также можно обмениваться значениями между серверным и клиентским кодом с помощью cookie. Сведения о записи и чтении cookie в серверном коде см. в разделах Практическое руководство. Запись файлов Cookie и Практическое руководство. Считывание файлов Cookie. Сведения об использовании JavaScript для чтения и записи объектов cookie см. в разделе JavaScript и cookie на веб-узле MSDN.

Совместное использование данных при выполнении асинхронных повторных передач

При использовании возможностей AJAX ASP.NET можно отправить пользовательские данные в виде строки от сервера к клиенту при выполнении асинхронных повторных передач (частичной отрисовке страницы) с помощью метода RegisterDataItem. Метод RegisterDataItem позволяет использовать серверный код для регистрации поля, которое присоединяется к элементу управления. Значение этого поля доступно в клиентском сценарии с помощью объектов AJAX ASP.NETSys.WebForms.PageLoadingEventArgs, Sys.WebForms.PageLoadedEventArgs и Sys.WebForms.PageLoadedEventArgs. Метод RegisterDataItem можно вызывать только во время асинхронной обратной передачи.

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

Создание компонентов клиентских сценариев

Клиентские компоненты — это объекты многократного использования, которые инкапсулируют JavaScript и в основе которых лежит Microsoft AJAX (библиотека). Эта библиотека предоставляет следующие базовые клиентские классы: Component (базовый класс для невизуальных компонентов), Control и Behavior. Наследование от этих классов обеспечивает широкие клиентские функциональные возможности, в том числе:

  • Доступ к жизненному циклу компонента от инициализации до удаления. Сюда относятся события, возникающие при изменении значений свойств.

  • Представление DOM-элемента в виде клиентского объекта, имеющего новые функциональные возможности. Это позволяет расширить возможности DOM-элементов. Например, можно добавить поведение «watermarking» и присоединить его к существующему текстовому полю.

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

Добавление клиентской функциональности серверным элементам управления

Любой существующий или пользовательский серверный элемент управления ASP.NET может быть преобразован в управляющий элемент-расширитель AJAX ASP.NET. Элемент расширения является серверным веб-элементом управления, который использует возможности обозревателя ECMAScript (JavaScript), DHTML и AJAX для добавления таких функций, как интерактивность и асинхронное взаимодействие с сервером.

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

См. также

Основные понятия

Серверные веб-элементы управления ASP.NET и возможности обозревателей

Модель событий серверного веб-элемента управления ASP.NET