serviceCollection.AddSingleton();

public interface IMyCache : IEnumerable>, IMemoryCache
{
    /// 

    /// Clears all cache entries.
    /// 
    void Clear();
}

public class MyMemoryCache : IMyCache
{
    private readonly IMemoryCache _memoryCache;
    private readonly ConcurrentDictionary _cacheEntries = new ConcurrentDictionary();

    public MyMemoryCache(IMemoryCache memoryCache)
    {
        this._memoryCache = memoryCache;
    }

    public void Dispose()
    {
        this._memoryCache.Dispose();
    }

    private void PostEvictionCallback(object key, object value, EvictionReason reason, object state)
    {
        if (reason != EvictionReason.Replaced)
            this._cacheEntries.TryRemove(key, out var _);
    }

    /// 
    public bool TryGetValue(object key, out object value)
    {
        return this._memoryCache.TryGetValue(key, out value);
    }

    /// 

    /// Create or overwrite an entry in the cache and add key to Dictionary.
    /// 
    /// An object identifying the entry.
    /// The newly created  instance.
    public ICacheEntry CreateEntry(object key)
    {
        var entry = this._memoryCache.CreateEntry(key);
        entry.RegisterPostEvictionCallback(this.PostEvictionCallback);
        this._cacheEntries.AddOrUpdate(key, entry, (o, cacheEntry) =>
        {
            cacheEntry.Value = entry;
            return cacheEntry;
        });
        return entry;
    }

    /// 
    public void Remove(object key)
    {
        this._memoryCache.Remove(key);
    }

    /// 
    public void Clear()
    {
        foreach (var cacheEntry in this._cacheEntries.Keys.ToList())
            this._memoryCache.Remove(cacheEntry);
    }

    public IEnumerator> GetEnumerator()
    {
        return this._cacheEntries.Select(pair => new KeyValuePair(pair.Key, pair.Value.Value)).GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }

    /// 

    /// Gets keys of all items in MemoryCache.
    /// 
    public IEnumerator