• Webinars
  • Docs
  • Download
  • Blogs
  • Contact Us
Show / Hide Table of Contents
  • Programmer's Guide
  • Client Side API Programming
    • Setting Up Development Environment
    • Basic Cache Operations
      • Initialize Cache
      • Add Data to Cache
      • Update Data in Cache
      • Fetch Data From Cache
      • Remove Data From Cache
      • Dispose Cache
    • Bulk Operations
      • Adding Collection to Cache
      • Updating Collection in Cache
      • Retrieving Collection from Cache
      • Removing Collection from Cache
      • Deleting Collection from Cache
    • Asynchronous Operations
      • Using Asynchronous Operations
      • Using Asynchronous Operations with Callback Methods
    • Groups and Subgroups
      • Adding/Updating Data Group in Cache
      • Retrieving Data Group from Cache
      • Removing Data Group from Cache
    • Tagging Data in NCache
      • Creating Tags
      • Adding Items with Tags
      • Retrieving Previously Tagged Data
      • Removing Tagged Items from Cache
    • Named Tags
    • Data Expiration Strategies
      • Using Absolute Expiration
      • Using Sliding Expiration
    • Cache Dependencies
      • Key Dependency
      • File Dependency
      • Notification based Dependencies
        • Database Dependency using SQL Server
        • Database Dependency using Oracle
      • Polling Based Dependency
      • Custom Data Source Dependency
      • Multiple Cache Sync Dependency
      • Aggregate Dependency
      • Add Dependency to Existing Item
      • Using CLR Procedures to Call NCache
    • Locking Data in NCache
      • Locking Items in Cache (Pessimistic Locking)
      • Locking Items with Cache Item Versioning (Optimistic Locking)
    • SQL Reference for NCache
      • SQL Syntax
      • Querying Samples for Operators
      • Querying Data in NCache
      • NCache Language Integrated Query (LINQ)
        • Using LINQ in NCache
        • Configuring LINQPad for NCache
        • Querying NCache Data in LINQPad
    • Event Notifications
      • Cache Level Event Notifications
      • Item Level Event Notifications
      • Custom Event Notifications
    • Publish/Subscribe (Pub/Sub) in NCache
      • Pub/Sub Topics
      • Managing Topics
      • Pub/Sub Messages
        • Message Behavior and Properties
        • Creating a Message
      • Publish Messages to Topic
      • Subscribe for Topic Messages
      • Monitoring Pub/Sub Topics
    • Continuous Query
    • Using Streams in NCache
      • Opening with Stream Modes
      • Adding and Updating Data with Streams
      • Retrieving Data from Streams
      • Closing a Stream
    • Security and Encryption
      • NCache Security
      • NCache Data Encryption
    • Data Compression
    • NCache Management API
  • Server Side API Programming
    • Cache Startup Loader
      • Components of Cache Startup Loader
      • Sample Implementation of ICacheLoader on Single Node
      • Sample Implementation of ICacheLoader with Distribution Hints
    • Data Source Providers (Backing Source)
      • Read-Through Caching
        • Configure Read-Through Provider
        • Using Read-Through with Cache Operations
      • Write-Through Caching
        • Configuring Write-Through Provider
        • Using Write-Through with Basic Operations
        • Using Write-Behind with Basic Operations
        • Using Write-Behind with Bulk Operations
        • Using Write-Behind with Async Operations
        • Monitor Write-Through Counters
    • Custom Dependency
      • Sample Implementation of Custom Dependency
      • Sample Usage of Custom Dependency
    • WAN Replication through Bridge
      • Bridge Configurations
      • Implementing Bridge Conflict Resolver
    • Entry Processor
      • Sample Implementation of IEntryProcessor Interface
      • Sample Usage of EntryProcessor
    • MapReduce
      • Sample Implementation of MapReduce Interfaces
      • Sample Usage of MapReduce
    • Aggregator
      • Sample Implementation of IValueExtractor Interface
      • Sample Implementation of IAggregator Interface
      • Sample Usage of Aggregator
    • Dynamic Compact Serialization
  • Client Side ASP.NET Features
    • ASP.NET
      • ASP.NET Session State Provider for NCache
      • Multi-Region ASP.NET Session State Provider for NCache
    • ASP.NET Core
      • Session Storage in ASP.NET Core
        • Configure NCache ASP.NET Core Session Provider
        • Configure ASP.NET Core Sessions with NCache IDistributedCache Provider
      • Multi-Region ASP.NET Core Session Provider for NCache
      • Object Caching in ASP.NET Core
    • ASP.NET SignalR
      • Using NCache Extension for SignalR
    • View State Caching
      • Configuring and Using Content Optimization
      • Group View State with Sessions
      • Limit View State Caching
      • Perform Page Level Grouping for View State
    • ASP.NET Output Cache
      • Configure ASP.NET Output Caching
      • Using ASP.NET Output Cache with Custom Hooks
  • Client Side Third Party Integrations
    • Migrating AppFabric to NCache
      • AppFabric API vs. NCache API
    • NHibernate
      • NCache as NHibernate Second Level Cache
      • Using NHibernate Query Caching
      • Configuring Database Synchronization with NHibernate
    • Entity Framework Caching Integration
      • NCache as Entity Framework Second Level Cache
      • Entity Framework Caching Config File
    • Entity Framework Core Caching
      • Installing NCache Entity Framework Core Provider
      • Configuring NCache Entity Framework Core Provider
      • Using NCache Entity Framework Core Provider
        • Caching Options for EF Core Provider
        • LINQ APIs for EF Core Provider
        • Cache Only APIs for EF Core Provider
        • Query Deferred APIs for EF Core Provider
      • Logging in NCache Entity Framework Core Provider
    • Memcached
      • NCache Memcached Gateway Approach
      • Memcached Client Plugin for .NET
    • Debug NCache Providers in Visual Studio
    • NCache for Visual Studio Extension

