ChangeMonitor Classe

Definizione

Fornisce una classe base per un tipo personalizzato derivato che monitora le modifiche dello stato dei dati da cui dipende un elemento della cache.Provides a base class for a derived custom type that monitors changes in the state of the data which a cache item depends on.

public ref class ChangeMonitor abstract : IDisposable
public abstract class ChangeMonitor : IDisposable
type ChangeMonitor = class
    interface IDisposable
Public MustInherit Class ChangeMonitor
Implements IDisposable
Ereditarietà
ChangeMonitor
Derivato
Implementazioni

Commenti

La ChangeMonitor classe viene utilizzata come classe di base per le classi di monitoraggio derivate specializzate per specifiche implementazioni della cache.The ChangeMonitor class is used as the base class for derived monitor classes that are specialized for particular cache implementations. Un' ChangeMonitor istanza di monitora le modifiche dello stato dei dati da cui dipende un elemento della cache.A ChangeMonitor instance monitors changes in the state of data which a cache item depends on. Ad esempio, l'elemento può essere un file o un'entità dati il cui contenuto viene memorizzato nella cache.For example, the item can be a file or data entity whose contents are cached. Se il file o l'entità di dati viene aggiornata, è necessario modificare anche la voce della cache associata.If the file or data entity is updated, the associated cache entry must be changed also. Gli elementi comuni che è possibile monitorare includono le entità di dati, ad esempio campi di database, valori, righe o tabelle, un'altra voce della cache e file e attributi di file.Common items that can be monitored include data entities (such as database fields, values, rows, or tables), another cache entry, and files and file attributes.

Una modifica di dipendenza è una modifica dello stato di una dipendenza.A dependency change is a change in the state of a dependency. In una tipica implementazione della cache, dopo ChangeMonitor che un'istanza di Invia una notifica alla cache che una dipendenza è stata modificata, la cache esegue l'azione richiesta, ad esempio invalidando la voce della cache inserita.In a typical cache implementation, after a ChangeMonitor instance notifies the cache that a dependency has changed, the cache performs the required action, such as invalidating the inserted cache entry.

È ChangeMonitor possibile personalizzare le classi derivate per monitorare le modifiche delle dipendenze per archivi dati diversi.Derived ChangeMonitor classes can be customized to monitor dependency changes for specific different data stores. Sono ad esempio disponibili implementazioni della cache per un file system, una memoria fisica o un database.For example, there are cache implementations for a file system, physical memory, or a database. La ChangeMonitor classe esamina le modifiche che si verificano all'esterno della cache, quindi avvisa la cache che si sono verificate le modifiche.The ChangeMonitor class examines changes that occur outside the cache, and then alerts the cache that changes have occurred.

Include le classi seguenti che derivano dalla ChangeMonitor classe: .NET Framework.NET FrameworkThe .NET Framework.NET Framework includes the following classes that derive from ChangeMonitor class:

Ognuna di queste classi funziona con tipi diversi di dipendenze.Each of these classes works with different types of dependencies. Ad esempio, la classe FileChangeMonitor derivata monitora le modifiche apportate a una cache per file System dati (file e cartelle) da cui dipende l'elemento della cache.For example, the derived FileChangeMonitor class monitors changes to a cache for file system data (files and folders) that the cache item depends on.

Note per gli implementatori

Se si crea un'implementazione della cache personalizzata o un tipo di monitoraggio delle modifiche derivato, è necessario attenersi a determinate linee guida.If you create a custom cache implementation or a derived change monitor type, you must follow certain guidelines. Nell'elenco seguente sono riepilogate queste linee guida.The following list summarizes these guidelines. Per ulteriori informazioni, vedere la documentazione relativa a singoli metodi o proprietà.For more information, see the documentation for individual methods or properties.

