• 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

Configuring Read-Through Provider

To use Read-through caching, you need to implement the IReadThruProvider interface provided by NCache. NCache framework will use this custom implementation to read data from the back-end data source. Please refer to Configuring Read-through in Administrators' Guide for more details.

Note that if a read-through provider is specified in client.ncconf in the default-readthru-provider tag, and has also been specified through API, the provider in API will overwrite the one specified in client.ncconf.

IReadThruProvider Interface

Method Description
Init This method will be called by NCache on cache startup. User can use this method for performing tasks like allocating resources, acquiring connections of data source etc. This method takes as input the HashMap instance of arguments passed to the provider through the NCache Manager (configuration settings). It allows you to pass a list of parameters to the provider. These parameters can be utilized in many ways. For example, the connection string of a data source can be specified as a parameter. Thus, it provides a flexible way to change the data source settings while configuring it without code changes. The other argument CacheId specifies the cache name for which read-through is configured.
LoadFromSource This method will be called by NCache if the required item is not found in cache store and NCache has to load it through configured data source. This method should contain logic to load an object from the configured data source. First argument "key" refers to the key of the required item. The second argument is an out parameter of type ProviderCacheItem which needs to be instantiated along with the required properties. Here you can associate various properties to loaded item before returning it back to NCache framework. Make sure that ProviderCacheItemValue assigned in this method is "Serializable" because NCache will later save that item to cache store to fulfill future requests. While implementing this method, you should take care of code thread safety as multiple Get requests can access this method for read-through. Also do care to avoid scenarios that cause recursive infinite loops e.g. in this method a Get request with read-through on the same cache handle will cause infinite recursion. In case of get, loadFromSource(string key, out ProviderCacheItemcacheItem) will be called from provider while for getBulk, loadFromSource(string[] keys) will be called to load items from data source.
Dispose This method will be called by the NCache framework when the cache stops. You can use this method for performing tasks like releasing resources, disposing connections etc. Here you can free the resources related to the data source for effective resource utilization.
Note

In NCache, read-through providers are configured on cache level, i.e. for clustered caches all nodes will contain provider configurations and their deployed assemblies.

Sample Implementation of IReadThruProvider

To implement IReadThruProvider, include the following namespace in your application: Alachisoft.NCache.Runtime.DatasourceProviders.


public class SampleReadThruProvider : IReadThruProvider
{
    private SqlConnection _connection;
    //Perform tasks like allocating resources or acquiring connections

    public void Init(IDictionary parameters, string cacheId)
    {
        object server = parameters["server"];
        object userId = parameters["username"];
        object password = parameters["password"];
        object database = parameters["database"];
        string connString = GetConnectionString(server.ToString(), database.ToString(), userId.ToString(), password.ToString());
        if (connString != "")
            _connection = new SqlConnection(connString);
        try
        {
            _connection.Open();
        }
        catch (Exception ex)
        {
            //handle exception
        }
    }

    //Responsible for loading an item from the external data source.
    public void LoadFromSource(string key, out ProviderCacheItem cacheItem)
    {
        //where LoadFromDataSource is the dummy method to load data from data source.
        object value = LoadFromDataSource(key);

        cacheItem = new ProviderCacheItem(value);
        cacheItem.ResyncItemOnExpiration = true;
    }

    //Perform tasks associated with freeing, releasing, or resetting resources.
    public void Dispose()
    {
        if (_connection != null)
            _connection.Close();
    }

    //Responsible for loading bulk of items from the external data source.
    public Dictionary<string, ProviderCacheItem> LoadFromSource(string[] keys)
    {
        Dictionary<string, ProviderCacheItem> dictionary = new Dictionary<string, ProviderCacheItem>();
        try
        {
            string key = null;
            for (int index = 0; index < keys.Length; index++)
            {
                key = keys[index];

                //where LoadFromDataSource is the dummy method to load data from data source.
                dictionary.Add(key, new ProviderCacheItem(LoadFromDataSource(key)));
            }
            return dictionary;
        }
        catch (Exception exp)
        {
            //handle exception
        }

        return dictionary;
    }
    private object LoadFromDataSource(string key)
    {
        object retrievedObject = null;
        // load item from your data source and populate retrieved Object
        return retrievedObject;
    }

    private string GetConnectionString (string server, string database, string userName, string password)
    {
        string connectionString = null;
        try
        {
            if (!string.IsNullOrEmpty(server))
                connectionString = "Server=" + server + ";";
            else
                //Server name is empty

            if (!string.IsNullOrEmpty(database))
                connectionString = connectionString + "Database=" + database + ";";
            else
                //Database is empty;

            if (!string.IsNullOrEmpty(userName))
                connectionString = connectionString + "User ID=" + userName + ";";
            else
                connectionString = connectionString+ "User ID=" + "" + ";";

            if (!string.IsNullOrEmpty(password))
                connectionString = connectionString + "Password=" + password + ";";
            else
                connectionString = connectionString + "Password=" + "" + ";";
        }
        catch (Exception exp)
        {
            // handle exception
        }
        return connectionString;
    }
}
Back to top Copyright © 2017 Alachisoft