Кэширование

От Майкрософт

Понимание кэширования важно для хорошо выполняющегося ASP.NET приложения. ASP.NET 1.x предложил три различных варианта кэширования; кэширование выходных данных, кэширование фрагментов и API кэша.

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

Новые возможности

Профили кэша

Профили кэша позволяют разработчикам определять определенные параметры кэша, которые затем можно применить к отдельным страницам. Например, если у вас есть некоторые страницы, которые должны истекать с кэша через 12 часов, можно легко создать профиль кэша, который можно применить к этим страницам. Чтобы добавить новый профиль кэша, используйте <раздел outputCacheSettings> в файле конфигурации. Например, ниже приведена конфигурация профиля кэша с именем twoday , которая настраивает длительность кэша в течение 12 часов.

<outputCacheSettings>
    <outputCacheProfiles>
        <add name="TwoDay" duration="43200" />
    </outputCacheProfiles>
</outputCacheSettings>

Чтобы применить этот профиль кэша к определенной странице, используйте атрибут CacheProfile директивы @OutputCache, как показано ниже:

<%@ OutputCache CacheProfile="TwoDay" %>

Настраиваемые зависимости кэша

ASP.NET разработчики версии 1.x требовали пользовательские зависимости кэша. В ASP.NET 1.x класс CacheDependency был запечатан, что препятствовало разработчикам выводить собственные классы из него. В ASP.NET 2.0 это ограничение удаляется, и разработчики могут разрабатывать собственные зависимости кэша. Класс CacheDependency позволяет создавать зависимости пользовательского кэша на основе файлов, каталогов или ключей кэша.

Например, приведенный ниже код создает новую зависимость пользовательского кэша на основе файла, который называется stuff.xml расположен в корне веб-приложения:

System.Web.Caching.CacheDependency dep = new
    System.Web.Caching.CacheDependency(Server.MapPath("stuff.xml"));
Response.AddCacheDependency(dep);
Cache.Insert("key", "value");

В этом сценарии при изменении файла stuff.xml кэшированный элемент является недействительным.

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

// insert a value into cache that will serve
// as the cache key
Cache["CacheKey"] = "something";

// create an array of cache keys
string[] keys = new String[1];
keys[0] = "CacheKey";

CacheDependency dep = new CacheDependency(null, keys);

// insert an item into cache with a dependency on
// the above CacheDependency
Cache.Insert("Key", "Value", dep);

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

// Remove the cache item that serves as the cache key
Cache.Remove("CacheKey");

Обратите внимание, что ключ элемента, который выступает в качестве ключа кэша, должен совпадать со значением, добавленным в массив ключей кэша.

Зависимости кэша SQL на основе опроса (также называемые зависимостями на основе таблиц)

SQL Server 7 и 2000 используют модель на основе опроса для зависимостей кэша SQL. Модель на основе опроса использует триггер в таблице базы данных, которая активируется при изменении данных в таблице. Этот триггер обновляет поле changeId в таблице уведомлений, которую периодически проверяет ASP.NET. Если поле changeId было обновлено, ASP.NET знает, что изменены данные и недействительны кэшированные данные.

Чтобы зависимость кэша SQL с помощью модели на основе опроса работала правильно, таблицы должны иметь уведомления. Это можно сделать программным способом с помощью класса SqlCacheDependencyAdmin или с помощью программы aspnet_regsql.exe.

Следующая командная строка регистрирует таблицу Products в базе данных Northwind, расположенной на экземпляре SQL Server с именем dbase для зависимости кэша SQL.

aspnet_regsql -S dbase -ed -d Northwind -E -et -t Products

Ниже приведено описание параметров командной строки, используемых в приведенной выше команде:

При выполнении этой команды в базу данных SQL Server вносятся следующие изменения:

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

