Procédure : Utiliser la mise en cache Windows Azure

Ouvrez le menu contextuel du projet Windows Azure, puis choisissez Nouveau projet de rôle de travail.

Dans la liste des modèles de projet, choisissez le modèle Rôle de travail du cache, puis spécifiez un nom pour le projet, par exemple CacheWorkerRole1.

Un projet de rôle de travail est créé.

Sous le projet Windows Azure, développez le nœud Rôles, ouvrez le menu contextuel pour le rôle de travail du cache que vous venez de créer, puis choisissez Propriétés.

Le concepteur de rôle pour ce projet apparaît.

Dans l'onglet Configuration, définissez la taille appropriée de l'ordinateur virtuel et le nombre d'instances de ce rôle.

Dans l'onglet Mise en cache, sous Paramètres du cluster de cache, remarquez que Cache dédié est sélectionné.

Configurez le comportement souhaité pour le cache par défaut ou créez des caches nommés avec des propriétés personnalisées.

Chaque cache nommé possède son propre ensemble de propriétés configurables. Pointez vers les en-têtes de tableau pour afficher des informations sur la façon dont vous pouvez configurer chaque cache nommé. Pour plus d'informations, consultez Procédure : Configurer la mise en cache Windows Azure.

Dans le menu contextuel du nœud Références, sous le projet qui contient le rôle dans lequel vous souhaitez utiliser un cache, choisissez Ajouter une référence.

Dans la boîte de dialogue Ajouter une référence, activez les cases à cocher appropriées pour ajouter des références aux assemblys suivants, puis cliquez sur le bouton OK :

• Microsoft.ApplicationServer.Caching.AzureClientHelper

• Microsoft.ApplicationServer.Caching.Client

• Microsoft.ApplicationServer.Caching.Core

• Microsoft.Web.DistributedCache

Dans le projet qui contient le rôle auquel vous souhaitez ajouter la mise en cache, ouvrez le fichier web.config d'un projet de rôle Web ou ouvrez le fichier app.config pour d'autres types de projet.

Si la section configSections n'existe pas, ajoutez-la. Dans cette section, ajoutez une déclaration de la section de mise en cache, comme le montre le code suivant.

<configSections>
    <section name="dataCacheClients" type="Microsoft.ApplicationServer.Caching.DataCacheClientsSection, Microsoft.ApplicationServer.Caching.Core" allowLocation="true" allowDefinition="Everywhere"/>
  </configSections>

Ajoutez du code XML qui identifie le cache nommé à utiliser.

<dataCacheClients>
    <tracing sinkType="DiagnosticSink" traceLevel="Verbose"/>
    <dataCacheClient name="default">
      <autoDiscover isEnabled="true" identifier="WebRole1"/>
    </dataCacheClient>
  </dataCacheClients>

Si vous déclarez un seul cache, le nom peut être default, comme le montre l'exemple précédent. Si vous déclarez plusieurs caches, ajoutez une section dataCacheClient distincte pour chaque cache et donnez un nom unique à chaque cache. Le cache qui est nommé par défaut est retourné lorsque, dans le code, vous appelez la méthode GetDefaultCache sur l'objet DataCacheFactory. L'attribut identifier spécifie le nom du projet de rôle Web auquel vous avez ajouté la prise en charge de la mise en cache ou un rôle de travail du cache.

Maintenant que vous avez configuré un cache distribué dans ce rôle, accédez-y à partir d'un code en créant un DataCacheFactory et un objet DataCache.

Dans un fichier code-behind, ajoutez des déclarations à votre classe Page et ajoutez un générateur de nombres aléatoires afin d'avoir des données pour tester le cache.

        static DataCacheFactory myFactory;
        static DataCache myCache;
        static Random randomizer = new Random();

Pour créer une application Web qui utilise le cache, remplacez le code dans la page Web Default.aspx par le code suivant.

<%@ Page Title="Home Page" Language="C#" MasterPageFile="~/Site.master" AutoEventWireup="true"
    CodeBehind="Default.aspx.cs" Inherits="WebRole1._Default" %>

