System.Web.Caching.DataCache Téléchargement - System.Web.Caching.DataCache Code source Téléchargement

Le cache ASP.NET WebForms a été implémenté très commodément pour la conservation des données opérationnelles. Dans les premières années de la plate-forme .NET, les développeurs travaillaient souvent pour travailler avec System.Web Names Namespace, même dans les applications WinForms.

Le modèle de code, qui est constamment proposé dans des articles sur la mise en cache ASP.NET, est très simple et pratique:

 // try to get an instance of object from cache
DataSet ds = HttpRuntime . Cache [ "KeyName" ] as DataSet ;
// check the result and recreate it, if it is null
if ( ds == null )
{
    ds = QueryDataFromDatabase ( ) ;
    HttpRuntime . Cache . Insert ( "KeyName" , ds ) ;
}
// using the instance of object that has been populated from cache or from storage
DataRow dr = ds . Tables [ 0 ] . Rows [ 0 ] ;

Cependant, l'implémentation ASP.NET CACHE n'inclut pas certaines fonctionnalités souhaitables.

Paramètres de cache ASP.NET

Bien que la méthode Cache.insert (String, Object), qui ajoute une valeur dans le cache, convient à la plupart des cas, il est souvent souhaitable d'appliquer différents paramètres de mise en cache en fonction des paramètres de l'application Web stockés dans le fichier web.config, et parfois même en désactivant complètement le cache pour l'ensemble de l'application. Dans ce cas, le code source ne doit pas être modifié et l'application doit s'exécuter sans recompilation.

Méthodes génériques et valeurs par défaut

Le cache ASP.NET renvoie toujours les instances de la classe object , quel que soit le type réel de l'instance. Dans la plupart des cas, ce n'est pas un problème, car les Nullable types peuvent être utilisés à la place des Value types . Vous aimeriez peut-être avoir des méthodes génériques pour récupérer les données du cache:

 // this is a dafault extraction data from cache
myClassName item = HttpRuntime . Cache [ "Key1" ] as myClassName ; 

// this is a desired extraction data with generic methods
myClassName item = DataCache . Get < myClassName > ( "Key1" ) ;

Si les méthodes génériques ne sont pas satisfaites pour vous, il est possible d'utiliser la version par défaut. En fait, ces deux options sont identiques. Mais les méthodes génériques offrent des fonctionnalités supplémentaires. Par exemple, la valeur par défaut pourrait être définie si le cache ne contient pas de valeur à récupérer:

 myClassName defaultValue = new myClassName ( /* init properties */ ) ;
myClassName item = DataCache . Get < myClassName > ( "Key1" , defaultValue ) ; 
/* if there is nothing in the cache, then the item will be defaultValue */

Données copiées profondes

Le cache ASP.NET renvoie toujours l'objet stocké dans le cache. Cela signifie que les modifications de toute propriété de l'objet extrait modifieront également l'objet stocké dans le cache, car ce sont les mêmes objets. Dans certains cas, vous voudrez peut-être modifier l'objet récupéré, mais laisser l'objet dans le cache inchangé. L'une des fonctionnalités pratiques consiste à récupérer une copie d'un objet à partir du cache qui peut être modifié sans se soucier de l'objet dans le cache.

Régions des données chéchées

Le cache ASP.NET est similaire à un NameValueCollection . C'est une solution simple et élégante pour une petite application Web, mais il devient difficile de générer les clés lorsque l'application grandit. Par exemple, envisagez de mettre en cache deux tables connexes, telles que les vendeurs et les modèles. Dans ce cas, l'application Web conservera toutes les données de la table des fournisseurs dans un objet en cache et de nombreux objets mis en cache pour les enregistrements associés du tableau des modèles. La clé pour les vendeurs est censé être un Vendors et les clés des modèles censés être Models.[VendorID] . Lorsque la table des vendeurs a changé, une instance mise en cache pour les fournisseurs et uniquement les instances associées pour les modèles doivent être supprimées du cache. Cela signifie que les données doivent être mises en cache et supprimées du cache par régions.

Mise en œuvre

Les fonctions décrites sont facultatives et peuvent être facilement implémentées dans n'importe quelle application Web. Le modèle de proxy est une bonne option pour implémenter toutes les fonctionnalités décrites. La bibliothèque résultante peut être utilisée sur tous les frameworks .NET, Démarrage de la version 2.0. Le .NET Framework 4.0 présente le System.Runtime.Caching Espace et plusieurs classes avec un nouveau modèle de mise en cache. Par conséquent, l'utilisation du cache ASP.NET standard et ses améliorations n'est pas requise.

Triste mais vrai.

Propriétés et paramètres

 /// <summary>
/// Is cache used or not
/// </summary>
public static bool IsCacheEnable ;

/// <summary>
/// How to store objects in the cache
/// </summary>
public static CacheExpirationType ExpirationType ;

/// <summary>
/// How long objects should be stored in the cache 
/// </summary>
public static TimeSpan ExpirationTime ;

Enum CacheExpirationType définit comment stocker des objets dans le cache

 /// <summary>
/// How to store objects in the cache
/// </summary>
public enum CacheExpirationType
{
    /// <summary>
    /// Without time limit, the value of the <seealso cref = "DataCache.ExpirationTime" /> property will be ignored
    /// </summary>
    NoExpiration ,

    /// <summary>
    /// The <seealso cref="DataCache.ExpirationTime"/> at which the inserted object expires and is removed from the cache
    /// </summary>
    AbsoluteExpiration ,

