69069

Користувацькі елементи керування

Лекция

Информатика, кибернетика и программирование

Він охоплює елементи керування інкапсулює базові HTMLдескриптори і елементи керування що забезпечують багату високорівневу модель такі як календар TreeView і елементи керування даними. Але навіть самий багатий набір елементів керування не в змозі задовольнити потреби кожного розробника.

Украинкский

2014-09-29

263 KB

6 чел.

Лекція №13

Користувацькі елементи керування

Базовий набір елементів керування платформи ASP.NET дуже широкий та вражаючий. Він охоплює елементи керування, інкапсулює базові HTML-дескриптори, і елементи керування, що забезпечують багату високорівневу модель, такі як календар, TreeView і елементи керування даними. Але навіть самий багатий набір елементів керування не в змозі задовольнити потреби кожного розробника. Рано чи пізно все одно доводиться створити власні компоненти користувацького інтерфейсу.

Включити в структуру Web-форми свої власні елементи керування в рамках платформи. NET можна двома способами:

користувацький елемент керування (User Control) – є невелика частина сторінки, яка може містити статичний HTML-код і серверні елементи керування Web. Перевагою для користувача елементів керування є те, що як тільки такий елемент створено, його можна багаторазово використовувати на безлічі сторінок одного і того ж Web-застосування. Більш того, для користувача елементу керування можна навіть придумувати свої властивості, події та методи.

спеціалізовані серверні елементи керування (custom server control) – скомпільовані класи, які програмним чином генерують свій власний HTML-код. На відміну від користувацьких елементів керування, які оголошуються подібно сторінкам веб-форм у файлі простого тексту, серверні елементи керування завжди попередньо компілюються у DLL-бібліотеки збірок. В залежності від коду серверного елемента керування, можна або розробити вміст "з нуля", або успадкувати зовнішній вигляд і поведінку від існуючого елемента керування Web, удосконаливши його функціональні особливості, або ж розробити інтерфейс, створюючи екземпляри і конфігуруючи групу із складових елементів керування.

У цій лекції розглядається перший варіант – користувацьких елементах керування. Вони найкращим чином підходять для стандартизації вмісту, який буде повторюватися на кожній сторінці Web-сайту. Припустимо, наприклад, що необхідно надати користувачам однаковий спосіб введення інформації про електронну адресу на декількох різних сторінках. Щоб вирішити це завдання, можна створити користувацький елемент керування адресою, що комбінує групу текстових полів і кілька пов'язаних засобів перевірки. Згодом елемент керування адресою можна буде додавати у будь-яку веб-форму і пов'язану з нею програму як один об'єкт.

Користувацькі елементи керування зручно застосовувати також, якщо необхідно створити і багаторазово використовувати верхні та нижні колонтитули сайту та засоби навігації. Майстер-сторінки, які розглядалися на попередній, доповнюють користувацькі елементи керування, дозволяючи стандартизувати компоновку Web-сторінок. У кожному з цих прикладів можна взагалі відсторонитися від користувацьких елементів керування, і просто копіювати і вставляти код за необхідності. Але у цьому випадку можна наштовхнутися на серйозні труднощі, як тільки знадобиться модифікувати, налаштувати або удосконалити елементи керування в майбутньому. Оскільки численні копії коду користувача інтерфейсу будуть розкидані по всьому Web-сайту, доведеться відшукувати кожну з них та знову і знову вносити одні й ті ж зміни. Зрозуміло, що для користувача елементи керування забезпечують більш елегантний, об'єктно-орієнтований підхід.

Примітка. Починаючи з версій ASP.NET 1.х, користувацькі елементи керування практично не зазнали змін. Єдиною відмінністю є нова модель прихованого коду (яка збігається з новою моделлю прихованого коду для Web-сторінок) і покращена підтримка часу проектування, яка дозволяє бачити користувацький елемент керування на поверхні конструктора сторінки у Visual Studio 2005.

Основи користувацьких елементів керування. Файли для користувацьких елементів керування (файли з розширенням .ascx) подібні файлам Web-форм ASP.NET (вони мають розширення .aspx). Як і Web-форми, призначені для користувача елементи управління складаються з частини інтерфейсу користувача з дескрипторами елементів керування (файл з розширенням sсх) і можуть використовувати файли всередині рядкових сценаріїв або файли прихованого коду з розширенням .cs. Користувацькі елементи керування можуть містити майже все, що містить Web-сторінка, включаючи статичний HTML-вміст і елементи керування ASP.NET. Крім того, вони отримують ті ж самі події, що й об'єкт сторінки (наприклад, події Load та PreRender), і розкривають через властивості такий же набір властивих ASP.NET об'єктів (наприклад, Application, Session, Request та Response).

До основних відмінностей між користувацькими елементами керування і Web-сторінками можна віднести наступні:

  •  Користувацький елемент керування починаються з директиви Control, а не Page; 
  •  Розширення користувацьких елемент керування – .ascx, а не .aspx; файли прихованого коду є нащадками класу System.Web.UI.UserControl. Насправді клас UserControl та клас Page обидва є нащадками одного й того ж класу TemplateControl, тому у них так багато однакових методів та подій.
  •  Користувацькі елементи керування не можуть бути запитані самим клієнтом (інакше ASP.NET видасть повідомлення про помилку – тип файлу, що не обслуговується), а, навпаки, впроваджуються в інші Web-сторінки.

Створення користувацького елементу керування. Щоб створити простий користувацький елемент керування виберіть в меню Website команду Add New Item, а потім шаблон Web User Control і задати ім’я WebUserControl.ascx.

Створений після виконання цих кроків файл .ascx містить тільки один рядок директиви

<%@ Control Language="C#" AutoEventWireup="true" CodeFile="WebUserControl.ascx.cs" Inherits="WebUserControl" %>

Користувацький елемент керуавння редагується в оболонці так само, як і звичайна сторінка. Файл підтримки .ascx.cs містить той же код, що і для звичайної сторінки. У даному прикладі він не потрібен, тому він залишиться порожнім. Нижче наведено код користувацького елементу керування, який містить рядок верхнього колонтитула:

<%@ Control Language="C#" AutoEventWireup="true" CodeFile="WebUserControl.ascx.cs" Inherits="WebUserControl" %>

<table width="100%"  border="0" bgcolor="blue">

 <tr><td>

 <font face="Vernada, Arial" size="6" color="yellow">

   <b>Користувацькі елементи керування</b></font></td>

 </tr>

 <tr><td align="right">

  <font size="3" color="white">

    <b>Усі права не захищені &copy; 2012</b></font></td>

 </tr>

</table>

Оскільки код користувацького елементу керування припускає його використання на сторінках, то перш за все створимо тестову сторінку з ім'ям Default2.aspx для впровадження в неї користувацького елементу керування.

Щоб використовувати елемент керування на сторінці, потрібно інтегрувати його у форму. Для цього потрібно виконати наступні кроки:

  •  зареєструвати елемент на сторінці, тобто за допомогою директиви @Register, розташованій на початку сторінки, потрібно повідомити ASP.NET, що десь на сторінці є посилання на користувацький елемент керування;
  •  помістити користувацький елемент керування на сторінку, вставивши в потрібне місце всередині дескриптора <form> посилання-тег на цей елемент.

