Memcached support for .NET source code

CAST supports Memcached via its com.castsoftware.nosqldotnet extension. Details about the support provided for .NET source code is discussed below.

Supported Client Libraries

Library	Supported
EnyimMemcached
WazMemcachedServer
WazMemcachedClient
CacheManager
LazyCache

Supported Operations

Operation	Scenario	Methods Supported
Select	Enyim Library	Enyim.Caching.MemcachedClient.Get Enyim.Caching.MemcachedClient.GetAsync Enyim.Caching.MemcachedClient.ExecuteGet
Select	CacheManager Library	CacheManager.Core.ICache.Get CacheManager.Core.ICache.Exists CacheManager.Core.ICache.Expire
Select	LazyCache Library	LazyCache.AppCacheExtensions.GetOrAdd LazyCache.AppCacheExtensions.GetOrAddAsync
Insert	Enyim Library	Enyim.Caching.MemcachedClient.Store Enyim.Caching.MemcachedClient.StoreAsync Enyim.Caching.MemcachedClient.ExecuteStore
Insert	CacheManager Library	CacheManager.Core.ICacheManager.GetOrAdd CacheManager.Core.ICacheManager.TryGetOrAdd
Insert	LazyCache Library	LazyCache.AppCacheExtensions.GetOrAdd LazyCache.AppCacheExtensions.GetOrAddAsync LazyCache.AppCacheExtensions.Add
Delete	Enyim Library	Enyim.Caching.MemcachedClient.Remove Enyim.Caching.MemcachedClient.RemoveAsync Enyim.Caching.MemcachedClient.ExecuteRemove
Delete	CacheManager Library	CacheManager.Core.ICache.Remove
Delete	LazyCache Library	LazyCache.IAppCache.Remove
Update	Enyim Library	Enyim.Caching.MemcachedClient.Increment Enyim.Caching.MemcachedClient.IncrementAsync Enyim.Caching.MemcachedClient.ExecuteIncrement Enyim.Caching.MemcachedClient.Decrement Enyim.Caching.MemcachedClient.DecrementAsync Enyim.Caching.MemcachedClient.ExecuteDecrement Enyim.Caching.MemcachedClient.Append Enyim.Caching.MemcachedClient.AppendAsync Enyim.Caching.MemcachedClient.PrependAsync Enyim.Caching.MemcachedClient.ExecuteAppend Enyim.Caching.MemcachedClient.Prepend Enyim.Caching.MemcachedClient.ExecutePrepend Enyim.Caching.MemcachedClient.Replace Enyim.Caching.MemcachedClient.ReplaceAsync
Update	CacheManager Library	CacheManager.Core.ICache.Put CacheManager.Core.ICacheManager.Update CacheManager.Core.ICacheManager.TryUpdate CacheManager.Core.ICacheManager.AddOrUpdate

Objects

Icon	Description
	DotNet Memcached Connection
	DotNet Memcached Data
	DotNet Unknown Memcached Connection
	DotNet Unknown Memcached Data

Links

Link type	Source and destination of link	Methods supported
belongsTo	From DotNet Memcached Data object to DotNet Memcached connection object	-
useSelectLink	Between the caller .Net method object and DotNet Memcached Data object	Get GetAsync ExecuteGet
useInsertLink	Between the caller .Net method object and DotNet Memcached Data object	Store StoreAsync ExecuteStore
useDeleteLink	Between the caller .Net method object and DotNet Memcached Data object	Remove RemoveAsync ExecuteRemove
useUpdateLink	Between the caller .Net method object and DotNet Memcached Data object	Increment IncrementAsync ExecuteIncrement Decrement DecrementAsync ExecuteDecrement Append AppendAsync ExecuteAppend Prepend PrependAsync ExecutePrepend

What results can you expect?

Some example scenarios are shown below:

Memcached Client Configuration

In the Memcached class file, when we add the server information by parsing the ipaddress and provide the port Number:

public MemcacedCache()
      {
         _logger = new Logger();
         var config = new MemcachedClientConfiguration();
         config.Servers.Add(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 11211));
         config.Protocol = MemcachedProtocol.Binary;
         
         _cache = new MemcachedClient(null, config);
      }

In the Memcached class file, when we pass the server information as a parameter:

