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.