• Для таблицы создается триггер SQL Server с именем table_name_AspNet_SqlCacheNotification_Trigger . Этот триггер выполняет AspNet_SqlCacheUpdateChangeIdStoredProcedure при выполнении инструкции INSERT, UPDATE или DELETE в таблице.
• Роль SQL Server с именем aspnet_ChangeNotification_ReceiveNotificationsOnlyAccess добавляется в базу данных.

Роль SQL Server aspnet_ChangeNotification_ReceiveNotificationsOnlyAccess имеет разрешения EXEC для AspNet_SqlCachePollingStoredProcedure. Чтобы модель опроса функционировала корректно, необходимо добавить учетную запись вашего процесса в роль aspnet_ChangeNotification_ReceiveNotificationsOnlyAccess. Средство aspnet_regsql.exe не будет делать это для вас.

Настройка зависимостей кэша SQL на основе опроса

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

• Настройка файла конфигурации ASP.NET.
• Настройка SqlCacheDependency

Настройка файла конфигурации ASP.NET

Помимо добавления строки подключения, как описано в предыдущем модуле, необходимо также настроить <элемент кэша> с элементом <sqlCacheDependency> , как показано ниже:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <connectionStrings>
    <add name="Pubs"
    connectionString="Data Source=(local);
      Initial Catalog=pubs;Integrated Security=true;"
    providerName="System.Data.SqlClient" />
  </connectionStrings>
  <system.web>
    <caching>
      <sqlCacheDependency enabled = "true" pollTime = "60000" >
        <databases>
          <add name="pubs" connectionStringName = "pubs" pollTime = "9000000" />
        </databases>
      </sqlCacheDependency>
    </caching>
  </system.web>
</configuration>

Эта конфигурация обеспечивает зависимость кэша SQL от базы данных pubs . Обратите внимание, что атрибут pollTime в элементе <sqlCacheDependency> по умолчанию — 60000 миллисекунда или 1 минуту. (Это значение не может быть меньше 500 миллисекундах.) В этом примере <элемент add> добавляет новую базу данных и переопределяет pollTime, установив для него значение 9000000 миллисекунд.

Настройка SqlCacheDependency

Следующим шагом является настройка SqlCacheDependency. Самый простой способ сделать это — указать значение атрибута SqlDependency в директиве @Outcache следующим образом:

<%@ OutputCache duration="60"
    VaryByParam="none" SqlDependency="pubs:authors" %>

В приведенной выше директиве OutputCache зависимость кэша SQL настраивается для таблицы авторов в базе данных pubs . Можно настроить несколько зависимостей, разделив их точкой с запятой так:

<%@ OutputCache duration="60"
    VaryByParam="none"
    SqlDependency="database_name:table_name;database_name:table_name" %>

Другим способом настройки SqlCacheDependency является программное выполнение этой задачи. Следующий код создает зависимость кэша SQL от таблицы авторов в базе данных pubs .

SqlCacheDependency dep = new SqlCacheDependency("pubs", "authors");

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

Аналогичным образом, если вы пытаетесь определить зависимость кэша SQL для таблицы, которая не была включена для уведомления, будет вызвана ошибка TableNotEnabledForNotificationException . Затем можно вызвать метод SqlCacheDependencyAdmin.EnableTableForNotifications , передав имя базы данных и имя таблицы.

В следующем примере кода показано, как правильно настроить обработку исключений при настройке зависимости кэша SQL.

try {
    SqlCacheDependency SqlDep = new
    SqlCacheDependency("pubs", "authors");
} catch (DatabaseNotEnabledForNotificationException exDBDis) {
    try {
        SqlCacheDependencyAdmin.EnableNotifications("pubs");
    } catch (UnauthorizedAccessException exPerm) {
        Response.Redirect("ErrorPage.htm");
    }
} catch (TableNotEnabledForNotificationException exTabDis) {
    try {
        SqlCacheDependencyAdmin.EnableTableForNotifications("pubs",
        "authors");
    } catch (System.Data.SqlClient.SqlException exc) {
        Response.Redirect("ErrorPage.htm");
    }
} finally {
    Cache.Insert("SqlSource", Source1, SqlDep);
}

