Objectcache - Removing all content after a few refreshes

Question

I’ve been working with the ObjectCache for some time and I have had some problems with users who disconnected after some time of use.

What’s going on that the ObjectCache is removing Cache after a few browser updates, is happening on my developer machine, and in the application under production.

This is my class:

using System;
using System.Runtime.Caching;

namespace autoSCORE.Utilidade.GerenciadorCache
{
    /// <summary>
    /// Gerencia a Criação, Atualização e Exclusão de Cache.
    /// </summary>
    /// <typeparam name="T">Objeto, do tipo <see cref="T"/>, preenchido com o Tipo de Conteúdo a ser guardado no Cache.</typeparam>
    public static class Cache<T> where T : class
    {
        /// <summary>
        /// Singleton do objeto, do tipo <see cref="System.Runtime.Caching.ObjectCache"/>.
        /// </summary>
        private static ObjectCache memoryCache = MemoryCache.Default;
        /// <summary>
        /// objeto, do tipo <see cref="System.Runtime.Caching.CacheItemPolicy"/>., com as Políticas do Cache.
        /// </summary>
        private static CacheItemPolicy cacheItemPolicy = null;

        /// <summary>
        /// Cria o Cache do Item desejado.
        /// </summary>
        /// <param name="chave">Objeto, do tipo <see cref="System.String"/>, preenchido com a Chave desejada.</param>
        /// <param name="conteudo">Objeto, do tipo <see cref="T"/>, preenchido com o Conteudo desejado.</param>
        /// <param name="persistir">Objeto, do tipo <see cref="System.Boolean"/>, preenchido com "True", para extender por 10 dias, ou "False", para extender por 60 minutos.</param>
        public static void Adicionar(string chave, T conteudo, bool persistir)
        {
            try
            {
                cacheItemPolicy = new CacheItemPolicy();
                cacheItemPolicy.Priority = CacheItemPriority.Default;
                cacheItemPolicy.SlidingExpiration = persistir ? new TimeSpan(10, 0, 0, 0) : new TimeSpan(1, 0, 0);

                memoryCache.Set(chave, conteudo, cacheItemPolicy);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// Retorna o Item, do Cache, desejado.
        /// </summary>
        /// <param name="chave">Objeto, do tipo <see cref="System.String"/>, preenchido com a Chave desejada.</param>
        /// <returns>Objeto, do tipo <see cref="T"/>, preenchido com o Conteudo recuperado.</returns>
        public static T Recuperar(string chave)
        {
            try
            {
                if (memoryCache.Contains(chave))
                {
                    var objectT = (T)memoryCache[chave];

                    if (objectT == null) return default(T);

                    System.Reflection.MethodInfo newInstanceOfObjectT =
                        objectT.GetType().GetMethod("MemberwiseClone", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);

                    if (newInstanceOfObjectT == null) return default(T);

                    return (T)newInstanceOfObjectT.Invoke(objectT, null);
                }
                else
                {
                    return default(T);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// Atualiza o Item, no Cache, desejado.
        /// </summary>
        /// <param name="chave">Objeto, do tipo <see cref="System.String"/>, preenchido com a Chave desejada.</param>
        /// <param name="novoConteudo">Objeto, do tipo <see cref="T"/>, preenchido com o novo Conteudo desejado.</param>
        public static void Atualizar(string chave, T novoConteudo)
        {
            try
            {
                if (memoryCache.Contains(chave))
                {
                    var content = (T)memoryCache[chave];

                    content = novoConteudo;

                    memoryCache[chave] = content;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }

        }

        /// <summary>
        /// Remove o Item desejado.
        /// </summary>
        /// <param name="chave">Objeto, do tipo <see cref="System.String"/>, preenchido com a Chave desejada.</param>
        public static void Remover(string chave)
        {
            try
            {
                if (memoryCache.Contains(chave))
                {
                    memoryCache.Remove(chave);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }

        }
    }
}

Thank you, Rodrigo Lemela Duarte