Директива @Register для наведеного вище прикладу має наступний вигляд:

<%@ Register TagPrefix="myElem" TagName="Header" Src="WebUserControl.ascx" %>

Як відомо, для розрізнення стандартних елементів керування на початку їх дескрипторного представлення використовується конструкція <префікс:тип_елемента атрибути ... />, наприклад:

<asp:TextBox ID="TextBox1" runat="server" />

Тут asp грає роль префікса TagPrefix (або умовного простору імен), а TextBox – тип елемента керування TagName. Директива реєстрації користувацьких елементів керування також для кращого їх розрізнення підтримує схожий синтаксис. Значення myElem та Header у прикладі задаються довільно, але далі цих значень на сторінці необхідно суворо дотримуватися, оскільки це префікс та ім’я дескриптора, що використовуються для оголошення нового елемента керування на сторіннці. Значення атрибуту Src ідентифікує вихідний файл, в якому міститься користувацький елемент керування, що підключається.

У зареєстрованих позначеннях користувацького елементу керування синтаксис його підключення до сторінки Default2.aspx буде таким:

   <myElem:Header ID="Header1" runat="server" />

У Visual Studio 2005 не потрібно руками прописувати наведену реєстрацію. Досить у вікні Solution Explorer перенести впроваджуваний файл в потрібне місце сторінки і підправити, за необхідності, сгенеровану оболонкою реєстрацію.

В результаті користувальницька сторінка Default2.aspx повинна мати таку HTML-розмітку

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default2.aspx.cs" Inherits="Default2" %>

<%@ Register TagPrefix="myElem" TagName="Header" Src="WebUserControl.ascx" %>

<html>

<head runat="server">

   <title></title>

</head>

<body>

   <form id="form1" runat="server">

   <myElem:Header ID="Header1" runat="server" />

   </form>

</body>

</html>

Ось таким чином до сторінки підключається файл, в якому міститься зовнішній частковий код. Цей код реально може бути будь-якої складності, включаючи всі відомі елементи керування. Зверніть увагу, що код файлу WebUserControl.ascx не містить посилань на інші сторінки і готовий використовуватися на будь-якій сторінці як додаток. З іншого боку, у файлі, в свою чергу, може бути розміщено інший користувацький елемент, розроблений раніше. У такому випадку цей підключений елемент потрібно зареєструвати на батьківському так само, як це робиться при підключенні до кінцевої сторінки.

Запустіть тестову сторінку на виконання, повинен вийти результат, наведений на слайді. Елемент керування верхнім колонтитулов є найпростішим з можливих прикладів користувацьких елементів керування, але і він може продемонструвати деякі з його переваг. Достатньо лише уявити який об’єм роботи доведеться виконати, якщо знадобиться вручну скопіювати код верхнього колонтитула у вся сторінки ASP.NET, а потім змінити заголовок, додати контактну інформацію або ще щось подібне. За наявності ж окремого користувацького елементу керування достатньо буде обновити лише один файл.

Додавання коду в користувацький елемент керування. Попередній приклад не містив коду, а лише демонстрував раціональний спосіб повторного використання статичного блоку користувацького інтерфейсу веб-сторінки. Але у багатьох випадках у користувацький елемент керування потрібно додавати деякий код або для обробки подій, або щоб додати функціональність, яка може знадобитися клієнтові. Цей код вноситься у клас користувацького елементу керування до блоку <script> прямо у файлі .ascx або у окремий файл прихованого коду .cs.

Обробка подій. Для початку скористаємося стандартним елементом керування LinkButton, який буде знімати з таймера сервера і відображати клієнтові поточний час. Кожного разу при натисканні на посиланні буде оновлюватися час, який воно відображає.

Нижче наведено приклад користувацького елементу керування, код якого розташовано у блоку <script> у файлі TimeDisplay.ascx:

<%@ Control Language="C#" ClassName="TimeDisplay" %>

<asp:LinkButton ID="lnkTime" runat="server" onclick="lnkTime_Click">lnkTime</asp:LinkButton>

<script runat="server">

   protected void Page_Load(object sender, EventArgs e)

   {

       if (!Page.IsPostBack) RefreshTime();

   }

   protected void lnkTime_Click(object sender, EventArgs e)

   {

       RefreshTime();

   }    

   public void RefreshTime()

   {

       lnkTime.Text = DateTime.Now.ToLongTimeString();

   }

</script>

У коді ми додали свою функцію RefreshTime (), оскільки її код потрібно викликати у двох місцях. Без цієї функції цілком можна обійтися, але якби її тіло складалося з великої кількості рядків, то це значно скоротило би текст застосування.

Додавання властивостей. Розширимо можливості попереднього прикладу. Додамо в код загальнодоступну властивість Format, якій в клієнті (сторінці, що використовує елемент) будемо передавати або порожній рядок, або рядок форматування. В залежності від цього користувацький елемент управління буде здатний відображати напис на кнопці LinkButton в різних форматах. З урахуванням цих змін оновлено метод RefreshTime().

Перероблений код файлу TimeDisplay.ascx.cs має наступний вигляд:

public partial class WebUserControl : System.Web.UI.UserControl

{

   protected void Page_Load(object sender, EventArgs e)

   {   if (!Page.IsPostBack) RefreshTime();

   }

   private string format; // Контрольоване властивістю поле

   public string Format   // Визначення властивості Format

   {   get { return format; }

       set { format = value; }

   }

   protected void LinkButton1_Click(object sender, EventArgs e)

   {   RefreshTime();

   }

   public void RefreshTime()

   {   if (format == "")

           lnkTime.Text = DateTime.Now.ToLongTimeString();

       else // Значення format задається в клієнті через властивість Format

           lnkTime.Text = DateTime.Now.ToString(format);

   }

}

На тестовій сторінці Default2.aspx розмістили два користувацьких елемента керування TimeDisplay: у першому формат відображення дати задається властивістю Format, а у другому дата відображається у форматі за промовчанням. Тестова сторінка є клієнтом для користувача елементу управління. Саме в дескрипторі елемента на клієнті визначається значення доданої властивості Format як атрибуту цього дескриптора. Зверніть увагу, що у підказувачі коду IntelliSense, вживаному при редагуванні дескриптора користувацького елемента керування, з'явилося нова властивість Format.

   <myElem:Header ID="Header1" 

      Format="dddd, dd MMMM yyyy HH:mm:ss tt (GTM z)" runat="server" />

   <hr />

   <myElem:Header ID="Header2" runat="server" />

Подання тестової сторінки з користувацькими елементами керування у броузері клієнта буде виглядати так, як показано на слайді.

Якщо використовуються прості типи властивостей, наприклад, int, DateTime, float тощо, то задати їх можна за допомогою рядкових значень при оголошенні елемента керування на головній сторінці. ASP.NET автоматично перетворює рядок у тип властивості, визначений у даному класі. Для цього використовується перетворювач типів.