Дополнительные сведения: https://msdn.microsoft.com/library/t9x04ed2.aspx

Зависимости кэша SQL на основе запросов (только SQL Server 2005)

При использовании SQL Server 2005 для зависимости SQL кэша модель, основанная на опросе, не требуется. При использовании с SQL Server 2005 зависимости кэша SQL напрямую взаимодействуют с экземпляром SQL Server через подключения SQL (дополнительная настройка не требуется) с использованием уведомлений о запросах SQL Server 2005.

Самый простой способ включить уведомление на основе запросов заключается в том, чтобы сделать это декларативно, задав атрибут SqlCacheDependency объекта источника данных в CommandNotification и установив для атрибута EnableCachingзначение true. С помощью этого метода код не требуется. Если результат команды, выполненной в отношении источника данных, изменится, это сделает данные кэша недействительными.

В следующем примере настраивается управление источником данных для зависимости кэша SQL.

<asp:SqlDataSource ID="ProductList" runat="server"
    ConnectionString="<%$ ConnectionStrings:Northwind %>"
    EnableCaching="true"
    SqlCacheDependency="CommandNotification"
    SelectCommand="SELECT * FROM [Products]" />

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

Можно также указать, что все источники данных включены для зависимостей кэша SQL, задав атрибут SqlDependency директивы @OutputCache для CommandNotification. В приведенном ниже примере показано это.

<%@ OutputCache SqlDependency="CommandNotification" 
    duration="60" VaryByParam="none" %>

Другим способом настройки зависимости кэша SQL на основе запросов является программное использование класса SqlCacheDependency. В следующем примере кода показано, как это достигается.

string sql = "SELECT ProductName, ProductID FROM Products";
SqlConnection conn = new
SqlConnection(ConfigurationManager.ConnectionStrings["Northwind"].ConnectionString);
SqlCommand cmd = new SqlCommand(sql, conn);
SqlCacheDependency dep = new SqlCacheDependency(cmd);
Response.AddCacheDependency(dep);

Дополнительные сведения: https://msdn.microsoft.com/library/default.asp?url=/library/enus/dnvs05/html/querynotification.asp

Замена пост-кэша

Кэширование страницы может значительно повысить производительность веб-приложения. Однако в некоторых случаях требуется кэшировать большую часть страницы и некоторые фрагменты страницы, чтобы быть динамическими. Например, если вы создаете страницу новостей, которая является полностью статической для заданных периодов времени, можно задать кэшировать всю страницу. Если вы хотите включить вращающийся рекламный баннер, который изменился на каждом запросе страницы, то часть страницы, содержащей рекламу, должна быть динамической. Чтобы кэшировать страницу, но динамически заменять некоторое содержимое, можно использовать ASP.NET пост-кэшовую подстановку. При подстановке после кэширования вся страница кэшируется с определёнными частями, помеченными как исключённые из кэширования. В примере рекламных баннеров элемент управления AdRotator позволяет воспользоваться преимуществами подстановки после кэша, чтобы объявления динамически создавались для каждого пользователя и для каждого обновления страницы.

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

• Декларативно с использованием элемента управления «Substitution».
• Программно, используя API элемента управления Substitution.
• Неявно, используя элемент управления AdRotator.

Управление заменой

Элемент управления подстановки ASP.NET задает раздел кэшированной страницы, который создается динамически, а не извлекается из кэша. Разместите элемент управления "Подстановка" на том месте страницы, где вы хотите, чтобы отображалось динамическое содержимое. Во время выполнения элемент управления "Подстановка" вызывает метод, заданный свойством MethodName. Метод должен возвращать строку, которая затем заменяет содержимое элемента управления «Подстановка». Этот метод должен быть статическим методом в элементе управления Page или UserControl. Использование элемента управления подстановки изменяет параметры кэширования с клиентской на серверную кэшируемость, чтобы страница не сохранялась в кэше на стороне клиента. Это гарантирует, что будущие запросы на страницу снова вызывают метод для создания динамического содержимого.

