IMemoryCache provides an in-memory cache storage, allowing you to store and retrieve objects that can be shared across different parts of a application to improve performence and reduce repeated computations or database accesses.

ICacheService Interface

public interface ICacheService : IDisposable
{
    bool Exists(string key);

    void LPush(string key, string val);
    void RPush(string key, string val);

    object ListDequeue(string key);
    T ListDequeue<T>(string key) where T : class;

    void ListRemove(string key, int keepIndex);

    bool AddObject(string key, object value, int expireSeconds = -1, bool isSliding = false);
    bool Add(string key, string value, int expireSeconds = -1, bool isSliding = false);

    bool Remove(string key);
    void RemoveAll(IEnumerable<string> keys);

    T Get<T>(string key) where T : class;
    string Get(string key);
}

MemoryCacheService Implementation

public class MemoryCacheService : ICacheService
{
    protected IMemoryCache _cache;

    public MemoryCacheService(IMemoryCache cache)
    {
        _cache = cache;
    }

    public bool Exists(string key)
    {
        if (key == null)
        {
            throw new ArgumentNullException(nameof(key));
        }
        return _cache.Get(key) != null;
    }

    public bool Add(string key, object value)
    {
        if (key == null)
        {
            throw new ArgumentNullException(nameof(key));
        }
        if (value == null)
        {
            throw new ArgumentNullException(nameof(value));
        }
        _cache.Set(key, value);
        return Exists(key);
    }

    public bool AddObject(string key, object value, int expireSeconds = -1, bool isSliding = false)
    {
        if (expireSeconds != -1)
        {
            _cache.Set(key, value,
                new MemoryCacheEntryOptions()
                    .SetSlidingExpiration(new TimeSpan(0, 0, expireSeconds)));
        }
        else
        {
            _cache.Set(key, value);
        }
        return true;
    }

    public bool Add(string key, string value, int expireSeconds = -1, bool isSliding = false)
    {
        return AddObject(key, value, expireSeconds, isSliding);
    }

    public void LPush(string key, string val) { }
    public void RPush(string key, string val) { }

    public T ListDequeue<T>(string key) where T : class
    {
        return null;
    }

    public object ListDequeue(string key)
    {
        return null;
    }

    public void ListRemove(string key, int keepIndex) { }

    public bool Add(string key, object value, TimeSpan expiresSliding, TimeSpan expiressAbsoulte)
    {
        _cache.Set(key, value,
            new MemoryCacheEntryOptions()
                .SetSlidingExpiration(expiresSliding)
                .SetAbsoluteExpiration(expiressAbsoulte));
        return Exists(key);
    }

    public bool Add(string key, object value, TimeSpan expiresIn, bool isSliding = false)
    {
        if (isSliding)
            _cache.Set(key, value,
                new MemoryCacheEntryOptions()
                    .SetSlidingExpiration(expiresIn));
        else
            _cache.Set(key, value,
                new MemoryCacheEntryOptions()
                    .SetAbsoluteExpiration(expiresIn));
        return Exists(key);
    }

    public bool Remove(string key)
    {
        if (key == null)
        {
            throw new ArgumentNullException(nameof(key));
        }
        _cache.Remove(key);
        return !Exists(key);
    }

    public void RemoveAll(IEnumerable<string> keys)
    {
        if (keys == null)
        {
            throw new ArgumentNullException(nameof(keys));
        }
        keys.ToList().ForEach(item => _cache.Remove(item));
    }

    public string Get(string key)
    {
        return _cache.Get(key)?.ToString();
    }

    public T Get<T>(string key) where T : class
    {
        if (key == null)
        {
            throw new ArgumentNullException(nameof(key));
        }
        return _cache.Get(key) as T;
    }

    public void Dispose()
    {
        if (_cache != null)
            _cache.Dispose();
        GC.SuppressFinalize(this);
    }
}