• 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

NCache Management API

NCache Management API is a set of programmable method calls that enable the user to perform basic management operations on out-proc caches without using either NCache Manager or NCache tools. The Management API in some cases relies on the client configuration files to perform an operation, whereas in some cases it is self-sufficient to execute a request.

To utilize NCache Management APIs, include the following namespace in your application: Alachisoft.NCache.Web.Management.

Start Cache Using API calls

StartCache methods enable the user to start an OutProc cache on the specified server. In case of failure, ManagementException is thrown by the cache. In this example, the user need to specify cache and server name to start a node.

//precondition: Cache has been registered but not initialized.
string cacheName = "mycache";
string serverName = "...."; // specify the server where cache is registered
try
{
    CacheManager.StartCache(cacheName, serverName);
}
catch (ManagementException ex)
{
    //thrown if no cache exists or server name is invalid
}
Important

In case you have security enabled, please refer to the section Security Configuration of Administrator Guide to stop and start cache cluster.

Stop Cache Using API calls

StopCache method is used to stop a cache on a particular server. If no server is specified, the method would read information from client configuration file. If the method fails to stop the cache or fails to find information regarding the cache, ManagementException is thrown. If called from the client node, the first server listed in the client configuration file associated with the cache will be stopped.

This example stops cache on an already started node. Cache and server name to stop cache on given node need to be specified.

try
{
    CacheManager.StopCache(cacheName, serverName);
}
catch (ManagementException ex)
{
    // handle exception
}
Important

In case you have security enabled, please refer to the section Security Configuration of Administrator Guide to stop and start cache cluster.

Viewing Cache Status Using API calls

GetCacheHealth method enables the user to view the status of cache server nodes. This method call returns a CacheHealth object against every call.

try
{
    CacheHealth cacheHealth = CacheManager.GetCacheHealth(cacheName);
}
catch (ManagementException)
{
    // handle exception
}

Monitoring Clients Connected to Cache

NCache provides the feature of enabling Client Activity Events. Using these events, each client that is connected to a clustered cache can subscribe to be notified about the connect/disconnect events of other clients. Each client can also specify a process level custom identifier which will be returned to the subscriber in case the client which specified it connects to or disconnects from a clustered cache.

Client Activity Events are fired when a client connects to or disconnects from a specified cache. These events are registered against the specified cache and will be handled in a user defined callback method.

Note

Make sure that client events have been enabled through NCache Manager before proceeding to use them.

To utilize the APIs, include the following namespaces in your application: -Alachisoft.NCache.Web.dll -Alachisoft.NCache.Runtime.dll

Initialize Cache

The AppName is a process level unique identifier which can be assigned at the time of initialization. For this purpose, before initializing the cache client, create an instance of CacheInitParams and assign a custom identifier string to its AppName property.

Thus, if this client connects or disconnects, the callbacks of all the clients which subscribed to the Client will get this AppName in their ClientInfo instance.

string cacheName = "myPartitionedCache";

CacheInitParams initParams = new CacheInitParams();
initParams.AppName = "AssignedAppName"; //assign custom identifier

//initialize cache with custom AppName property
Cache cache = NCache.InitializeCache(cacheName, initParams);

Create Event Callback Method

The callback method is user defined and is called once the clients are connected/disconnected from the cache. The method is registered against the CacheClientConnectivityChanged event property of CacheClientConnectivityChangedCallback type in a specific cache. Hence, the method created should match the signature of the delegate:

public delegate void CacheClientConnectivityChangedCallback(string cacheId, ClientInfo client, ConnectivityStatus status);

The method created contains the following parameters:

//user defined event callback method
static void MyClientConnectivityCallback(string cacheName, ClientInfo clientInfo, ConnectivityStatus status)
{
    //handle event
}
Parameters Description
cacheName Name of the cache with which the clients are connected or disconnected. This acts as the sender of the event.
status Enum which determines the connectivity status of the client: Disconnected = 0 Connected =1
clientInfo An object of the ClientInfo class containing information regarding the client which caused the event to fire.

Client Info class

Member Description Default Value
AppName User assigned, process-level, unique identifier Client process ID
ClientID Unique client identifier -
IPAddress IP through which the client is connected -
MachineName Machine Name of the client -
ProcessID Process ID of the client -

Register Event

The method is registered by appending it to the CacheClientConnectivityChanged property as an event callback. This enables the client to listen for connect/disconnect events of other clients. If another client connects to or disconnects from the specified cache, the callback method is called.

//register method to event
cache.CacheClientConnectivityChanged += MyClientConnectivityCallback;

Monitor Client Info of Connected Clients

The ClientInfo of each connected client is available locally in the form of cache.ClientInfo property.

ClientInfo info = cache.ClientInfo;
string AppName = info.AppName;
string clientID = info.ClientID;
System.Net.IPAddress ip = info.IPAddress;
string machineName = info.MachineName;
int processID = info.ProcessID;

View List of Connected Clients

To get information of all the clients connected to the cache on demand, use the GetConnectedClientsList() method on the cache as:

IList<ClientInfo> connectedClients = cache.GetConnectedClientsList();
Back to top Copyright © 2017 Alachisoft