NCache.DistributedLock 5.3.800

NCache.DistributedLock

An NCache implementation of the DistributedLock API, providing distributed locking, semaphore, and reader-writer lock primitives backed by an NCache cluster. This package plugs into the DistributedLock.Core abstractions (IDistributedLock, IDistributedSemaphore, IDistributedReaderWriterLock), so it can be used as a drop-in synchronization provider anywhere those interfaces are expected — with lock keys auto-expired in NCache as a safety net against processes that crash while holding a lock.

Installation

Install-Package NCache.DistributedLock

or, using the .NET CLI:

dotnet add package NCache.DistributedLock

Prerequisites

• Targets .NET Framework 4.6.2 and .NET 6.0 (or later).
• An NCache 5.3.800 (or later) server should be up and running, with the target cache already created/registered on it.

Getting Started

Setting up NCache

Starting with NCache SDK 5.3.800, the application names only the cache; the server it connects to is read from the application's own configuration file, with one entry per cache name.

.NET (appsettings.json):

{
  "ncache": {
    "YourCacheName": {
      "server": "10.0.0.1",
      "port": 9800
    }
  }
}

.NET Framework (App.config / Web.config):

<configuration>
  <configSections>
    <section name="ncache" type="Alachisoft.NCache.Client.NCacheSection, Alachisoft.NCache.Client" />
  </configSections>
  <ncache>
    <caches>
      <add name="YourCacheName" server="10.0.0.1" port="9800" />
    </caches>
  </ncache>
</configuration>

Replace YourCacheName with the name of your cache and 10.0.0.1 with the IP/hostname of a node hosting it. Multiple servers can be listed as a comma-separated value (for example "10.0.0.1,10.0.0.2").

Note

The ncache section is validated strictly: an unknown setting or an invalid port is reported as a configuration error naming the cache and the setting. Use the setting names shown above (server, port, ...), not names such as CacheName or ServerList.

Setting up Package

1. Connect to your NCache cache and create a synchronization provider:

   using Alachisoft.NCache.Client;
   using NCache.DistributedLock.Providers;
   
   ICache cache = CacheManager.GetCache("YourCacheName");
   
   var provider = new NCacheDistributedSynchronizationProvider(cache);
   

   NCacheDistributedSynchronizationProvider implements IDistributedLockProvider, IDistributedSemaphoreProvider, and IDistributedReaderWriterLockProvider, so it can create any of the three primitives below.

   Lock keys expire in NCache after 15 seconds by default (the safety net for crashed processes). To use a different expiration, pass it to the provider:

   var provider = new NCacheDistributedSynchronizationProvider(cache, expirationTime: TimeSpan.FromSeconds(30));
   

2. Distributed Lock — mutual-exclusion lock backed by an NCache key:

   var distributedLock = provider.CreateLock("my-resource-name");
   // or directly: new NCacheDistributedLock("my-resource-name", cache, TimeSpan.FromSeconds(15));
   
   using (var handle = distributedLock.Acquire(TimeSpan.FromSeconds(30)))
   {
       // critical section
   }
   // lock is released when the handle is disposed
   

3. Distributed Semaphore — bounded-count lock allowing up to N concurrent holders, with automatic cleanup of acquisitions left behind by crashed processes:

   var semaphore = provider.CreateSemaphore("my-resource-name", maxCount: 3);
   // or directly: new NCacheDistributedSemaphore("my-resource-name", 3, cache, TimeSpan.FromSeconds(15));
   
   using (var handle = semaphore.Acquire(TimeSpan.FromSeconds(30)))
   {
       // up to 3 concurrent holders allowed
   }
   

4. Distributed Reader-Writer Lock — multiple concurrent readers or a single exclusive writer, with writers waiting for active readers to release before acquiring:

   var rwLock = provider.CreateReaderWriterLock("my-resource-name");
   // or directly: new NCacheDistributedReaderWriterLock("my-resource-name", cache, TimeSpan.FromSeconds(15));
   
   using (var readHandle = rwLock.AcquireReadLock(TimeSpan.FromSeconds(30)))
   {
       // shared read access
   }
   
   using (var writeHandle = rwLock.AcquireWriteLock(TimeSpan.FromSeconds(30)))
   {
       // exclusive write access
   }
   

   The TryAcquire... variants return null instead of throwing when the lock cannot be acquired within the timeout.

Resources

• NCache Integration Docs
• Client SDK Docs
• Programmer's Guide
• DistributedLock GitHub

Technical Support

Alachisoft provides various technical support resources.

Visit the Alachisoft Support Center to select a support resource appropriate for your issue.

To request additional features or report a documentation discrepancy, contact support@alachisoft.com.

License

Copyright © 2026 Alachisoft. All rights reserved.