Example #1
0
        /// <summary>
        /// Returns DefinedValue object from cache.  If definedValue does not already exist in cache, it
        /// will be read and added to cache
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public static DefinedValueCache Read(int id)
        {
            string cacheKey = DefinedValueCache.CacheKey(id);

            ObjectCache       cache        = MemoryCache.Default;
            DefinedValueCache definedValue = cache[cacheKey] as DefinedValueCache;

            if (definedValue != null)
            {
                return(definedValue);
            }
            else
            {
                Rock.Model.DefinedValueService definedValueService = new Rock.Model.DefinedValueService();
                Rock.Model.DefinedValue        definedValueModel   = definedValueService.Get(id);
                if (definedValueModel != null)
                {
                    definedValue = CopyModel(definedValueModel);

                    cache.Set(cacheKey, definedValue, new CacheItemPolicy());

                    return(definedValue);
                }
                else
                {
                    return(null);
                }
            }
        }
Example #2
0
        /// <summary>
        /// Adds or updates an item in cache.
        /// </summary>
        /// <param name="key">The key.</param>
        /// <param name="region">The region.</param>
        /// <param name="obj">The object.</param>
        /// <param name="expiration">The expiration.</param>
        /// <param name="cacheTags">The cache tags.</param>
        public static void AddOrUpdate(string key, string region, object obj, TimeSpan expiration, string cacheTags)
        {
            if (region.IsNotNullOrWhiteSpace())
            {
                RockCacheManager <object> .Instance.AddOrUpdate(key, region, obj, expiration);

                AddOrUpdateObjectCacheKey(region, key);
            }
            else
            {
                RockCacheManager <object> .Instance.AddOrUpdate(key, obj, expiration);

                AddOrUpdateObjectCacheKey(region, key);
            }

            if (cacheTags.IsNotNullOrWhiteSpace())
            {
                // trim the results since the tag name could come from lava and not from a prevalidated value stored in DefinedValue.
                var cacheTagList = cacheTags.Split(',').Select(t => t.Trim());
                foreach (var cacheTag in cacheTagList)
                {
                    // Don't save the tag if it is not valid.
                    int cacheTagDefinedTypeId = DefinedTypeCache.Get(Rock.SystemGuid.DefinedType.CACHE_TAGS).Id;
                    Rock.Model.DefinedValueService definedValueService = new Rock.Model.DefinedValueService(new Rock.Data.RockContext());
                    var validCacheTags = definedValueService.Queryable().Where(v => v.DefinedTypeId == cacheTagDefinedTypeId && v.Value == cacheTag).ToList();
                    if (validCacheTags.Count == 0)
                    {
                        return;
                    }

                    var value = RockCacheManager <List <string> > .Instance.Get(cacheTag, CACHE_TAG_REGION_NAME) ?? new List <string>();

                    if (!value.Contains(key))
                    {
                        value.Add(key);
                        RockCacheManager <List <string> > .Instance.AddOrUpdate(cacheTag, CACHE_TAG_REGION_NAME, value);

                        _stringCacheKeyReferences.Add(new CacheKeyReference {
                            Key = cacheTag, Region = region
                        });
                    }
                }
            }
        }