Provides a base class for a derived custom type that monitors changes in the state of the data which a cache item depends on.
Assembly: System.Runtime.Caching (in System.Runtime.Caching.dll)
Thetype exposes the following members.
|Dispose()||Releases all resources that are used by the current instance of the class.|
|Dispose(Boolean)||Releases all managed and unmanaged resources and any references to the instance. This overload must be implemented by derived change-monitor classes.|
|Equals(Object)||Determines whether the specified object is equal to the current object. (Inherited from Object.)|
|Finalize||Allows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection. (Inherited from Object.)|
|GetHashCode||Serves as the default hash function. (Inherited from Object.)|
|GetType||Gets the Type of the current instance. (Inherited from Object.)|
|InitializationComplete||Called from the constructor of derived classes to indicate that initialization is finished.|
|MemberwiseClone||Creates a shallow copy of the current Object. (Inherited from Object.)|
|NotifyOnChanged||Called by Cache implementers to register a callback and notify an ObjectCache instance through the OnChangedCallback delegate when a dependency has changed.|
|OnChanged||Called by derived classes to raise the event when a dependency changes.|
|ToString||Returns a string that represents the current object. (Inherited from Object.)|
The class is used as the base class for derived monitor classes that are specialized for particular cache implementations. A instance monitors changes in the state of data which a cache item depends on. For example, the item can be a file or data entity whose contents are cached. If the file or data entity is updated, the associated cache entry must be changed also. 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.
A dependency change is a change in the state of a dependency. In a typical cache implementation, after a instance notifies the cache that a dependency has changed, the cache performs the required action, such as invalidating the inserted cache entry.
Derived classes can be customized to monitor dependency changes for specific different data stores. For example, there are cache implementations for a file system, physical memory, or a database. The class examines changes that occur outside the cache, and then alerts the cache that changes have occurred.
The .NET Framework includes the following classes that derive from class:
Each of these classes works with different types of dependencies. For example, the derived FileChangeMonitor class monitors changes to a cache for file system data (files and folders) that the cache item depends on.Notes to Inheritors
If you create a custom cache implementation or a derived change monitor type, you must follow certain guidelines. The following list summarizes these guidelines. For more information, see the documentation for individual methods or properties.
The constructor of a derived class must set the UniqueId property, begin monitoring, and call InitializationComplete method before the method returns. 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.
After a instance is inserted into a ObjectCache implementation, the ObjectCache instance require that the change monitor is disposed. Even if the insertion is invalid and causes an exception, the ObjectCache implementation must call the Dispose overload.
After a derived change monitor is inserted into a cache, the ObjectCache implementation must call NotifyOnChanged, by passing a OnChangedCallback object. The NotifyOnChanged method can be called only one time. If a dependency change has already occurred, the OnChangedCallback instance will be called immediately when NotifyOnChanged is called. Otherwise, the OnChangedCallback instance will be called only one time. This one time call occurs either when the OnChanged method is called because the instance detected a change, or when the Dispose method is called on the , whichever occurs first.
A instance can call the OnChanged method either before a cache implementation has called NotifyOnChanged method or after. If the OnChanged method is called before NotifyOnChanged is called, the base implementation will notify the cache that this has occurred and will trigger the callback to be passed to NotifyOnChanged immediately when NotifyOnChanged is invoked. Any state data that is passed to the OnChanged method is saved by the change monitor and subsequently passed to the NotifyOnChanged method when the NotifyOnChanged method is invoked.
The Dispose method overload must be called to dispose of the instance. The rules for calling Dispose are as follows:
Before an item is inserted into the cache, it is the responsibility of caller to dispose of a instance.
Once cache item and the instances that are associated with it are passed to a cache, the cache implementer must make sure that that the Dispose method is called, even if the insert fails.
After an item and its associated 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. As a result, the OnChanged method is automatically invoked.
Taking these rules into consideration, the Dispose method must be called in one of the following ways:
Users must call the Dispose method overload if they decide not to insert the derived change-monitor instance into a cache.
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. When the insertion attempt causes an exception, the cache implementation must dispose of any associated dependencies.
If the cache entry is removed, the cache implementation must also dispose of the dependency.
This automatic call to the dispose method during the event firing only occurs if the initialization of the instance was previously completed.
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.