ChangeMonitor.Dispose Méthode

Définition

Espace de noms:

System.Runtime.Caching

Assembly:

System.Runtime.Caching.dll

Paquet:

System.Runtime.Caching v8.0.0

Libère toutes les ressources utilisées par l'instance actuelle de la classe ChangeMonitor.

Surcharges

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.

Remarques

La Dispose méthode est utilisée pour libérer le ChangeMonitor instance et les ressources associées. La méthode publique Dispose est appelée pour coordonner le processus d’élimination avec les événements clés du cycle de vie des classes de surveillance des modifications dérivées (telles que l’initialisation) et pour libérer l’instance ChangeMonitor afin que le instance puisse être récupéré à la poubelle. La Dispose méthode est implémentée par des classes de surveillance des modifications dérivées pour supprimer leurs ressources managées et non managées.

Dispose()

Source:

ChangeMonitor.cs

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

public:
 virtual void Dispose();

public void Dispose ();

abstract member Dispose : unit -> unit
override this.Dispose : unit -> unit

Public Sub Dispose ()

Implémente

Dispose()

Exceptions

InvalidOperationException

L'initialisation n'est pas terminée dans la classe d'analyseur de modification dérivée qui a appelé la méthode Dispose() de base.

Remarques

La Dispose méthode appelle la Dispose méthode des classes dérivées une seule fois, la première fois qu’elle est appelée. Les appels suivants à la Dispose méthode n’ont aucun effet. Une fois la méthode appelée, la IsDisposed propriété est définie sur true.

La Dispose surcharge doit être appelée pour éliminer un ChangeMonitor instance. Voici les règles d’appel de la méthode dispose :

• Avant d’insérer un élément 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 qui doit s’assurer que est Dispose appelé, même si l’insertion échoue.

• Une fois qu’un élément et ses instances associées ChangeMonitor sont passés à 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 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.

  • L’implémentation du cache est responsable de l’appel de la Dispose surcharge si l’implémentation tente d’insérer le instance change-monitor dans un cache d’objets, mais que l’insertion échoue. 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 méthode appelle automatiquement la Dispose méthode après avoir appelé un rappel inscrit via la NotifyOnChanged méthode.

Notes

Cette suppression automatique pendant le déclenchement de l’événement se produit uniquement si l’initialisation du ChangeMonitor instance terminée précédemment.

Quand le constructeur d’un moniteur de modifications dérivé appelle la InitializationComplete méthode, si l’état du moniteur de modifications 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 l’analyse des modifications.

Notes

Les utilisateurs ne doivent pas appeler la Dispose méthode. Toutefois, vous ne pouvez pas empêcher les utilisateurs d’appeler la méthode. Par conséquent, si c’est le cas, la OnChanged méthode est appelée. Dans ce cas, l’entrée du cache est avertie comme si la dépendance avait changé.

Pour empêcher les classes dérivées de remplacer la Dispose méthode, la méthode n’est pas une implémentation d’interface explicite.

Voir aussi

• OnChanged(Object)

Dispose(Boolean)

Source:

ChangeMonitor.cs

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.

protected:
 abstract void Dispose(bool disposing);

protected abstract void Dispose (bool disposing);

abstract member Dispose : bool -> unit

Protected MustOverride Sub Dispose (disposing As Boolean)

Paramètres

disposing

Boolean

true pour libérer les ressources managées et non managées, ainsi que les références à une instance de ChangeMonitor ; false pour libérer uniquement les ressources non managées. Lorsque la valeur false est transmise, la méthode Dispose(Boolean) est appelée par un thread finalizer et les références managées externes ne sont probablement plus valides, car elles ont déjà été récupérées par le garbage collector.

Remarques

Lorsque la valeur de disposing la valeur est true, toutes les ressources managées et non managées sont supprimées et toutes les références à cet objet sont libérées afin que les instance de surveillance des modifications dérivées puissent être collectées. Il est garanti que la méthode de base Dispose n’appellera la méthode implémentée Dispose qu’une seule fois.

Notes pour les responsables de l’implémentation

Un moniteur de modifications doit implémenter la Dispose(Boolean) surcharge pour libérer toutes les ressources managées et non managées lorsque la valeur de disposing est true. La Dispose(Boolean) surcharge de méthode qui a une disposing valeur de true n’est appelée qu’une seule fois, c’est-à-dire lorsque le instance est supprimé pour la première fois. Un moniteur de modification ne doit pas appeler directement la Dispose(Boolean) surcharge. Un moniteur de modifications dérivé peut appeler la méthode sans paramètre Dispose() public sur la classe de base ChangeMonitor .

Un moniteur de modifications peut également implémenter une méthode finaliseur. Dans ce cas, le finaliseur peut appeler la Dispose(Boolean) méthode et lui passer la disposing valeur .false Toutefois, cela n’est généralement pas nécessaire. La surveillance des modifications de dépendance est généralement effectuée par un service qui conserve une référence au instance de surveillance des modifications. La référence empêche le instance d’être ramassé à la mémoire et rend donc une méthode finaliseur inutile. Pour éviter les fuites de mémoire, lorsqu’une dépendance change, la OnChanged(Object) méthode supprime le instance du moniteur de modification (sauf si l’initialisation n’est pas terminée).