Dans ASP.NET 1.x, nous pouvons utiliser CacheDependency pour implémenter des stratégies de dépendance du cache, mais comme cette classe est scellée, nous ne pouvons pas hériter de cette classe pour implémenter nos propres stratégies. Mais avec ASP.NET 2.0, nous pouvons déjà dériver nos propres classes de dépendances de cache à partir de cette classe.
Supposons que nous souhaitions concevoir une page et que nous devions obtenir les dernières informations sur les articles sur la page d'accueil du blog. Afin d'améliorer les performances, nous espérons que les données de la page ne seront régénérées que lors de la mise à jour de la page d'accueil du parc de blogs, sinon elles seront obtenues directement depuis le cache. Comment y parvenir ?
1. Concevez la classe BlogCacheDependency
et analysez-la d'abord. Tout d'abord, il ne fait aucun doute que cette classe doit être dérivée de CacheDependency, puis elle peut être utilisée dans la méthode Insert de Cache, ou utilisée dans la classe AggregateDependency.
Deuxièmement, du point de vue du RSS fourni par Blog Park et de la conception des pages, vous pouvez placer les données RSS dans le cache et utiliser une conversion de style lors de leur affichage. Lors de la vérification des dépendances, il suffit simplement de comparer si le RSS actuel est le même que le RSS du site Web.
Une question plus importante est la suivante : quand vérifions-nous et comparons-nous les données RSS ? À chaque demande ? Évidemment non. Cela revient presque à ne pas utiliser de cache, et cela ajoute en fait une charge inutile. Et si vous vous enregistriez sans demande ? Nous pouvons utiliser une minuterie pour le contrôler et lui permettre de vérifier régulièrement s'il y a une mise à jour. S'il y a une mise à jour, il informera la dépendance du changement.
Nous savons que la classe CacheDependency possède une propriété HasChanged, mais comment BlogCacheDependency indique-t-il à sa classe de base lorsqu'elle détecte un changement de dépendance ? C'est la mission de la nouvelle méthode NotifyDependencyChanged dans la classe CacheDependency dans ASP.NET 2.0.
De plus, afin de faciliter la réutilisation, la classe BlogCacheDependency doit disposer d'un flux de données pour enregistrer l'URL des données RSS que l'on souhaite obtenir. Il existe également un intervalle de temps pour faciliter le réglage de la vitesse de rafraîchissement pendant l'utilisation.
OK, jetons un coup d'œil au code d'implémentation actuel :
1public class BlogCacheDependency : CacheDependency
2{
3 minuterie privée _tickTimer ;
4 int privé _timeInterval ;
5 XPathNavigator privé _rss ;
6 chaîne privée _feed ;
7
8 XPathNavigator RSS public
9 {
10 obtenir
11 {
12 retour _rss ;
13}
14}
15
16 BlogCacheDependency public (flux de chaîne, int timeInterval)
17 {
18 _feed = alimentation;
19 _timeInterval = timeInterval ;
20 _rss = GetRSS();
21 _tickTimer = nouveau Timer (nouveau TimerCallback (CheckDependencyCallback),
22 ceci, _timeInterval * 1000, _timeInterval * 1000);
vingt-trois }
vingt-quatre
25 XPathNavigator GetRSS() privés
26 {
27 XPathDocument rssDoc = new XPathDocument(_feed);
28 return rssDoc.CreateNavigator();
29 }
30
31 public void CheckDependencyCallback (expéditeur de l'objet)
32 {
33 BlogCacheDependency bcd = expéditeur en tant que BlogCacheDependency ;
34 XPathNavigator newRSS = GetRSS();
35 si (newRSS.OuterXml != _rss.OuterXml)
36 {
37 bcd.NotifyDependencyChanged(bcd, EventArgs.Empty);
38 }
39 }
40
41 remplacement protégé void DependencyDispose()
42 {
43 _tickTimer = nul ;
44 base.DependencyDispose();
45 }
46}
47
48
Ici, le constructeur de BlogCacheDependency utilise _tickTimer pour implémenter un mécanisme de vérification régulière des mises à jour, qui appelle la méthode CheckDependencyCallback en fonction de l'intervalle de temps défini.
La méthode CheckDependencyCallback compare les deux informations RSS si elles sont différentes, la méthode NotifyDependencyChanged est appelée pour informer la classe de base que la dépendance du cache correspondante a changé et que les données du cache doivent être effacées.
2. Conception de la page
Voici le code de la page (abrégé) qui montre comment utiliser BlogCacheDependency :
1<script runat="server">
2 void protégé Page_Load (expéditeur d'objet, EventArgs e)
3 {
Flux à 4 chaînes = " http://www.cnblogs.com/RSS.aspx " ;
5 si (Cache[feed] == null)
6 {
7 BlogCacheDependency bcd = new BlogCacheDependency(flux, 600);
8 Cache.Insert(flux, bcd.RSS, bcd);
9 Label1.Text = "Les données actuelles viennent d'être obtenues et ont été mises à jour dans le cache !";
10}
11 autres
12 {
13 Label1.Text = "Les données actuelles sont obtenues du cache !";
14}
15 RssXml.XPathNavigator = Cache[feed] comme System.Xml.XPath.XPathNavigator ;
16 RssXml.TransformSource = "translate.xsl";
17}
18
19
20<corps>
21 <form id="form1" runat="serveur">
22 derniers articles de Blog Park :
23 <br />
24 <asp:Xml ID="RssXml" runat="serveur" />
25 <br />
26 <asp:Label ID="Label1" runat="server" ForeColor="red" />
27 </form>
28</corps>
29
Dans cet exemple, l'intervalle de temps défini pour accéder à la liste des derniers articles sur la page d'accueil du parc de blogs est de 600 secondes, c'est-à-dire que l'état de mise à jour est vérifié toutes les 10 minutes.
Plusieurs points sont à noter :
1. Faites attention à l'attribut RssXml.XPathNavigator utilisé. Certaines personnes peuvent se demander pourquoi RssXml.Document n'est pas utilisé ? En fait, l'attribut Document a été supprimé dans .NET 2.0. Le remplacement recommandé est l'attribut XPathNavigator. Comme vous pouvez le voir dans la classe BlogCacheDependency précédente, il est créé à partir de XPathDocument.CreateNavigator() à partir de MSDN. La classe XPathDocument fournit un cache rapide en lecture seule, évidemment plus adapté à cet exemple.
2. Pensez-y, quel est le but de la méthode DependencyDispose dans la classe BlogCacheDependency ? En quoi diffère-t-elle de la méthode Dispose ? Pensons-y. Si un changement de dépendance a été trouvé lors de la vérification des mises à jour, mais que la demande n'a pas été renvoyée, la méthode CheckDependencyCallback sera-t-elle exécutée en continu à intervalles réguliers ? Si tel est vraiment le cas, cela ne serait-il pas complètement redondant, car tant qu'un changement est détecté une fois, il n'est pas nécessaire de vérifier à nouveau. Et si nous suivons ou enregistrons les journaux, nous pouvons constater qu'en fait, tant que des changements de dépendance sont détectés, ils ne seront plus vérifiés. Quel est le secret ? Si vous y réfléchissez, vous saurez que la méthode NotifyDependencyChanged a beaucoup de mystère, et la raison pour laquelle il existe une méthode DependencyDispose est en fait ici. Les idées de conception qu’il contient valent la peine d’être savourées.
3. Je n'en dirai pas plus sur le Translate.xsl utilisé sur la page
, mais voici les principaux codes :
1<xsl:template match="channel">
2 <div>
3 <xsl:for-each select="item">
4 <a>
5 <xsl:nom de l'attribut="href">
6 <xsl:value-of select="link"/>
7 </xsl:attribut>
8 <xsl:value-of select="title"/>
9 </a>
10 <br />
11 </xsl:pour-chacun>
12 </div>
13
4. Exécution :
voici une capture d'écran de l'exécution initiale :
Lorsqu'aucun nouveau message n'apparaît sur la page d'accueil du jardin du blog, nous actualisons la page et obtenons toujours la page suivante :
Une fois qu'il y a un nouveau message, l'image précédente apparaîtra lors de l'actualisation.
5. Voulez-vous être plus avancé ?
Si vous êtes aussi paresseux que moi ou plus paresseux que moi, vous pouvez envisager d'utiliser javascript pour écrire une petite fonction qui actualise automatiquement la page, puis la décore, ou la conditionne dans un composant réutilisable pour une utilisation sur votre site Web. Ou est-ce que vous vous voulez juste créer quelque chose comme une « collection de contenu qui me tient le plus à cœur » dans cette machine ? Eh bien, je pense que l'effet sera plutôt bon.