Порядок генерації подій ініціалізації. При створенні користувацьких елементів керування та додавання в них своїх властивостей важливо знати, в якому порядку відбувається створення і ініціалізація об'єктів на сторінці, що використовує користувацький елемент керування. Цей порядок наступний:

Виконується віддалений запит сторінки і вона завантажується у пам'ять сервера.

Конструктором класу створюється та ініціалізується користувацький елемент керування. У конструкторі класу виконується присвоєння значень за проммовчанням та ініціалізація.

Присвоюються значення атрибутів, передбачені в дескрипторі користувацького елемента керування.

Створюється об'єкт батьківської сторінки

Виконується подія Page.Load батьківської сторінки, в обробнику Page_Load() якої можна передбачити перепризначення атрибутів, властивостей користувацького елементу керування.

Виконується подія Page.Load користувацького елемента керування.

Звідси важливий висновок, що якщо спробувати ініціалізувати користувацький елемент керування в його обробнику Page_Load(), то він перезапише всі свої налаштування, виконані в батьківському коді, оскільки спрацьовує останнім. Так, якби в останньому прикладі обробник Page_Load() користувацького елемента керування ініціалізував поле формату і мав би вигляд

protected void Page_Load(object sender, EventArgs e)

{   format = "";

   if (!Page.IsPostBack) RefreshTime();

}

то у вікні браузера обидва варіанти елементів керування відображалися б без форматування.

Використання спеціальних об’єктів. Багато користувацьких елементів керування розроблюються саме для того, щоб абстрагуватися від подробиць звичайних сценаріїв за допомогою високорівневої моделі елементів керування. Наприклад, для виводу інформації про адресу можна згрупувати декілька текстових полів в один високорівневий елемент керування, а потім, змоделювавши цей тип, використовувати більш складні дані, ніж окремі рядки та числа. Часто доводиться створювати спеціальні класи для організації взаємодії між користувацьким елементом керування та веб-сторінкою. Розглянемо приклад, в якому створимо складний користувацький елемент керування LinkTable, призначений для генерування набору гіперпосилань у форматованій таблиці. Для зручності частину коду розмістимо в окремому самостійному класі LinkTableItem, в якому буде визначена інформація, необхідна для кожного посилання. Для цього необхідно:

1. Створити сторінку веб-форми з роздільним кодом і ім'ям LinkTableTest.aspx

2. Зробити цю сторінку стартовою

3. Додати до проекту нову папку із зарезервованим ім'ям App_Code.

4. Через контекстне меню на створеній папці слід виконати команду Add New Item. У вікні майстра додайте до застосування новий клас C# з ім'ям LinkTableItem.cs.

Цей клас у своїх полях буде зберігати інформацію, необхідну для користувача елемента керування, а через властивості здійснювати доступ до неї.

Заповніть допоміжний клас у файлі LinkTableItem.cs наступним кодом

/// <summary>

/// Допоміжний клас LinkTableItem

/// </summary>

public class LinkTableItem

{   // Сбережені поля закритого типу

   private string text, url;

   // Конструктор по умолчанию

   public LinkTableItem()

   {   // Пустий конструктор за промовчанням обов'язковий,

       // оскільки є загальний конструктор

   }

   // Загальний конструктор

   public LinkTableItem(string text, string url)

   {   // Внутрішнім полям присвоюються значення,

       // передані з батьківського об'єкту

       this.text = text;

       this.url = url;

   }

   // Визначення властивостей доступу до внутрішніх полів

   public string Text

   {   get { return text; }

       set { text = value; }

   }

   public string Url

   {   get { return url; }

       set { url = value; }

   }

}

Тепер потрібно створити користувальницький елемент, який буде керувати цим допоміжним класом.

5. Створити користувацький елемент керування з роздільним кодом та ім'ям LinkTable. Для цього виконайте команду Add New Item, викликавши контекстне меню для вузла проекту (самий верхній вузол) в панелі Solution Explorer і встановивши шаблон Web User Control. Користувацький елементу міститиме наступні стандартні компоненти:

  •  таблиця з вкладки HTML, яка буде форматувати розміщення стандартних елементів керування;
  •  елемент Label з вкладки Стандартні в верхній комірці таблиці, який буде визначати заголовок набору посилань;
  •  елемент Image з вкладки HTML, який визначатиме малюнок маркера посилань;
  •  DataList з вкладки даних в нижній комірці таблиці;
  •  HyperLink з вкладки Стандартні.

Дескрипторний код користувацького елементу керування матиме наступний вигляд:

<%@ Control Language="C#" AutoEventWireup="true" CodeFile="LinkTable.ascx.cs" Inherits="LinkTable" %>

<table border="1" cellpadding="2" cellspacing="0" width="100%">

   <tr>

       <td>

           <asp:Label ID="lblTitle" runat="server"

               ForeColor="#C00000" Font-Bold="true" 

               Font-Names="Vernada" Font-Size="Small">

               <!--Тут буде заголовок-->

           </asp:Label>

       </td>

   </tr>

   <tr>

       <td>

           <asp:DataList ID="listContent" runat="server">

               <ItemTemplate>

                   <img width="25" height="13" src="Yes.gif" alt="маркер">

                   <asp:HyperLink ID="HyperLink1" runat="server"

                       NavigateUrl='<%# DataBinder.Eval(Container.DataItem, "Url") %>'

                       Text='<%# DataBinder.Eval(Container.DataItem, "Text") %>' />

               </ItemTemplate>

           </asp:DataList>

       </td>

   </tr>

</table>

Дескриптор <img> для краси визначає маркер розміром 25x13, який можна виготовити самостійно або взяти вже існуючий. Атрибут Alt задає альтернативний напис у полі малюнка, якщо останній не буде знайдений.

6. Тепер розширимо функціональність користувацького елементу керування LinkTable. Для цього слід відредагувати файл LinkTable.ascx.cs наступним чином:

public partial class LinkTable : System.Web.UI.UserControl

{

   public string Title

   {   get { return lblTitle.Text; }

       set { lblTitle.Text = value; }

   }

   private LinkTableItem[] items;

   public LinkTableItem[] Items

   {   get { return items; }

       set

       {   items = value;

           // Оновлюємо сітку

           listContent.DataSource = items;

           listContent.DataBind();

       }

   }

}

7. Розробка користувальницького елемента керування закінчена. Тепер потрібно помістити його на налаштовувану тестову сторінку LinkTableTest.aspx, яку ми створили на самому початку виконання цього прикладу і зробили її стартовою.

Відкрийте через панель Solution Explorer на редагування файл LinkTableTest.aspx в режимі Design і перетягніть на форму з цієї панелі вузол LinkTable.ascx користувацького елементу керування.

Дескрипторного подання тестової сторінки із зареєстрованим на ній користувацьким елементом керування матиме такий вигляд

<html xmlns="http://www.w3.org/1999/xhtml">

<head runat="server">

   <title></title>

</head>

<body>

   <form id="form1" runat="server">

   <div>

       <uc1:LinkTable ID="LinkTable1" runat="server" />

   </div>

   </form>

</body>