Data Expiration Strategies

NCache supports time-based data invalidation where you can specify the time or interval to expire your cache data. This type of data invalidation is used if changes to the data occur in a deterministic time fashion or where you can determine the frequency of data change. For example, customer information or region information may not be frequently updated, so you can use a time based expiration to invalidate such data.

You will specify this time/interval with the items of cache data. NCache maintains an index for items with time based expiration. A dedicated thread checks cache data for these expired items periodically after a configurable interval of time called Clean Interval. By default, its value is 15 seconds, which means that the maximum time an item can take to be removed from the cache is (expiration time + clean interval). So you should select this interval carefully according to the expiration time of your data.

Absolute Expiration

You can add an item to the cache with absolute expiration by specifying the exact date and time at which the item should be invalidated. When this time is elapsed, the item will be removed from the cache. Here, NCache maintains UTC time for absolute expiration on the caching servers which facilitates the case where clients and cache servers are in different time zones. This means that expiration time specified by clients (in any time zone) will be converted to UTC on the cache server and the item will be expired on the exact date and time as specified by clients. You can specify the expiration time ranging from seconds to days and months.

However, note that the item will be removed when expired on the next cache clean up interval. For example, if you specify an expiration of 10 seconds with an item and cache clean up interval is configured to 15 seconds, then item will be removed within the time frame of 15-25 seconds.

Sliding Expiration

In Sliding expiration, you want the cache to retain the data as long as it is being used by the application and throw away any data that has not been used for a specific period of time. For example, JSP session data can be stored in the cache as long as the session is active. For this type of data, you can specify sliding expiration ranging from seconds to days and months.

Whenever a cache data with sliding expiration is accessed, its time to live in cache is extended by the expiration interval specified, e.g. an item with 30 seconds sliding expiration will be removed from the cache if not accessed for at least 30 seconds. However, with each get, the item's expiration interval will be reset to 30 seconds, extending its life in the cache by 30 seconds.

Similar to absolute expiration, cache items with sliding expiration are removed on cache cleanup interval.

Note

The Client Cache will utilize the same expiration enabled on the clustered cache. It does not have its own independent expiration policy.

If no expiration is provided with cache item, it will reside in the cache till explicit removal. This can lead to cache storage overwhelming. Also please refer to Eviction Policies which is another feature of NCache to control cache storage usage.

Default Expirations

NCache has introduced a new set of default expirations that can aid you in setting your data invalidation strategies with more flexibility. All of the default expirations have a minimum value of 5 seconds.

  • Default
  • Default Longer

It is up to you whether you want to incorporate expiration into your cache or not. By default, expiration is disabled.

Important

To enable expiration, it is mandatory that you enable it through NCache Manager. If you pass the API for default expiration and it is not configured through Manager, it will not work.

However, there are rules you must remember while setting the expiration either through API or through configuration:

If you enable expiration, you must configure one the following default expirations:

  1. Default Absolute
  2. Default Sliding
  3. Default Absolute Longer
  4. Default Sliding Longer

There are multiple scenarios where configuration of expiration policy through the NCache Manager and API will overlap, which will trigger the following behaviors:

  • If Expiration is enabled, but default expiration is not passed from the API, Absolute Default will be used.

  • If a certain default Expiration mode is enabled, the same default must be passed through the API as well, otherwise expiration will not work.

For example, when an API call receives Sliding Longer expiration:

  • If Default Sliding Longer is configured, it will be used as default.

  • If Default Sliding Longer is not configured, no expiration will take place.

  • If Expiration is enabled and the time value is passed through the API call, the value passed through API will be used. If no value is passed, the value configured in NCache Manager is used.

  • If Expiration is enabled and both policies (Sliding and Absolute) are passed through the API, an exception will be thrown.

  • If Expiration is disabled, an API call with any of the defaults will be ignored and items will be inserted without expiration. However, if you pass the expiration with time value from API (non-default expiration), then it will take place regardless of the configuration.

Note

Make sure to apply configuration after enabling expiration using NCache Manager as guided in Configuring Data Expirations in Administrators' Guide.

In This Section

Sliding Expiration
Explains how to perform operations using Sliding Expiration.

Absolute Expiration
Explains how to perform operations using Absolute Expiration.

Back to top Copyright © 2017 Alachisoft