Partager via

ChangeMonitor Classe

  • Référence

Définition

Espace de noms:
System.Runtime.Caching
Assembly:
System.Runtime.Caching.dll
Paquet:
System.Runtime.Caching v9.0.0
Source:
ChangeMonitor.cs
Source:
ChangeMonitor.cs
Source:
ChangeMonitor.cs

Fournit une classe de base pour un type personnalisé dérivé qui surveille les modifications de l'état des données dont dépend un élément de cache.

public ref class ChangeMonitor abstract : IDisposable
public abstract class ChangeMonitor : IDisposable
type ChangeMonitor = class
    interface IDisposable
Public MustInherit Class ChangeMonitor
Implements IDisposable
Héritage
Object
ChangeMonitor
Dérivé
Implémente
IDisposable

Remarques

La ChangeMonitor classe est utilisée comme classe de base pour les classes de moniteur dérivées spécialisées pour des implémentations de cache particulières. Un ChangeMonitor instance surveille les modifications de l’état des données dont dépend un élément de cache. Par exemple, l’élément peut être un fichier ou une entité de données dont le contenu est mis en cache. Si le fichier ou l’entité de données est mis à jour, l’entrée de cache associée doit également être modifiée. Les éléments courants qui peuvent être surveillés incluent les entités de données (telles que les champs de base de données, les valeurs, les lignes ou les tables), une autre entrée de cache et les fichiers et attributs de fichier.

Une modification de dépendance est une modification de l’état d’une dépendance. Dans une implémentation de cache classique, après qu’un ChangeMonitor instance informe le cache qu’une dépendance a changé, le cache effectue l’action requise, telle que l’invalidation de l’entrée de cache insérée.

Les classes dérivées ChangeMonitor peuvent être personnalisées pour surveiller les modifications de dépendance pour différents magasins de données spécifiques. Par exemple, il existe des implémentations de cache pour un système de fichiers, une mémoire physique ou une base de données. La ChangeMonitor classe examine les modifications qui se produisent en dehors du cache, puis avertit le cache que des modifications se sont produites.

Le .NET Framework inclut les classes suivantes qui dérivent de la ChangeMonitor classe :

Chacune de ces classes fonctionne avec différents types de dépendances. Par exemple, la classe dérivée FileChangeMonitor surveille les modifications apportées à un cache pour les données du système de fichiers (fichiers et dossiers) dont dépend l’élément de cache.

Notes pour les responsables de l’implémentation