</html>

Відкрийте на редагування файл підтримки сторінки LinkTableTest.aspx.cs і заповніть його наступним кодом

public partial class LinkTableTest : System.Web.UI.Page

{

 protected void Page_Load(object sender, EventArgs e)

 {   // Формуємо заголовок списку

     LinkTable1.Title = "Список пошукових сайтів";

     // Створюємо список елементів - гіперпосилань

     LinkTableItem[] items = new LinkTableItem[3];

     items[0] = new LinkTableItem("Посилання №1 на Google", "https://www.google.com.ua/");

     items[1] = new LinkTableItem("Посилання №2 на Yandex", "http://www.yandex.ua/");

     items[2] = new LinkTableItem("Посилання №3 на Rambler", "http://nova.rambler.ru");

     LinkTable1.Items = items;

 }

}

Запустіть програму і отримайте результат, наведений на слайді.

Додавання подій. Подія – це вбудований механізм C#, за допомогою якого автоматично забезпечується повідомлення зареєстрованих об'єктів щодо необхідності виконання ними певної дії. Об'єкт надає свої методи-обробники для реагування на виникнення певної події. У цьому випадку говорять, що об'єкт підписався на деяку подію. Такий механізм дозволяє окремим об'єктам обмінюватися повідомленнями і реагувати на них.

Технічно подія є деякою адресною змінною, що посилається на екземпляр класу, який підтримує подія. Якщо значення цього посилання дорівнює null, то подія не відбулася, оскільки немає відповідного об'єкту. Один об'єкт генерує подію (створює екземпляр) і надсилає повідомлення через канал повідомлень операційної системи. Інші, підписані на цю подію об'єкти застосування, отримують це повідомлення разом з додатковою інформацією та запускають відповідні обробники, попередньо передавши їм додаткову інформацію в якості аргументів.

Для оголошення адресної змінної події використовуються делегати. Делегати подаються спеціальним класом, який визначає сигнатуру (типи, кількість і порядок аргументів), переданої з подією інформації сторони-відправника, і сигнатуру обробників події сторони-приймача. Делегат оголошується у глобальній області видимості рівня класу, щоб зробити подію видимою у всіх класах застосування. Об'єкт, породжений класом-делегатом, і є подією.

За допомогою конструктора делегата при створенні його нового екземпляра в подію додається посилання на обробник і встановлюється контроль за сигнатурою цього обробника. Цей процес називається реєстрацією події в класі або підпискою на подію. Події підтримують багатодресатну передачу (multicasting). Це означає, що одна й таж подія може приймати багато об'єктів, але обробляти цю подію кожен об'єкт буде своїм методом, який він вказав у конструкторі делегата при підписці на цю подію.

Ось так скорочено, загальними словами, без відповідних прикладів виглядає механізм використання подій і делегатів у мові C#. Тепер розглянемо питання, як додати подію до користувацького елементу керування, щоб він належним чином реагував на подію, надісланої йому клієнтом сторінки.

Ми цю задачу поставимо як розвиток попереднього прикладу, тому для подальшої роботи потрібно створити копію файлів цього прикладу та трішки модифікувати їх.

У попередньому прикладі за допомогою допоміжного класу LinkTableItem можна було додавати в класі користувацького елементу керування LinkTableTest нові гіперпосилання типу asp:HyperLink до елементу asp:DataList. Клацання клієнта на одному з гіперпосилань перенаправляло на відповідну адресу. Тепер необхідно перехоплювати і розпізнавати клацання на будь-якому гіперпосиланні для контролю за діями користувача: при виборі деякого посилання перевіряти, чи дозволено цей перехід. Потрібно розпізнавати вибране гіперпосилання і виводити його на екран.

Раніше в дескрипторного поданні користувацького елементу керування застосовувався стандартний елемент asp:HyperLink. Якщо подивитися на клас цього елемента System.Web.UI.WebControls.HyperLink через панель Object Browser, то можна побачити, що він не має жодних подій. З іншого боку, клас LinkButton має дві події, які генерує елемент при виборі користувача. Саме ці події перехоплюються у наступному прикладі в елементі керування.

1. Змініть тип елемента в шаблоні <ItemTemplate> дескрипторного подання файла LinkTableExt.ascx на нове ім'я атрибута CommandArgument, після чого файл повинен бути таким

        <ItemTemplate>

             <img width="25" height="13" src="Yes.gif" alt="маркер">

             <asp:LinkButton ID="HyperLink1" runat="server" 

                 CommandArgument='<%# DataBinder.Eval(Container.DataItem, "Url") %>'

                 Text='<%# DataBinder.Eval(Container.DataItem, "Text") %>'>

             </asp:LinkButton>

        </ItemTemplate>

Створити подію з ім'ям LinkClicked. Для розпізнавання вибраного пункту списку разом з майбутньою подією LinkCliked потрібно буде передавати інформацію про значення властивостей Text та Url, визначених раніше у допоміжному класі LinkTableItem.cs. Потім в обробнику події LinkClicked ця інформація буде розпізнаватися та виведитися на екран.

2. Безпосередньо екземпляр класу LinkTableItem.cs в аргументах події передавати не можна, оскільки він має не той тип, тому необхідно упакувати його в клас LinkTableEventArgs, який зобов'язаний бути спадкоємцем бібліотечного класу System.EventArgs. Оголосимо також делегата події в глобальній області видимості у файлі LinkTableExt.ascx.cs підтримки користувацького елемента керування.

// Оголошуємо делегат події LinkClicked у глобальній області видимості,

// який визначить сигнатуру події та обробника

public delegate void LinkClickedEventHandler(object sender, LinkTableEventArgs e);

// Клас-упаковка екземпляру LinkTableItem для

// передачі з подією у якості аргументу

public class LinkTableEventArgs : EventArgs

{   // Конструктор

   public LinkTableEventArgs(LinkTableItem item)

   {

       selectedItem = item;

   }

   // Внутрішнє поле буде зберігати об'єкт гіперпосилання

   // та контролюватися властивістю "тільки для читання"

   private LinkTableItem selectedItem;

   public LinkTableItem SelectedItem

   {

       get { return selectedItem; }

   }

   // Внутрішнє поле зберігаї прапор скасування, переданий класом-джерелом,  

   // що згенерував подію, для обробника класа-приймача

   private bool cancel = false;// Ініціюється при створенні

   public bool Cancel

   {

       get { return cancel; }

       set { cancel = value; }

   }

}

Таким чином, оголошено клас для упаковки переданої в подію інформації. Також оголошено делегата, за допомогою якого створюватиметься подія. Тепер потрібно додати код, який перехопить клацання користувача на певному гіперпосиланні, розпізнає цю гіперпосилання і через подію LinkClicked відправить цю інформацію в канал повідомлень Windows. Звичайно ж, цим має займатися клас LinkTable підтримки користувацького елемента керування.

