MemoryCache Classe

Définition

Espace de noms:

System.Runtime.Caching

Assembly:

System.Runtime.Caching.dll

Paquet:

System.Runtime.Caching v8.0.0

Source:

MemoryCache.cs

Représente le type qui implémente un cache en mémoire.

public ref class MemoryCache : System::Runtime::Caching::ObjectCache, IDisposable

public class MemoryCache : System.Runtime.Caching.ObjectCache, IDisposable

type MemoryCache = class
    inherit ObjectCache
    interface IEnumerable
    interface IDisposable

Public Class MemoryCache
Inherits ObjectCache
Implements IDisposable

Héritage

Object

ObjectCache

MemoryCache

Implémente

IEnumerable IDisposable

Exemples

L’exemple suivant déclare une référence au cache de mémoire par défaut instance. L’entrée de cache utilise un CacheItemPolicy objet pour fournir des détails d’éviction et d’expiration pour l’entrée du cache. Il utilise également un ChangeMonitor objet pour surveiller l’état des données sources (qui sont un fichier) sur le système de fichiers.

Private Sub btnGet_Click(ByVal sender As Object, ByVal e As EventArgs)
    Dim cache As ObjectCache = MemoryCache.[Default]
    Dim fileContents As String = TryCast(cache("filecontents"), String)

    If fileContents Is Nothing Then
        Dim policy As New CacheItemPolicy()
        Dim filePaths As New List(Of String)()
        filePaths.Add("c:\cache\example.txt")

        policy.ChangeMonitors.Add(New HostFileChangeMonitor(filePaths))

        ' Fetch the file contents.
        fileContents = File.ReadAllText("c:\cache\example.txt")

        cache.[Set]("filecontents", fileContents, policy)
    End If

    Label1.Text = fileContents
End Sub

private void btnGet_Click(object sender, EventArgs e)
{
    ObjectCache cache = MemoryCache.Default;
    string fileContents = cache["filecontents"] as string;

    if (fileContents == null)
    {
        CacheItemPolicy policy = new CacheItemPolicy();

        List<string> filePaths = new List<string>();
        filePaths.Add("c:\\cache\\example.txt");

        policy.ChangeMonitors.Add(new
        HostFileChangeMonitor(filePaths));

        // Fetch the file contents.
        fileContents =
            File.ReadAllText("c:\\cache\\example.txt");

        cache.Set("filecontents", fileContents, policy);
    }

    Label1.Text = fileContents;
}

Remarques

La classe MemoryCache est une implémentation concrète de la classe ObjectCache abstraite.

Notes

La MemoryCache classe est similaire à la classe ASP.NET Cache . La MemoryCache classe possède de nombreuses propriétés et méthodes d’accès au cache qui vous seront familières si vous avez utilisé la classe ASP.NET Cache . Les différences main entre les Cache classes et MemoryCache sont que la MemoryCache classe a été modifiée pour la rendre utilisable par les applications .NET Framework qui ne sont pas ASP.NET applications. Par exemple, la MemoryCache classe n’a aucune dépendance sur l’assembly System.Web . Une autre différence est que vous pouvez créer plusieurs instances de la MemoryCache classe pour une utilisation dans la même application et dans la même AppDomain instance.

La MemoryCache classe n’autorise null pas comme valeur dans le cache. Toute tentative d’ajout ou de modification d’une entrée de cache avec la valeur de null échouera.

Le MemoryCache type n’implémente pas les régions de cache. Par conséquent, lorsque vous appelez MemoryCache des méthodes qui implémentent des méthodes de base qui contiennent un paramètre pour les régions, ne passez pas de valeur pour le paramètre. Les méthodes qui utilisent le paramètre region fournissent toutes une valeur par défaut null . Par exemple, la surcharge de méthode MemoryCache.AddOrGetExisting a un regionName paramètre dont la valeur par défaut est null.

Constructeurs

MemoryCache(String, NameValueCollection)	Initialise une nouvelle instance de la classe MemoryCache.
MemoryCache(String, NameValueCollection, Boolean)	Initialise une nouvelle instance de la classe MemoryCache.

Propriétés

