Partager via

ChangeMonitor Classe

Définition

Espace de noms:
System.Runtime.Caching
Assembly:
System.Runtime.Caching.dll
Paquet:
System.Runtime.Caching v11.0.0-preview.3.26207.106
Source:
ChangeMonitor.cs
Source:
ChangeMonitor.cs
Source:
ChangeMonitor.cs
Source:
ChangeMonitor.cs

Fournit une classe de base pour un type personnalisé dérivé qui surveille les modifications apportées à 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. Une ChangeMonitor instance surveille les modifications apportées à l’état des données dont dépend un élément de cache. Par exemple, l’élément peut être une entité de fichier ou de données dont le contenu est mis en cache. Si l’entité de fichier ou de données est mise à jour, l’entrée de cache associée doit également être modifiée. Les éléments courants qui peuvent être surveillés incluent des entités de données (telles que des champs de base de données, des valeurs, des lignes ou des tables), une autre entrée de cache et des fichiers et des 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, une fois qu’une 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 des 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 alerte le cache qui a été modifié.

L’infrastructure .NET inclut les classes suivantes qui dérivent de 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 la UniqueId surveillance et appeler InitializationComplete() la méthode avant que la méthode ne retourne. Si un constructeur rencontre une erreur pendant les constructions et doit avoir à supprimer des ressources, le constructeur ne peut appeler la Dispose surcharge qu’après l’appel de la méthode, car la InitializationComplete()Dispose surcharge lève une InvalidOperationException exception si l’initialisation n’est pas terminée.

  • Si des modifications se produisent dans les données surveillées avant l’initialisation terminée, 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 terminé 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 exige 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, l’instance OnChangedCallback est appelée immédiatement quand NotifyOnChanged(OnChangedCallback) elle est appelée. Sinon, l’instance OnChangedCallback n’est appelée qu’une seule fois. Cet appel unique se produit soit lorsque la OnChanged(Object) méthode est appelée, car l’instance ChangeMonitor a détecté une modification, soit lorsque la Dispose() méthode est appelée sur le ChangeMonitor, selon ce qui se produit en premier.

  • L’instance OnChangedCallback fournie par une ObjectCache implémentation doit supprimer l’entrée de cache associée et spécifier une raison à l’aide de l’énumération DependencyChanged .

  • Une ChangeMonitor instance peut appeler la OnChanged(Object) méthode avant qu’une implémentation de cache n’ait appelé NotifyOnChanged(OnChangedCallback) 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 rappel à passer NotifyOnChanged(OnChangedCallback) immédiatement quand il 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 modification doit implémenter la Dispose(Boolean) méthode. Pour plus d’informations, consultez la documentation de la Dispose(Boolean) méthode.

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

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

    • Une fois l’élément de cache et les ChangeMonitor instances associées à celui-ci passées à 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 a changé. Par conséquent, la OnChanged(Object) méthode est appelée automatiquement.

  • En tenant compte 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 méthode Dispose() s’ils décident de ne pas insérer l’instance de moniteur de modification dérivée dans un cache.

    • Si l’implémentation tente d’insérer l’instance de moniteur de modification dans un cache d’objets, mais que l’insertion échoue, l’implémentation du cache est chargée d’appeler 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 du 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 appelle 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.

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

Constructeurs

Nom Description
ChangeMonitor()

Initialise une nouvelle instance de la classe ChangeMonitor. Ce constructeur est appelé à partir de constructeurs dans des classes dérivées pour initialiser la classe de base.

Propriétés

Nom Description
HasChanged

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

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

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

Méthodes

Nom Description
Dispose()

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

Libère toutes les ressources managées et non managées et toutes les références à l’instance ChangeMonitor . Cette surcharge doit être implémentée par les classes de moniteur de modification dérivées.
Equals(Object)

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

(Hérité de Object)
GetHashCode()

Sert de fonction de hachage par défaut.

(Hérité de Object)
GetType()

Obtient la Type de l’instance actuelle.

(Hérité de Object)
InitializationComplete()

Appelé à partir du constructeur de classes dérivées pour indiquer que l’initialisation est terminée.
MemberwiseClone()

Crée une copie superficielle du Objectactuel.

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

Appelé par les implémenteurs de cache pour inscrire un rappel et notifier une ObjectCache instance par le biais du OnChangedCallback délégué lorsqu’une dépendance a changé.
OnChanged(Object)

Appelée par des classes dérivées pour déclencher l’événement lorsqu’une dépendance change.
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