-Il costruttore di una classe derivata deve impostare la UniqueId proprietà, iniziare il monitoraggio e chiamare InitializationComplete() il metodo prima che il metodo restituisca.- The constructor of a derived class must set the UniqueId property, begin monitoring, and call InitializationComplete() method before the method returns. Se un costruttore incontra un errore durante le costruzioni e deve eliminare le risorse, il Dispose costruttore può chiamare l'overload solo dopo la chiamata al InitializationComplete() metodo perché l' Dispose overload genera un' InvalidOperationException eccezione se l'inizializzazione non viene completata.If a constructor encounters an error during constructions and must have to dispose of resources, the constructor can only call the Dispose overload after the InitializationComplete() method is called because the Dispose overload will throw an InvalidOperationException exception if initialization is not completed.

-Se si verificano modifiche nei dati monitorati prima del completamento dell'inizializzazione, il costruttore deve chiamare OnChanged(Object) il metodo prima di InitializationComplete() chiamare il metodo.- If changes occur in the data that is being monitored before initialization is complete, the constructor must call the OnChanged(Object) method before calling the InitializationComplete() method.

-Dopo che è ChangeMonitor stata creata un'istanza di un tipo derivato, è necessario inserire il ObjectCache monitoraggio in un'implementazione personalizzata.- After a derived ChangeMonitor type is instantiated, you must insert the monitor into a custom ObjectCache implementation. In alternativa, se si è terminato di utilizzare il monitoraggio delle Dispose modifiche, chiamare il metodo.Or if you are finished using the change monitor, call the Dispose method.

-Dopo l' ChangeMonitor inserimento di un'istanza in ObjectCache un'implementazione di ObjectCache , l'istanza richiede che il monitoraggio delle modifiche venga eliminato.- After a ChangeMonitor instance is inserted into a ObjectCache implementation, the ObjectCache instance require that the change monitor is disposed. Anche se l'inserimento non è valido e genera un'eccezione, ObjectCache l'implementazione deve chiamare Dispose l'overload.Even if the insertion is invalid and causes an exception, the ObjectCache implementation must call the Dispose overload.

-Dopo l'inserimento di un monitoraggio delle modifiche derivato in una cache ObjectCache , l'implementazione NotifyOnChanged(OnChangedCallback)deve chiamare, passando OnChangedCallback un oggetto.- After a derived change monitor is inserted into a cache, the ObjectCache implementation must call NotifyOnChanged(OnChangedCallback), by passing a OnChangedCallback object. Il NotifyOnChanged(OnChangedCallback) metodo può essere chiamato solo una volta.The NotifyOnChanged(OnChangedCallback) method can be called only one time. Se si è già verificata una modifica di OnChangedCallback dipendenza, l'istanza verrà chiamata NotifyOnChanged(OnChangedCallback) immediatamente quando viene chiamato il metodo.If a dependency change has already occurred, the OnChangedCallback instance will be called immediately when NotifyOnChanged(OnChangedCallback) is called. In caso contrario OnChangedCallback , l'istanza verrà chiamata solo una volta.Otherwise, the OnChangedCallback instance will be called only one time. Questa chiamata una volta si verifica quando viene OnChanged(Object) chiamato il metodo perché l' ChangeMonitor istanza ha rilevato una modifica o quando il Dispose() metodo viene chiamato su ChangeMonitor, a seconda di quale si verifica per primo.This one time call occurs either when the OnChanged(Object) method is called because the ChangeMonitor instance detected a change, or when the Dispose() method is called on the ChangeMonitor, whichever occurs first.

-L' OnChangedCallback istanza fornita da un' ObjectCache implementazione deve rimuovere la voce della cache associata e specificare un motivo usando l' DependencyChanged enumerazione.- The OnChangedCallback instance that is provided by an ObjectCache implementation should remove the associated cache entry and specify a reason by using the DependencyChanged enumeration.