API подстановки

Чтобы создать динамическое содержимое для кэшированного страницы программным способом, можно вызвать метод WriteSubstitution в коде страницы, передав его имя метода в качестве параметра. Метод, обрабатывающий создание динамического содержимого, принимает один параметр HttpContext и возвращает строку. Возвращаемая строка — это содержимое, которое будет подставлено в указанном месте. Преимущество вызова метода WriteSubstitution вместо декларативного использования элемента управления Подстановки заключается в том, что можно вызывать метод любого произвольного объекта, а не вызывать статический метод объекта Page или UserControl.

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

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

Серверный элемент управления AdRotator реализует поддержку подстановки после кэширования. Если на странице размещен элемент управления AdRotator, он будет отображать уникальные объявления по каждому запросу независимо от того, кэшируется ли родительская страница. В результате страница, содержащая элемент управления AdRotator, кэшируется только на стороне сервера.

Класс ControlCachePolicy

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

При доступе к свойству BasePartialCachingControl.CachePolicy элемента управления PartialCachingControl всегда будет получен допустимый объект ControlCachePolicy. Однако при доступе к свойству UserControl.CachePolicy элемента управления UserControl возвращается допустимый объект ControlCachePolicy, только если пользовательский элемент управления уже упакован элементом управления BasePartialCachingControl. Если он не упакован, объект ControlCachePolicy, возвращаемый свойством, вызовет исключения при попытке управления им, так как он не имеет связанного элемента BasePartialCachingControl. Чтобы определить, поддерживает ли экземпляр UserControl кэширование без создания исключений, проверьте свойство SupportsCaching .

Использование класса ControlCachePolicy является одним из нескольких способов включения кэширования выходных данных. В следующем списке описаны методы, которые можно использовать для включения кэширования выходных данных:

• Используйте директиву @OutputCache , чтобы включить кэширование выходных данных в декларативных сценариях.
• Используйте атрибут PartialCachingAttribute , чтобы включить кэширование для пользовательского элемента управления в файле кода программной части.
• Используйте класс ControlCachePolicy, чтобы указать параметры кэша в программных контекстах, где вы работаете с экземплярами BasePartialCachingControl, которые были включены в кэш при динамической загрузке с использованием одного из предыдущих методов и метода System.Web.UI.TemplateControl.LoadControl.

Экземпляром ControlCachePolicy можно успешно управлять только между этапами Init и PreRender жизненного цикла элемента управления. При изменении объекта ControlCachePolicy после этапа preRender ASP.NET вызывает исключение, так как любые изменения, внесенные после отрисовки элемента управления, не могут повлиять на параметры кэша (элемент управления кэшируется во время этапа отрисовки). Наконец, экземпляр пользовательского элемента управления (а значит, и его объект ControlCachePolicy) доступен для программной манипуляции только в момент его фактической отрисовки.

Изменения в конфигурации кэширования — <элемент кэширования>

В ASP.NET 2.0 есть несколько изменений в конфигурации кэширования. Элемент <кэширования> является новым в ASP.NET 2.0 и позволяет вносить изменения конфигурации кэширования в файл конфигурации. Доступны следующие атрибуты.

Элемент кэша <>

В элементе кэша <> доступны следующие атрибуты:

Элемент <outputCache>

Для элемента outputCache< доступны >следующие атрибуты.

Элемент <outputCacheSettings>

Элемент <outputCacheSettings> позволяет создавать профили кэша, как описано ранее. Единственным дочерним элементом элемента <outputCacheSettings является элемент >outputCacheProfiles< для настройки профилей кэша.>

Элемент <sqlCacheDependency>

Для элемента sqlCacheDependency< доступны >следующие атрибуты.

Дополнительная информация