3. У файлі LinkTableExt.ascx у режимі Design в панелі Properties створити обробник для події ItemCommand користувацького елемента керування. Додати у клас LinkTable створений обробник стандартного події наступний код

   // Оголошуємо у класі подію LinkClicked

   // за допомогою раніше створеного глобального делегата

   public event LinkClickedEventHandler LinkClicked;

   protected void listContent_ItemCommand(object source, DataListCommandEventArgs e)

   {   if (LinkClicked != null)

       {   // Виділяємо об'єкт посилання, на якій було виконано клацання

           LinkButton link = (LinkButton)e.Item.Controls[1];

           // Виділяємо необхідні властивості Text та Url через атрибути

           // дескриптора елемента LinkButton та зберігаємо їх

           // в екземплярі допоміжного класу

           LinkTableItem item = new LinkTableItem(link.Text, link.CommandArgument);

           // Передаємо посилання на збережені властивості у клас упаковки аргументів

           LinkTableEventArgs args = new LinkTableEventArgs(item);

           // Генеруємо подію

           LinkClicked(this, args);

           // Дозволяємо клієнту перейти за посиланням, якщо клас-отримувач не заборонив

           if (args.Cancel != true)

           {

               Response.Redirect(item.Url);

           }

       }

   }

Тепер подія LinkClicked буде виникати кожного разу, коли користувач клацне на гіперпосиланні користувацького елементу керування. Класом-одержувачем цієї події визначено тестову сторінку. Саме в ній буде створено функцію-обробник, яка розпакує передані подією аргументи і виведе отриману інформацію на екран. Про всяк випадок виконується перевірка існування події, щоб напевно запобігти генерації системного виключення. Для цього перевіряється, чи не містить змінна події null-посилання. Якщо містить, то це означає, що на даний момент не зарегістровано жодного обробника події (можливо, елемент керування не було створено). Якщо змінна не дорівнює null, можна викликати подію.

Працювати з цією подією не так легко, як зі стандартним набором елементів керування ASP.NET, оскільки користувацькі елементи керування не забезпечують у повному обсязі підтримки часу проектування. В результаті не можна використовувати вікно Properties, щоб підключити обробник події під час проектування. Навпаки, необхідно самостійно написати обробник події і код для його підключення.

Враховуючи, що в режимі проектування оболонка підтримує автоматичне створення обробників через панель властивостей тільки для подій бібліотечних класів, створимо заготовку обробника вручну. При цьому потрібно дотримуватися сигнатури, заданої оголошеним раніше делегатом. Але і в цьому випадку підказувач IntelliSense оболонки нам допомагає.

4. Відкрийте на редагування файл LinkTableExtTest.aspx.cs і в кінці обробника події Page_Load() класу LinkTableTest почніть набирати ім'я об'єкта LinkTable1, під яким на тестовій сторінці знаходиться примірник зареєстрованого на ній користувацького елементу керування. Підказувач коду IntelliSense відразу відреагує на ці дії. Натиснувши два рази клавішу Tab отримайте і зареєструйте подію в класі-приймачі через глобального делегата і заготовку обробника. Після генерації оболонкою таким способом заготовки обробника далі можна поступити одним із таких способів:

1) або залишити все як є і почати заповнювати обробник;

2) або залишити заготівлю обробника, а код реєстрації події знищити

       LinkTable1.LinkClicked += new LinkClickedEventHandler(LinkTable1_LinkClicked);

Якщо вибрати другий спосіб, тоді потрібно в дескрипторного поданні користувацького елементу додати атрибут OnLinkClicked = "LinkTable1_LinkClicked", щоб прив'язати до події створений обробник (зверніть увагу, що ім'я атрибуту формується з імені події та префікса On). Але і в цьому випадку підказувач IntelliSense теж допомагає

5. Давайте виберемо другий спосіб. Знищіть реєстрацію події в класі LinkTableTest, скопіюйте ім'я згенерованого обробника і додайте його в атрибут OnLinkClicked = "LinkTable1_LinkClicked" дескриптора <uc1:LinkTable ID="LinkTable1" runat="server" /> файлу тестової сторінки LinkTableExtTest.aspx

6. У режимі Design тестової сторінки розмістіть елемент Label з вкладки Standard, задайте йому ім'я lblInfo і очистіть поле його властивості Text (або видаліть однойменний атрибут у дескрипторі). У ньму відображатиметься інформація про натиснуте гіперпосилання.

7. У файлі LinkTableExtTest.aspx.cs заповніть обробник так

public void LinkTable1_LinkClicked(object sender, LinkTableEventArgs e)

   {   // Шукаємо підрядок у рядку, що викликає

       if (e.SelectedItem.Text.IndexOf("Yandex") > 0)

       {   e.Cancel = false; /* Пропустити */   }

       else

       {   e.Cancel = true;  // Не пускати далі

           lblInfo.Text = "Ви вибрали " + "\"" + e.SelectedItem.Text + 

              "\".";

           lblInfo.Text += " Вибачте, але Вам не дозволено переходити на " + 

              e.SelectedItem.Url + "!!!";

       }

   }

Запустіть тестову сторінку LinkTableExtTest.aspx і помилуйтеся на свою роботу

Динамічне створення користувацького елемента керування. До цього моменту розглядали питання створення користувацького елемента керування в режимі проектування і подальше управління ним в програмному режимі. Але на сторінці може знадобитися довантажувати і налаштовувати користувацький елемент керування динамічно ("на льоту"). Як це робиться для користувацького елемента керування.

Потрібно виконати наступні кроки:

Створювати при кожному завантаженні сторінки в обробнику її події Page.Load екземпляр класу користувацького елемента керування, заздалегідь підготовленого в файлах *.ascx та *.ascx.cs. Створення та реєстрація примірника користувацького елементу в коді сторінки здійснюється статичним методом Page.LoadControl().

Резервувати за допомогою елемента PlaceHolder місце розміщення для точного позиціонування на сторінці користувацького елемента керування.

Обов'язково присвоювати після динамічного створення значення властивості ID користувацького елемента керування, особливо, коли створюється кілька примірників одного і того ж елемента.

Це може знадобитися для однозначної ідентифікації елемента в коді сторінки при пошуку посилання на екземпляр, виконуваному за допомогою статичного методу Page.FindControl(), який якраз використовує значення ідентифікатора ID.

Є деяка специфіка динамічного створення призначеного користувацького елемента керування. Не можна створити користувацький елемент безпосередньо, як це робиться з бібліотечним елементом керування через конструктор класу. Користувацький елемент керуваління складається не тільки з підтримуючого класу у файлі *.ascx.cs, але і з дескрипторної частини файлу *.ascx. Тому на етапі проектування він не представлений загальним класом, примірник якого можна було б створити за допомогою конструктора. Примірник користувацького елемента керування створюється самою ASP.NET об'єднанням цих двох частин на етапі виконання.

З цією метою використовується метод Page.Load.Control(). При виклику Load.Control() йому передається ім'я файлу розмітки з розширенням *.ascx користувацького елемента керування. Метод повертає обєкт UserControl, який потім можна додавати на сторінку і приводити до специфічного типу класу для отримання доступу до функціональних можливостей, характерних для елемента керування. Нижче наведено приклад динамічного завантаження користувацького елемента керування TimeDisplay і додавання його на сторінку за допомогою елемента керування PlaceHolder:

       TimeDisplay ctrl = (TimeDisplay)Page.LoadControl("TimeDisplay.ascx");

       PlaceHolder1.Controls.Add(ctrl);