-Un' ChangeMonitor istanza può chiamare il OnChanged(Object) metodo prima che un'implementazione della cache abbia NotifyOnChanged(OnChangedCallback) chiamato il metodo o dopo.- A ChangeMonitor instance can call the OnChanged(Object) method either before a cache implementation has called NotifyOnChanged(OnChangedCallback) method or after. Se il OnChanged(Object) metodo viene chiamato prima NotifyOnChanged(OnChangedCallback) della chiamata a, l' ChangeMonitor implementazione di base invierà una notifica alla cache che si è verificata e attiverà il callback NotifyOnChanged(OnChangedCallback) da passare NotifyOnChanged(OnChangedCallback) immediatamente quando viene richiamato.If the OnChanged(Object) method is called before NotifyOnChanged(OnChangedCallback) is called, the base ChangeMonitor implementation will notify the cache that this has occurred and will trigger the callback to be passed to NotifyOnChanged(OnChangedCallback) immediately when NotifyOnChanged(OnChangedCallback) is invoked. Qualsiasi dato di stato passato al OnChanged(Object) metodo viene salvato dal monitoraggio delle modifiche e successivamente passato NotifyOnChanged(OnChangedCallback) al metodo quando viene richiamato il NotifyOnChanged(OnChangedCallback) metodo.Any state data that is passed to the OnChanged(Object) method is saved by the change monitor and subsequently passed to the NotifyOnChanged(OnChangedCallback) method when the NotifyOnChanged(OnChangedCallback) method is invoked.

-Un monitoraggio delle modifiche deve implementare Dispose(Boolean) il metodo.- A change monitor must implement the Dispose(Boolean) method. Per altre informazioni, vedere la documentazione del metodo Dispose(Boolean).For more information, see the Dispose(Boolean) method documentation.

-L' Dispose() overload del metodo deve essere chiamato per eliminare l' ChangeMonitor istanza.- The Dispose() method overload must be called to dispose of the ChangeMonitor instance. Le regole per la chiamata a Dispose sono le seguenti:The rules for calling Dispose are as follows: -Prima che un elemento venga inserito nella cache, è responsabilità del chiamante eliminare un' ChangeMonitor istanza.- Before an item is inserted into the cache, it is the responsibility of caller to dispose of a ChangeMonitor instance.

-Una volta che l'elemento ChangeMonitor della cache e le istanze associate vengono passati a una cache, l'implementatore della cache deve assicurarsi che venga Dispose chiamato il metodo, anche se l'inserimento ha esito negativo.- Once cache item and the ChangeMonitor instances that are associated with it are passed to a cache, the cache implementer must make sure that the Dispose method is called, even if the insert fails.

-Dopo che un elemento e le ChangeMonitor istanze associate vengono passati a una cache, il chiamante non deve eliminare la dipendenza perché quando Dispose viene chiamato il metodo, la chiamata viene considerata come se la dipendenza venisse modificata.- After an item and its associated ChangeMonitor instances are passed to a cache, the caller must not dispose the dependency because when the Dispose method is called, the call is treated as if the dependency has changed. Di conseguenza, il OnChanged(Object) metodo viene richiamato automaticamente.As a result, the OnChanged(Object) method is automatically invoked.

-Tenendo in considerazione queste regole, è Dispose necessario chiamare il metodo in uno dei modi seguenti:- Taking these rules into consideration, the Dispose method must be called in one of the following ways: -Gli utenti devono chiamare Dispose() l'overload del metodo se decidono di non inserire l'istanza di monitoraggio delle modifiche derivata in una cache.- Users must call the Dispose() method overload if they decide not to insert the derived change-monitor instance into a cache.

-Se l'implementazione tenta di inserire l'istanza di monitoraggio delle modifiche in una cache degli oggetti, ma l'inserimento ha esito negativo, l'implementazione Dispose() della cache è responsabile della chiamata dell'overload.- If the implementation tries to insert the change-monitor instance into an object cache but the insertion fails, the cache implementation is responsible for calling the Dispose() overload. Quando il tentativo di inserimento genera un'eccezione, l'implementazione della cache deve eliminare eventuali dipendenze associate.When the insertion attempt causes an exception, the cache implementation must dispose of any associated dependencies.

-Se la voce della cache viene rimossa, l'implementazione della cache deve eliminare anche la dipendenza.- If the cache entry is removed, the cache implementation must also dispose of the dependency.

