如何处理更新缓存中的对象？

Question

我希望这是问这个问题的正确地方，但是在最近经历了一些奇怪的行为之后，我在执行some research 之后意识到，当使用 .NET 内存缓存并从缓存中检索对象时，您会检索到该对象的引用缓存中的对象，而不是对象的副本，因此对对象的任何更新都将保留在缓存中。

在下面的示例中，学生在StudentController 中更新，并再次检索CourseController，学生包含更新后的值而无需刷新缓存。

我最初的方法是在更新数据库后清除缓存的学生集合（因为我认为缓存的版本不会包含更新），但鉴于存在这种持久性，是否需要再次重新填充缓存数据库已更新？

    // Student controller
    public class StudentController : Controller
    {
        // omitted for brevity.

        public ActionResult UpdateStudent(int id)
        {                               
            var student = CollegeCache.Students[id];

            student.FirstName = "SpongeBob"

            studentRepository.update(student)   

            // CollegeCache.clearStudents();        
        }
    }

    // Course controller
    public class CourseController : Controller
    {
        // omitted for brevity.

        public ActionResult GetCoursesDetails(int id)
        {                               
            var student = CollegeCache.Students[id];

            // here student.FirstName will be "SpongeBob", and not it's original value.
        }
    }   

    // Cache helper class
    public static class CollegeCache
    {
        private static readonly ObjectCache cache = new MemoryCache("College");
        private static object locker = new object();

        public static readonly string StudentsKey = "StudentsKey";

        // Clears the entire cache store.
        public static void Clear()
        {
            foreach (var item in cache)
                cache.Remove(item.Key);
        }

        // Clears a single cache entry.
        public static void Clear(string key)
        {
            cache.Remove(key);
        }

        // Add to cache helper
        private static void Add(string key, object value, DateTimeOffset expiration,
            CacheItemPriority priority = CacheItemPriority.Default)
        {
            var policy = new CacheItemPolicy();
            policy.AbsoluteExpiration = expiration;
            policy.Priority = priority;

            var item = new CacheItem(key, value);
            cache.Add(item, policy);
        }

        // Students cache store.
        public static Dictionary<int, Student> Students
        {
            get
            {
                var dictionary = cache[StudentsKey] as Dictionary<int, Student>;
                if (dictionary == null)
                {
                    lock (locker)
                    {
                        dictionary = db.Students.All().ToList().ToDictionary(a => a.Id);
                        Add(StudentsKey, dictionary, DateTime.Now.AddHours(1));
                    }
                }

                return dictionary;
            }
        }

        // Clears the users cache store.
        public static void ClearStudents()
        {
            Clear(StudentsKey);
        }
    }   

Answer 1

一般来说，如果您更新基础数据源中的数据，那么您还必须在缓存中更新它，否则缓存中的数据未来获取的状态将比数据库中的数据陈旧且不稳定。你会不同步。您可以清除缓存并重新填充，但每次更新时这样做会很昂贵 - 出于上述原因，不建议这样做。仅当您成功更新数据库中的数据并更新缓存时才应更新。

由于您更新了有问题的对象，缓存应该以某种方式“自动”更新（前提是您从缓存中获取了对象）但是我仍然会在缓存端进行显式更新，因为如果数据源抛出错误（即 SQLException）？您需要确保正确更新相关对象，否则您会遇到数据完整性问题:)