<asp:Content ID="HeaderContent" runat="server" ContentPlaceHolderID="HeadContent">
</asp:Content>
<asp:Content ID="BodyContent" runat="server" ContentPlaceHolderID="MainContent">
 
     <p style="font-size:large; height: 283px;">
        <asp:Label ID="Label0" runat="server" Text="Text for the cache:   " />
        <asp:TextBox runat="server" ID="TextBox1" Width="125" /> <br /> <br />

        <asp:Button runat="server" onclick="OnPutInCache" Text="Put in Cache" id="AddCachedItemsButton" /> &nbsp;&nbsp;&nbsp;
        <asp:Button runat="server" onclick="OnGetFromCache" Text="Get from Cache" id="GetCachedItemsButton" /> &nbsp;&nbsp;&nbsp;
        <asp:Label ID="Label1" runat="server" Width="500" />

        <br /> <br />  <br /> 
    
        Cached Datestamp: <%= DateTime.Now.ToString() %><br />
        Fresh Datestamp: <asp:Substitution runat="server" methodname="GetFreshDateTime" id="UnCachedArea" /><br /><br />
    </p>

</asp:Content>

Ajoutez du code pour initialiser le cache.

        protected void Page_Load(object sender, EventArgs e)
        {
            try
            {
                //Get a named cache (or default cache)
                if (myCache == null)
                {
                    // You should initialize the data cache factory
                    // once and keep reusing the same object.
                    myFactory = new DataCacheFactory();
                    myCache = myFactory.GetDefaultCache();
                    // If you want to get a handle to a named cache
                    // that is not the default cache, supply the
                    // cache's name from the configuration file:
                    // myCache = myFactory.GetCache("anotherNamedCache");
                }
            }
            catch (DataCacheException dce)
            {
                Label1.Text = dce.ToString();
            }
        }

Ce code d'initialisation doit être appelé avant toute tentative d'utilisation du cache. Par exemple, vous pouvez ajouter ce code au gestionnaire d'événements Page_Load. Sinon, un handle vers le cache est créé à l'aide de la méthode de fabrique du cache GetDefaultCache(). Si aucun nom de cache n'est spécifié, le cache nommé Défaut est utilisé. L'exception DataCacheException peut être levée chaque fois que vous travaillez avec des méthodes de cache. Le code précédent intercepte cette exception et l'affiche à l'utilisateur sur un contrôle Label.

Ajoutez le code pour utiliser le cache.

        /// <summary>
        /// Adds the value of the TextBox to the cache
        /// </summary>
        protected void OnPutInCache(object sender, EventArgs e)
        {
            try
            {
                myCache.Put("MyKey", TextBox1.Text);
                Label1.Text = " \" " + TextBox1.Text + "\" has been added to the cache.";
            }
            catch (DataCacheException dce)
            {
                Label1.Text = dce.ToString();
            }
        }

n'importe quelles données. Comme le montre l'exemple, vous utilisez la méthode Put pour ajouter des données dans le cache. Le cache fonctionne comme un dictionnaire. Le premier argument est la clé ; le second argument correspond aux données que vous souhaitez mettre en cache.

Récupérez des données de la mise en cache en appelant la méthode Get et en fournissant la clé.

        /// <summary>
        /// Gets the cached item (that was added from the TextBox)
        /// </summary>
        protected void OnGetFromCache(object sender, EventArgs e)
        {
            try
            {
                string outputFromCache = myCache.Get("MyKey") as string;
                Label1.Text = "\"" + outputFromCache + "\" has been retrieved from the cache.";
            }
            catch (DataCacheException dce)
            {
                Label1.Text = dce.ToString();
            }
        }

Ouvrez le fichier web.config pour l'application ASP.NET pour laquelle vous souhaitez configurer la mise en cache de sortie.

Ajoutez les lignes suivantes pour configurer la mise en cache de sortie afin d'utiliser le cache distribué.

    <caching>
      <outputCache defaultProvider="defaultProvider" >
        <providers>
          <add cacheName="default"
               name="defaultProvider"
               dataCacheClientName="nameOfDataCacheClient"
               applicationName="<unique-appId>"
               type= "Microsoft.Web.DistributedCache.DistributedCacheOutputCacheProvider, Microsoft.Web.DistributedCache" />
        </providers>
      </outputCache>
    </caching>