Не дивлячись на ці недоліки, динамічне завантаження зручно використовувати при роботі з користувацькими елементами керування, зокрема для створення конфігурованих портальних каркасів.

Перетворення сторінки в користувацький елемент керування. Часто користувацький елемент керування простіше зробити зі звичайної сторінки .aspx. Це робиться так:

Спочатку потрібно розробити звичайну сторінку, наштувати її і перевірити у дії.

Перейменувати розширення файлу з ASPX в ASCX

Директиву @Page разом з її атрибутами слід видалити і замінити директивою @Control з необхідними атрибутами.

Видалити з коду всі дескриптори <html>, <body>, <form>, <head>.

У коді файлу підтримки замінити базовий клас сторінки System.Web.UI.Page на System.Web.UI.UserControl.

Якщо використовується модель сумісного коду, то потрібно в директиву Control обов'язково додати атрибут ClassName="ім’я_файла_або_будь-яке_ім’я". Він сповіщає ASP.NET, що код, який потрібно компілювати, знаходиться у тому ж файлі в дескрипторах <script>. Без цієї інформації файл компілюватися не буде.

Портальні каркаси. Управління динамічним завантаженням багатьох користувацьких елементів керування (портальні каркаси)

Отже, ми розробили декілька користувацьких елементів керування:

  •  Header.ascx – верхній колонтитул;
  •  TimeDisplay.ascx – кнопка-посилання, що повертає неформатований і форматований дату-час;
  •  LinkTable.ascx – список гіперпосилань;
  •  LinkTableExt.ascx – список гіперпосилань з попереднім аналізом вибору користувача (для цього створили події).

Для кожного з цих елементів керування розроблялася своя тестова сторінка, на яку елемент керування розміщався декларативно. Тепер давайте на прикладі розглянемо питання, коли на сторінку потрібно помістити програмно відразу кілька різних користувальницьких елементів управління.

Створимо сторінку, яка міститиме три елемента керування DropDownList, PlaceHolder, Label. Коли користувач вибирає елемент у випадаючому списку DropDownList, сторінка відсилається обратно і динамічно завантажується відповідний користувацький елемент керування, який вставляється у заповнювач PlaceHolder.

Створимо нову сторінку DynamicUserControls.aspx з роздільним кодом і зробимо її стартовою. У списку панелі Properties виберіть елемент DOCUMENT і задайте його властивості Title значення Портальні каркаси

У режимі Design помістіть з вкладки Стандартні елемент Panel та надайте йому ім'я Panel1 (воно генерується автоматично). Цей елемент буде служити контейнером для інших елементів управління, в тому числі і для користувальницького

Помістіть всередину контейнера Panel1 один за одним по вертикалі стандартні елементи

DropDownList з автоматично згенерували ім'ям DropDownList1 – для вибору завантажуваного в контейнер для користувача елементу управління

PlaceHolder з автоматично згенерували ім'ям PlaceHolder1 – для позиціювання в контейнері для користувача елементу управління

Label з автоматично згенерували ім'ям Label1 – для відображення імені файлу, з якого в контейнер завантажений користувача елемент управління

За великим рахунком нам в даному прикладі байдуже, які імена будуть мати екземпляри дочірніх елементів. Однозначно розрізняти їх в коді можна по знайденим посиланням. Посилання, в свою чергу, можна шукати в іменованому контейнері за типом дочірнього елемента, оскільки поміщені на сторінку елементи мають різний тип. Але сама оболонка Visual Studio 2005 вимагає, щоб на сторінці не було декларативно оголошених дескрипторів з однаковими значеннями ID.

Зауважимо, що контейнер Panel1, як батько, за промовчанням буде визначати основні властивості своїх дочірніх елементів, такі як колір фону, колір переднього плану, шрифт тощо, якщо тільки вони не визначені явним чином.

Раніше ми перерахували користувача елементи управління, які створили в даній роботі. Виберемо кілька з них для динамічного розміщення. Імена цих елементів потрібно занести в список DropDownList1. Нехай це будуть елементи:

Виділіть об'єкт DropDownList1 в контейнері Panel1 і заповніть декларативно його властивість Items так, як показано у таблиці:

Items[i]

Text

Value

Items[1]

Верхній колонтитул

HeaderTest.ascx

Items[2]

Кнопка «дата-час»

TimeDisplayTest.ascx

Items[3]

Список гіперпосилань

LinkTableTest.ascx

Items[4]

Контрольований список гіперпосилань

LinkTableExtTest.ascx

Встановіть для елемента DropDownList1 його властивість AutoPostBack в значення True, щоб забезпечити постинг сторінки при виборі користувачем потрібної опції.

Будемо вважати, що один з трьох стандартних елементів керування контейнера, а саме список, заповнено декларативно. Два інших елементи контейнера будемо заповнювати програмно.

Таким чином, один контейнер майже збудовано. Але ми хочемо розмістити на сторінці три таких контейнера, щоб мати можливість у кожен з них програмно завантажувати вибрані через список DropDownList1 користувавацькі елементи керування. При цьому слід переконатися, що вони працюють незалежно один від одного і кожен робить те, що повинен шляхом реагування на свої власні події.

У режимі Design тестової сторінки розмістіть по вертикалі один за одним три копії контейнера Panel1 разом з його дочірніми елементами. Простежте, щоб контейнери мали імена Panel1, Panel2, Panel3

Через список, що розкривається панелі Properties виділяйте послідовно кожний контейнер Panel1, Panel2, Panel3 і налаштуйте їх властивості так

BackColor = Web / Gainsboro

BorderWidth = 1px

HorizontalAlign = центр

BorderStyle = Ridge

EnableViewState = "False"

Ми закінчили етап проектування сторінки для даного прикладу. Виконайте сформовану сторінку DynamicUserControls.aspx, щоб переконатися в працездатності налаштувань режиму Design.

Таким чином, виконано інтерфейсну заготовку портальних каркасів на тестовій сторінці. Тепер наповнимо їх функціональністю, яка б забезпечила контейнерну завантаження вибраних користувацьких елементів керування. Цю функціональність ми забезпечимо, кодуючи файл DynamicUserControls.aspx.cs прихованого коду сторінки. Нижче ми переконаємося, що програмно завантажені в портальні каркаси для користувача елементи управління обробляють свої події точно також, як ніби-то кожен з них знаходиться на окремій тестовій сторінці.

Відкрийте на редагування файл DynamicUserControls.aspx.cs. Додайте в клас DynamicUserControls наступний код

public partial class DynamicUserControls : System.Web.UI.Page

{

   protected void Page_Load(object sender, EventArgs e)

   {   // Загрузити портальні каркаси

       MyLoadControls(Panel1);

       MyLoadControls(Panel2);

       MyLoadControls(Panel3);

   }

   // Допоміжна функція

   private void MyLoadControls(Control containerPanel)