namespace MemcachedTryout
{
   internal class MemcacedCache : ICache
   {  const string MEMCACHE_HOST = "127.0.0.1";
      const int MEMCACHE_PORT = 14551;
      public MemcacedCache()
      {
        _logger = new Logger();
         var config = new MemcachedClientConfiguration();
         config.Servers.Add(GetIPEndPointFromHostName(MEMCACHE_HOST, MEMCACHE_PORT));
         _cache = new MemcachedClient(null, config);
      }
  ---
}

If the server information is provided in xml file:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <configSections>
    <section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler,log4net" />
    <sectionGroup name="enyim.com">
      <section name="memcached" type="Enyim.Caching.Configuration.MemcachedClientSection, Enyim.Caching" />
    </sectionGroup>
  </configSections>

  <enyim.com>
    <memcached protocol="Binary">
      <servers>
         <!--put your own server(s) here-->
        <add address="127.0.0.1" port="11211" />
      </servers>
    </memcached>
  </enyim.com>

  <log4net>
    <appender name="ConsoleAppender" type="log4net.Appender.ConsoleAppender">
      <layout type="log4net.Layout.PatternLayout,log4net">
        <param name="ConversionPattern" value="%d [%t] %-5p %c %m%n" />
      </layout>
    </appender>
    <root>
      <level value="Debug" />
      <appender-ref ref="ConsoleAppender" />
    </root>
  </log4net>
</configuration>

Memcached Unknown Connection Object

In the Memcached class file, when we pass the server information as a parameter and if passed parameter is unresolved it will create Unknown Connection Object:

namespace MemcachedTryout
{
   internal class MemcacedCache : ICache
   {
      private readonly MemcachedClient _cache;
      private readonly ILogger _logger;

      public MemcacedCache()
      {
         _logger = new Logger();
         var config = new MemcachedClientConfiguration();
         config.Servers.Add(GetIPEndPointFromHostName(MEMCACHE_HOST, MEMCACHE_PORT));     
         _cache = new MemcachedClient(null, config);
      }
 ----
}

WazMemcached Library

public string MemcachedRoleName { get; set; }
public string EndpointName { get; set; }
private MemcachedClient Client
{
   get { return _client ?? (_client = WindowsAzureMemcachedHelpers.CreateDefaultClient(MemcachedRoleName, EndpointName)); }
}

Insert Operations

Enyim

  public async Task<bool> Addsync<T>(string key, T value)
      {
         _logger.Debug("Adding item to cache with key {0}", key);
         return await _cache.Store(StoreMode.Set, "Hello", value, TimeSpan.FromDays(90));
      }

CacheManager

public ValuesController(ICacheManager<string> valuesCache, ICacheManager<int> intCache, ICacheManager<DateTime> dates)
{
	_cache = valuesCache;

	dates.Add("now", DateTime.UtcNow);
	intCache.Add("count", 1);
}

Select Operations

Enyim

public async Task<T> Getsync<T>(string key)
      {
         var cacheItem = await _cache.Get<T>(Constants.num33);
        
         if (cacheItem == null)
         {
            _logger.Debug("Cache miss with key {0}", key);
            return default(T);
         }
         _logger.Debug("Cache hit with key {0}", key);
         return cacheItem;
      }

CacheManager

public IActionResult Get(string key)
{
	var value = _cache.GetCacheItem(key);
	if (value == null)
	{
		return NotFound();
	}

	return Json(value.Value);
}

LazyCache

[HttpGet]
[Route("api/dbtime")]
public DbTimeEntity Get()
{
	Func<DbTimeEntity> actionThatWeWantToCache = () => dbContext.GeDbTime();

	var cachedDatabaseTime = cache.GetOrAdd(cacheKey, actionThatWeWantToCache);

	return cachedDatabaseTime;
}

Select Operations

Enyim

public async Task<bool> Removesync(string key)
      {
         _logger.Debug("Removing item from cache with key {0}", key);
         return await _cache.Remove(Constants.key);
      }

CacheManager

public IActionResult Delete(string key)
{
if (_cache.Remove(key))
{
return Ok();
}

return NotFound();
}

LazyCache

[HttpDelete]
[Route("api/dbtime")]
public IActionResult DeleteFromCache()
{
cache.Remove(cacheKey);
var friendlyMessage = new {Message = $"Item with key '{cacheKey}' removed from server in-memory cache"};
return Ok(friendlyMessage);
}

Update Operations

Enyim

public async Task<bool> Updatesync<T>(string key, T value)
      {
		 _cache.Increment("num1", 1, 10);
		 
      }

CacheManager

public IActionResult Put(string key, [FromBody]string value)
{
	if (_cache.AddOrUpdate(key, value, (v) => value) != null)
	{
		return Ok();
	}

	return NotFound();
}

Known Limitations

In case data is not resolved, Unknown data objects are created.