Problème à l'aide de HttpRuntime.Cache

Suis à l'aide de la suite .net code pour ajouter des objets à cache:

public static void Add<T>(string key, T dataToCache)
{
    try
    {
        ApplicationLog.Instance.WriteInfoFormat("Inserting item with key {0} into Cache...", key);

        HttpRuntime.Cache.Insert(
            key,
            dataToCache,
            null,
            DateTime.Now.AddDays(7),
            System.Web.Caching.Cache.NoSlidingExpiration);
    }

    catch (Exception ex)
    {
        ApplicationLog.Instance.WriteException(ex);             
    }
}

et voici mon code pour récupérer des valeurs de cache:

public static T Get<T>(string key) 
{   
    try
    {                
        if (Exists(key))
        {
            ApplicationLog.Instance.WriteInfoFormat("Retrieving item with key {0} from Cache...", key);

            return (T)HttpRuntime.Cache[key];
        }
        else
        {
            ApplicationLog.Instance.WriteInfoFormat("Item with key {0} does not exist in Cache.", key);
            return default(T); 
        }
    }
    catch(Exception ex)
    {
        ApplicationLog.Instance.WriteException(ex);
        return default(T); 
    }
}


public static bool Exists(string key)
{
    bool retVal = false;
    try
    {
        retVal= HttpRuntime.Cache[key] != null;
    }
    catch (Exception ex)
    {
        ApplicationLog.Instance.WriteException(ex);
    }
    return retVal; 
}

Mais je trouve que, après toutes les 2 minutes,l'objet mis en cache valeur null résultant en tirant cette valeur à partir de la base de données à nouveau.

Ce qui me manque ici?

Je pense que le code qui utilise la mémoire cache serait plus pertinente. Par exemple, êtes-vous en ajoutant la même clé pour le cache plusieurs fois?
Parce qu'il est l'aide de l'insert, c'vais mettre à jour l'article si elle est déjà dans le cache.
Est votre ASP.NET configuration des paramètres par défaut? Par exemple, est l'ASP.NET jeu de la corbeille pour une raison quelconque, après une certaine quantité de mémoire est allouée, ou le temps a passé? Comment au sujet de vos paramètres de pool d'applications? Fondamentalement, vous êtes sûr que le HttpRuntime n'est pas en cours de redémarrage?
Notez qu'une condition de concurrence existe dans votre méthode Get (), étant donné que le cache peut être mis à jour entre la Exists() appel et HttpRuntime.Cache[key]. Voir le dernier point ici: stackoverflow.com/a/11432864/188926

OriginalL'auteur user74042 | 2009-06-22

  1. 6

    Quand vous dites toutes les deux minutes à la valeur insérée est définie sur null, cela signifie juste l'élément qui vous intéresse ou de chaque élément dans le cache?

    Je demande cela parce que le cache n'existe que tant que l'application est en cours d'exécution. Si l'application est redémarrée, le cache s'en va. Ceci pourrait expliquer le comportement si tout s'en va toutes les 2 minutes. Dans ce cas, vous avez un autre problème sur vos mains: pourquoi le redémarrage de l'application toutes les 2 minutes.

    Si c'est seulement CERTAINS éléments, alors il pourrait être un problème de mémoire. Le cache nettoie de lui-même en réponse à la faible mémoire. Je crois qu'il y a un moyen de définir la priorité sur les valeurs insérées. Mais cela ne devrait être un problème lorsque vous êtes faible sur la mémoire.

    Si ce n'est toujours pas à résoudre votre problème, il existe un moyen de découvrir pourquoi un élément est supprimé. Il est expliqué ici.

    merci pour ur d'entrée...oui, la valeur est définie sur null pour chaque élément dans le cache..
    Pouvez-vous vérifier les journaux de confirmer si l'application est en train de redémarrer, et si oui, pourquoi? Une fois que vous trouver que vous devriez être en mesure de le résoudre ou de poster une autre question.

    OriginalL'auteur colithium

  2. 7

    Tout d'abord, votre accès n'est pas synchronisées de sorte que c'est une grande source de problèmes. La lecture de la HttpRuntime Cache est garanti pour être thread-safe de sorte que vous devriez vraiment essayer de lire votre article en tant que votre première étape sur chaque opération de cache.

    De vérifier si Exists et fait de la récupération de l'élément beaucoup de choses peuvent se produire (comme votre article n'étant plus là). Vous devriez obtenir une poignée de l'élément que vous recherchez, et si il n'y est pas de fournir thread-safe insertion par l'extraction à partir de votre banque de données persistantes.

    De sorte que votre Add logique serait d'obtenir à l'intérieur de votre Get SI les données n'est pas là. Il n'y a rien de fondamentalement mauvais dans la fourniture de séparer Add logique et vous devez mesurer le coût de la frappe de la base de données plusieurs fois par rapport à un blocage demande en outre à ce que le morceau de données.

    T GetT(string key)
{
    T item = (cache.Get(key) as T);
    if (item == null)
    {
        lock (yourSyncRoot)
        {
            //double check it here
            item = (cache.Get(key) as T);
            if (item != null)
                return item;

            item = GetMyItemFromMyPersistentStore(key); //db?
            if (item == null)
                return null;

            string[] dependencyKeys = {your, dependency, keys};

            cache.Insert(key, item, new CacheDependency(null, dependencyKeys), 
                         absoluteExpiration, slidingExpiration, priority, null);
        }
    }
    return item;
}

    En fonction de votre stratégie d'expiration vous pouvez accéder à vos données en mémoire et de fournir un service rapide & accès synchronisé, mais comme je l'ai dit, de le mesurer et de l'ajuster à vos besoins. Dans une logique d'entreprise après la mise à jour de votre article et bien l'enregistrer sur votre magasin persistant, il suffit de retirer de la mémoire cache et le prochain appel à votre Get va chercher de nouveau.

    pourquoi êtes-vous de verrouillage qui pratiquent si le cache d'accès est thread-safe?
    ce pourrait être améliorée touch my ajout d'un lambda pour l'Obtenir et en fait une extension de la méthode... statique T Get<T>(Cache cache, String key, Func<T> retrieveFunc);
    l'accès est thread-safe" signifie qu'une seule opération de l'objet se comporte de manière atomique et ne sera pas causer des pannes lorsqu'il est frappé par plusieurs threads. Cependant, de multiples opérations sur les objets doivent encore être synchronisées par des verrous, même pour les thread-safe collections. Ici, nous avons un "Get" et "Insert" si le get ne pas trouver un objet. Cette paire doit être verrouillé ou de deux ou de plusieurs threads peuvent passer le "Get", de ne pas trouver un objet, et de le créer et de l'Insérer. Si nous voulons qu'un seul thread pour créer et insérer l'objet, puis l'opération paire doit être verrouillé. Le modèle commun.

    OriginalL'auteur user134706

  3. 2

    Il pourrait être parce que la mémoire est faible, le cache sera automatiquement tuer éléments dans le cache lorsque la mémoire est de plus en plus rares, Il y a un paramètre facultatif pour définir la priorité d'éléments dans le cache si vous voulez un élément à être effacée avant l'autre.

    OriginalL'auteur Tetraneutron