Есть некоторые дополнительные сведения, которые следует учитывать в отношении конфигурации кэша.

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

  • x86 2 ГБ: 800 МБ или 60% физической ОЗУ, в зависимости от того, что меньше
  • x86 3 ГБ: 1800 МБ или 60% физической оперативной памяти, в зависимости от того, что меньше
  • x64: 1 terabyte или 60% физической ОЗУ, в зависимости от того, что меньше

• Если как для рабочего процесса задано ограничение частных байтов, так и для <кэша предусмотрено privateBytesLimit/>, кэш будет использовать минимальное значение из двух.

• Как и в версии 1.x, мы удаляем записи кэша и вызываем GC.Collect по двум причинам:

  • Мы очень близко к ограничению частных байтов
  • Объем доступной памяти составляет около или менее 10%

• Вы можете эффективно отключить сокращение и кэширование в условиях низкого уровня доступной памяти, установив <процент кэша PhysicalMemoryUseLimit/> в 100.

• В отличие от версии 1.x, в 2.0 будет приостанавливаться выполнение операций по освобождению и сборке мусора, если последний вызов GC.Collect не уменьшил число private bytes или размер управляемых куч более чем на 1% от предела памяти для кэша.

Lab1: Кастомные зависимости кэша

1. Создайте новый веб-сайт.

2. Добавьте новый XML-файл с именем cache.xml и сохраните его в корне веб-приложения.

3. Добавьте следующий код в метод Page_Load в коде default.aspx:

   System.Web.Caching.CacheDependency dep = new
       System.Web.Caching.CacheDependency(Server.MapPath("cache.xml"));
   Response.AddCacheDependency(dep);
   Cache.Insert("time", DateTime.Now.ToString());
   Response.Write(Cache["time"]);
   

4. Добавьте следующее в начало default.aspx в исходном представлении:

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

5. Перейти к Default.aspx. Что такое время?

6. Обновите окно браузера. Что такое время?

7. Откройте cache.xml и добавьте следующий код:

   <anElement></anElement>
   

8. Сохраните cache.xml.

9. Обновите браузер. Что такое время?

10. Объясните, почему время обновляется вместо отображения ранее кэшированных значений:

Лабораторная работа 2. Использование зависимостей кэша на основе опроса

В этой лаборатории используется проект, созданный в предыдущем модуле, который позволяет изменять данные в базе данных Northwind с помощью элемента управления GridView и DetailsView.

1. Откройте проект в Visual Studio 2005.

2. Запустите программу aspnet_regsql в базе данных Northwind, чтобы включить базу данных и таблицу Products. Используйте следующую команду из командной строки Visual Studio:

   aspnet_regsql -S server -ed -d Northwind -E -et -t Products
   

3. Добавьте следующее в файл web.config:

   <caching>
       <sqlCacheDependency enabled = "true" pollTime = "60000" >
           <databases>
               <add name="Northwind" connectionStringName = "Northwind" pollTime = "9000000" />
           </databases>
       </sqlCacheDependency>
   </caching>
   

4. Добавьте новую веб-форму с именем showdata.aspx.

5. Добавьте следующую директиву @outputcache на страницу showdata.aspx:

   <%@ OutputCache SqlDependency="Northwind:Products" Duration="480" VaryByParam="None"%>
   

6. Добавьте следующий код в метод Page_Load в showdata.aspx:

   Response.Write(DateTime.Now.ToString() + "<br><br>");
   

7. Добавьте новый элемент управления SqlDataSource в showdata.aspx и настройте его для использования подключения к базе данных Northwind. Нажмите кнопку Далее.

8. Установите флажки ProductName и ProductID и нажмите кнопку "Далее".

9. Нажмите кнопку «Готово».

10. Добавьте новый GridView на страницу showdata.aspx.

11. Выберите SqlDataSource1 из раскрывающегося списка.

12. Сохраните и просмотрите showdata.aspx. Запишите отображаемое время.