Cache of T

Cacheable.cs

using System;

namespace MyNameSpace
{
    public class Cacheable<T> where T : class
    {
        private readonly Func<T> _refresh;
        private T _current;
        private DateTime _timestamp;
        private readonly TimeSpan _limit;

        public Cacheable(Func<T> refresh, TimeSpan limit)
        {
            _refresh = refresh;
            _limit = limit;
        }
        public Cacheable(Func<T> refresh)
            : this(refresh, TimeSpan.FromMinutes(60))
        { }

        public T Get()
        {
            if (_current == null || HasExpired())
            {
                return RefreshCache();
            }
            return _current;
        }

        private T RefreshCache()
        {
            _current = _refresh();
            _timestamp = DateTime.UtcNow;
            return _current;
        }

        private bool HasExpired()
        {
            var timeElapsed = DateTime.UtcNow - _timestamp;
            return timeElapsed > _limit;
        }
    }
}

CacheTests.cs

using System;
using System.Threading;
using Xunit;

namespace MyNameSpace.Tests
{
    public class CacheTests
    {
        [Fact]
        public void CanReuseCachedObject()
        {
            var cache = new Cacheable<string>(() => DateTime.Now.ToString(), TimeSpan.FromSeconds(10));
            var ob1 = cache.Get();
            Thread.Sleep(1000);
            var ob2 = cache.Get();
            Assert.Equal(ob1, ob2);
        }

        [Fact]
        public void CanGetNewObjectOnceExpired()
        {
            var cache = new Cacheable<string>(() => DateTime.Now.ToString(), TimeSpan.FromTicks(1));
            var ob1 = cache.Get();
            Thread.Sleep(1000);
            var ob2 = cache.Get();
            Assert.NotEqual(ob1, ob2);
        }
    }
}