What is In Memory DB in MVC

using System;
using System.Collections.Generic;

namespace GenericCache
{
    public class SearchCache<T> : List<T> 
        where T : class
    {
        public delegate IEnumerable<T> DataSourceFunction();

        #region Properties
        // Instance control
        private static SearchCache<T> _instance;
        private static readonly object _syncLock = new object();
        

        // Cache refresh control
        public DateTime Initialized { get; private set; }
        public DateTime Refreshed { get; private set; }
        public int Interval { get; private set; }

        public DataSourceFunction DataSource { get; set; }

        // Hit tracking to for usage and efficiency statistics
        public int Hits { get; protected set; }
        public int ReachBacks { get; protected set; }

        public int CacheHits
        {
            get { return Hits - ReachBacks; }
        }

        #endregion

        #region CTOR/DTOR
        public SearchCache(DataSourceFunction dataSource)
        {
            Initialized = DateTime.Now;
            Interval = 60; // refresh time in minutes
            Hits = 0;
            ReachBacks = 0;
            DataSource = dataSource;
            CheckInterval();
        }

        #endregion

        #region Internal Methods

        /// <summary>
        /// Make sure that the singleton is only populated per interval.
        /// </summary>
        private void CheckInterval()
        {
                Hits++;

                // If the update threshold has been exceeded.
                if (Refreshed.AddMinutes(Interval) < DateTime.Now)
                {
                    Populate();
                }            
        }

        /// <summary>
        /// Get search data into the cache
        /// </summary>
        private void Populate()
        {

                // Empty Cache
                this.Clear();                

                this.AddRange(DataSource());

                // Statistical tracking
                ReachBacks++;
                Refreshed = DateTime.Now;
            
        }
        #endregion

        #region External Methods
        public static SearchCache<T> Instance(DataSourceFunction dataSource)
        {

                if (_instance == null)
                {
                    lock (_syncLock)
                    {
                        _instance = new SearchCache<T>(dataSource);
                    }
                }
                _instance.CheckInterval();
                return _instance;
            
        }

        /// <summary>
        /// Forces the cache to refresh outside the normal interval
        /// </summary> 
        public void Refresh()
        {
            Hits++;
            Populate();
        }

        /// <summary>
        ///  Reset the cache to an initialized state
        /// </summary>
        public void Zeroize()
        {
            Clear();
            Initialized = DateTime.Now;

            Hits = 1;
            ReachBacks = 0;

            Populate();
        }
        #endregion
    }
}

var myCache = SearchCache<T>.Instance(/*function that return IEnumerable<T>*/);