    /// <summary>
    /// The interval <seealso cref="DataCache.ExpirationTime"/> between the time the inserted object is last accessed and the time at which that object expires
    /// </summary>
    SlidingExpiration
}

Méthodes pour extraire les données du cache

 /// <summary>
/// Retrieves the specified item from the Cache object
/// </summary>
/// <typeparam name="T">The type for the cache item to retrieve</typeparam>
/// <param name="key">The identifier for the cache item to retrieve</param>
/// <param name="defaultValue">The default value if the object is not in the cache</param>
/// <returns>The retrieved cache item, or <paramref name="defaultValue"/> if the key is not found</returns>
public static T GetData < T > ( string key , T defaultValue = default ( T ) )

/// <summary>
/// Retrieves the deep copied of specified item from the Cache object
/// </summary>
/// <typeparam name="T">The type for the cache item to retrieve</typeparam>
/// <param name="key">The identifier for the cache item to retrieve</param>
/// <param name="defaultValue">The default value if the object is not in the cache</param>
/// <returns>The retrieved cache item, or <paramref name="defaultValue"/> if the key is not found</returns>
public static T GetDeepCopiedData < T > ( string key , T defaultValue = default ( T ) )

Méthodes pour stocker des données dans le cache

 /// <summary>
/// Inserts an item into the cache with a cache key to reference its location, using default values provided by the settings
/// </summary>
/// <param name="key">The cache key used to reference the item</param>
/// <param name="value">The object to be inserted into the cache</param>
public static void InsertData ( string key , object value )

/// <summary>
/// Inserts an item into the cache with a cache key to reference its location, using the absolute expiration time
/// </summary>
/// <param name="key">The cache key used to reference the item</param>
/// <param name="value">The object to be inserted into the cache</param>
/// <param name="expirationTime">How long the object should be stored in the cache</param>
public static void InsertAbsoluteExpirationData ( string key , object value , TimeSpan expirationTime )

/// <summary>
/// Inserts an item into the cache with a cache key to reference its location, using the sliding expiration time
/// </summary>
/// <param name="key">The cache key used to reference the item</param>
/// <param name="value">The object to be inserted into the cache</param>
/// <param name="expirationTime">How long the object should be stored in the cache</param>
public static void InsertSlidingExpirationData ( string key , object value , TimeSpan expirationTime )

/// <summary>
/// Inserts an item into the cache with a cache key to reference its location, using the type of expiration and default value for expiration time
/// </summary>
/// <param name="key">The cache key used to reference the item</param>
/// <param name="value">The object to be inserted into the cache</param>
/// <param name="expirationType">How to store objects in the cache</param>
public static void InsertExpirationData ( string key , object value , CacheExpirationType expirationType )

/// <summary>
/// Inserts an item into the cache with a cache key to reference its location, using the type of expiration and expiration time
/// </summary>
/// <param name="key">The cache key used to reference the item</param>
/// <param name="value">The object to be inserted into the cache</param>
/// <param name="expirationType">How to store objects in the cache</param>
/// <param name="expirationTime">How long the object should be stored in the cache</param>
public static void InsertExpirationData ( string key , object value , CacheExpirationType expirationType , TimeSpan expirationTime )

Méthodes pour supprimer les données du cache

 /// <summary>
/// Removes the specified item from the application's cache 
/// </summary>
/// <param name="key">An identifier for the cache item to remove</param>
public static void RemoveDataByKey ( string key )

/// <summary>
/// Removes all items from the application's cache that starts with key
/// </summary>
/// <param name="keyStartsWith">An starts with identifier for the cache item to remove</param>
public static void RemoveAllDataByKey ( string keyStartsWith )

/// <summary>
/// Removes all items from the application's cache 
/// </summary>
public static void RemoveAllData ( )

Exemple d'utilisation

1. Paramètres les paramètres par défaut lorsque l'application démarre

 public class Global : System . Web . HttpApplication
{
    protected void Application_Start ( object sender , EventArgs e )
    {
        Settings settings = Settings . Default ;
        DataCache . IsCacheEnable = settings . IsCacheEnable ;
        DataCache . ExpirationType = settings . ExpirationType ;
        DataCache . ExpirationTime = settings . ExpirationTime ;
    }
}

2. Implémentez le modèle standard fonctionnant avec le cache sur la page ou en dal

 public partial class DefaultPage : System . Web . UI . Page
{
    public const string STR_CACHENAME = "something" ;

    protected void Page_Load ( object sender , EventArgs e )
    {
        if ( ! this . IsPostBack )
        {
            SomethingDataModel val = DataCache . GetData < SomethingDataModel > ( STR_CACHENAME ) ;
            if ( val == null ) 
            {
                SomethingDataModel val = new SomethingDataModel ( ) ; // get data from ...
                DataCache . InsertData ( STR_CACHENAME , val ) ;
            }
            DataBind ( val ) ; // use data on the page
        }
    }
}

Si vous souhaitez définir des paramètres de temps différents de spécifiés par défaut dans le cache, utilisez l'une des méthodes Insert{Which}Data .

3. Dans le panneau d'administration ou lorsque la base de données a été mise à jour

 public partial class DefaultPage : System . Web . UI . Page
{
    public const string STR_CACHENAME = "something" ;

    protected void Page_Load ( object sender , EventArgs e )
    {
        if ( this . IsPostBack )
        {
            DAL . Update ( ) ; // update the database ...
            DataCache . RemoveAllDataByKey ( STR_CACHENAME ) ; // clear cache
            Response . Redirect ( "Default.aspx" ) ; // proccessing the request
        }
    }
}