   {   // Допоміжні посилання на інтерфейсні елементи

       DropDownList list = null;

       PlaceHolder ph = null;

       Label lbl = null;

       // Перебрати усі дочірні елементи поточного

       // контейнера і знайти посилання на об'єкти дочірніх

       // інтерфейсних елементів за їх типами

       foreach (Control ctrl in containerPanel.Controls)

       {   if (ctrl is DropDownList)

               list = (DropDownList)ctrl;

           else if (ctrl is PlaceHolder)

               ph = (PlaceHolder)ctrl;

           else if (ctrl is Label)

               lbl = (Label)ctrl;

       }

       // Узяти інформацію з виділеного

       // елемента списку поточного контейнера

       string lstValue = list.SelectedItem.Value;

       string lstText = list.SelectedItem.Text;

       lbl.Text = "";

       // Заповнити поточний контейнер

       if (lstValue.EndsWith(".ascx"))

       {   ph.Controls.Add(Page.LoadControl(lstValue));

           lbl.Text = "Загрузили: " + lstValue + " - " + lstText;

       }

   }

}

Створимо користувацькі елементи керівання, які реалізують користувацький інтерфейс і функціональність, використану при виконанні прикладів у тестових сторінках. Для цого треба переробити тестові сторінки.

Виконання прикладу завершене. Код тестової сторінки при черговому завантаженні буде програмно створювати свої користувацькі елементи керування для кожного контейнера панелі і розміщувати їх в елементах PlaceHolder.

Виконайте сторінку DynamicUserControls.aspx і випробуйте її. Результат буде приблизно таким, як на слайді.

Поняття про кешування ASP.NET

Багато розробників вважають кешування чимось зайвим, але вони помиляються. Розумне застосування кешування забезпечує 2-х, 3-х і навіть 10-й кратне підвищення продуктивності за рахунок утримання в пам'яті важливої інформації навіть на короткий період часу.

ASP.NET насправді підтримує два типи кешування. Застосування можуть, і повинні, використовувати обидва типи, тому що вони доповнюють один одне:

• Кешування виводу – це найпростіший тип кешування. Він зберігає копію остаточно згенерованої HTML-сторінки, відправленої клієнтові. Наступний клієнт, який запросить цю ж сторінку, насправді не буде чекати її виконання. Замість цього готовий HTML-вивід буде відправлений йому автоматично. Таким чином, повністю економиться час, необхідний на запуск сторінки і її коду.

• Кешування даних – це кешування управляється вручну з коду застосування. Щоб використовувати кешування даних, у кеші зберігаються важливі частини інформації, які вимагають значного часу на повторну реконструкцію (наприклад, DataSet, отриманий з бази даних). Інші сторінки можуть перевірити існування цієї інформації і використовувати її, таким чином, пропускаючи кроки, які зазвичай підлягають виконанню для її отримання. Кешування даних – це концептуально те ж саме, що використання стану застосування, але більшою мірою дружньо до сервера, оскільки елементи видаляються з кеша автоматично, коли він виростає до занадто великого розміру, від чого може постраждати продуктивність. Можна налаштувати автоматичне видалення елементів з кеша через певний час.

Також на цих моделях побудовані два спеціалізованих типу кешування:

• Кешування фрагментів – це спеціалізований тип кешування виводу – замість кешування HTML-сторінок цілком, воно дозволяє кешувати HTML по частинах. Цей механізм працює за рахунок збереження обробленого НТML-виводу користувацьких елементів керування на сторінці. Коли наступного разу виковнюється дана сторінка, збуджуються ті ж події (й тому код сторінки буде працювати як і раніше), але код відповідних користувацьких елементів керування вже не виконується.

• Кешування джерел даних – це кешування, вбудоване в елементи керування, що представляють джерела даних, зокрема SqlDataSource, ObjectDataSource та XmlDataSource. Технічно кешування джерел даних використовує кешування даних. Відмінність в тому, що не доводиться явно управляти цим процесом. Замість цього потрібно просто конфігурувати відповідні властивості, і елемент керування, що представляє джерело даних, управляє процесом збереження в кеші і витягів з нього.

Почнемо з основ кешування виводу і кешування даних.

Кешування виводу. При кешуванні виведення в пам'яті зберігається остаточно згенерований HTML-код сторінки. Коли та ж сторінка запитується знову, її об'єкт управління не створюється заново, життєвий цикл сторінки не запускається і нічого з коду не виконується. Замість цього користувачеві доставляється кеширований HTML. Ясно, що кешування виведення теоретично забезпечує максимальне зростання продуктивності, оскільки виключаються всі накладні витрати, пов'язані з виконанням коду застосування.

Примітка. Сторінка ASP.NET може використовувати інші статичні ресурси (такі як графіку), які не знаходяться під управлінням ASP.NET. Не турбуйтеся про їх кешування, IIS автоматично обробляє кешування файлів більш ефективним чином, ніж кеш ASP.NET.

Декларативне кешування виводу. Щоб побачити кешування виводу у дії, можна створити просту сторінку, яка буде показувати поточний час. На рис. 11.1 показаний приклад.

Рис. 11.1. Кешування цілої сторінки

Код для цієї сторінки досить простий. Він встановлює поточну дату і час в елемент керування етикетки при настанні події Page.Load:

protected void Page_Load(object sender, EventArgs e)

{

lblDate.Text = "The time is now:<br />";

lblDate.Text += DateTime.Now.ToString();

}

Існують два способи додати сторінку в вихідний кеш. Найбільш поширений підхід полягає у вставці директиви OutputCache в початок файлу ASPX, як показано нижче.:

<%@ OutputCache Duration="20" VaryByParam="None" %>

Тут вказані два обов’язкові атрибути:

Duration – встановлює термін кешування в секундах;

VaryByParam – встановлює залежність кешування від GET та POST параметрів:

None – не залежить від параметров, тобто для будь-яких GET та POST параметрів буде виводитися одна і та ж кешована сторінка;

* – для всіх поєднань значень усіх GET та POST параметрів будуть створюватися окремі копії сторінки в кеші;

список рядків (розділених символом крапка з комою), що містіть імена атрибутів рядка запиту GET або імена полів, що повертаються у тілі POST-запиту.

Зауваження. Установка кэширования страницы исключает возможность её аутентификации т. к. кэшированные страницы на уровне ядра вообще обходят конвейер ASP.NET.

У цьому прикладі атрибут Duration інструктує ASP.NET про те, що сторінку потрібно зберігати в кеші протягом 20 секунд.

При запуску цієї тестової сторінки виявляється деякий цікава поведінка. При першому зверненні до неї буде відображено поточний час. Якщо оновити сторінку через кілька секунд, її вміст оновлено не буде. Замість цього ASP.NET автоматично відправить клієнту кеширований HTML-вивід (припускаючи, що це сталося до закінчення 20 секунд, і тому копія не була вилучена з кеша). Якщо кешована сторінка застаріє, ASP.NET запустить її код знову, генеруючи нову кешовану копію, і буде використовувати її протягом наступних 20 секунд.