-L'implementazione interna del OnChanged(Object) metodo chiama automaticamente il Dispose metodo dopo aver chiamato un callback registrato tramite NotifyOnChanged(OnChangedCallback).- The internal implementation of the OnChanged(Object) method automatically calls the Dispose method after it calls a callback that is registered through NotifyOnChanged(OnChangedCallback).


Questa chiamata automatica al metodo Dispose durante la generazione dell'evento si verifica solo se l'inizializzazione dell' ChangeMonitor istanza è stata completata in precedenza.This automatic call to the dispose method during the event firing only occurs if the initialization of the ChangeMonitor instance was previously completed.

Quando il costruttore di un monitoraggio delle modifiche derivato InitializationComplete() chiama il metodo, se lo stato del monitoraggio delle modifiche è già stato modificato (ovvero lo stato monitorato è già stato modificato quando il costruttore era ancora attivo) InitializationComplete() , il metodo verrà Elimina automaticamente il monitoraggio delle modifiche.When a derived change monitor's constructor calls the InitializationComplete() method, if the state of the change monitor has already changed (that is, the state that is monitored already changed when the constructor was still active) then the InitializationComplete() method will automatically dispose of the change monitor. -La HasChanged proprietà è impostata su true dopo che OnChanged(Object) il metodo viene chiamato dall'istanza di monitoraggio delle modifiche derivata, indipendentemente dal fatto OnChangedCallback che un oggetto sia stato impostato da una chiamata NotifyOnChanged(OnChangedCallback) al metodo.- The HasChanged property is set to true after the OnChanged(Object) method is called by the derived change-monitor instance, regardless of whether a OnChangedCallback object has been set by a call to the NotifyOnChanged(OnChangedCallback) method or not.

Costruttori

ChangeMonitor()

Inizializza una nuova istanza della classe ChangeMonitor.Initializes a new instance of the ChangeMonitor class. Questo costruttore viene chiamato da costruttori in classi derivate per inizializzare la classe base.This constructor is called from constructors in derived classes to initialize the base class.

Proprietà

HasChanged

Ottiene un valore che indica che lo stato monitorato dalla classe ChangeMonitor è stato modificato.Gets a value that indicates that the state that is monitored by the ChangeMonitor class has changed.

IsDisposed

Ottiene un valore che indica che viene eliminata un'istanza derivata di una classe ChangeMonitor.Gets a value that indicates that the derived instance of a ChangeMonitor class is disposed.

UniqueId

Ottiene un valore che rappresenta l'istanza della classe ChangeMonitor.Gets a value that represents the ChangeMonitor class instance.

Metodi

Dispose()

Rilascia tutte le risorse utilizzate dall'istanza corrente della classe ChangeMonitor.Releases all resources that are used by the current instance of the ChangeMonitor class.

Dispose(Boolean)

Rilascia tutte le risorse gestite e non gestite ed eventuali riferimenti all'istanza di ChangeMonitor.Releases all managed and unmanaged resources and any references to the ChangeMonitor instance. Questo overload deve essere implementato dalle classi derivate di monitoraggio delle modifiche.This overload must be implemented by derived change-monitor classes.

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Ereditato da Object)
GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Ereditato da Object)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
InitializationComplete()

Chiamato dal costruttore di classi derivate per indicare che l'inizializzazione è terminata.Called from the constructor of derived classes to indicate that initialization is finished.

MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
NotifyOnChanged(OnChangedCallback)

Chiamato dalle implementazioni della cache per registrare un callback e notificare a un'istanza ObjectCache tramite il delegato OnChangedCallback quando una dipendenza viene modificata.Called by Cache implementers to register a callback and notify an ObjectCache instance through the OnChangedCallback delegate when a dependency has changed.

OnChanged(Object)

Chiamato dalle classi derivate per generare l'evento quando viene modificata una dipendenza.Called by derived classes to raise the event when a dependency changes.

ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Ereditato da Object)

Si applica a

Thread safety

Questo tipo è thread-safe.This type is thread safe.

Vedi anche