Implementing a C# “cache” for a legacy .NET 3.5 “desktop” application?

Recommendation is to never get your hands dirty for such performance-oriented parts of your application unless you have a solid experience/understanding. Oh, before I start the answer, I should suggest that migrating the code to .NET Framework 4 and onwards (.NET Core and .NET Core vNext) should be the preferable route to take here. .NET Framework 3 and older systems are no longer supported and you are more likely to stumble upon such issues.

If you are interested in using the in-memory caching solution, please refer to modern caching systems such as Redis/Memcached to make the best possible use of caching resources and the system.

Redis[^]

Note: please verify if the server/client libraries for the caching systems provide support for .NET Framework 3.5, which is highly unlikely.

If you are still looking for something more custom, then try checking this thread on SO[^]; it gives an idea of how a cache system looks like. One thing to note is that caching is more than just storing, caching is about removing elements when no longer needed in the cache to maintain a manageable size, etc.

using System.Data;

namespace MyNamespace
{
    public sealed class MyData
    {
        private static readonly MyData instance = new MyData();
        private DataTable data;

        public DataTable Data
        {
            get
            {
                return data;
            }
        }
            
        static MyData()
        {
        }

        private MyData()
        {
            // Populate your data here

            data = new DataTable();
            data.Columns.Add("ID", typeof(int));
            data.Columns.Add("Name", typeof(string));

            data.Rows.Add(1, "John");
            data.Rows.Add(1, "David");
        }

        public static MyData Instance
        {
            get
            {
                return instance;
            }
        }
    }
}

Usage

private void Form1_Load(object sender, EventArgs e)
{
    DataTable dt = MyData.Instance.Data;

    System.Diagnostics.Debug.WriteLine(dt.Rows[0][0].ToString() + " " + dt.Rows[0][1].ToString());
}

public class CustomMemoryCachePolicy
{
    public CustomMemoryCachePolicy(DateTime expiration)
    {
        Expiration = expiration;
    }

    public DateTime Expiration { get; set; }
}

public class CustomMemoryCache
{
    private Dictionary<string, object> cacheObjects;
    private Dictionary<string, CustomMemoryCachePolicy> cacheObjectsPolicy;

    public CustomMemoryCache()
    {
        cacheObjects = new Dictionary<string, object>();
        cacheObjectsPolicy = new Dictionary<string, CustomMemoryCachePolicy>();
    }

    public object Get(string key)
    {
        lock (cacheObjects)
        {
            ApplyPolicies(key);
            object target;
            cacheObjects.TryGetValue(key, out target);
            return target ?? null;
        }
    }

    public void Set(string key, object value, CustomMemoryCachePolicy policy = null)
    {
        lock (cacheObjects)
        {
            ApplyPolicies(key);
            cacheObjects.Add(key, value);
            cacheObjectsPolicy.Add(key, policy);
        }
    }

    public bool Contains(string key)
    {
        ApplyPolicies(key);
        return cacheObjects.ContainsKey(key);
    }

    private void ApplyPolicies(string key)
    {
        CustomMemoryCachePolicy targetPolicy;
        cacheObjectsPolicy.TryGetValue(key, out targetPolicy);

        if(targetPolicy != null)
        {
            if(DateTime.Now > targetPolicy.Expiration)
            {
                Remove(key);
            }
        }
    }

    public void Remove(string key)
    {
        lock (cacheObjects)
        {
            if (cacheObjects.ContainsKey(key))
                cacheObjects.Remove(key);

            if (cacheObjectsPolicy.ContainsKey(key))
                cacheObjectsPolicy.Remove(key);
        }
    }
}