Wednesday, July 27, 2016

Getting Umbraco Content - IPublishedContent vs IContent vs Node vs Document

There are couple of ways to get Umbraco content. Some returns the data from db and some does from the cache. Here is some details about them and how you use it in an umbraco project.

  • IContent is managed by IContentService and is targetted at back-end, read-write access to content. It's what you want to use when you need to manage content.
  • IPublishedContent is managed by the "content cache" and is targetted at front-end, read-only access to content. It's what you want to user when rendering content.
  • Document and INode are (roughly) the legacy equivalents of IContent and IPublishedContent. They should not be used anymore, and will eventually be obsoleted entirely. So better ignore them.

Way 1
var contentService = new ContentService();
IContent content = contentService.GetById(123);
  • Gets the content from the database.
  • Returns both published and unpublished content.
  • Preferred way to get editable content for CRUD operations in Umbraco 7+.
Way 2
var umbracoHelper = new UmbracoHelper(UmbracoContext.Current);
IPublishedContent content = umbracoHelper.TypedContent(123);
  • Gets the content from the cache.
  • Only returns published content.
  • Preferred way to get cached content in Umbraco 7+.
Way 3
var content = new Document(123);
  • Gets the content from the database.
  • Returns both published and umpublished content.
  • Old way to get editable content for CRUD operations.
Way 4
var node = new Node(123);
  • Old way to get content from the cache.
  • Only returns published content.


Tuesday, July 26, 2016

Cache Handler

Below is a CacheHandler that might be useful to store data in cache objects so rather than returning the data from db, we can return it from the Cache objects

// CacheHanlder.cs
using XYZProject.Infrastructure.Constants;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Web;
using System.Web.Caching;
using System.Web.Configuration;

namespace XYZProject.Infrastructure.EventHandlers
{
    public static class CacheHandler
    {
        /// <summary>
        /// Returns ExpirationMinutes from Web.config
        /// </summary>
        private static int ExpirationMinutes
        {
            get
            {
                return ToInt32(WebConfigurationManager.AppSettings["CacheExpirationMinutes"]);
            }
        }

        public static object GetValue(string key)
        {
            return HttpContext.Current.Cache[key];
        }

        public static void ClearCache(string key)
        {
            HttpContext.Current.Cache.Remove(key);
        }

        /// <summary>
        /// Clears all service cache for Profile and Framework service methods
        /// </summary>
        /// <param name="userGuid"></param>
        public static void ClearAllServiceCache(Guid userGuid)
        {
            List<string> getAllCacheKeyMembers = CacheConstants.GetAllCacheKeyMembers();
            foreach (string item in getAllCacheKeyMembers)
            {
                string key = item + userGuid;
                HttpContext.Current.Cache.Remove(key);
            }
        }

        /// <summary>
        /// Sets Cache Vaue with an Absolute Expiration
        /// If expirationMinutes is 0, then it gets the expirationMinutes value from the Web.config
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="expirationMinutes"></param>
        public static void SetValueWithAbsoluteExpiration(string key, object value, int expirationMinutes = 0)
        {
            if (expirationMinutes == 0)
            {
                expirationMinutes = ExpirationMinutes;
            }
            HttpContext.Current.Cache.Insert(key, value, null, DateTime.Now.AddMinutes(expirationMinutes), Cache.NoSlidingExpiration, CacheItemPriority.Normal, null);
        }

        public static void SetValueWithNoExpiration(string Key, object value)
        {
            HttpContext.Current.Cache.Insert(Key, value);
        }

        #region [ Int Converter ]

        private static bool Assigned(this object o)
        {
            if (o is string)
                return !string.IsNullOrEmpty((string)o);

            return (o != null);
        }

        public static Int32 ToInt32(object value, Int32 defaultValue)
        {
            Int32 retVal = defaultValue;
            if (value.Assigned())
            {
                Int32.TryParse(Convert.ToString(value), out retVal);
            }

            return retVal;
        }

        public static Int32 ToInt32(object value)
        {
            return ToInt32(value, 0);
        }

        #endregion
    }
}



// CacheConstants.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace XYZProject.Infrastructure.Constants
{
    public static class CacheConstants
    {
        public static class ProfileServiceCacheKeyMember
        {
            public const string GetProfileViewModelAsync = "GetProfileViewModelAsync_";
            public const string GetSkillsAsync = "GetSkillsAsync_";
            public const string GetProfileAsync = "GetProfileAsync_";
            public const string GetProfileModelAsync = "GetProfileModelAsync_";
            public const string GetPreferencesAsync = "GetPreferencesAsync_";
            public const string GetNonCertifiedQualificationsAsync = "GetNonCertifiedQualificationsAsync_";
            public const string GetPhotoAsync = "GetPhotoAsync_";
            public const string GetInterestsAsync = "GetInterestsAsync_";
            public const string GetAboutMeAsync = "GetAboutMeAsync_";
            public const string GetAccessLevelsAsync = "GetAccessLevelsAsync_";
            public const string GetAwardsAsync = "GetAwardsAsync_";
            public const string GetContactDetailsAsync = "GetContactDetailsAsync_";
            public const string GetCurriculumInterestsAsync = "GetCurriculumInterestsAsync_";
            public const string GetNationalitiesAsync = "GetNationalitiesAsync_";
            public const string GetEthnicitiesAsync = "GetEthnicitiesAsync_";
            public const string GetGendersAsync = "GetGendersAsync_";
        }

        public static class FrameworkServiceCacheKeyMember
        {
            public const string GetProgrammeRegistrationsAsync = "GetProgrammeRegistrationsAsync_";
            public const string GetComponentProgrammesAsync = "GetComponentProgrammesAsync_";
            public const string GetEventProgrammesAsync = "GetEventProgrammesAsync_";
            public const string GetEventRegistrationAsync = "GetEventRegistrationAsync_";
            public const string GetEventRegistrationsAsync = "GetEventRegistrationsAsync_";
            public const string GetEventStructureAsync = "GetEventStructureAsync_";
            public const string GetEvidenceAsync = "GetEvidenceAsync_";
            public const string GetEvidencesAsync = "GetEvidencesAsync_";
            public const string GetProgrammeProgrammesAsync = "GetProgrammeProgrammesAsync_";
            public const string GetProgrammeStructureAsync = "GetProgrammeStructureAsync_";
        }

        public static List<string> GetAllCacheKeyMembers()
        {
            List<string> cacheKeyMembers = new List<string>();

            Type typeProfileServiceCacheKeyMember = typeof(ProfileServiceCacheKeyMember);

            foreach (var p in typeProfileServiceCacheKeyMember.GetFields())
            {
                var v = p.GetValue(null); //static classes cannot be instanced, so use null...
                cacheKeyMembers.Add(v.ToString());
            }

            Type typeFrameworkServiceCacheKeyMember = typeof(FrameworkServiceCacheKeyMember);

            foreach (var p in typeFrameworkServiceCacheKeyMember.GetFields())
            {
                var v = p.GetValue(null); //static classes cannot be instanced, so use null...
                cacheKeyMembers.Add(v.ToString());
            }

            return cacheKeyMembers.Distinct().ToList();
        }
    }
}