En ASP.NET 1.x, podemos usar CacheDependency para implementar estrategias de dependencia de caché, pero como esta clase está sellada, no podemos heredar esta clase para implementar nuestras propias estrategias. Pero con ASP.NET 2.0, ya podemos derivar nuestras propias clases de dependencia de caché a partir de esta clase.
Supongamos que queremos diseñar una página y necesitamos obtener la información de publicación más reciente de la página de inicio del blog. Para mejorar el rendimiento, esperamos que los datos de la página solo se regeneren cuando se actualice la página de inicio del parque de blogs; de lo contrario, se obtendrán directamente del caché. ¿Cómo lograrlo?
1. Diseñe la clase BlogCacheDependency
y analícela primero. En primer lugar, no hay duda de que esta clase debe derivarse de CacheDependency y luego puede usarse en el método Insert de Cache o en la clase AggregateDependency.
En segundo lugar, desde la perspectiva del RSS proporcionado por Blog Park y el diseño de la página, puede colocar datos RSS en el caché y utilizar una conversión de estilo al mostrarlos. Al verificar las dependencias, solo necesitamos comparar simplemente si el RSS actual es el mismo que el RSS del sitio web.
Una pregunta más importante es: ¿cuándo comprobamos y comparamos los datos RSS? ¿En cada solicitud? Obviamente no. Esto es casi lo mismo que no usar caché y, de hecho, agrega una carga innecesaria. ¿Qué pasa con el check-in sin una solicitud? Podemos usar un temporizador para controlarlo y permitirle verificar si hay una actualización periódicamente. Si hay una actualización, notificará a la dependencia del cambio.
Sabemos que la clase CacheDependency tiene una propiedad HasChanged, pero ¿cómo le dice BlogCacheDependency a su clase base cuando detecta un cambio de dependencia? Esta es la misión del nuevo método NotifyDependencyChanged en la clase CacheDependency en ASP.NET 2.0.
Además, para facilitar la reutilización, la clase BlogCacheDependency debe tener un feed de datos para guardar la URL de los datos RSS que queremos obtener. También hay un intervalo de tiempo para facilitar el ajuste de la velocidad de actualización durante el uso.
Bien, echemos un vistazo al código de implementación real:
1 clase pública BlogCacheDependency: CacheDependency
2{
3 Temporizador privado _tickTimer;
4 privado int _timeInterval;
5 XPathNavigator privado _rss;
6 cadena privada _feed;
7
8 RSS públicos XPathNavigator
9 {
10 obtener
11 {
12 retorno _rss;
13}
14}
15
16 BlogCacheDependency público (alimentación de cadena, int timeInterval)
17 {
18 _alimentar = alimentar;
19 _timeInterval = intervalodetiempo;
20 _rss = ObtenerRSS();
21 _tickTimer = nuevo temporizador (nuevo TimerCallback (CheckDependencyCallback),
22 esto, _timeInterval * 1000, _timeInterval * 1000);
veintitrés }
veinticuatro
25 XPathNavigator privado GetRSS()
26 {
27 XPathDocument rssDoc = nuevo XPathDocument(_feed);
28 retorno rssDoc.CreateNavigator();
29 }
30
31 CheckDependencyCallback público vacío (remitente del objeto)
32 {
33 BlogCacheDependency bcd = remitente como BlogCacheDependency;
34 XPathNavigator nuevoRSS = GetRSS();
35 si (nuevoRSS.OuterXml! = _rss.OuterXml)
36 {
37 bcd.NotifyDependencyChanged(bcd, EventArgs.Empty);
38 }
39 }
40
41 anulación protegida void DependencyDispose()
42 {
43 _tickTimer = nulo;
44 base.DependencyDispose();
45 }
46}
47
48
Aquí, el constructor de BlogCacheDependency usa _tickTimer para implementar un mecanismo para verificar actualizaciones periódicamente, que llama al método CheckDependencyCallback de acuerdo con el intervalo de tiempo establecido.
El método CheckDependencyCallback compara la información de dos RSS. Si son diferentes, se llama al método NotifyDependencyChanged para notificar a la clase base que la dependencia de caché correspondiente ha cambiado y que los datos en el caché deben borrarse.
2. Diseño de página
El siguiente es el código de página (abreviado), que muestra cómo utilizar BlogCacheDependency:
1<script runat="server">
2 Page_Load vacío protegido (remitente del objeto, EventArgs e)
3 {
Alimentación de 4 cadenas = " http://www.cnblogs.com/RSS.aspx ";
5 si (caché[feed] == nulo)
6 {
7 BlogCacheDependency bcd = nuevo BlogCacheDependency(feed, 600);
8 Caché.Insertar(feed, bcd.RSS, bcd);
9 Label1.Text = "¡Los datos actuales acaban de obtenerse y actualizarse en la memoria caché!";
10}
11 más
12 {
13 Label1.Text = "¡Los datos actuales se obtienen del caché!";
14}
15 RssXml.XPathNavigator = Caché[feed] como System.Xml.XPath.XPathNavigator;
16 RssXml.TransformSource = "traducir.xsl";
17}
18</script>
19
20<cuerpo>
21 <formulario id="form1" runat="servidor">
22 últimas publicaciones de Blog Park:
23 <br />
24 <asp:Xml ID="RssXml" runat="servidor" />
25 <br />
26 <asp:Label ID="Label1" runat="servidor" ForeColor="rojo" />
27 </formulario>
28</cuerpo>
29
En este ejemplo, el intervalo de tiempo establecido para acceder a la lista de últimas publicaciones en la página de inicio del parque de blogs es de 600 segundos, es decir, el estado de la actualización se verifica cada 10 minutos.
Varios puntos que vale la pena señalar:
1. Preste atención al atributo RssXml.XPathNavigator utilizado. Algunas personas pueden preguntarse por qué no se usa RssXml.Document. De hecho, el atributo Documento ha sido abolido en .NET 2.0. El reemplazo recomendado es el atributo XPathNavigator. Como puede ver en la clase BlogCacheDependency anterior, se crea a partir de XPathDocument.CreateNavigator(). La clase XPathDocument proporciona un caché rápido de solo lectura, que obviamente es más adecuado para este ejemplo.
2. Piénselo, ¿cuál es el propósito del método DependencyDispose en la clase BlogCacheDependency? ¿En qué se diferencia del método Dispose? Pensemos en ello. Si se encuentra un cambio de dependencia al buscar actualizaciones, pero la solicitud no se ha enviado nuevamente, ¿se ejecutará el método CheckDependencyCallback continuamente a intervalos? Si este es realmente el caso, ¿no sería completamente redundante? Porque siempre que se detecte un cambio una vez, no es necesario volver a comprobarlo. Y si rastreamos o registramos registros, podemos encontrar que, de hecho, mientras se encuentren cambios de dependencia, no se volverán a verificar. ¿Cuál es el secreto? Si lo piensa, sabrá que el método NotifyDependencyChanged tiene mucho misterio, y la razón por la que existe un método DependencyDispose está en realidad aquí. Vale la pena saborear las ideas de diseño que contiene.
3. No diré más sobre el Translate.xsl usado en la página
, pero aquí están los códigos principales:
1<xsl:template match="channel">
2 <div>
3 <xsl:para-cada seleccionar="elemento">
4 <a>
5 <xsl:nombre del atributo="href">
6 <xsl:valor-de selección="enlace"/>
7 </xsl:atributo>
8 <xsl:valor-de selección="título"/>
9</a>
10 <br />
11 </xsl:para-cada>
12 </div>
13</xsl:plantilla>
4. Ejecución:
esta es una captura de pantalla de la ejecución inicial:
Cuando no aparecen nuevas publicaciones en la página de inicio del jardín del blog, actualizamos la página y siempre obtenemos la siguiente página:
Una vez que haya una nueva publicación, la imagen anterior aparecerá al actualizar.
5. ¿Quieres ser más avanzado?
Si eres tan vago como yo o más vago que yo, entonces puedes considerar usar javascript para escribir una pequeña función que actualice automáticamente la página y luego decorarla, o empaquetarla en un componente reutilizable para usar en tu sitio web. ¿Solo quieres crear algo así como una “colección de contenido que más me importa” en esta máquina? Bueno, creo que el efecto será bastante bueno.