Pour le nom de cache, spécifiez le nom du cache nommé approprié, qui est hébergé par le dataCacheClient spécifié. L'attribut dataCacheClient spécifie le rôle qui héberge le cache.

Ajoutez la directive OutputCache dans les pages où vous souhaitez mettre en cache la sortie.

<%@ OutputCache Duration="60" VaryByParam="*" %>

La durée est l'intervalle de temps, en secondes, pendant lequel les données doivent rester dans le cache. VaryByParam indique qu'une version différente de la page doit être mise en cache pour chaque combinaison de paramètres. L'astérisque (*) dans ce contexte signifie varier selon tous les paramètres. Vous pouvez aussi spécifier des paramètres par nom. Pour une description complète des options disponibles, consultez Directive OutputCache (page éventuellement en anglais)

Vous avez configuré le cache de sortie.

Ouvrez le fichier web.config pour l'application Web ASP.NET pour laquelle vous souhaitez configurer la mise en cache d'état de session.

Ajoutez les lignes suivantes et spécifiez le nom du cache que vous souhaitez utiliser (dans ce cas, « default »), le nom du fournisseur, le nom de dataCacheClient et l'appId de l'application.

    <!--Set up custom session state provider -->
    <sessionState mode="Custom" customProvider="defaultProvider">
      <providers>
        <add cacheName="default"
             name="defaultProvider"
             dataCacheClientName="nameOfDataCacheClient"
             applicationName="<unique-appId>"
             type= "Microsoft.Web.DistributedCache.DistributedCacheSessionStateStoreProvider, Microsoft.Web.DistributedCache"/>
      </providers>
    </sessionState>

Ouvrez l'onglet Mise en cache du concepteur de rôle pour un rôle.

Sous Caches nommés, ajoutez un cache nommé pour la sortie et un autre pour les informations d'état de session.

Dans la table Caches nommés, définissez les propriétés pour les caches nommés.

Par exemple, vous pouvez définir la politique d'éviction sur TTL pour le cache de sortie et sur Aucun pour le cache d'état de session.

Ouvrez le fichier web.config, puis utilisez les nouvelles valeurs pour les attributs cacheName dans les sections outputCache et sessionState.

Assurez-vous d'avoir la dernière version de NuGet installée.

Pour plus d'informations et pour obtenir des instructions d'installation, consultez NuGet (page éventuellement en anglais).

Dans l'Explorateur de solutions, ouvrez le menu contextuel pour le nœud de projet du rôle auquel vous souhaitez ajouter la mise en cache, puis choisissez Gérer les packages NuGet.

La boîte de dialogue Gérer les packages NuGet s'affiche.

Pour la version de juin 2012, assurez-vous que la liste en haut de la boîte de dialogue Gérer les packages NuGet contient Inclure la version préliminaire, et non Stable uniquement.

Dans la galerie en ligne, sélectionnez Mise en cache Windows Azure, puis cliquez sur le bouton Installer.

Le projet est modifié, des références aux assemblys de mise en cache sont ajoutées et des fichiers de configuration sont mis à jour pour configurer un cache.

Dans le fichier de configuration pour le projet, recherchez l'élément dataCacheClient qui a un élément enfant autoDiscover.

Dans cet élément enfant, modifiez la valeur de l'attribut identifier en le remplaçant par le nom du rôle qui fournit le cache.

    <dataCacheClient name="default">
      <autoDiscover isEnabled="true" identifier="CacheWorkerRole1"/>
    </dataCacheClient>

Pour démarrer l'utilisation du cache, modifiez votre code comme décrit précédemment dans cette rubrique.

Pour activer un cache d'état de session ou un cache de sortie, modifiez le fichier de configuration pour le rôle approprié et apportez d'autres modifications comme décrit précédemment dans cette rubrique. Pour utiliser le cache par programme, ajoutez le code approprié à vos fichiers code-behind pour créer un cache, puis ajoutez et récupérez les données.

(facultatif) Pour gérer les packages NuGet pour une solution complète et ajouter le support de mise en cache à plusieurs projets simultanément, ouvrez le menu contextuel pour le nœud solution, puis choisissez Gérer les packages NuGet. .