Si vous créez une implémentation de cache personnalisée ou un type de moniteur de modification dérivé, vous devez suivre certaines instructions. La liste suivante récapitule ces instructions. Pour plus d’informations, consultez la documentation relative aux méthodes ou propriétés individuelles.

  • Le constructeur d’une classe dérivée doit définir la propriété, commencer l’analyse UniqueId et appeler InitializationComplete() la méthode avant que la méthode ne retourne. Si un constructeur rencontre une erreur pendant les constructions et doit disposer de ressources, le constructeur ne peut appeler la Dispose surcharge qu’après l’appel de la InitializationComplete() méthode, car la Dispose surcharge lève une InvalidOperationException exception si l’initialisation n’est pas terminée.

  • Si des modifications se produisent dans les données analysées avant la fin de l’initialisation, le constructeur doit appeler la OnChanged(Object) méthode avant d’appeler la InitializationComplete() méthode .

  • Une fois qu’un type dérivé ChangeMonitor est instancié, vous devez insérer le moniteur dans une implémentation personnalisée ObjectCache . Ou si vous avez fini d’utiliser le moniteur de modification, appelez la Dispose méthode .

  • Une fois qu’une ChangeMonitor instance est insérée dans une ObjectCache implémentation, l’instance ObjectCache exiger que le moniteur de modification soit supprimé. Même si l’insertion n’est pas valide et provoque une exception, l’implémentation ObjectCache doit appeler la Dispose surcharge.

  • Une fois qu’un moniteur de modification dérivé est inséré dans un cache, l’implémentation ObjectCache doit appeler NotifyOnChanged(OnChangedCallback), en passant un OnChangedCallback objet . La NotifyOnChanged(OnChangedCallback) méthode ne peut être appelée qu’une seule fois. Si une modification de dépendance s’est déjà produite, le OnChangedCallback instance est appelé immédiatement quand NotifyOnChanged(OnChangedCallback) est appelé. Sinon, le OnChangedCallback instance ne sera appelé qu’une seule fois. Cet appel unique se produit soit lorsque la OnChanged(Object) méthode est appelée parce que le ChangeMonitor instance a détecté une modification, soit lorsque la Dispose() méthode est appelée sur le ChangeMonitor, selon ce qui se produit en premier.

  • Le OnChangedCallback instance fourni par une ObjectCache implémentation doit supprimer l’entrée de cache associée et spécifier une raison à l’aide de l’énumérationDependencyChanged.

  • Un ChangeMonitor instance peut appeler la OnChanged(Object) méthode avant qu’une implémentation de cache ait appelé NotifyOnChanged(OnChangedCallback) la méthode ou après. Si la OnChanged(Object) méthode est appelée avant NotifyOnChanged(OnChangedCallback) d’être appelée, l’implémentation de base ChangeMonitor informe le cache que cela s’est produit et déclenche le passage du rappel à NotifyOnChanged(OnChangedCallback) immédiatement quand NotifyOnChanged(OnChangedCallback) est appelé. Toutes les données d’état passées à la OnChanged(Object) méthode sont enregistrées par le moniteur de modification, puis transmises à la NotifyOnChanged(OnChangedCallback) méthode lorsque la NotifyOnChanged(OnChangedCallback) méthode est appelée.

  • Un moniteur de modifications doit implémenter la Dispose(Boolean) méthode . Pour plus d'informations, consultez la documentation sur la méthode Dispose(Boolean).

  • La Dispose() surcharge de méthode doit être appelée pour supprimer le ChangeMonitor instance. Les règles d’appel de Dispose sont les suivantes :

    • Avant qu’un élément ne soit inséré dans le cache, il incombe à l’appelant de supprimer un ChangeMonitor instance.

    • Une fois que l’élément de cache et les ChangeMonitor instances qui lui sont associées sont passés à un cache, l’implémenteur de cache doit s’assurer que la Dispose méthode est appelée, même si l’insertion échoue.

    • Une fois qu’un élément et ses instances associées ChangeMonitor sont passées à un cache, l’appelant ne doit pas supprimer la dépendance, car lorsque la Dispose méthode est appelée, l’appel est traité comme si la dépendance avait changé. Par conséquent, la OnChanged(Object) méthode est appelée automatiquement.

  • Compte tenu de ces règles, la Dispose méthode doit être appelée de l’une des manières suivantes :

    • Les utilisateurs doivent appeler la surcharge de Dispose() méthode s’ils décident de ne pas insérer le instance de moniteur de modification dérivé dans un cache.

    • Si l’implémentation tente d’insérer l’instance du moniteur de modification dans un cache d’objets, mais que l’insertion échoue, l’implémentation du cache est responsable de l’appel de la Dispose() surcharge. Lorsque la tentative d’insertion provoque une exception, l’implémentation du cache doit supprimer toutes les dépendances associées.

    • Si l’entrée de cache est supprimée, l’implémentation du cache doit également supprimer la dépendance.

    • L’implémentation interne de la OnChanged(Object) méthode appelle automatiquement la Dispose méthode après qu’elle a appelé un rappel inscrit via NotifyOnChanged(OnChangedCallback).

Remarque : Cet appel automatique à la méthode de suppression pendant le déclenchement de l’événement se produit uniquement si l’initialisation de l’instance ChangeMonitor a été effectuée précédemment.

Lorsque le constructeur d’un moniteur de modifications dérivé appelle la InitializationComplete() méthode, si l’état du moniteur de modification a déjà changé (autrement dit, l’état surveillé a déjà changé lorsque le constructeur était toujours actif), la InitializationComplete() méthode supprime automatiquement le moniteur de modification.

Constructeurs

ChangeMonitor()

Initialise une nouvelle instance de la classe ChangeMonitor. Ce constructeur est appelé par les constructeurs de classes dérivées pour initialiser la classe de base.

Propriétés

HasChanged

Obtient une valeur qui indique que l'état surveillé par la classe ChangeMonitor a changé.
IsDisposed

Obtient une valeur qui indique que l'instance dérivée d'une classe ChangeMonitor est supprimée.
UniqueId

Obtient une valeur qui représente l'instance de la classe ChangeMonitor.

Méthodes

Dispose()

Libère toutes les ressources qui sont utilisées par l'instance actuelle de la classe ChangeMonitor.
Dispose(Boolean)

Libère toutes les ressources managées et non managées, ainsi que les références à l'instance ChangeMonitor. Cette surcharge doit être implémentée par des classes de surveillance des modifications dérivées.
Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.

(Hérité de Object)
GetHashCode()

Fait office de fonction de hachage par défaut.

(Hérité de Object)
GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
InitializationComplete()

Appelé par le constructeur des classes dérivées pour indiquer que l'initialisation est terminée.
MemberwiseClone()

Crée une copie superficielle du Object actuel.

(Hérité de Object)
NotifyOnChanged(OnChangedCallback)

Appelée par les implémenteurs de cache pour inscrire un rappel et notifier une instance de ObjectCache via le délégué OnChangedCallback lorsqu'une dépendance a été modifiée.
OnChanged(Object)

Appelé par les classes dérivées pour déclencher l'événement lorsqu'une dépendance a été modifiée.
ToString()

Retourne une chaîne qui représente l'objet actuel.

(Hérité de Object)

S’applique à

Cohérence de thread

Ce type est thread-safe.

Voir aussi