Двадцять секунд можуть здатися незначним періодом часу, проте на сильно навантаженому сайті різниця може виявитися вельми відчутною. Наприклад, можна кешувати сторінку, яка представляє список продуктів з каталогу. Виконуючи кешування сторінки протягом 20 секунд, можна обмежите для неї доступ до бази трьома операціями в хвилину. Без кешування сторінка буде намагатися підключатися до бази даних при кожному зверненні клієнта і легко може досягти декількох десятків запитів в хвилину.

Звичайно, якщо вказати, що сторінка повинна зберігатися 20 секунд, це не означає, що точно так воно і буде. Сторінка може бути виключена з кеша раніше, якщо система виявить, що їй не вистачає пам'яті.

Це дозволяє використовувати кешування вільно, не особливо піклуючись про те, що застосування споживає занадто багато життєво необхідної пам'яті.

Порада. При перекомпіляції кешованої сторінки ASP.NET автоматично видаляє її з кеша. Це запобігає проблемі, пов'язаній з тим, що сторінка не буде правильно оновлена через те, що використовується стара, кешована версія. Крім того, можна відключити кешування в період тестування застосування. В іншому випадку виникнуть складнощі з наглядом за змінними, точками останова і іншими прийомами налагодження, оскільки код не буде виконуватися, коли доступна кешована версія сторінки.

Післякешева підстановка і кешування фрагментів. У деяких випадках може виявитися, що неможливо кешувати цілу сторінку, але хотілося б при цьому кешувати деяку її частину, яка не міняється, і яку дорого створювати заново. Існує два способи впоратися з цим завданням:

Фрагментне кешування – ідентифікується тільки той вміст, який необхідно кешувати, він розміщується в оболонку виділеного користувацького елемента керування та кешується вивід тільки цього елемента.

Післякешева підстановка – ідентифікується тільки динамічна частина вмісту, яку можна кешувати. Потім цей вміст замінюється чимось іншим, використовуючи елемент керування Substitution. Послекешевая підстановка - нововведення ASP.NET 2.0.

З цих двох прийомів фрагментного кешування реалізувати легше. Однак рішення про те, який з прийомів використовувати, звичайно заснований на обсязі інформації, яку потрібно кешувати.  Якщо кешуванню підлягає маленька, окрема частина вмісту сторінки, то має сенс застосувати фрагментне кешування. І, навпаки, якщо є тільки невелика частина динамічного вмісту, то післякешева підстановка може підійти краще. Обидва підходи забезпечують приблизно рівну продуктивність.

Порада. Найбільш гнучкий спосіб реалізації сценарій часткового кешування полягає в повній відмові від кешування виводу і застосуванні кешування даних для обробки процесу у коді програмним способом.

Фрагментне кешування. Щоб реалізувати фрагментне кешування, потрібно створити для користувача елемент управління для частини сторінки, яку необхідно кешувати. Потім можна додати до цього елемента керування директиву OutputCache. В результаті вся сторінка не буде кешуватися, а користувацький елемент керування буде.

Фрагментного кешування – це концептуально те ж саме, що і кешування сторінок. Є тільки одна пастка: якщо сторінка витягує кешовану версію для користувацького елемента керування, вона не може взаємодіяти з ним у коді. Наприклад, якщо елемент керування включає властивості, то код Web-сторінки не може до них звертатися або модифікувати їх. Коли використовується кешована версія користувацького елемента керуваління, в сторінку просто вставляється блок HTML. Відповідний об'єкт елемента керування недоступний.

Часткове кешування сторінок. Кешування частинами припускає застосування користувацьких елементів керування. Користувацькі елементи можна кешувати окремо з урахуванням GET, POST параметрів. Для сторінок, що містять динамічні розділи, можна виділити статичні частини в один або більше користувацьких елемента керування і використовувати директиву @OutputCache для їх кешування.

Кешований вивід користувацьких елементів керування найчастіше варіюють за значеннями властивостей вкладених у нього елементів керування, а не за GET, POST параметрами сторінки, в яку він впроваджується. У цьому випадку застосовують спеціальний атрибут кешування VaryByControl, наприклад:

 <% @ OutputCache Duration = '30' VaryByControl ='ddlCountry;% ddlCity'>

Директива @OutputCache користувацького елементу керування забезпечує його кешування у вигляді множини копій для всіх варіантів поєднання значень, вхідних в нього елементів ddlCountry і ddlCity.

За промовчанням різні сторінки не використовують одну й ту ж кешовану копію користувацького елементу керування. Для того, щоб цього уникнути треба в директиву @OutputCache додати атрибут Shared зі значенням true, наприклад:

<%@ OutputCache Duration=’30’ VaryByParam=’None’ Shared=’true’ %>

Зауваження 1. Використання VaryByControl, за наявності в користувацькому елементі керування кодів C#, може призводити до некоректної роботи з кеш-копією компонента. Необхідна копія користувацького елементу, може бути відсутньою у пам'яті.

Зауваження 2. Щоб уникнути проблем з пам'яттю необхідно обмежувати обсяг пам'яті, доступний програмному забезпеченню IIS (Maximum Used Memory для кожного пулу застосувань). Зазвичай він становить 60% загального обсягу фізичної пам'яті комп'ютера.

http://www.intuit.ru/department/internet/praspnet/6/1.html

http://www.gsub.kiev.ua/Arts/?aid=356&action=view

http://www.cyberguru.ru/microsoft-net/wpf-silverlight/usercontrols.html

http://www.askit.ru/custom/asp_net/m8/08_web_user_controls.htm

http://www.mql5.com/ru/articles/310


 

А также другие работы, которые могут Вас заинтересовать

62540. Разнообразие растений и животных 32.91 KB
  Личностные УУД положительное отношение к учебной деятельности. Личностные УУД проявление положительного отношения к познавательной деятельности интереса к учебному материалу. Регулятивные УУД планирование своего действия в соответствии с поставленной задачей и условиями ее реализации.
62543. О МАМЕ И О ПАПЕ 24.55 KB
  Цель урока: Дать первоначальные представления о православных основах семьи. Задачи урока: Познакомить с проявлением православных традиций в семье. Познакомить с Владимировской иконой Божией Матери.
62544. Основные понятия алгебры логики 23.1 KB
  Высказывание это фомулировка своего понимания окружающего мира. Высказывание является повествовательным преждложением в котором что-либо отрицается или утверждается. По поводу высказывание можно сказать истинно оно или ложно.
62545. Диффузия 24.1 KB
  Цели урока: познакомить учащихся с диффузией в жидкостях, газах и твердых телах; научить объяснять явление диффузии и скорость ее протекания в зависимости от температуры тела; развитие самостоятельности учащихся в процессе работы...
62546. Действия с информацией. Хранение информации 24.73 KB
  Цель урока: акцентировать внимание учащихся на действиях с информацией информационных процессах; познакомить со способами хранения информации. Изучением всевозможных способов передачи хранения и обработки информации.
62547. Открытие протона и нейтрона 960.86 KB
  Учитель записывает под диктовку на доску. Учитель вносит дополнения в список на доске. Учитель дополняет список на доске.