In Coherence for .NET, the Near Cache is an INamedCache implementation that wraps the front cache and the back cache using a read-through/write-through approach. If the back cache implements the IObservableCache interface, then the Near Cache can use either the Listen None, Listen Present, Listen All, or Listen Auto strategy to invalidate any front cache entries that might have been changed in the back cache
For more information on Near Cache, the Listen* invalidation strategies, and the read-through/write-through approach, see "Near Cache" in "Getting Started with Oracle Coherence".
The Tangosol.Net.Cache.NearCache class enables you to programatically instantiate and configure .NET Near Cache functionality. However, it is recommended that you use a cache configuration descriptor to configure the NearCache.
A typical Near Cache is configured to use a local cache (thread safe, highly concurrent, size-limited and/or auto-expiring local cache) as the front cache and a remote cache as a back cache. A Near Cache is configured by using the near-scheme element which has two child elements: front-scheme for configuring a local (front) cache and back-scheme for defining a remote (back) cache.
A Near Cache is configured by using the <near-scheme> element in the coherence-cache-config file. This element has two required subelements: front-scheme for configuring a local (front-tier) cache and a back-scheme for defining a remote (back-tier) cache. While a local cache (<local-scheme>) is a typical choice for the front-tier, you can also use non-JVM heap based caches, (<external-scheme> or <paged-external-scheme>) or schemes based on Java objects (<class-scheme>).
The remote or back-tier cache is described by the <back-scheme> element. A back-tier cache can be either a distributed cache (<distributed-scheme>) or a remote cache (<remote-cache-scheme>). The <remote-cache-scheme> element enables you to use a clustered cache from outside the current cluster.
Optional subelements of <near-scheme> include <invalidation-strategy> for specifying how the front-tier and back-tier objects will be kept synchronized and <listener> for specifying a listener which will be notified of events occurring on the cache.
For an example configuration, see "Sample Near Cache Configuration". The elements in the file are described in the <near-scheme> section.
A reference to a configured Near Cache can then be obtained by name by using the CacheFactory class:
Instances of all INamedCache implementations, including NearCache, should be explicitly released by calling the INamedCache.Release() method when they are no longer needed, to free up any resources they might hold.
If the particular INamedCache is used for the duration of the application, then the resources will be cleaned up when the application is shut down or otherwise stops. However, if it is only used for a period, the application should call its Release() method when finished using it.
Alternatively, you can leverage the fact that INamedCache extends IDisposable and that all cache implementations delegate a call to IDisposable.Dispose() to INamedCache.Release(). This means that if you need to obtain and release a cache instance within a single method, you can do so with a using block:
Example 17-2 Obtaining and Releasing a Reference to a Near Cache
using (INamedCache cache = CacheFactory.GetCache("my-cache"))
{
// use cache as usual
}
After the using block terminates, IDisposable.Dispose() will be call on the INamedCache instance, and all resources associated with it will be released.