CacheMemoryLimit	Obtient la quantité de mémoire, en octets, de l'ordinateur pouvant être utilisée par le cache.
Default	Obtient une référence à l'instance de MemoryCache par défaut.
DefaultCacheCapabilities	Obtient une description des fonctionnalités que fournit le cache.
Item[String]	Obtient ou définit une valeur du cache en utilisant la propriété d'indexeur par défaut pour une instance de la classe MemoryCache.
Name	Obtient le nom du cache.
PhysicalMemoryLimit	Obtient le pourcentage de mémoire physique que le cache peut utiliser.
PollingInterval	Obtient la durée maximale après laquelle le cache met à jour ses statistiques de mémoire.

Méthodes

Add(CacheItem, CacheItemPolicy)	Insère une entrée dans le cache à l'aide d'une instance de CacheItem et ajoute des détails concernant le mode d'expulsion de l'entrée.
Add(String, Object, CacheItemPolicy, String)	En cas de substitution dans une classe dérivée, insère une entrée dans le cache, en spécifiant des informations sur le mode de suppression de l'entrée. (Hérité de ObjectCache)
Add(String, Object, DateTimeOffset, String)	En cas de substitution dans une classe dérivée, insère une entrée dans le cache sans remplacer d'entrée d'entrée de cache existante. (Hérité de ObjectCache)
AddOrGetExisting(CacheItem, CacheItemPolicy)	Ajoute une entrée dans le cache à l'aide de l'instance de CacheItem spécifiée et des détails concernant le mode de suppression de l'entrée.
AddOrGetExisting(String, Object, CacheItemPolicy, String)	Insère une entrée dans le cache à l'aide de la clé et de la valeur spécifiées, ainsi que des détails spécifiés concernant le mode de suppression.
AddOrGetExisting(String, Object, DateTimeOffset, String)	Ajoute une entrée dans le cache à l'aide de la clé spécifiée, d'une valeur et d'une valeur d'expiration absolue.
Contains(String, String)	Détermine si une entrée de cache existe dans le cache.
CreateCacheEntryChangeMonitor(IEnumerable<String>, String)	Crée un objet CacheEntryChangeMonitor qui peut déclencher des événements en réponse à des modifications apportées aux entrées du cache spécifiées.
Dispose()	Libère toutes les ressources qui sont utilisées par l'instance actuelle de la classe MemoryCache.
Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
Get(String, String)	Retourne une entrée du cache.
GetCacheItem(String, String)	Retourne l'entrée spécifiée du cache sous la forme d'une instance de CacheItem.
GetCount(String)	Retourne le nombre total d'entrées dans le cache.
GetEnumerator()	Crée un énumérateur qui peut être utilisé pour itérer au sein d’une collection d’entrées de cache.
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetLastSize(String)	Obtient la taille de la région nommée.
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
GetValues(IEnumerable<String>, String)	Retourne un ensemble d'entrées du cache qui correspondent aux clés spécifiées.
GetValues(String, String[])	Obtient un ensemble d'entrées du cache qui correspondent aux clés spécifiées. (Hérité de ObjectCache)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
Remove(String, CacheEntryRemovedReason, String)	Supprime une entrée du cache en utilisant la raison.
Remove(String, String)	Supprime une entrée du cache.
Set(CacheItem, CacheItemPolicy)	Insère une entrée dans le cache à l'aide d'une instance de CacheItem pour fournir la clé et la valeur de l'entrée de cache.
Set(String, Object, CacheItemPolicy, String)	Insère une entrée dans le cache à l'aide d'une clé et d'une valeur pour l'éviction.
Set(String, Object, DateTimeOffset, String)	Insère une entrée dans le cache à l'aide d'une clé et d'une valeur, et spécifie les détails d'expiration basés sur l'heure.
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)
Trim(Int32)	Supprime un pourcentage spécifié d'entrées de cache de l'objet de cache.

Implémentations d’interfaces explicites

IEnumerable.GetEnumerator()	Prend en charge l’itération au sein d’une collection générique.
IEnumerable<KeyValuePair<String,Object>>.GetEnumerator()	Prend en charge l’itération sur une collection fortement typée. (Hérité de ObjectCache)

Méthodes d’extension

Cohérence de thread

Ce type est thread-safe.

Voir aussi

• ObjectCache
• Procédure pas à pas : mise en cache de données d’application dans ASP.NET
• Mise en cache dans les applications .NET Framework