Update version

for members

.gitignore

@@ -85,3 +85,4 @@ NDependOut/*
 *.ndproj
 QueryResult.htm
 *.ndproj
+src/Umbraco.Tests/Views/web.config

build/Build.bat

@@ -1,6 +1,6 @@
 @ECHO OFF
 SET release=6.2.0
-SET comment=
+SET comment=beta
 SET version=%release%
 
 IF [%comment%] EQU [] (SET version=%release%) ELSE (SET version=%release%-%comment%)

src/Umbraco.Core/ApplicationContext.cs

@@ -12,7 +12,7 @@ using Umbraco.Core.Services;
 
 namespace Umbraco.Core
 {
-	/// <summary>
+    /// <summary>
     /// the Umbraco Application context
     /// </summary>
     /// <remarks>
@@ -20,61 +20,45 @@ namespace Umbraco.Core
     /// </remarks>
     public class ApplicationContext : IDisposable
     {
-    	/// <summary>
-        /// Constructor
-        /// </summary>        
-        internal ApplicationContext(DatabaseContext dbContext, ServiceContext serviceContext)
-            : this(dbContext, serviceContext, true)
-    	{
-    			
-    	}
 
         /// <summary>
         /// Constructor
         /// </summary>
         /// <param name="dbContext"></param>
         /// <param name="serviceContext"></param>
-        /// <param name="enableCache"></param>
-        public ApplicationContext(DatabaseContext dbContext, ServiceContext serviceContext, bool enableCache)
-            : this(enableCache)
+        /// <param name="cache"></param>
+        public ApplicationContext(DatabaseContext dbContext, ServiceContext serviceContext, CacheHelper cache)
         {
+            if (dbContext == null) throw new ArgumentNullException("dbContext");
+            if (serviceContext == null) throw new ArgumentNullException("serviceContext");
+            if (cache == null) throw new ArgumentNullException("cache");
             _databaseContext = dbContext;
-            _services = serviceContext;		
+            _services = serviceContext;
+            ApplicationCache = cache;
         }
 
-		/// <summary>
-		/// Empty constructor normally reserved for unit tests when a DatabaseContext or a ServiceContext is not
-		/// necessarily required or needs to be set after construction.
-		/// </summary>
-		internal ApplicationContext() : this(true)
-		{			
-		}
-
         /// <summary>
-        /// Constructor used to specify if we will enable application cache or not
+        /// Creates a basic app context
         /// </summary>
-        /// <param name="enableCache"></param>
-        public ApplicationContext(bool enableCache)
+        /// <param name="cache"></param>
+        public ApplicationContext(CacheHelper cache)
         {
-            //create a new application cache from the HttpRuntime.Cache
-            ApplicationCache = HttpRuntime.Cache == null
-                ? new CacheHelper(new System.Web.Caching.Cache(), enableCache)
-                : new CacheHelper(HttpRuntime.Cache, enableCache);
+            ApplicationCache = cache;
         }
 
-	    /// <summary>
-	    /// A method used to set and/or ensure that a global ApplicationContext singleton is created.
-	    /// </summary>
-	    /// <param name="appContext">
-	    /// The instance to set on the global application singleton
-	    /// </param>
-	    /// <param name="replaceContext">If set to true and the singleton is already set, it will be replaced</param>
-	    /// <returns></returns>
-	    /// <remarks>
-	    /// This is NOT thread safe 
-	    /// </remarks>
-	    public static ApplicationContext EnsureContext(ApplicationContext appContext, bool replaceContext)
-	    {
+        /// <summary>
+        /// A method used to set and/or ensure that a global ApplicationContext singleton is created.
+        /// </summary>
+        /// <param name="appContext">
+        /// The instance to set on the global application singleton
+        /// </param>
+        /// <param name="replaceContext">If set to true and the singleton is already set, it will be replaced</param>
+        /// <returns></returns>
+        /// <remarks>
+        /// This is NOT thread safe 
+        /// </remarks>
+        public static ApplicationContext EnsureContext(ApplicationContext appContext, bool replaceContext)
+        {
             if (ApplicationContext.Current != null)
             {
                 if (!replaceContext)
@@ -82,56 +66,56 @@ namespace Umbraco.Core
             }
             ApplicationContext.Current = appContext;
             return ApplicationContext.Current;
-	    }
+        }
 
-	    /// <summary>
-	    /// A method used to create and ensure that a global ApplicationContext singleton is created.
-	    /// </summary>
-	    /// <param name="enableCache"></param>
-	    /// <param name="replaceContext">
-	    /// If set to true will replace the current singleton instance - This should only be used for unit tests or on app 
-	    /// startup if for some reason the boot manager is not the umbraco boot manager.
-	    /// </param>
-	    /// <param name="dbContext"></param>
-	    /// <param name="serviceContext"></param>
-	    /// <returns></returns>
-	    /// <remarks>
-	    /// This is NOT thread safe 
-	    /// </remarks>
-	    public static ApplicationContext EnsureContext(DatabaseContext dbContext, ServiceContext serviceContext, bool enableCache, bool replaceContext)
+        /// <summary>
+        /// A method used to create and ensure that a global ApplicationContext singleton is created.
+        /// </summary>
+        /// <param name="cache"></param>
+        /// <param name="replaceContext">
+        /// If set to true will replace the current singleton instance - This should only be used for unit tests or on app 
+        /// startup if for some reason the boot manager is not the umbraco boot manager.
+        /// </param>
+        /// <param name="dbContext"></param>
+        /// <param name="serviceContext"></param>
+        /// <returns></returns>
+        /// <remarks>
+        /// This is NOT thread safe 
+        /// </remarks>
+        public static ApplicationContext EnsureContext(DatabaseContext dbContext, ServiceContext serviceContext, CacheHelper cache, bool replaceContext)
         {
             if (ApplicationContext.Current != null)
             {
                 if (!replaceContext)
                     return ApplicationContext.Current;
             }
-            var ctx = new ApplicationContext(dbContext, serviceContext, enableCache);
+            var ctx = new ApplicationContext(dbContext, serviceContext, cache);
             ApplicationContext.Current = ctx;
             return ApplicationContext.Current;
         }
 
-	    /// <summary>
-    	/// Singleton accessor
-    	/// </summary>
-    	public static ApplicationContext Current { get; internal set; }
+        /// <summary>
+        /// Singleton accessor
+        /// </summary>
+        public static ApplicationContext Current { get; internal set; }
 
-		/// <summary>
-		/// Returns the application wide cache accessor
-		/// </summary>
-		/// <remarks>
-		/// Any caching that is done in the application (app wide) should be done through this property
-		/// </remarks>
-		public CacheHelper ApplicationCache { get; private set; }
+        /// <summary>
+        /// Returns the application wide cache accessor
+        /// </summary>
+        /// <remarks>
+        /// Any caching that is done in the application (app wide) should be done through this property
+        /// </remarks>
+        public CacheHelper ApplicationCache { get; private set; }
 
-    	// IsReady is set to true by the boot manager once it has successfully booted
+        // IsReady is set to true by the boot manager once it has successfully booted
         // note - the original umbraco module checks on content.Instance in umbraco.dll
         //   now, the boot task that setup the content store ensures that it is ready
         bool _isReady = false;
-		readonly System.Threading.ManualResetEventSlim _isReadyEvent = new System.Threading.ManualResetEventSlim(false);
-		private DatabaseContext _databaseContext;
-		private ServiceContext _services;
+        readonly ManualResetEventSlim _isReadyEvent = new ManualResetEventSlim(false);
+        private DatabaseContext _databaseContext;
+        private ServiceContext _services;
 
-		public bool IsReady
+        public bool IsReady
         {
             get
             {
@@ -141,14 +125,14 @@ namespace Umbraco.Core
             {
                 AssertIsNotReady();
                 _isReady = value;
-				_isReadyEvent.Set();
+                _isReadyEvent.Set();
             }
         }
 
-		public bool WaitForReady(int timeout)
-		{
-			return _isReadyEvent.WaitHandle.WaitOne(timeout);
-		}
+        public bool WaitForReady(int timeout)
+        {
+            return _isReadyEvent.WaitHandle.WaitOne(timeout);
+        }
 
 
         // notes
@@ -157,14 +141,14 @@ namespace Umbraco.Core
         //   the system is configured if they match
         //   if they don't, install runs, updates web.config (presumably) and updates GlobalSettings.ConfiguredStatus
         //
-        //   then there is Application["umbracoNeedConfiguration"] which makes no sense... getting rid of it...
+        //   then there is Application["umbracoNeedConfiguration"] which makes no sense... getting rid of it... SD: I have actually remove that now!
         //
         public bool IsConfigured
         {
             // todo - we should not do this - ok for now
             get
             {
-            	return Configured;
+                return Configured;
             }
         }
 
@@ -180,45 +164,45 @@ namespace Umbraco.Core
         /// </remarks>
         internal string OriginalRequestUrl { get; set; }
 
-		private bool Configured
-		{
-			get
-			{
-				try
-				{
-					string configStatus = ConfigurationStatus;
-					string currentVersion = UmbracoVersion.Current.ToString(3);
+        private bool Configured
+        {
+            get
+            {
+                try
+                {
+                    string configStatus = ConfigurationStatus;
+                    string currentVersion = UmbracoVersion.Current.ToString(3);
 
 
-					if (currentVersion != configStatus)
-					{
-						LogHelper.Info<ApplicationContext>("CurrentVersion different from configStatus: '" + currentVersion + "','" + configStatus + "'");
-					}
-						
+                    if (currentVersion != configStatus)
+                    {
+                        LogHelper.Info<ApplicationContext>("CurrentVersion different from configStatus: '" + currentVersion + "','" + configStatus + "'");
+                    }
 
-					return (configStatus == currentVersion);
-				}
-				catch
-				{
-					return false;
-				}
-			}
-		}
 
-		private string ConfigurationStatus
-		{
-			get
-			{
-				try
-				{
-					return ConfigurationManager.AppSettings["umbracoConfigurationStatus"];
-				}
-				catch
-				{
-					return String.Empty;
-				}
-			}			
-		}
+                    return (configStatus == currentVersion);
+                }
+                catch
+                {
+                    return false;
+                }
+            }
+        }
+
+        private string ConfigurationStatus
+        {
+            get
+            {
+                try
+                {
+                    return ConfigurationManager.AppSettings["umbracoConfigurationStatus"];
+                }
+                catch
+                {
+                    return String.Empty;
+                }
+            }
+        }
 
         private void AssertIsReady()
         {
@@ -232,39 +216,39 @@ namespace Umbraco.Core
                 throw new Exception("ApplicationContext has already been initialized.");
         }
 
-		/// <summary>
-		/// Gets the current DatabaseContext
-		/// </summary>
-		/// <remarks>
-		/// Internal set is generally only used for unit tests
-		/// </remarks>
-		public DatabaseContext DatabaseContext
-		{
-			get
-			{
-				if (_databaseContext == null)
-					throw new InvalidOperationException("The DatabaseContext has not been set on the ApplicationContext");
-				return _databaseContext;
-			}
-			internal set { _databaseContext = value; }
-		}
-		
-		/// <summary>
-		/// Gets the current ServiceContext
-		/// </summary>
-		/// <remarks>
-		/// Internal set is generally only used for unit tests
-		/// </remarks>
-		public ServiceContext Services
-		{
-			get
-			{
-				if (_services == null)
-					throw new InvalidOperationException("The ServiceContext has not been set on the ApplicationContext");
-				return _services;
-			}
-			internal set { _services = value; }
-		}
+        /// <summary>
+        /// Gets the current DatabaseContext
+        /// </summary>
+        /// <remarks>
+        /// Internal set is generally only used for unit tests
+        /// </remarks>
+        public DatabaseContext DatabaseContext
+        {
+            get
+            {
+                if (_databaseContext == null)
+                    throw new InvalidOperationException("The DatabaseContext has not been set on the ApplicationContext");
+                return _databaseContext;
+            }
+            internal set { _databaseContext = value; }
+        }
+
+        /// <summary>
+        /// Gets the current ServiceContext
+        /// </summary>
+        /// <remarks>
+        /// Internal set is generally only used for unit tests
+        /// </remarks>
+        public ServiceContext Services
+        {
+            get
+            {
+                if (_services == null)
+                    throw new InvalidOperationException("The ServiceContext has not been set on the ApplicationContext");
+                return _services;
+            }
+            internal set { _services = value; }
+        }
 
 
         private volatile bool _disposed;
@@ -290,26 +274,26 @@ namespace Umbraco.Core
                 //clear the cache
                 if (ApplicationCache != null)
                 {
-                    ApplicationCache.ClearAllCache();    
+                    ApplicationCache.ClearAllCache();
                 }
                 //reset all resolvers
                 ResolverCollection.ResetAll();
                 //reset resolution itself (though this should be taken care of by resetting any of the resolvers above)
                 Resolution.Reset();
-                
+
                 //reset the instance objects
                 this.ApplicationCache = null;
                 if (_databaseContext != null) //need to check the internal field here
                 {
                     if (DatabaseContext.IsDatabaseConfigured)
                     {
-                        DatabaseContext.Database.Dispose();       
-                    }                    
+                        DatabaseContext.Database.Dispose();
+                    }
                 }
                 this.DatabaseContext = null;
                 this.Services = null;
                 this._isReady = false; //set the internal field
-                
+
                 // Indicate that the instance has been disposed.
                 _disposed = true;
             }

src/Umbraco.Core/Attempt{T}.cs

@@ -160,5 +160,15 @@ namespace Umbraco.Core
         {
             return new Attempt<T>(condition, result, null);
         }
+
+        /// <summary>
+        /// Implicity operator to check if the attempt was successful without having to access the 'success' property
+        /// </summary>
+        /// <param name="a"></param>
+        /// <returns></returns>
+        public static implicit operator bool(Attempt<T> a)
+        {
+            return a.Success;
+        }
     }
 }

src/Umbraco.Core/Cache/CacheKeys.cs

@@ -1,3 +1,5 @@
+using System;
+
 namespace Umbraco.Core.Cache
 {
 
@@ -9,6 +11,7 @@ namespace Umbraco.Core.Cache
         public const string ApplicationTreeCacheKey = "ApplicationTreeCache";
         public const string ApplicationsCacheKey = "ApplicationCache";
 
+        [Obsolete("This is no longer used and will be removed from the codebase in the future")]
         public const string UserTypeCacheKey = "UserTypeCache";
 
         public const string ContentItemCacheKey = "contentItem";
@@ -24,13 +27,16 @@ namespace Umbraco.Core.Cache
 
         public const string MemberLibraryCacheKey = "UL_GetMember";
         public const string MemberBusinessLogicCacheKey = "MemberCacheItem_";
-
+        
         public const string TemplateFrontEndCacheKey = "template";
         public const string TemplateBusinessLogicCacheKey = "UmbracoTemplateCache";
 
         public const string UserContextCacheKey = "UmbracoUserContext";
         public const string UserContextTimeoutCacheKey = "UmbracoUserContextTimeout";
+
+        [Obsolete("This is no longer used and will be removed from the codebase in the future")]
         public const string UserCacheKey = "UmbracoUser";
+        
         public const string UserPermissionsCacheKey = "UmbracoUserPermissions";
 
         public const string ContentTypeCacheKey = "UmbracoContentType";

src/Umbraco.Core/Cache/CacheProviderBase.cs

@@ -1,25 +0,0 @@
-using System;
-using System.Collections.Generic;
-
-namespace Umbraco.Core.Cache
-{
-    /// <summary>
-    /// An abstract class for implementing a basic cache provider
-    /// </summary>
-    /// <remarks>
-    /// THIS MUST REMAIN INTERNAL UNTIL WE STREAMLINE HOW ALL CACHE IS HANDLED, WE NEED TO SUPPORT HTTP RUNTIME CACHE, IN MEMORY CACHE, ETC...
-    /// </remarks>
-    internal abstract class CacheProviderBase
-    {
-        public abstract void ClearAllCache();
-        public abstract void ClearCacheItem(string key);
-        public abstract void ClearCacheObjectTypes(string typeName);
-        public abstract void ClearCacheObjectTypes<T>();
-        public abstract void ClearCacheObjectTypes<T>(Func<string, T, bool> predicate);
-        public abstract void ClearCacheByKeySearch(string keyStartsWith);
-        public abstract void ClearCacheByKeyExpression(string regexString);
-        public abstract IEnumerable<T> GetCacheItemsByKeySearch<T>(string keyStartsWith);
-        public abstract T GetCacheItem<T>(string cacheKey);
-        public abstract T GetCacheItem<T>(string cacheKey, Func<T> getCacheItem);
-    }
-}

src/Umbraco.Core/Cache/CacheProviderExtensions.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Web.Caching;
+
+namespace Umbraco.Core.Cache
+{
+    /// <summary>
+    /// Extensions for strongly typed access
+    /// </summary>
+    internal static class CacheProviderExtensions
+    {
+        public static T GetCacheItem<T>(this IRuntimeCacheProvider provider,
+            string cacheKey,
+            Func<T> getCacheItem,
+            TimeSpan? timeout,
+            bool isSliding = false,
+            CacheItemPriority priority = CacheItemPriority.Normal,
+            CacheItemRemovedCallback removedCallback = null,
+            string[] dependentFiles = null)
+        {
+            var result = provider.GetCacheItem(cacheKey, () => getCacheItem(), timeout, isSliding, priority, removedCallback, dependentFiles);
+            return result == null ? default(T) : result.TryConvertTo<T>().Result;
+        }
+
+        public static void InsertCacheItem<T>(this IRuntimeCacheProvider provider,
+            string cacheKey,
+            Func<T> getCacheItem,
+            TimeSpan? timeout = null,
+            bool isSliding = false,
+            CacheItemPriority priority = CacheItemPriority.Normal,
+            CacheItemRemovedCallback removedCallback = null,
+            string[] dependentFiles = null)
+        {
+            provider.InsertCacheItem(cacheKey, () => getCacheItem(), timeout, isSliding, priority, removedCallback, dependentFiles);
+        }
+
+        public static IEnumerable<T> GetCacheItemsByKeySearch<T>(this ICacheProvider provider, string keyStartsWith)
+        {
+            var result = provider.GetCacheItemsByKeySearch(keyStartsWith);
+            return result.Select(x => x.TryConvertTo<T>().Result);
+        }
+
+        public static T GetCacheItem<T>(this ICacheProvider provider, string cacheKey)
+        {
+            var result = provider.GetCacheItem(cacheKey);
+            if (result == null)
+            {
+                return default(T);
+            }
+            return result.TryConvertTo<T>().Result;
+        }
+
+        public static T GetCacheItem<T>(this ICacheProvider provider, string cacheKey, Func<T> getCacheItem)
+        {
+            var result = provider.GetCacheItem(cacheKey, () => getCacheItem());
+            if (result == null)
+            {
+                return default(T);
+            }
+            return result.TryConvertTo<T>().Result;
+        }
+    }
+}

src/Umbraco.Core/Cache/DictionaryCacheProviderBase.cs

@@ -0,0 +1,198 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.RegularExpressions;
+using System.Threading;
+
+namespace Umbraco.Core.Cache
+{
+    internal abstract class DictionaryCacheProviderBase : ICacheProvider
+    {
+        protected static readonly ReaderWriterLockSlim Locker = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
+        protected abstract DictionaryCacheWrapper DictionaryCache { get; }
+
+        /// <summary>
+        /// Clears everything in umbraco's runtime cache
+        /// </summary>
+        /// <remarks>
+        /// Does not clear other stuff the user has put in httpruntime.cache!
+        /// </remarks>
+        public virtual void ClearAllCache()
+        {
+            using (new WriteLock(Locker))
+            {
+                var keysToRemove = DictionaryCache.Cast<object>()
+                                                  .Select(item => new DictionaryItemWrapper(item))
+                                                  .Where(c => c.Key is string && ((string)c.Key).StartsWith(CacheItemPrefix) && DictionaryCache[c.Key.ToString()] != null)
+                                                  .Select(c => c.Key)
+                                                  .ToList();
+
+                foreach (var k in keysToRemove)
+                {
+                    DictionaryCache.Remove(k);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Clears the item in umbraco's runtime cache with the given key 
+        /// </summary>
+        /// <param name="key">Key</param>
+        public virtual void ClearCacheItem(string key)
+        {
+            using (new WriteLock(Locker))
+            {
+                if (DictionaryCache[GetCacheKey(key)] == null) return;
+                DictionaryCache.Remove(GetCacheKey(key)); ;
+            }
+        }
+
+        /// <summary>
+        /// Clears all objects in the System.Web.Cache with the System.Type name as the
+        /// input parameter. (using [object].GetType())
+        /// </summary>
+        /// <param name="typeName">The name of the System.Type which should be cleared from cache ex "System.Xml.XmlDocument"</param>
+        public virtual void ClearCacheObjectTypes(string typeName)
+        {
+            using (new WriteLock(Locker))
+            {
+                var keysToRemove = DictionaryCache
+                    .Cast<object>()
+                    .Select(item => new DictionaryItemWrapper(item))
+                    .Where(c =>
+                    {
+                        var k = c.Key.ToString();
+                        var v = DictionaryCache[k];
+                        return v != null && v.GetType().ToString().InvariantEquals(typeName);
+                    })
+                    .Select(c => c.Key)
+                    .ToList();
+
+                foreach (var k in keysToRemove)
+                    DictionaryCache.Remove(k);
+            }
+        }
+
+        public virtual void ClearCacheObjectTypes<T>()
+        {
+            using (new WriteLock(Locker))
+            {
+                var typeOfT = typeof(T);
+                var keysToRemove = DictionaryCache
+                    .Cast<object>()
+                    .Select(item => new DictionaryItemWrapper(item))
+                    .Where(c =>
+                    {
+                        var k = c.Key.ToString();
+                        var v = DictionaryCache[k];
+                        return v != null && v.GetType() == typeOfT;
+                    })
+                    .Select(c => c.Key)
+                    .ToList();
+
+                foreach (var k in keysToRemove)
+                    DictionaryCache.Remove(k);
+            }
+        }
+
+        public virtual void ClearCacheObjectTypes<T>(Func<string, T, bool> predicate)
+        {
+            using (new WriteLock(Locker))
+            {
+                var typeOfT = typeof(T);
+                var keysToRemove = DictionaryCache
+                    .Cast<object>()
+                    .Select(item => new DictionaryItemWrapper(item))
+                    .Where(c =>
+                    {
+                        var k = c.Key.ToString();
+                        var v = DictionaryCache[k];
+                        return v != null && v.GetType() == typeOfT && predicate(k, (T)v);
+                    })
+                    .Select(c => c.Key)
+                    .ToList();
+
+                foreach (var k in keysToRemove)
+                    DictionaryCache.Remove(k);
+            }
+        }
+
+        /// <summary>
+        /// Clears all cache items that starts with the key passed.
+        /// </summary>
+        /// <param name="keyStartsWith">The start of the key</param>
+        public virtual void ClearCacheByKeySearch(string keyStartsWith)
+        {
+            var keysToRemove = DictionaryCache.Cast<object>()
+                                              .Select(item => new DictionaryItemWrapper(item))
+                                              .Where(c => c.Key is string && ((string)c.Key).InvariantStartsWith(string.Format("{0}-{1}", CacheItemPrefix, keyStartsWith)))
+                                              .Select(c => c.Key)
+                                              .ToList();
+
+            foreach (var k in keysToRemove)
+            {
+                DictionaryCache.Remove(k);
+            }
+        }
+
+        /// <summary>
+        /// Clears all cache items that have a key that matches the regular expression
+        /// </summary>
+        /// <param name="regexString"></param>
+        public virtual void ClearCacheByKeyExpression(string regexString)
+        {
+            var keysToRemove = new List<object>();
+            foreach (var item in DictionaryCache)
+            {
+                var c = new DictionaryItemWrapper(item);
+                var s = c.Key as string;
+                if (s != null)
+                {
+                    var withoutPrefix = s.TrimStart(string.Format("{0}-", CacheItemPrefix));
+                    if (Regex.IsMatch(withoutPrefix, regexString))
+                    {
+                        keysToRemove.Add(c.Key);
+                    }
+                }
+            }
+
+            foreach (var k in keysToRemove)
+            {
+                DictionaryCache.Remove(k);
+            }
+        }
+
+        public virtual IEnumerable<object> GetCacheItemsByKeySearch(string keyStartsWith)
+        {
+            return (from object item in DictionaryCache
+                    select new DictionaryItemWrapper(item)
+                    into c
+                    where c.Key is string && ((string) c.Key).InvariantStartsWith(string.Format("{0}-{1}", CacheItemPrefix, keyStartsWith))
+                    select c.Value).ToList();
+        }
+
+        /// <summary>
+        /// Returns a cache item by key, does not update the cache if it isn't there.
+        /// </summary>
+        /// <param name="cacheKey"></param>
+        /// <returns></returns>
+        public virtual object GetCacheItem(string cacheKey)
+        {
+            var result = DictionaryCache.Get(GetCacheKey(cacheKey));
+            return result;
+        }
+
+        public abstract object GetCacheItem(string cacheKey, Func<object> getCacheItem);        
+
+        /// <summary>
+        /// We prefix all cache keys with this so that we know which ones this class has created when 
+        /// using the HttpRuntime cache so that when we clear it we don't clear other entries we didn't create.
+        /// </summary>
+        protected const string CacheItemPrefix = "umbrtmche";
+
+        protected string GetCacheKey(string key)
+        {
+            return string.Format("{0}-{1}", CacheItemPrefix, key);
+        }
+    }
+}

src/Umbraco.Core/Cache/DictionaryCacheWrapper.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Collections;
+
+namespace Umbraco.Core.Cache
+{
+    internal class DictionaryCacheWrapper : IEnumerable
+    {
+        private readonly IEnumerable _inner;
+        private readonly Func<object, object> _get;
+        private readonly Action<object> _remove;
+
+        public DictionaryCacheWrapper(
+            IEnumerable inner,
+            Func<object, object> get,
+            Action<object> remove)
+        {
+            _inner = inner;
+            _get = get;
+            _remove = remove;
+        }
+
+        public object this[object key]
+        {
+            get
+            {
+                return Get(key);
+            }            
+        }
+
+        public object Get(object key)
+        {
+            return _get(key);
+        }
+
+        public void Remove(object key)
+        {
+            _remove(key);
+        }
+
+        public IEnumerator GetEnumerator()
+        {
+            return _inner.GetEnumerator();
+        }
+    }
+}

src/Umbraco.Core/Cache/DictionaryItemWrapper.cs

@@ -0,0 +1,14 @@
+namespace Umbraco.Core.Cache
+{
+    internal class DictionaryItemWrapper
+    {
+        public DictionaryItemWrapper(dynamic item)
+        {
+            Key = item.Key;
+            Value = item.Value;
+        }
+        
+        public object Key { get; private set; }
+        public object Value { get; private set; }
+    }
+}

src/Umbraco.Core/Cache/HttpRequestCacheProvider.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.RegularExpressions;
+using System.Web;
+
+namespace Umbraco.Core.Cache
+{
+    /// <summary>
+    /// A cache provider that caches items in the HttpContext.Items
+    /// </summary>
+    internal class HttpRequestCacheProvider : DictionaryCacheProviderBase
+    {
+        private readonly Func<HttpContextBase> _context;
+
+        public HttpRequestCacheProvider(HttpContext context)
+        {
+            _context = () => new HttpContextWrapper(context);
+        }
+
+        public HttpRequestCacheProvider(Func<HttpContextBase> context)
+        {
+            _context = context;
+        }
+
+        protected override DictionaryCacheWrapper DictionaryCache
+        {
+            get
+            {
+                var ctx = _context();
+                return new DictionaryCacheWrapper(
+                    ctx.Items,
+                    o => ctx.Items[o],
+                    o => ctx.Items.Remove(o));
+            }
+        }
+
+        public override object GetCacheItem(string cacheKey, Func<object> getCacheItem)
+        {
+            var ctx = _context();
+            var ck = GetCacheKey(cacheKey);
+            return ctx.Items[ck] ?? (ctx.Items[ck] = getCacheItem());
+        }
+
+    }
+}

src/Umbraco.Core/Cache/HttpRuntimeCacheProvider.cs

@@ -1,106 +1,31 @@
 using System;
 using System.Collections;
-using System.Collections.Generic;
 using System.Linq;
-using System.Text.RegularExpressions;
+using System.Threading;
+using System.Web;
 using System.Web.Caching;
 using Umbraco.Core.Logging;
+using CacheItemPriority = System.Web.Caching.CacheItemPriority;
 
 namespace Umbraco.Core.Cache
 {
     /// <summary>
     /// A CacheProvider that wraps the logic of the HttpRuntime.Cache
     /// </summary>
-    internal class HttpRuntimeCacheProvider : RuntimeCacheProviderBase
+    internal class HttpRuntimeCacheProvider : DictionaryCacheProviderBase, IRuntimeCacheProvider
     {
         private readonly System.Web.Caching.Cache _cache;
-        private static readonly object Locker = new object();
-
+        private readonly DictionaryCacheWrapper _wrapper;
+        
         public HttpRuntimeCacheProvider(System.Web.Caching.Cache cache)
         {
             _cache = cache;
+            _wrapper = new DictionaryCacheWrapper(_cache, s => _cache.Get(s.ToString()), o => _cache.Remove(o.ToString()));
         }
 
-        /// <summary>
-        /// Clears everything in umbraco's runtime cache, which means that not only
-        /// umbraco content is removed, but also other cache items from pages running in
-        /// the same application / website. Use with care :-)
-        /// </summary>
-        public override void ClearAllCache()
+        protected override DictionaryCacheWrapper DictionaryCache
         {
-            var cacheEnumerator = _cache.GetEnumerator();
-            while (cacheEnumerator.MoveNext())
-            {
-                _cache.Remove(cacheEnumerator.Key.ToString());
-            }
-        }
-
-        /// <summary>
-        /// Clears the item in umbraco's runtime cache with the given key 
-        /// </summary>
-        /// <param name="key">Key</param>
-        public override void ClearCacheItem(string key)
-        {
-            // NH 10 jan 2012
-            // Patch by the always wonderful Stéphane Gay to avoid cache null refs
-            lock (Locker)
-            {
-                if (_cache[key] == null) return;
-                _cache.Remove(key); ;
-            }
-        }
-
-
-        /// <summary>
-        /// Clears all objects in the System.Web.Cache with the System.Type name as the
-        /// input parameter. (using [object].GetType())
-        /// </summary>
-        /// <param name="typeName">The name of the System.Type which should be cleared from cache ex "System.Xml.XmlDocument"</param>
-        public override void ClearCacheObjectTypes(string typeName)
-        {
-            try
-            {
-                lock (Locker)
-                {
-                    foreach (DictionaryEntry c in _cache)
-                    {
-                        if (_cache[c.Key.ToString()] != null
-                            && _cache[c.Key.ToString()].GetType().ToString().InvariantEquals(typeName))
-                        {
-                            _cache.Remove(c.Key.ToString());
-                        }
-                    }
-                }
-            }
-            catch (Exception e)
-            {
-                LogHelper.Error<CacheHelper>("Cache clearing error", e);
-            }
-        }
-
-        /// <summary>
-        /// Clears all objects in the System.Web.Cache with the System.Type specified
-        /// </summary>
-        public override void ClearCacheObjectTypes<T>()
-        {
-            try
-            {
-                lock (Locker)
-                {
-                    foreach (DictionaryEntry c in _cache)
-                    {
-                        if (_cache[c.Key.ToString()] != null
-                            && _cache[c.Key.ToString()].GetType() == typeof(T))
-                        {
-                            _cache.Remove(c.Key.ToString());
-                        }
-                    }
-                }
-            }
-            catch (Exception e)
-            {
-                LogHelper.Error<CacheHelper>("Cache clearing error", e);
-            }
+            get { return _wrapper; }
         }
 
         /// <summary>
@@ -130,254 +55,94 @@ namespace Umbraco.Core.Cache
             }
         }
 
-        /// <summary>
-        /// Clears all cache items that starts with the key passed.
-        /// </summary>
-        /// <param name="keyStartsWith">The start of the key</param>
-        public override void ClearCacheByKeySearch(string keyStartsWith)
-        {
-            foreach (DictionaryEntry c in _cache)
-            {
-                if (c.Key is string && ((string)c.Key).InvariantStartsWith(keyStartsWith))
-                {
-                    ClearCacheItem((string)c.Key);
-                }
-            }
-        }
-
-        /// <summary>
-        /// Clears all cache items that have a key that matches the regular expression
-        /// </summary>
-        /// <param name="regexString"></param>
-        public override void ClearCacheByKeyExpression(string regexString)
-        {
-            foreach (DictionaryEntry c in _cache)
-            {
-                if (c.Key is string && Regex.IsMatch(((string)c.Key), regexString))
-                {
-                    ClearCacheItem((string)c.Key);
-                }
-            }
-        }
-
-        public override IEnumerable<T> GetCacheItemsByKeySearch<T>(string keyStartsWith)
-        {
-            return (from DictionaryEntry c in _cache
-                    where c.Key is string && ((string)c.Key).InvariantStartsWith(keyStartsWith)
-                    select c.Value.TryConvertTo<T>()
-                    into attempt
-                    where attempt.Success
-                    select attempt.Result).ToList();
-        }
-
-        /// <summary>
-        /// Returns a cache item by key, does not update the cache if it isn't there.
-        /// </summary>
-        /// <typeparam name="TT"></typeparam>
-        /// <param name="cacheKey"></param>
-        /// <returns></returns>
-        public override TT GetCacheItem<TT>(string cacheKey)
-        {
-            var result = _cache.Get(cacheKey);
-            if (result == null)
-            {
-                return default(TT);
-            }
-            return result.TryConvertTo<TT>().Result;
-        }
-
         /// <summary>
         /// Gets (and adds if necessary) an item from the cache with all of the default parameters
         /// </summary>
-        /// <typeparam name="TT"></typeparam>
         /// <param name="cacheKey"></param>
         /// <param name="getCacheItem"></param>
         /// <returns></returns>
-        public override TT GetCacheItem<TT>(string cacheKey, Func<TT> getCacheItem)
+        public override object GetCacheItem(string cacheKey, Func<object> getCacheItem)
         {
-            return GetCacheItem(cacheKey, CacheItemPriority.Normal, null, null, null, getCacheItem, Locker);
+            return GetCacheItem(cacheKey, getCacheItem, null, dependentFiles: null);
         }
 
         /// <summary>
-        /// Gets (and adds if necessary) an item from the cache with the specified absolute expiration date (from NOW)
+        /// This overload is here for legacy purposes
         /// </summary>
-        /// <typeparam name="TT"></typeparam>
         /// <param name="cacheKey"></param>
-        /// <param name="timeout">This will set an absolute expiration from now until the timeout</param>
         /// <param name="getCacheItem"></param>
-        /// <returns></returns>
-        public override TT GetCacheItem<TT>(string cacheKey,
-                                            TimeSpan? timeout, Func<TT> getCacheItem)
-        {
-            return GetCacheItem(cacheKey, null, timeout, getCacheItem);
-        }
-
-        /// <summary>
-        /// Gets (and adds if necessary) an item from the cache with the specified absolute expiration date (from NOW)
-        /// </summary>
-        /// <typeparam name="TT"></typeparam>
-        /// <param name="cacheKey"></param>
-        /// <param name="refreshAction"></param>
-        /// <param name="timeout">This will set an absolute expiration from now until the timeout</param>
-        /// <param name="getCacheItem"></param>
-        /// <returns></returns>
-        public override TT GetCacheItem<TT>(string cacheKey,
-                                            CacheItemRemovedCallback refreshAction, TimeSpan? timeout,
-                                            Func<TT> getCacheItem)
-        {
-            return GetCacheItem(cacheKey, CacheItemPriority.Normal, refreshAction, timeout, getCacheItem);
-        }
-
-        /// <summary>
-        /// Gets (and adds if necessary) an item from the cache with the specified absolute expiration date (from NOW)
-        /// </summary>
-        /// <typeparam name="TT"></typeparam>
-        /// <param name="cacheKey"></param>
+        /// <param name="timeout"></param>
+        /// <param name="isSliding"></param>
         /// <param name="priority"></param>
-        /// <param name="refreshAction"></param>
-        /// <param name="timeout">This will set an absolute expiration from now until the timeout</param>
-        /// <param name="getCacheItem"></param>
+        /// <param name="removedCallback"></param>
+        /// <param name="dependency"></param>
         /// <returns></returns>
-        public override TT GetCacheItem<TT>(string cacheKey,
-                                            CacheItemPriority priority, CacheItemRemovedCallback refreshAction, TimeSpan? timeout,
-                                            Func<TT> getCacheItem)
+        internal object GetCacheItem(string cacheKey, Func<object> getCacheItem, TimeSpan? timeout, bool isSliding = false, CacheItemPriority priority = CacheItemPriority.Normal, CacheItemRemovedCallback removedCallback = null, CacheDependency dependency = null)
         {
-            return GetCacheItem(cacheKey, priority, refreshAction, null, timeout, getCacheItem);
-        }
+            cacheKey = GetCacheKey(cacheKey);
 
-        /// <summary>
-        /// Gets (and adds if necessary) an item from the cache with the specified absolute expiration date (from NOW)
-        /// </summary>
-        /// <typeparam name="TT"></typeparam>
-        /// <param name="cacheKey"></param>
-        /// <param name="priority"></param>
-        /// <param name="refreshAction"></param>
-        /// <param name="cacheDependency"></param>
-        /// <param name="timeout">This will set an absolute expiration from now until the timeout</param>
-        /// <param name="getCacheItem"></param>
-        /// <returns></returns>
-        public override TT GetCacheItem<TT>(string cacheKey,
-                                            CacheItemPriority priority,
-                                            CacheItemRemovedCallback refreshAction,
-                                            CacheDependency cacheDependency,
-                                            TimeSpan? timeout,
-                                            Func<TT> getCacheItem)
-        {
-            return GetCacheItem(cacheKey, priority, refreshAction, cacheDependency, timeout, getCacheItem, Locker);
-        }
-
-        /// <summary>
-        /// Gets (and adds if necessary) an item from the cache with the specified absolute expiration date (from NOW)
-        /// </summary>
-        /// <typeparam name="TT"></typeparam>
-        /// <param name="cacheKey"></param>
-        /// <param name="priority"></param>
-        /// <param name="refreshAction"></param>
-        /// <param name="cacheDependency"></param>
-        /// <param name="timeout">This will set an absolute expiration from now until the timeout</param>
-        /// <param name="getCacheItem"></param>
-        /// <param name="syncLock"></param>
-        /// <returns></returns>
-        private TT GetCacheItem<TT>(string cacheKey,
-                                     CacheItemPriority priority, CacheItemRemovedCallback refreshAction,
-                                     CacheDependency cacheDependency, TimeSpan? timeout, Func<TT> getCacheItem, object syncLock)
-        {
-            var result = _cache.Get(cacheKey);
-            if (result == null)
+            using (var lck = new UpgradeableReadLock(Locker))
             {
-                lock (syncLock)
+                var result = DictionaryCache.Get(cacheKey);
+                if (result == null)
                 {
-                    result = _cache.Get(cacheKey);
-                    if (result == null)
-                    {
-                        result = getCacheItem();
-                        if (result != null)
-                        {
-                            //we use Insert instead of add if for some crazy reason there is now a cache with the cache key in there, it will just overwrite it.
-                            _cache.Insert(cacheKey, result, cacheDependency,
-                                          timeout == null ? System.Web.Caching.Cache.NoAbsoluteExpiration : DateTime.Now.Add(timeout.Value),
-                                          TimeSpan.Zero, priority, refreshAction);
-                        }
+                    lck.UpgradeToWriteLock();
+
+                    result = getCacheItem();
+                    if (result != null)
+                    {                        
+                        var absolute = isSliding ? System.Web.Caching.Cache.NoAbsoluteExpiration : (timeout == null ? System.Web.Caching.Cache.NoAbsoluteExpiration : DateTime.Now.Add(timeout.Value));
+                        var sliding = isSliding == false ? System.Web.Caching.Cache.NoSlidingExpiration : (timeout ?? System.Web.Caching.Cache.NoSlidingExpiration);
+
+                        _cache.Insert(cacheKey, result, dependency, absolute, sliding, priority, removedCallback);
                     }
+
                 }
+                return result;
             }
-            return result.TryConvertTo<TT>().Result;
         }
 
-        /// <summary>
-        /// Inserts an item into the cache, if it already exists in the cache it will be replaced
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <param name="cacheKey"></param>
-        /// <param name="priority"></param>
-        /// <param name="getCacheItem"></param>
-        public override void InsertCacheItem<T>(string cacheKey,
-                                                CacheItemPriority priority,
-                                                Func<T> getCacheItem)
+        public object GetCacheItem(string cacheKey, Func<object> getCacheItem, TimeSpan? timeout, bool isSliding = false, CacheItemPriority priority = CacheItemPriority.Normal, CacheItemRemovedCallback removedCallback = null, string[] dependentFiles = null)
         {
-            InsertCacheItem(cacheKey, priority, null, null, null, getCacheItem);
-        }
-
-        /// <summary>
-        /// Inserts an item into the cache, if it already exists in the cache it will be replaced
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <param name="cacheKey"></param>
-        /// <param name="priority"></param>
-        /// <param name="timeout">This will set an absolute expiration from now until the timeout</param>
-        /// <param name="getCacheItem"></param>
-        public override void InsertCacheItem<T>(string cacheKey,
-                                                CacheItemPriority priority,
-                                                TimeSpan? timeout,
-                                                Func<T> getCacheItem)
-        {
-            InsertCacheItem(cacheKey, priority, null, null, timeout, getCacheItem);
-        }
-
-        /// <summary>
-        /// Inserts an item into the cache, if it already exists in the cache it will be replaced
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <param name="cacheKey"></param>
-        /// <param name="priority"></param>
-        /// <param name="cacheDependency"></param>
-        /// <param name="timeout">This will set an absolute expiration from now until the timeout</param>
-        /// <param name="getCacheItem"></param>
-        public override void InsertCacheItem<T>(string cacheKey,
-                                                CacheItemPriority priority,
-                                                CacheDependency cacheDependency,
-                                                TimeSpan? timeout,
-                                                Func<T> getCacheItem)
-        {
-            InsertCacheItem(cacheKey, priority, null, cacheDependency, timeout, getCacheItem);
-        }
-
-        /// <summary>
-        /// Inserts an item into the cache, if it already exists in the cache it will be replaced
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <param name="cacheKey"></param>
-        /// <param name="priority"></param>
-        /// <param name="refreshAction"></param>
-        /// <param name="cacheDependency"></param>
-        /// <param name="timeout">This will set an absolute expiration from now until the timeout</param>
-        /// <param name="getCacheItem"></param>
-        public override void InsertCacheItem<T>(string cacheKey,
-                                                CacheItemPriority priority,
-                                                CacheItemRemovedCallback refreshAction,
-                                                CacheDependency cacheDependency,
-                                                TimeSpan? timeout,
-                                                Func<T> getCacheItem)
-        {
-            object result = getCacheItem();
-            if (result != null)
+            CacheDependency dependency = null;
+            if (dependentFiles != null && dependentFiles.Any())
             {
-                //we use Insert instead of add if for some crazy reason there is now a cache with the cache key in there, it will just overwrite it.
-                _cache.Insert(cacheKey, result, cacheDependency,
-                              timeout == null ? System.Web.Caching.Cache.NoAbsoluteExpiration : DateTime.Now.Add(timeout.Value),
-                              TimeSpan.Zero, priority, refreshAction);
+                dependency = new CacheDependency(dependentFiles);
             }
+            return GetCacheItem(cacheKey, getCacheItem, timeout, isSliding, priority, removedCallback, dependency);
         }
 
+        /// <summary>
+        /// This overload is here for legacy purposes
+        /// </summary>
+        /// <param name="cacheKey"></param>
+        /// <param name="getCacheItem"></param>
+        /// <param name="timeout"></param>
+        /// <param name="isSliding"></param>
+        /// <param name="priority"></param>
+        /// <param name="removedCallback"></param>
+        /// <param name="dependency"></param>
+        internal void InsertCacheItem(string cacheKey, Func<object> getCacheItem, TimeSpan? timeout = null, bool isSliding = false, CacheItemPriority priority = CacheItemPriority.Normal, CacheItemRemovedCallback removedCallback = null, CacheDependency dependency = null)
+        {
+            var result = getCacheItem();
+            if (result == null) return;
+
+            cacheKey = GetCacheKey(cacheKey);           
+
+            var absolute = isSliding ? System.Web.Caching.Cache.NoAbsoluteExpiration : (timeout == null ? System.Web.Caching.Cache.NoAbsoluteExpiration : DateTime.Now.Add(timeout.Value));
+            var sliding = isSliding == false ? System.Web.Caching.Cache.NoSlidingExpiration : (timeout ?? System.Web.Caching.Cache.NoSlidingExpiration);
+
+            _cache.Insert(cacheKey, result, dependency, absolute, sliding, priority, removedCallback);
+        }
+
+        public void InsertCacheItem(string cacheKey, Func<object> getCacheItem, TimeSpan? timeout = null, bool isSliding = false, CacheItemPriority priority = CacheItemPriority.Normal, CacheItemRemovedCallback removedCallback = null, string[] dependentFiles = null)
+        {
+            CacheDependency dependency = null;
+            if (dependentFiles != null && dependentFiles.Any())
+            {
+                dependency = new CacheDependency(dependentFiles);
+            }
+            InsertCacheItem(cacheKey, getCacheItem, timeout, isSliding, priority, removedCallback, dependency);
+        }
     }
 }

src/Umbraco.Core/Cache/ICacheProvider.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+
+namespace Umbraco.Core.Cache
+{
+    /// <summary>
+    /// An abstract class for implementing a basic cache provider
+    /// </summary>
+    public interface ICacheProvider
+    {
+        void ClearAllCache();
+        void ClearCacheItem(string key);
+        void ClearCacheObjectTypes(string typeName);
+        void ClearCacheObjectTypes<T>();
+        void ClearCacheObjectTypes<T>(Func<string, T, bool> predicate);
+        void ClearCacheByKeySearch(string keyStartsWith);
+        void ClearCacheByKeyExpression(string regexString);
+        IEnumerable<object> GetCacheItemsByKeySearch(string keyStartsWith);
+        object GetCacheItem(string cacheKey);
+        object GetCacheItem(string cacheKey, Func<object> getCacheItem);
+    }
+}

src/Umbraco.Core/Cache/IRuntimeCacheProvider.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Runtime.Caching;
+using System.Text;
+using System.Web.Caching;
+using CacheItemPriority = System.Web.Caching.CacheItemPriority;
+
+namespace Umbraco.Core.Cache
+{
+    /// <summary>
+    /// An abstract class for implementing a runtime cache provider
+    /// </summary>
+    /// <remarks>
+    /// </remarks>
+    public interface IRuntimeCacheProvider : ICacheProvider
+    {
+        object GetCacheItem(
+            string cacheKey, 
+            Func<object> getCacheItem, 
+            TimeSpan? timeout,
+            bool isSliding = false,
+            CacheItemPriority priority = CacheItemPriority.Normal,
+            CacheItemRemovedCallback removedCallback = null,
+            string[] dependentFiles = null);
+
+        void InsertCacheItem(
+            string cacheKey,
+            Func<object> getCacheItem,
+            TimeSpan? timeout = null,
+            bool isSliding = false,
+            CacheItemPriority priority = CacheItemPriority.Normal,
+            CacheItemRemovedCallback removedCallback = null,
+            string[] dependentFiles = null);
+
+    }
+}

src/Umbraco.Core/Cache/NullCacheProvider.cs

@@ -5,85 +5,62 @@ using System.Web.Caching;
 
 namespace Umbraco.Core.Cache
 {
-    internal class NullCacheProvider : RuntimeCacheProviderBase
+    internal class NullCacheProvider : IRuntimeCacheProvider
     {
-        public override void ClearAllCache()
+        public virtual void ClearAllCache()
         {
         }
 
-        public override void ClearCacheItem(string key)
+        public virtual void ClearCacheItem(string key)
         {
         }
 
-        public override void ClearCacheObjectTypes(string typeName)
+        public virtual void ClearCacheObjectTypes(string typeName)
         {
         }
 
-        public override void ClearCacheObjectTypes<T>()
+        public virtual void ClearCacheObjectTypes<T>()
         {
         }
 
-        public override void ClearCacheObjectTypes<T>(Func<string, T, bool> predicate)
+        public virtual void ClearCacheObjectTypes<T>(Func<string, T, bool> predicate)
         {
         }
 
-        public override void ClearCacheByKeySearch(string keyStartsWith)
+
+
+
+        public virtual void ClearCacheByKeySearch(string keyStartsWith)
         {
         }
 
-        public override void ClearCacheByKeyExpression(string regexString)
+        public virtual void ClearCacheByKeyExpression(string regexString)
         {
         }
 
-        public override IEnumerable<T> GetCacheItemsByKeySearch<T>(string keyStartsWith)
+        public virtual IEnumerable<object> GetCacheItemsByKeySearch(string keyStartsWith)
         {
-            return Enumerable.Empty<T>();
+            return Enumerable.Empty<object>();
         }
 
-        public override T GetCacheItem<T>(string cacheKey)
+        public virtual object GetCacheItem(string cacheKey)
         {
-            return default(T);
+            return default(object);
         }
 
-        public override T GetCacheItem<T>(string cacheKey, Func<T> getCacheItem)
+        public virtual object GetCacheItem(string cacheKey, Func<object> getCacheItem)
         {
             return getCacheItem();
         }
 
-        public override T GetCacheItem<T>(string cacheKey, TimeSpan? timeout, Func<T> getCacheItem)
+        public object GetCacheItem(string cacheKey, Func<object> getCacheItem, TimeSpan? timeout, bool isSliding = false, CacheItemPriority priority = CacheItemPriority.Normal, CacheItemRemovedCallback removedCallback = null, string[] dependentFiles = null)
         {
             return getCacheItem();
         }
 
-        public override T GetCacheItem<T>(string cacheKey, CacheItemRemovedCallback refreshAction, TimeSpan? timeout, Func<T> getCacheItem)
-        {
-            return getCacheItem();
-        }
-
-        public override T GetCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheItemRemovedCallback refreshAction, TimeSpan? timeout, Func<T> getCacheItem)
-        {
-            return getCacheItem();
-        }
-
-        public override T GetCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheItemRemovedCallback refreshAction, CacheDependency cacheDependency, TimeSpan? timeout, Func<T> getCacheItem)
-        {
-            return getCacheItem();
-        }
-
-        public override void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, Func<T> getCacheItem)
-        {
-        }
-
-        public override void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, TimeSpan? timeout, Func<T> getCacheItem)
-        {
-        }
-
-        public override void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheDependency cacheDependency, TimeSpan? timeout, Func<T> getCacheItem)
-        {
-        }
-
-        public override void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheItemRemovedCallback refreshAction, CacheDependency cacheDependency, TimeSpan? timeout, Func<T> getCacheItem)
+        public void InsertCacheItem(string cacheKey, Func<object> getCacheItem, TimeSpan? timeout = null, bool isSliding = false, CacheItemPriority priority = CacheItemPriority.Normal, CacheItemRemovedCallback removedCallback = null, string[] dependentFiles = null)
         {
+            
         }
     }
 }

src/Umbraco.Core/Cache/ObjectCacheRuntimeCacheProvider.cs

@@ -0,0 +1,213 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Runtime.Caching;
+using System.Text.RegularExpressions;
+using System.Threading;
+using System.Web.Caching;
+using Umbraco.Core.Logging;
+using CacheItemPriority = System.Web.Caching.CacheItemPriority;
+
+namespace Umbraco.Core.Cache
+{
+    /// <summary>
+    /// A cache provider that wraps the logic of a System.Runtime.Caching.ObjectCache
+    /// </summary>
+    internal class ObjectCacheRuntimeCacheProvider : IRuntimeCacheProvider
+    {
+        private static readonly ReaderWriterLockSlim Locker = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
+        internal ObjectCache MemoryCache;
+
+        public ObjectCacheRuntimeCacheProvider()
+        {
+            MemoryCache = new MemoryCache("in-memory");
+        }
+
+        public virtual void ClearAllCache()
+        {
+            using (new WriteLock(Locker))
+            {
+                MemoryCache.DisposeIfDisposable();
+                MemoryCache = new MemoryCache("in-memory");
+            }
+        }
+
+        public virtual void ClearCacheItem(string key)
+        {
+            using (new WriteLock(Locker))
+            {
+                if (MemoryCache[key] == null) return;
+                MemoryCache.Remove(key);
+            }            
+        }
+
+        public virtual void ClearCacheObjectTypes(string typeName)
+        {
+            using (new WriteLock(Locker))
+            {
+                var keysToRemove = MemoryCache
+                    .Where(c => c.Value != null && c.Value.GetType().ToString().InvariantEquals(typeName))
+                    .Select(c => c.Key)
+                    .ToArray();
+                foreach (var k in keysToRemove)
+                    MemoryCache.Remove(k);
+            }
+        }
+
+        public virtual void ClearCacheObjectTypes<T>()
+        {
+            using (new WriteLock(Locker))
+            {
+                var typeOfT = typeof (T);
+                var keysToRemove = MemoryCache
+                    .Where(c => c.Value != null && c.Value.GetType() == typeOfT)
+                    .Select(c => c.Key)
+                    .ToArray();
+                foreach (var k in keysToRemove)
+                    MemoryCache.Remove(k);
+            }
+        }
+
+        public virtual void ClearCacheObjectTypes<T>(Func<string, T, bool> predicate)
+        {
+            using (new WriteLock(Locker))
+            {
+                var typeOfT = typeof(T);
+                var keysToRemove = MemoryCache
+                    .Where(c => c.Value != null && c.Value.GetType() == typeOfT && predicate(c.Key, (T)c.Value))
+                    .Select(c => c.Key)
+                    .ToArray();
+                foreach (var k in keysToRemove)
+                    MemoryCache.Remove(k);
+            }
+        }
+
+        public virtual void ClearCacheByKeySearch(string keyStartsWith)
+        {
+            using (new WriteLock(Locker))
+            {
+                var keysToRemove = (from c in MemoryCache where c.Key.InvariantStartsWith(keyStartsWith) select c.Key).ToList();
+                foreach (var k in keysToRemove)
+                {
+                    MemoryCache.Remove(k);
+                }
+            }            
+        }
+
+        public virtual void ClearCacheByKeyExpression(string regexString)
+        {
+            using (new WriteLock(Locker))
+            {
+                var keysToRemove = (from c in MemoryCache where Regex.IsMatch(c.Key, regexString) select c.Key).ToList();
+                foreach (var k in keysToRemove)
+                {
+                    MemoryCache.Remove(k);
+                }
+            }     
+        }
+
+        public virtual IEnumerable<object> GetCacheItemsByKeySearch(string keyStartsWith)
+        {
+            return (from c in MemoryCache
+                    where c.Key.InvariantStartsWith(keyStartsWith)
+                    select c.Value).ToList();
+        }
+
+        public virtual object GetCacheItem(string cacheKey)
+        {
+            var result = MemoryCache.Get(cacheKey);
+            return result;
+        }
+
+        public virtual object GetCacheItem(string cacheKey, Func<object> getCacheItem)
+        {
+            return GetCacheItem(cacheKey, getCacheItem, null);
+        }
+
+        public object GetCacheItem(
+            string cacheKey, 
+            Func<object> getCacheItem, 
+            TimeSpan? timeout, 
+            bool isSliding = false, 
+            CacheItemPriority priority = CacheItemPriority.Normal,
+            CacheItemRemovedCallback removedCallback = null, 
+            string[] dependentFiles = null)
+        {
+            using (var lck = new UpgradeableReadLock(Locker))
+            {
+                var result = MemoryCache.Get(cacheKey);
+                if (result == null)
+                {
+                    lck.UpgradeToWriteLock();
+
+                    result = getCacheItem();
+                    if (result != null)
+                    {
+                        var policy = GetPolicy(timeout, isSliding, removedCallback, dependentFiles);
+                        MemoryCache.Set(cacheKey, result, policy);
+                    }
+                }
+                return result;
+            }
+        }
+
+        public void InsertCacheItem(string cacheKey, Func<object> getCacheItem, TimeSpan? timeout = null, bool isSliding = false, CacheItemPriority priority = CacheItemPriority.Normal, CacheItemRemovedCallback removedCallback = null, string[] dependentFiles = null)
+        {
+            object result = getCacheItem();
+            if (result != null)
+            {
+                var policy = GetPolicy(timeout, isSliding, removedCallback, dependentFiles);
+                MemoryCache.Set(cacheKey, result, policy);
+            }
+        }
+
+        private static CacheItemPolicy GetPolicy(TimeSpan? timeout = null, bool isSliding = false, CacheItemRemovedCallback removedCallback = null, string[] dependentFiles = null)
+        {
+            var absolute = isSliding ? ObjectCache.InfiniteAbsoluteExpiration : (timeout == null ? ObjectCache.InfiniteAbsoluteExpiration : DateTime.Now.Add(timeout.Value));
+            var sliding = isSliding == false ? ObjectCache.NoSlidingExpiration : (timeout ?? ObjectCache.NoSlidingExpiration);
+
+            var policy = new CacheItemPolicy
+            {
+                AbsoluteExpiration = absolute,
+                SlidingExpiration = sliding
+            };
+
+            if (dependentFiles != null && dependentFiles.Any())
+            {
+                policy.ChangeMonitors.Add(new HostFileChangeMonitor(dependentFiles.ToList()));
+            }
+            
+            if (removedCallback != null)
+            {
+                policy.RemovedCallback = arguments =>
+                {
+                    //convert the reason
+                    var reason = CacheItemRemovedReason.Removed;
+                    switch (arguments.RemovedReason)
+                    {
+                        case CacheEntryRemovedReason.Removed:
+                            reason = CacheItemRemovedReason.Removed;
+                            break;
+                        case CacheEntryRemovedReason.Expired:
+                            reason = CacheItemRemovedReason.Expired;
+                            break;
+                        case CacheEntryRemovedReason.Evicted:
+                            reason = CacheItemRemovedReason.Underused;
+                            break;
+                        case CacheEntryRemovedReason.ChangeMonitorChanged:
+                            reason = CacheItemRemovedReason.Expired;
+                            break;
+                        case CacheEntryRemovedReason.CacheSpecificEviction:
+                            reason = CacheItemRemovedReason.Underused;
+                            break;
+                    }
+                    //call the callback
+                    removedCallback(arguments.CacheItem.Key, arguments.CacheItem.Value, reason);
+                };
+            }
+            return policy;
+        }
+        
+    }
+}

src/Umbraco.Core/Cache/RuntimeCacheProviderBase.cs

@@ -1,24 +0,0 @@
-using System;
-using System.Text;
-using System.Web.Caching;
-
-namespace Umbraco.Core.Cache
-{
-    /// <summary>
-    /// An abstract class for implementing a runtime cache provider
-    /// </summary>
-    /// <remarks>
-    /// THIS MUST REMAIN INTERNAL UNTIL WE STREAMLINE HOW ALL CACHE IS HANDLED, WE NEED TO SUPPORT HTTP RUNTIME CACHE, IN MEMORY CACHE, REQUEST CACHE, ETC...
-    /// </remarks>
-    internal abstract class RuntimeCacheProviderBase : CacheProviderBase
-    {
-        public abstract T GetCacheItem<T>(string cacheKey, TimeSpan? timeout, Func<T> getCacheItem);
-        public abstract T GetCacheItem<T>(string cacheKey, CacheItemRemovedCallback refreshAction, TimeSpan? timeout, Func<T> getCacheItem);
-        public abstract T GetCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheItemRemovedCallback refreshAction, TimeSpan? timeout, Func<T> getCacheItem);
-        public abstract T GetCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheItemRemovedCallback refreshAction, CacheDependency cacheDependency, TimeSpan? timeout, Func<T> getCacheItem);
-        public abstract void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, Func<T> getCacheItem);
-        public abstract void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, TimeSpan? timeout, Func<T> getCacheItem);
-        public abstract void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheDependency cacheDependency, TimeSpan? timeout, Func<T> getCacheItem);
-        public abstract void InsertCacheItem<T>(string cacheKey, CacheItemPriority priority, CacheItemRemovedCallback refreshAction, CacheDependency cacheDependency, TimeSpan? timeout, Func<T> getCacheItem);
-    }
-}

src/Umbraco.Core/Cache/StaticCacheProvider.cs

@@ -10,71 +10,64 @@ namespace Umbraco.Core.Cache
     /// <summary>
     /// A cache provider that statically caches everything in an in memory dictionary
     /// </summary>
-    internal class StaticCacheProvider : CacheProviderBase
+    internal class StaticCacheProvider : ICacheProvider
     {
-        private readonly ConcurrentDictionary<string, object> _staticCache = new ConcurrentDictionary<string, object>();
+        internal readonly ConcurrentDictionary<string, object> StaticCache = new ConcurrentDictionary<string, object>();
 
-        public override void ClearAllCache()
+        public virtual void ClearAllCache()
         {
-            _staticCache.Clear();
+            StaticCache.Clear();
         }
 
-        public override void ClearCacheItem(string key)
+        public virtual void ClearCacheItem(string key)
         {
             object val;
-            _staticCache.TryRemove(key, out val);
+            StaticCache.TryRemove(key, out val);
         }
 
-        public override void ClearCacheObjectTypes(string typeName)
+        public virtual void ClearCacheObjectTypes(string typeName)
         {
-            _staticCache.RemoveAll(kvp => kvp.Value != null && kvp.Value.GetType().ToString().InvariantEquals(typeName));
+            StaticCache.RemoveAll(kvp => kvp.Value != null && kvp.Value.GetType().ToString().InvariantEquals(typeName));
         }
 
-        public override void ClearCacheObjectTypes<T>()
-        {
-            var typeOfT = typeof (T);
-            _staticCache.RemoveAll(kvp => kvp.Value != null && kvp.Value.GetType() == typeOfT);
-        }
-
-        public override void ClearCacheObjectTypes<T>(Func<string, T, bool> predicate)
+        public virtual void ClearCacheObjectTypes<T>()
         {
             var typeOfT = typeof(T);
-            _staticCache.RemoveAll(kvp => kvp.Value != null && kvp.Value.GetType() == typeOfT && predicate(kvp.Key, (T)kvp.Value));
+            StaticCache.RemoveAll(kvp => kvp.Value != null && kvp.Value.GetType() == typeOfT);
         }
 
-        public override void ClearCacheByKeySearch(string keyStartsWith)
+        public virtual void ClearCacheObjectTypes<T>(Func<string, T, bool> predicate)
         {
-            _staticCache.RemoveAll(kvp => kvp.Key.InvariantStartsWith(keyStartsWith));
+            var typeOfT = typeof(T);
+            StaticCache.RemoveAll(kvp => kvp.Value != null && kvp.Value.GetType() == typeOfT && predicate(kvp.Key, (T)kvp.Value));
         }
 
-        public override void ClearCacheByKeyExpression(string regexString)
+        public virtual void ClearCacheByKeySearch(string keyStartsWith)
         {
-            _staticCache.RemoveAll(kvp => Regex.IsMatch(kvp.Key, regexString));
+            StaticCache.RemoveAll(kvp => kvp.Key.InvariantStartsWith(keyStartsWith));
         }
 
-        public override IEnumerable<T> GetCacheItemsByKeySearch<T>(string keyStartsWith)
+        public virtual void ClearCacheByKeyExpression(string regexString)
         {
-            return (from KeyValuePair<string, object> c in _staticCache
+            StaticCache.RemoveAll(kvp => Regex.IsMatch(kvp.Key, regexString)); 
+        }
+
+        public virtual IEnumerable<object> GetCacheItemsByKeySearch(string keyStartsWith)
+        {
+            return (from KeyValuePair<string, object> c in StaticCache
                     where c.Key.InvariantStartsWith(keyStartsWith)
-                    select c.Value.TryConvertTo<T>()
-                    into attempt
-                    where attempt.Success
-                    select attempt.Result).ToList();
+                    select c.Value).ToList();
         }
 
-        public override T GetCacheItem<T>(string cacheKey)
+        public virtual object GetCacheItem(string cacheKey)
         {
-            var result = _staticCache[cacheKey];
-            if (result == null)
-            {
-                return default(T);
-            }
-            return result.TryConvertTo<T>().Result;
+            var result = StaticCache[cacheKey];
+            return result;
         }
 
-        public override T GetCacheItem<T>(string cacheKey, Func<T> getCacheItem)
+        public virtual object GetCacheItem(string cacheKey, Func<object> getCacheItem)
         {
-            return (T)_staticCache.GetOrAdd(cacheKey, key => getCacheItem());
+            return StaticCache.GetOrAdd(cacheKey, key => getCacheItem());
         }
         
     }

src/Umbraco.Core/CacheHelper.cs

@@ -12,203 +12,130 @@ using Umbraco.Core.Logging;
 namespace Umbraco.Core
 {
 
-	/// <summary>
-	/// Class that is exposed by the ApplicationContext for application wide caching purposes
-	/// </summary>
+    /// <summary>
+    /// Class that is exposed by the ApplicationContext for application wide caching purposes
+    /// </summary>
     public class CacheHelper
-	{
-	    private readonly bool _enableCache;
-        private readonly CacheProviderBase _staticCache;
-        private readonly CacheProviderBase _nullStaticCache = new NullCacheProvider();
-        private readonly RuntimeCacheProviderBase _httpCache;
-        private readonly RuntimeCacheProviderBase _nullHttpCache = new NullCacheProvider();
+    {
+        private readonly bool _enableCache;
+        private readonly ICacheProvider _requestCache;
+        private readonly ICacheProvider _nullRequestCache = new NullCacheProvider();
+        private readonly ICacheProvider _staticCache;
+        private readonly ICacheProvider _nullStaticCache = new NullCacheProvider();
+        private readonly IRuntimeCacheProvider _httpCache;
+        private readonly IRuntimeCacheProvider _nullHttpCache = new NullCacheProvider();
 
-		public CacheHelper(System.Web.Caching.Cache cache)
-            : this(cache, true)
-		{
-		}
+        /// <summary>
+        /// Creates a cache helper with disabled caches
+        /// </summary>
+        /// <returns></returns>
+        /// <remarks>
+        /// Good for unit testing
+        /// </remarks>
+        public static CacheHelper CreateDisabledCacheHelper()
+        {
+            return new CacheHelper(null, null, null, false);
+        }
 
-	    internal CacheHelper(System.Web.Caching.Cache cache, bool enableCache)
-            : this(new HttpRuntimeCacheProvider(cache), enableCache)
-	    {            
-	    }
-
-        internal CacheHelper(RuntimeCacheProviderBase httpCacheProvider, bool enableCache)
-            : this(httpCacheProvider, new StaticCacheProvider(), enableCache)
+        /// <summary>
+        /// Initializes a new instance for use in the web
+        /// </summary>
+        public CacheHelper()
+            : this(
+                new HttpRuntimeCacheProvider(HttpRuntime.Cache),
+                new StaticCacheProvider(),
+                new HttpRequestCacheProvider(() => new HttpContextWrapper(HttpContext.Current)))
         {
         }
 
-        internal CacheHelper(RuntimeCacheProviderBase httpCacheProvider, CacheProviderBase staticCacheProvider, bool enableCache)
+        /// <summary>
+        /// Initializes a new instance for use in the web
+        /// </summary>
+        /// <param name="cache"></param>
+        public CacheHelper(System.Web.Caching.Cache cache)
+            : this(
+                new HttpRuntimeCacheProvider(cache),
+                new StaticCacheProvider(),
+                new HttpRequestCacheProvider(() => new HttpContextWrapper(HttpContext.Current)))
         {
-            _httpCache = httpCacheProvider;
-            _staticCache = staticCacheProvider;
+        }
+
+        /// <summary>
+        /// Initializes a new instance based on the provided providers
+        /// </summary>
+        /// <param name="httpCacheProvider"></param>
+        /// <param name="staticCacheProvider"></param>
+        /// <param name="requestCacheProvider"></param>
+        public CacheHelper(
+            IRuntimeCacheProvider httpCacheProvider,
+            ICacheProvider staticCacheProvider,
+            ICacheProvider requestCacheProvider)
+            : this(httpCacheProvider, staticCacheProvider, requestCacheProvider, true)
+        {
+        }
+
+        /// <summary>
+        /// Private ctor used for creating a disabled cache helper
+        /// </summary>
+        /// <param name="httpCacheProvider"></param>
+        /// <param name="staticCacheProvider"></param>
+        /// <param name="requestCacheProvider"></param>
+        /// <param name="enableCache"></param>
+        private CacheHelper(
+            IRuntimeCacheProvider httpCacheProvider,
+            ICacheProvider staticCacheProvider,
+            ICacheProvider requestCacheProvider,
+            bool enableCache)
+        {
+            if (enableCache)
+            {
+                _httpCache = httpCacheProvider;
+                _staticCache = staticCacheProvider;
+                _requestCache = requestCacheProvider;
+            }
+            else
+            {
+                _httpCache = null;
+                _staticCache = null;
+                _requestCache = null;
+            }
+
             _enableCache = enableCache;
         }
 
-        #region Static cache
-
         /// <summary>
-        /// Clears the item in umbraco's static cache
+        /// Returns the current Request cache
         /// </summary>
-        internal void ClearAllStaticCache()
+        public ICacheProvider RequestCache
         {
-            if (!_enableCache)
-            {
-                _nullStaticCache.ClearAllCache();
-            }
-            else
-            {
-                _staticCache.ClearAllCache();
-            }
+            get { return _enableCache ? _requestCache : _nullRequestCache; }
         }
 
         /// <summary>
-        /// Clears the item in umbraco's static cache with the given key 
+        /// Returns the current Runtime cache
         /// </summary>
-        /// <param name="key">Key</param>
-        internal void ClearStaticCacheItem(string key)
+        public ICacheProvider StaticCache
         {
-            if (!_enableCache)
-            {
-                _nullStaticCache.ClearCacheItem(key);
-            }
-            else
-            {
-                _staticCache.ClearCacheItem(key);
-            }
+            get { return _enableCache ? _staticCache : _nullStaticCache; }
         }
 
         /// <summary>
-        /// Clears all objects in the static cache with the System.Type name as the
-        /// input parameter. (using [object].GetType())
+        /// Returns the current Runtime cache
         /// </summary>
-        /// <param name="typeName">The name of the System.Type which should be cleared from cache ex "System.Xml.XmlDocument"</param>
-        internal void ClearStaticCacheObjectTypes(string typeName)
+        public IRuntimeCacheProvider RuntimeCache
         {
-            if (!_enableCache)
-            {
-                _nullStaticCache.ClearCacheObjectTypes(typeName);
-            }
-            else
-            {
-                _staticCache.ClearCacheObjectTypes(typeName);
-            }
+            get { return _enableCache ? _httpCache : _nullHttpCache; }
         }
 
-        /// <summary>
-        /// Clears all objects in the static cache with the System.Type specified
-        /// </summary>
-        internal void ClearStaticCacheObjectTypes<T>()
-        {
-            if (!_enableCache)
-            {
-                _nullStaticCache.ClearCacheObjectTypes<T>();
-            }
-            else
-            {
-                _staticCache.ClearCacheObjectTypes<T>();
-            }
-        }
+        #region Legacy Runtime/Http Cache accessors
 
-	    internal void ClearStaticCacheObjectTypes<T>(Func<string, T, bool> predicate)
-	    {
-	        if (_enableCache)
-                _staticCache.ClearCacheObjectTypes(predicate);
-            else
-                _nullStaticCache.ClearCacheObjectTypes(predicate);
-	    }
-
-        /// <summary>
-        /// Clears all static cache items that starts with the key passed.
-        /// </summary>
-        /// <param name="keyStartsWith">The start of the key</param>
-        internal void ClearStaticCacheByKeySearch(string keyStartsWith)
-        {
-            if (!_enableCache)
-            {
-                _nullStaticCache.ClearCacheByKeySearch(keyStartsWith);
-            }
-            else
-            {
-                _staticCache.ClearCacheByKeySearch(keyStartsWith);
-            }
-        }
-
-        /// <summary>
-        /// Clears all cache items that have a key that matches the regular expression
-        /// </summary>
-        /// <param name="regexString"></param>
-        internal void ClearStaticCacheByKeyExpression(string regexString)
-        {
-            if (!_enableCache)
-            {
-                _nullStaticCache.ClearCacheByKeyExpression(regexString);
-            }
-            else
-            {
-                _staticCache.ClearCacheByKeyExpression(regexString);
-            }
-        }
-
-        internal IEnumerable<T> GetStaticCacheItemsByKeySearch<T>(string keyStartsWith)
-        {
-            if (!_enableCache)
-            {
-                return _nullStaticCache.GetCacheItemsByKeySearch<T>(keyStartsWith);
-            }
-            else
-            {
-                return _staticCache.GetCacheItemsByKeySearch<T>(keyStartsWith);
-            }
-        }
-
-        /// <summary>
-        /// Returns a static cache item by key, does not update the cache if it isn't there.
-        /// </summary>
-        /// <typeparam name="TT"></typeparam>
-        /// <param name="cacheKey"></param>
-        /// <returns></returns>
-        internal TT GetStaticCacheItem<TT>(string cacheKey)
-        {
-            if (!_enableCache)
-            {
-                return _nullStaticCache.GetCacheItem<TT>(cacheKey);
-            }
-            else
-            {
-                return _staticCache.GetCacheItem<TT>(cacheKey);
-            }
-        }
-
-        /// <summary>
-        /// Gets (and adds if necessary) an item from the static cache with all of the default parameters
-        /// </summary>
-        /// <typeparam name="TT"></typeparam>
-        /// <param name="cacheKey"></param>
-        /// <param name="getCacheItem"></param>
-        /// <returns></returns>
-        internal TT GetStaticCacheItem<TT>(string cacheKey, Func<TT> getCacheItem)
-        {
-            if (!_enableCache)
-            {
-                return _nullStaticCache.GetCacheItem<TT>(cacheKey, getCacheItem);
-            }
-            else
-            {
-                return _staticCache.GetCacheItem<TT>(cacheKey, getCacheItem);
-            }
-        }
-
-        #endregion
-
-
-	    #region Runtime/Http Cache
         /// <summary>
         /// Clears the item in umbraco's runtime cache
         /// </summary>
+        [Obsolete("Do not use this method, access the runtime cache from the RuntimeCache property")]
         public void ClearAllCache()
         {
-            if (!_enableCache)
+            if (_enableCache == false)
             {
                 _nullHttpCache.ClearAllCache();
             }
@@ -222,9 +149,10 @@ namespace Umbraco.Core
         /// Clears the item in umbraco's runtime cache with the given key 
         /// </summary>
         /// <param name="key">Key</param>
+        [Obsolete("Do not use this method, access the runtime cache from the RuntimeCache property")]
         public void ClearCacheItem(string key)
         {
-            if (!_enableCache)
+            if (_enableCache == false)
             {
                 _nullHttpCache.ClearCacheItem(key);
             }
@@ -240,9 +168,10 @@ namespace Umbraco.Core
         /// input parameter. (using [object].GetType())
         /// </summary>
         /// <param name="typeName">The name of the System.Type which should be cleared from cache ex "System.Xml.XmlDocument"</param>
+        [Obsolete("Do not use this method, access the runtime cache from the RuntimeCache property")]
         public void ClearCacheObjectTypes(string typeName)
         {
-            if (!_enableCache)
+            if (_enableCache == false)
             {
                 _nullHttpCache.ClearCacheObjectTypes(typeName);
             }
@@ -255,9 +184,10 @@ namespace Umbraco.Core
         /// <summary>
         /// Clears all objects in the System.Web.Cache with the System.Type specified
         /// </summary>
+        [Obsolete("Do not use this method, access the runtime cache from the RuntimeCache property")]
         public void ClearCacheObjectTypes<T>()
         {
-            if (!_enableCache)
+            if (_enableCache == false)
             {
                 _nullHttpCache.ClearCacheObjectTypes<T>();
             }
@@ -271,9 +201,10 @@ namespace Umbraco.Core
         /// Clears all cache items that starts with the key passed.
         /// </summary>
         /// <param name="keyStartsWith">The start of the key</param>
+        [Obsolete("Do not use this method, access the runtime cache from the RuntimeCache property")]
         public void ClearCacheByKeySearch(string keyStartsWith)
         {
-            if (!_enableCache)
+            if (_enableCache == false)
             {
                 _nullHttpCache.ClearCacheByKeySearch(keyStartsWith);
             }
@@ -287,9 +218,10 @@ namespace Umbraco.Core
         /// Clears all cache items that have a key that matches the regular expression
         /// </summary>
         /// <param name="regexString"></param>
+        [Obsolete("Do not use this method, access the runtime cache from the RuntimeCache property")]
         public void ClearCacheByKeyExpression(string regexString)
         {
-            if (!_enableCache)
+            if (_enableCache == false)
             {
                 _nullHttpCache.ClearCacheByKeyExpression(regexString);
             }
@@ -299,9 +231,10 @@ namespace Umbraco.Core
             }
         }
 
+        [Obsolete("Do not use this method, access the runtime cache from the RuntimeCache property")]
         public IEnumerable<T> GetCacheItemsByKeySearch<T>(string keyStartsWith)
         {
-            if (!_enableCache)
+            if (_enableCache == false)
             {
                 return _nullHttpCache.GetCacheItemsByKeySearch<T>(keyStartsWith);
             }
@@ -317,9 +250,10 @@ namespace Umbraco.Core
         /// <typeparam name="TT"></typeparam>
         /// <param name="cacheKey"></param>
         /// <returns></returns>
+        [Obsolete("Do not use this method, access the runtime cache from the RuntimeCache property")]
         public TT GetCacheItem<TT>(string cacheKey)
         {
-            if (!_enableCache)
+            if (_enableCache == false)
             {
                 return _nullHttpCache.GetCacheItem<TT>(cacheKey);
             }
@@ -336,9 +270,10 @@ namespace Umbraco.Core
         /// <param name="cacheKey"></param>
         /// <param name="getCacheItem"></param>
         /// <returns></returns>
+        [Obsolete("Do not use this method, access the runtime cache from the RuntimeCache property")]
         public TT GetCacheItem<TT>(string cacheKey, Func<TT> getCacheItem)
         {
-            if (!_enableCache)
+            if (_enableCache == false)
             {
                 return _nullHttpCache.GetCacheItem<TT>(cacheKey, getCacheItem);
             }
@@ -356,16 +291,17 @@ namespace Umbraco.Core
         /// <param name="timeout">This will set an absolute expiration from now until the timeout</param>
         /// <param name="getCacheItem"></param>
         /// <returns></returns>
+        [Obsolete("Do not use this method, access the runtime cache from the RuntimeCache property")]
         public TT GetCacheItem<TT>(string cacheKey,
             TimeSpan timeout, Func<TT> getCacheItem)
         {
-            if (!_enableCache)
+            if (_enableCache == false)
             {
-                return _nullHttpCache.GetCacheItem<TT>(cacheKey, timeout, getCacheItem);
+                return _nullHttpCache.GetCacheItem<TT>(cacheKey, getCacheItem, timeout);
             }
             else
             {
-                return _httpCache.GetCacheItem<TT>(cacheKey, timeout, getCacheItem);
+                return _httpCache.GetCacheItem<TT>(cacheKey, getCacheItem, timeout);
             }
         }
 
@@ -378,17 +314,18 @@ namespace Umbraco.Core
         /// <param name="timeout">This will set an absolute expiration from now until the timeout</param>
         /// <param name="getCacheItem"></param>
         /// <returns></returns>
+        [Obsolete("Do not use this method, access the runtime cache from the RuntimeCache property")]
         public TT GetCacheItem<TT>(string cacheKey,
             CacheItemRemovedCallback refreshAction, TimeSpan timeout,
             Func<TT> getCacheItem)
         {
             if (!_enableCache)
             {
-                return _nullHttpCache.GetCacheItem<TT>(cacheKey, refreshAction, timeout, getCacheItem);
+                return _nullHttpCache.GetCacheItem<TT>(cacheKey, getCacheItem, timeout, removedCallback: refreshAction);
             }
             else
             {
-                return _httpCache.GetCacheItem<TT>(cacheKey, refreshAction, timeout, getCacheItem);
+                return _httpCache.GetCacheItem<TT>(cacheKey, getCacheItem, timeout, removedCallback: refreshAction);
             }
         }
 
@@ -402,17 +339,18 @@ namespace Umbraco.Core
         /// <param name="timeout">This will set an absolute expiration from now until the timeout</param>
         /// <param name="getCacheItem"></param>
         /// <returns></returns>
+        [Obsolete("Do not use this method, access the runtime cache from the RuntimeCache property")]
         public TT GetCacheItem<TT>(string cacheKey,
             CacheItemPriority priority, CacheItemRemovedCallback refreshAction, TimeSpan timeout,
             Func<TT> getCacheItem)
         {
-            if (!_enableCache)
+            if (_enableCache == false)
             {
-                return _nullHttpCache.GetCacheItem<TT>(cacheKey, priority, refreshAction, timeout, getCacheItem);
+                return _nullHttpCache.GetCacheItem<TT>(cacheKey, getCacheItem, timeout, false, priority, refreshAction);
             }
             else
             {
-                return _httpCache.GetCacheItem<TT>(cacheKey, priority, refreshAction, timeout, getCacheItem);
+                return _httpCache.GetCacheItem<TT>(cacheKey, getCacheItem, timeout, false, priority, refreshAction);
             }
         }
 
@@ -427,6 +365,7 @@ namespace Umbraco.Core
         /// <param name="timeout">This will set an absolute expiration from now until the timeout</param>
         /// <param name="getCacheItem"></param>
         /// <returns></returns>
+        [Obsolete("Do not use this method, we no longer support the caching overloads with references to CacheDependency, use the overloads specifying a file collection instead")]
         public TT GetCacheItem<TT>(string cacheKey,
             CacheItemPriority priority,
             CacheItemRemovedCallback refreshAction,
@@ -434,13 +373,19 @@ namespace Umbraco.Core
             TimeSpan timeout,
             Func<TT> getCacheItem)
         {
-            if (!_enableCache)
+            if (_enableCache == false)
             {
-                return _nullHttpCache.GetCacheItem<TT>(cacheKey, priority, refreshAction, cacheDependency, timeout, getCacheItem);
+                return _nullHttpCache.GetCacheItem<TT>(cacheKey, getCacheItem, timeout, false, priority, refreshAction, null);
             }
             else
             {
-                return _httpCache.GetCacheItem<TT>(cacheKey, priority, refreshAction, cacheDependency, timeout, getCacheItem);
+                var cache = _httpCache as HttpRuntimeCacheProvider;
+                if (cache != null)
+                {
+                    var result = cache.GetCacheItem(cacheKey, () => getCacheItem(), timeout, false, priority, refreshAction, cacheDependency);
+                    return result == null ? default(TT) : result.TryConvertTo<TT>().Result;
+                }
+                throw new InvalidOperationException("Cannot use this obsoleted overload when the current provider is not of type " + typeof(HttpRuntimeCacheProvider));
             }
         }
 
@@ -453,6 +398,7 @@ namespace Umbraco.Core
         /// <param name="cacheDependency"></param>
         /// <param name="getCacheItem"></param>
         /// <returns></returns>
+        [Obsolete("Do not use this method, we no longer support the caching overloads with references to CacheDependency, use the overloads specifying a file collection instead")]
         public TT GetCacheItem<TT>(string cacheKey,
             CacheItemPriority priority,
             CacheDependency cacheDependency,
@@ -460,11 +406,17 @@ namespace Umbraco.Core
         {
             if (!_enableCache)
             {
-                return _nullHttpCache.GetCacheItem<TT>(cacheKey, priority, null, cacheDependency, null, getCacheItem);
+                return _nullHttpCache.GetCacheItem<TT>(cacheKey, getCacheItem, null, false, priority, null, null);
             }
             else
             {
-                return _httpCache.GetCacheItem<TT>(cacheKey, priority, null, cacheDependency, null, getCacheItem);
+                var cache = _httpCache as HttpRuntimeCacheProvider;
+                if (cache != null)
+                {
+                    var result = cache.GetCacheItem(cacheKey, () => getCacheItem(), null, false, priority, null, cacheDependency);
+                    return result == null ? default(TT) : result.TryConvertTo<TT>().Result;
+                }
+                throw new InvalidOperationException("Cannot use this obsoleted overload when the current provider is not of type " + typeof(HttpRuntimeCacheProvider));
             }
         }
 
@@ -479,13 +431,13 @@ namespace Umbraco.Core
                                        CacheItemPriority priority,
                                        Func<T> getCacheItem)
         {
-            if (!_enableCache)
+            if (_enableCache == false)
             {
-                _nullHttpCache.InsertCacheItem<T>(cacheKey, priority, getCacheItem);
+                _nullHttpCache.InsertCacheItem<T>(cacheKey, getCacheItem, priority: priority);
             }
             else
             {
-                _httpCache.InsertCacheItem<T>(cacheKey, priority, getCacheItem);
+                _httpCache.InsertCacheItem<T>(cacheKey, getCacheItem, priority: priority);
             }
         }
 
@@ -502,13 +454,13 @@ namespace Umbraco.Core
                                        TimeSpan timeout,
                                        Func<T> getCacheItem)
         {
-            if (!_enableCache)
+            if (_enableCache == false)
             {
-                _nullHttpCache.InsertCacheItem<T>(cacheKey, priority, timeout, getCacheItem);
+                _nullHttpCache.InsertCacheItem<T>(cacheKey, getCacheItem, timeout, priority: priority);
             }
             else
             {
-                _httpCache.InsertCacheItem<T>(cacheKey, priority, timeout, getCacheItem);
+                _httpCache.InsertCacheItem<T>(cacheKey, getCacheItem, timeout, priority: priority);
             }
         }
 
@@ -521,19 +473,25 @@ namespace Umbraco.Core
         /// <param name="cacheDependency"></param>
         /// <param name="timeout">This will set an absolute expiration from now until the timeout</param>
         /// <param name="getCacheItem"></param>
+        [Obsolete("Do not use this method, we no longer support the caching overloads with references to CacheDependency, use the overloads specifying a file collection instead")]
         public void InsertCacheItem<T>(string cacheKey,
                                        CacheItemPriority priority,
                                        CacheDependency cacheDependency,
                                        TimeSpan timeout,
                                        Func<T> getCacheItem)
         {
-            if (!_enableCache)
+            if (_enableCache == false)
             {
-                _nullHttpCache.InsertCacheItem<T>(cacheKey, priority, cacheDependency, timeout, getCacheItem);
+                _nullHttpCache.InsertCacheItem<T>(cacheKey, getCacheItem, timeout, priority: priority, dependentFiles: null);
             }
             else
             {
-                _httpCache.InsertCacheItem<T>(cacheKey, priority, cacheDependency, timeout, getCacheItem);
+                var cache = _httpCache as HttpRuntimeCacheProvider;
+                if (cache != null)
+                {
+                    cache.InsertCacheItem(cacheKey, () => getCacheItem(), timeout, false, priority, null, cacheDependency);
+                }
+                throw new InvalidOperationException("Cannot use this obsoleted overload when the current provider is not of type " + typeof(HttpRuntimeCacheProvider));
             }
         }
 
@@ -547,6 +505,7 @@ namespace Umbraco.Core
         /// <param name="cacheDependency"></param>
         /// <param name="timeout">This will set an absolute expiration from now until the timeout</param>
         /// <param name="getCacheItem"></param>
+        [Obsolete("Do not use this method, we no longer support the caching overloads with references to CacheDependency, use the overloads specifying a file collection instead")]
         public void InsertCacheItem<T>(string cacheKey,
                                        CacheItemPriority priority,
                                        CacheItemRemovedCallback refreshAction,
@@ -554,17 +513,22 @@ namespace Umbraco.Core
                                        TimeSpan? timeout,
                                        Func<T> getCacheItem)
         {
-            if (!_enableCache)
+            if (_enableCache == false)
             {
-                _nullHttpCache.InsertCacheItem<T>(cacheKey, priority, refreshAction, cacheDependency, timeout, getCacheItem);
+                _nullHttpCache.InsertCacheItem<T>(cacheKey, getCacheItem, timeout, false, priority, refreshAction, null);
             }
             else
             {
-                _httpCache.InsertCacheItem<T>(cacheKey, priority, refreshAction, cacheDependency, timeout, getCacheItem);
+                var cache = _httpCache as HttpRuntimeCacheProvider;
+                if (cache != null)
+                {
+                    cache.InsertCacheItem(cacheKey, () => getCacheItem(), timeout, false, priority, refreshAction, cacheDependency);
+                }
+                throw new InvalidOperationException("Cannot use this obsoleted overload when the current provider is not of type " + typeof(HttpRuntimeCacheProvider));
             }
-        } 
+        }
         #endregion
 
-	}
+    }
 
 }

src/Umbraco.Core/CacheRefreshersResolver.cs

@@ -27,7 +27,7 @@ namespace Umbraco.Core
 		/// <summary>
 		/// Gets the <see cref="ICacheRefresher"/> implementations.
 		/// </summary>
-		public IEnumerable<ICacheRefresher> CacheResolvers
+		public IEnumerable<ICacheRefresher> CacheRefreshers
 		{
 			get
 			{

src/Umbraco.Core/Configuration/ClientDependencyConfiguration.cs

@@ -16,7 +16,7 @@ namespace Umbraco.Core.Configuration
         }
 
         /// <summary>
-        /// Increases the version number in ClientDependency.config by 1
+        /// Changes the version number in ClientDependency.config to a random value to avoid stale caches
         /// </summary>
         internal bool IncreaseVersionNumber()
         {
@@ -28,9 +28,9 @@ namespace Umbraco.Core.Configuration
 
                     var versionAttribute = clientDependencyConfigXml.Root.Attribute("version");
 
-                    int oldVersion;
-                    int.TryParse(versionAttribute.Value, out oldVersion);
-                    var newVersion = oldVersion + 1;
+                    //Set the new version to the hashcode of now
+                    var oldVersion = versionAttribute.Value;
+                    var newVersion = Math.Abs(DateTime.UtcNow.GetHashCode());
 
                     versionAttribute.SetValue(newVersion);
                     clientDependencyConfigXml.Save(_fileName, SaveOptions.DisableFormatting);

src/Umbraco.Core/Configuration/GlobalSettings.cs

@@ -7,6 +7,7 @@ using System.Web.Configuration;
 using System.Web.Routing;
 using System.Xml;
 using System.Xml.Linq;
+using System.Xml.XPath;
 using Umbraco.Core.IO;
 using Umbraco.Core.Logging;
 
@@ -255,7 +256,38 @@ namespace Umbraco.Core.Configuration
                 SaveSetting("umbracoConfigurationStatus", value);
             }
         }
-
+        
+        /// <summary>
+        /// Gets or sets the Umbraco members membership providers' useLegacyEncoding state. This will return a boolean
+        /// </summary>
+        /// <value>The useLegacyEncoding status.</value>
+        public static bool UmbracoMembershipProviderLegacyEncoding
+        {
+            get
+            {
+                return ConfiguredMembershipProvidersLegacyEncoding(Constants.Conventions.Member.UmbracoMemberProviderName);
+            }
+            set
+            {
+                SetMembershipProvidersLegacyEncoding(Constants.Conventions.Member.UmbracoMemberProviderName, value);
+            }
+        }
+        
+        /// <summary>
+        /// Gets or sets the Umbraco users membership providers' useLegacyEncoding state. This will return a boolean
+        /// </summary>
+        /// <value>The useLegacyEncoding status.</value>
+        public static bool UmbracoUsersMembershipProviderLegacyEncoding
+        {
+            get
+            {
+                return ConfiguredMembershipProvidersLegacyEncoding(Constants.Conventions.User.UmbracoUsersProviderName);
+            }
+            set
+            {
+                SetMembershipProvidersLegacyEncoding(Constants.Conventions.User.UmbracoUsersProviderName, value);
+            }
+        }
 		
         /// <summary>
         /// Saves a setting into the configuration file.
@@ -315,6 +347,43 @@ namespace Umbraco.Core.Configuration
             return fileName;
         }
 
+        private static void SetMembershipProvidersLegacyEncoding(string providerName, bool useLegacyEncoding)
+        {
+            var webConfigFilename = GetFullWebConfigFileName();
+            var webConfigXml = XDocument.Load(webConfigFilename, LoadOptions.PreserveWhitespace);
+
+            var membershipConfigs = webConfigXml.XPathSelectElements("configuration/system.web/membership/providers/add").ToList();
+
+            if (membershipConfigs.Any() == false) 
+                return;
+
+            var provider = membershipConfigs.SingleOrDefault(c => c.Attribute("name") != null && c.Attribute("name").Value == providerName);
+
+            if (provider == null) 
+                return;
+
+            provider.SetAttributeValue("useLegacyEncoding", useLegacyEncoding);
+            
+            webConfigXml.Save(webConfigFilename, SaveOptions.DisableFormatting);
+        }
+        
+        private static bool ConfiguredMembershipProvidersLegacyEncoding(string providerName)
+        {
+            var webConfigFilename = GetFullWebConfigFileName();
+            var webConfigXml = XDocument.Load(webConfigFilename, LoadOptions.PreserveWhitespace);
+
+            var membershipConfigs = webConfigXml.XPathSelectElements("configuration/system.web/membership/providers/add").ToList();
+
+            var provider = membershipConfigs.SingleOrDefault(c => c.Attribute("name") != null && c.Attribute("name").Value == providerName);
+            
+            var useLegacyEncodingAttribute = provider.Attribute("useLegacyEncoding");
+            
+            bool useLegacyEncoding;
+            bool.TryParse(useLegacyEncodingAttribute.Value, out useLegacyEncoding);
+
+            return useLegacyEncoding;
+        }
+
         /// <summary>
         /// Gets the full path to root.
         /// </summary>
@@ -704,8 +773,12 @@ namespace Umbraco.Core.Configuration
                         StartsWithContainer _newReservedList = new StartsWithContainer();
                         foreach (string reservedUrl in _reservedUrlsCache.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries))
                         {
+                            if (string.IsNullOrWhiteSpace(reservedUrl))
+                               continue;
+                            
+
                             //resolves the url to support tilde chars
-                            string reservedUrlTrimmed = IOHelper.ResolveUrl(reservedUrl).Trim().ToLower();
+                            string reservedUrlTrimmed = IOHelper.ResolveUrl(reservedUrl.Trim()).Trim().ToLower();
                             if (reservedUrlTrimmed.Length > 0)
                                 _newReservedList.Add(reservedUrlTrimmed);
                         }
@@ -713,8 +786,11 @@ namespace Umbraco.Core.Configuration
                         foreach (string reservedPath in _reservedPathsCache.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries))
                         {
                             bool trimEnd = !reservedPath.EndsWith("/");
+                            if (string.IsNullOrWhiteSpace(reservedPath))
+                                continue;
+                           
                             //resolves the url to support tilde chars
-                            string reservedPathTrimmed = IOHelper.ResolveUrl(reservedPath).Trim().ToLower();
+                            string reservedPathTrimmed = IOHelper.ResolveUrl(reservedPath.Trim()).Trim().ToLower();
 
                             if (reservedPathTrimmed.Length > 0)
                                 _newReservedList.Add(reservedPathTrimmed + (reservedPathTrimmed.EndsWith("/") ? "" : "/"));

src/Umbraco.Core/Configuration/UmbracoSettings.cs

@@ -309,7 +309,7 @@ namespace Umbraco.Core.Configuration
                 {
                     return value;
                 }
-                return "UMB_UCONTEXT";
+                return Constants.Web.AuthCookieName;
             }
         }
 
@@ -658,7 +658,7 @@ namespace Umbraco.Core.Configuration
 			{
 				string defaultProvider = GetKey("/settings/providers/users/DefaultBackofficeProvider");
 				if (String.IsNullOrEmpty(defaultProvider))
-					defaultProvider = "UsersMembershipProvider";
+                    defaultProvider = Constants.Conventions.User.UmbracoUsersProviderName;
 
 				return defaultProvider;
 			}
@@ -855,6 +855,8 @@ namespace Umbraco.Core.Configuration
 		/// <summary>
 		/// Whether to replace double dashes from url (ie my--story----from--dash.aspx caused by multiple url replacement chars
 		/// </summary>
+		// was used by the legacy short string helper, is not used anymore by the new default short string helper
+        // should update documentation
         internal static bool RemoveDoubleDashesFromUrlReplacing
 		{
 			get

src/Umbraco.Core/Configuration/UmbracoVersion.cs

@@ -23,7 +23,7 @@ namespace Umbraco.Core.Configuration
         /// Gets the version comment (like beta or RC).
         /// </summary>
         /// <value>The version comment.</value>
-        public static string CurrentComment { get { return ""; } }
+        public static string CurrentComment { get { return "beta"; } }
 
         // Get the version of the umbraco.dll by looking at a class in that dll
         // Had to do it like this due to medium trust issues, see: http://haacked.com/archive/2010/11/04/assembly-location-and-medium-trust.aspx

src/Umbraco.Core/Constants-Conventions.cs

@@ -85,7 +85,7 @@ namespace Umbraco.Core
 
 				/// <summary>
 				/// MediaType alias for a folder.
-				/// </summary>
+                /// </summary>
 				public const string Folder = "Folder";
 
 				/// <summary>
@@ -94,9 +94,19 @@ namespace Umbraco.Core
 				public const string Image = "Image";
 			}
 
+
+            /// <summary>
+            /// Constants for Umbraco user
+            /// </summary>
+		    public static class User
+		    {
+                public static readonly string UmbracoUsersProviderName = "UsersMembershipProvider";
+		    }
+
 		    /// <summary>
 		    /// Constants for Umbraco Member property aliases.
 		    /// </summary>
+		    
 		    public static class Member
 		    {
                 public static readonly string UmbracoMemberProviderName = "UmbracoMembershipProvider";
@@ -166,140 +176,89 @@ namespace Umbraco.Core
 
                 public const string FailedPasswordAttemptsLabel = "Failed Password Attempts";
 
-		        internal static Dictionary<string, PropertyType>
-		            StandardPropertyTypeStubs = new Dictionary<string, PropertyType>
-		                                        {
-		                                            {
-		                                                Comments,
-		                                                new PropertyType(
-		                                                new Guid(
-		                                                PropertyEditors
-		                                                .TextboxMultiple),
-		                                                DataTypeDatabaseType
-		                                                .Ntext)
-		                                                {
-		                                                    Alias = Comments,
-		                                                    Name =
-		                                                        CommentsLabel
-		                                                }
-		                                            },
-		                                            {
-		                                                FailedPasswordAttempts,
-		                                                new PropertyType(
-		                                                new Guid(
-		                                                PropertyEditors
-		                                                .Integer),
-		                                                DataTypeDatabaseType
-		                                                .Integer)
-		                                                {
-		                                                    Alias =
-		                                                        FailedPasswordAttempts,
-		                                                    Name =
-		                                                        FailedPasswordAttemptsLabel
-		                                                }
-		                                            },
-		                                            {
-		                                                IsApproved,
-		                                                new PropertyType(
-		                                                new Guid(
-		                                                PropertyEditors
-		                                                .TrueFalse),
-		                                                DataTypeDatabaseType
-		                                                .Integer)
-		                                                {
-		                                                    Alias = IsApproved,
-		                                                    Name =
-		                                                        IsApprovedLabel
-		                                                }
-		                                            },
-		                                            {
-		                                                IsLockedOut,
-		                                                new PropertyType(
-		                                                new Guid(
-		                                                PropertyEditors
-		                                                .TrueFalse),
-		                                                DataTypeDatabaseType
-		                                                .Integer)
-		                                                {
-		                                                    Alias =
-		                                                        IsLockedOut,
-		                                                    Name =
-		                                                        IsLockedOutLabel
-		                                                }
-		                                            },
-		                                            {
-		                                                LastLockoutDate,
-		                                                new PropertyType(
-		                                                new Guid(
-		                                                PropertyEditors.Date),
-		                                                DataTypeDatabaseType
-		                                                .Date)
-		                                                {
-		                                                    Alias =
-		                                                        LastLockoutDate,
-		                                                    Name =
-		                                                        LastLockoutDateLabel
-		                                                }
-		                                            },
-		                                            {
-		                                                LastLoginDate,
-		                                                new PropertyType(
-		                                                new Guid(
-		                                                PropertyEditors.Date),
-		                                                DataTypeDatabaseType
-		                                                .Date)
-		                                                {
-		                                                    Alias =
-		                                                        LastLoginDate,
-		                                                    Name =
-		                                                        LastLoginDateLabel
-		                                                }
-		                                            },
-		                                            {
-		                                                LastPasswordChangeDate,
-		                                                new PropertyType(
-		                                                new Guid(
-		                                                PropertyEditors.Date),
-		                                                DataTypeDatabaseType
-		                                                .Date)
-		                                                {
-		                                                    Alias =
-		                                                        LastPasswordChangeDate,
-		                                                    Name =
-		                                                        LastPasswordChangeDateLabel
-		                                                }
-		                                            },
-		                                            {
-		                                                PasswordAnswer,
-		                                                new PropertyType(
-		                                                new Guid(
-		                                                PropertyEditors
-		                                                .Textbox),
-		                                                DataTypeDatabaseType
-		                                                .Nvarchar)
-		                                                {
-		                                                    Alias =
-		                                                        PasswordAnswer,
-		                                                    Name =
-		                                                        PasswordAnswerLabel
-		                                                }
-		                                            },
-		                                            {
-		                                                PasswordQuestion,
-		                                                new PropertyType(
-		                                                new Guid(
-		                                                PropertyEditors
-		                                                .Textbox),
-		                                                DataTypeDatabaseType
-		                                                .Nvarchar)
-		                                                {
-		                                                    Alias =
-		                                                        PasswordQuestion,
-		                                                    Name =
-		                                                        PasswordQuestionLabel
-		                                                }
-		                                            }
-		                                        };
+                /// <summary>
+                /// Group name to put the membership properties on
+                /// </summary>
+                internal const string StandardPropertiesGroupName = "Membership";
+
+		        internal static Dictionary<string, PropertyType> GetStandardPropertyTypeStubs()
+		        {
+		            return new Dictionary<string, PropertyType>
+		                {
+		                    {
+		                        Comments,
+		                        new PropertyType(new Guid(PropertyEditors.TextboxMultiple), DataTypeDatabaseType.Ntext, true)
+		                            {
+		                                Alias = Comments,
+		                                Name = CommentsLabel
+		                            }
+		                    },
+		                    {
+		                        FailedPasswordAttempts,
+		                        new PropertyType(new Guid(PropertyEditors.NoEdit), DataTypeDatabaseType.Integer, true)
+		                            {
+		                                Alias = FailedPasswordAttempts,
+		                                Name = FailedPasswordAttemptsLabel
+		                            }
+		                    },
+		                    {
+		                        IsApproved,
+		                        new PropertyType(new Guid(PropertyEditors.TrueFalse), DataTypeDatabaseType.Integer, true)
+		                            {
+		                                Alias = IsApproved,
+		                                Name = IsApprovedLabel
+		                            }
+		                    },
+		                    {
+		                        IsLockedOut,
+		                        new PropertyType(new Guid(PropertyEditors.TrueFalse), DataTypeDatabaseType.Integer, true)
+		                            {
+		                                Alias = IsLockedOut,
+		                                Name = IsLockedOutLabel
+		                            }
+		                    },
+		                    {
+		                        LastLockoutDate,
+		                        new PropertyType(new Guid(PropertyEditors.NoEdit), DataTypeDatabaseType.Date, true)
+		                            {
+		                                Alias = LastLockoutDate,
+		                                Name = LastLockoutDateLabel
+		                            }
+		                    },
+		                    {
+		                        LastLoginDate,
+		                        new PropertyType(new Guid(PropertyEditors.NoEdit), DataTypeDatabaseType.Date, true)
+		                            {
+		                                Alias = LastLoginDate,
+		                                Name = LastLoginDateLabel
+		                            }
+		                    },
+		                    {
+		                        LastPasswordChangeDate,
+		                        new PropertyType(new Guid(PropertyEditors.NoEdit), DataTypeDatabaseType.Date, true)
+		                            {
+		                                Alias = LastPasswordChangeDate,
+		                                Name = LastPasswordChangeDateLabel
+		                            }
+		                    },
+		                    {
+		                        PasswordAnswer,
+		                        new PropertyType(new Guid(PropertyEditors.NoEdit), DataTypeDatabaseType.Nvarchar, true)
+		                            {
+		                                Alias = PasswordAnswer,
+		                                Name = PasswordAnswerLabel
+		                            }
+		                    },
+		                    {
+		                        PasswordQuestion,
+		                        new PropertyType(new Guid(PropertyEditors.NoEdit), DataTypeDatabaseType.Nvarchar, true)
+		                            {
+		                                Alias = PasswordQuestion,
+		                                Name = PasswordQuestionLabel
+		                            }
+		                    }
+		                };
+		        } 
 		    }
 
 			/// <summary>
@@ -311,6 +270,8 @@ namespace Umbraco.Core
 				/// MemberType alias for default member type.
 				/// </summary>
 				public const string Member = "Member";
+
+                public const string SystemDefaultProtectType = "_umbracoSystemDefaultProtectType";
 			}
 
 			/// <summary>

src/Umbraco.Core/Constants-Web.cs

@@ -0,0 +1,22 @@
+namespace Umbraco.Core
+{
+	public static partial class Constants
+	{		
+        /// <summary>
+        /// Defines the identifiers for Umbraco system nodes.
+        /// </summary>
+        public static class Web
+        {
+            /// <summary>
+            /// The preview cookie name
+            /// </summary>
+            public const string PreviewCookieName = "UMB_PREVIEW";
+
+            /// <summary>
+            /// The auth cookie name
+            /// </summary>
+            public const string AuthCookieName = "UMB_UCONTEXT";
+
+        }
+	}
+}

src/Umbraco.Core/ControlExtensions.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Web.UI;
+
+namespace Umbraco.Core
+{
+    internal static class ControlExtensions
+    {
+        /// <summary>
+        /// Recursively finds a control with the specified identifier.
+        /// </summary>
+        /// <typeparam name="T">
+        /// The type of control to be found.
+        /// </typeparam>
+        /// <param name="parent">
+        /// The parent control from which the search will start.
+        /// </param>
+        /// <param name="id">
+        /// The identifier of the control to be found.
+        /// </param>
+        /// <returns>
+        /// The control with the specified identifier, otherwise <see langword="null"/> if the control 
+        /// is not found.
+        /// </returns>
+        public static T FindControlRecursive<T>(this Control parent, string id) where T : Control
+        {
+            if ((parent is T) && (parent.ID == id))
+            {
+                return (T)parent;
+            }
+
+            foreach (Control control in parent.Controls)
+            {
+                var foundControl = FindControlRecursive<T>(control, id);
+                if (foundControl != null)
+                {
+                    return foundControl;
+                }
+            }
+            return default(T);
+        }
+
+    }
+}

src/Umbraco.Core/CoreBootManager.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using Umbraco.Core.Cache;
 using Umbraco.Core.Configuration;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models.PublishedContent;
@@ -38,6 +39,7 @@ namespace Umbraco.Core
 		private bool _isComplete = false;
         private readonly UmbracoApplicationBase _umbracoApplication;
 		protected ApplicationContext ApplicationContext { get; private set; }
+        protected CacheHelper ApplicationCache { get; set; }
 
 	    protected UmbracoApplicationBase UmbracoApplication
 	    {
@@ -57,16 +59,19 @@ namespace Umbraco.Core
 
 	        InitializeProfilerResolver();
 
+            CreateApplicationCache();
+
             _timer = DisposableTimer.DebugDuration<CoreBootManager>("Umbraco application starting", "Umbraco application startup complete");
 
 			//create database and service contexts for the app context
 			var dbFactory = new DefaultDatabaseFactory(GlobalSettings.UmbracoConnectionName);
 		    Database.Mapper = new PetaPocoMapper();
 			var dbContext = new DatabaseContext(dbFactory);
-			var serviceContext = new ServiceContext(
-				new PetaPocoUnitOfWorkProvider(dbFactory), 
-				new FileUnitOfWorkProvider(), 
-				new PublishingStrategy());
+            var serviceContext = new ServiceContext(
+                new PetaPocoUnitOfWorkProvider(dbFactory),
+                new FileUnitOfWorkProvider(),
+                new PublishingStrategy(),
+                ApplicationCache);
 
             CreateApplicationContext(dbContext, serviceContext);
 
@@ -94,7 +99,21 @@ namespace Umbraco.Core
         protected virtual void CreateApplicationContext(DatabaseContext dbContext, ServiceContext serviceContext)
         {
             //create the ApplicationContext
-            ApplicationContext = ApplicationContext.Current = new ApplicationContext(dbContext, serviceContext);
+            ApplicationContext = ApplicationContext.Current = new ApplicationContext(dbContext, serviceContext, ApplicationCache);
+        }
+
+        /// <summary>
+        /// Creates and assigns the ApplicationCache based on a new instance of System.Web.Caching.Cache
+        /// </summary>
+        protected virtual void CreateApplicationCache()
+        {
+            var cacheHelper = new CacheHelper(
+                        new ObjectCacheRuntimeCacheProvider(),
+                        new StaticCacheProvider(),
+                //we have no request based cache when not running in web-based context
+                        new NullCacheProvider());
+
+            ApplicationCache = cacheHelper;
         }
 
         /// <summary>
@@ -231,7 +250,7 @@ namespace Umbraco.Core
                 () => PluginManager.Current.ResolveAssignedMapperTypes());
 
 			RepositoryResolver.Current = new RepositoryResolver(
-				new RepositoryFactory());
+                new RepositoryFactory(ApplicationCache));
 
 		    SqlSyntaxProvidersResolver.Current = new SqlSyntaxProvidersResolver(
                 new[] { typeof(MySqlSyntaxProvider), typeof(SqlCeSyntaxProvider), typeof(SqlServerSyntaxProvider) })
@@ -266,17 +285,10 @@ namespace Umbraco.Core
             PropertyValueConvertersResolver.Current = new PropertyValueConvertersResolver(
                 PluginManager.Current.ResolveTypes<IPropertyValueConverter>());
 
-            // use the new DefaultShortStringHelper but sort-of remain compatible
-            // - use UmbracoSettings UrlReplaceCharacters
-            // - allow underscores in terms, allow leading digits
+            // use the new DefaultShortStringHelper
             ShortStringHelperResolver.Current = new ShortStringHelperResolver(
-                new DefaultShortStringHelper()
-                    .WithConfig(CleanStringType.Url, DefaultShortStringHelper.ApplyUrlReplaceCharacters, 
-                        allowUnderscoreInTerm: true, allowLeadingDigits: true));
-
-            // that was the old one
-            //ShortStringHelperResolver.Current = new ShortStringHelperResolver(
-            //    new LegacyShortStringHelper());
+                //new LegacyShortStringHelper());
+                new DefaultShortStringHelper().WithDefaultConfig());
 
 		    UrlSegmentProviderResolver.Current = new UrlSegmentProviderResolver(
 		        typeof (DefaultUrlSegmentProvider));

src/Umbraco.Core/DatabaseContext.cs

@@ -433,24 +433,19 @@ namespace Umbraco.Core
             return _result;
         }
 
-        internal Result CreateDatabaseSchemaAndDataOrUpgrade()
+        internal Result CreateDatabaseSchemaAndData()
         {
-            if (_configured == false || (string.IsNullOrEmpty(_connectionString) || string.IsNullOrEmpty(ProviderName)))
+            var readyForInstall = CheckReadyForInstall();
+            if (readyForInstall.Success == false)
             {
-                return new Result
-                           {
-                               Message =
-                                   "Database configuration is invalid. Please check that the entered database exists and that the provided username and password has write access to the database.",
-                               Success = false,
-                               Percentage = "10"
-                           };
+                return readyForInstall.Result;
             }
-
+            
             try
             {
                 LogHelper.Info<DatabaseContext>("Database configuration status: Started");
 
-                var message = string.Empty;
+                string message;
 
                 var database = new UmbracoDatabase(_connectionString, ProviderName);
                 var supportsCaseInsensitiveQueries = SqlSyntaxContext.SqlSyntaxProvider.SupportsCaseInsensitiveQueries(database);
@@ -465,50 +460,73 @@ namespace Umbraco.Core
 
                     return new Result { Message = message, Success = false, Percentage = "15" };
                 }
-                else if (supportsCaseInsensitiveQueries == null)
-                {
-                    message = "<p>&nbsp;</p><p>Warning! Could not check if your database type supports case insensitive queries. <br />We currently do not support these databases that do not support case insensitive queries.</p>" +
-                              "<p>You can check this by looking for the following setting in your my.ini file in your MySQL installation directory:</p>" +
-                              "<pre>lower_case_table_names=1</pre><br />" +
-                              "<p>Note: Make sure to check with your hosting provider if they support case insensitive queries as well.</p>" +
-                              "<p>For more technical information on case sensitivity in MySQL, have a look at " +
-                              "<a href='http://dev.mysql.com/doc/refman/5.0/en/identifier-case-sensitivity.html'>the documentation on the subject</a></p>";
-                }
-                else
-                {
-                    if (SqlSyntaxContext.SqlSyntaxProvider.GetType() == typeof(MySqlSyntaxProvider))
-                    {
-                        message = "<p>&nbsp;</p><p>Congratulations, the database step ran successfully!</p>" +
-                                  "<p>Note: You're using MySQL and the database instance you're connecting to seems to support case insensitive queries.</p>" +
-                                  "<p>However, your hosting provider may not support this option. Umbraco does not currently support MySQL installs that do not support case insensitive queries</p>" +
-                                  "<p>Make sure to check with your hosting provider if they support case insensitive queries as well.</p>" +
-                                  "<p>They can check this by looking for the following setting in the my.ini file in their MySQL installation directory:</p>" +
-                                  "<pre>lower_case_table_names=1</pre><br />" +
-                                  "<p>For more technical information on case sensitivity in MySQL, have a look at " +
-                                  "<a href='http://dev.mysql.com/doc/refman/5.0/en/identifier-case-sensitivity.html'>the documentation on the subject</a></p>";
-                    }
-                }
+
+                message = GetResultMessageForMySql(supportsCaseInsensitiveQueries);
 
                 var schemaResult = ValidateDatabaseSchema();
                 var installedVersion = schemaResult.DetermineInstalledVersion();
                 
-
                 //If Configuration Status is empty and the determined version is "empty" its a new install - otherwise upgrade the existing
                 if (string.IsNullOrEmpty(GlobalSettings.ConfigurationStatus) && installedVersion.Equals(new Version(0, 0, 0)))
                 {
                     database.CreateDatabaseSchema();
                     message = message + "<p>Installation completed!</p>";
+
+                    //now that everything is done, we need to determine the version of SQL server that is executing
+                    LogHelper.Info<DatabaseContext>("Database configuration status: " + message);
+                    return new Result { Message = message, Success = true, Percentage = "100" };
                 }
-                else
-                {
-                    var configuredVersion = string.IsNullOrEmpty(GlobalSettings.ConfigurationStatus)
+
+                //we need to do an upgrade so return a new status message and it will need to be done during the next step
+                LogHelper.Info<DatabaseContext>("Database requires upgrade");
+                message = "<p>Upgrading database, this may take some time...</p>";
+                return new Result
+                    {
+                        RequiresUpgrade = true, 
+                        Message = message, 
+                        Success = true, 
+                        Percentage = "30"
+                    };
+            }
+            catch (Exception ex)
+            {
+                return HandleInstallException(ex);
+            }
+        }
+
+        /// <summary>
+        /// This assumes all of the previous checks are done!
+        /// </summary>
+        /// <returns></returns>
+        internal Result UpgradeSchemaAndData()
+        {
+            var readyForInstall = CheckReadyForInstall();
+            if (readyForInstall.Success == false)
+            {
+                return readyForInstall.Result;
+            }
+
+            try
+            {
+                LogHelper.Info<DatabaseContext>("Database upgrade started");
+
+                var database = new UmbracoDatabase(_connectionString, ProviderName);
+                var supportsCaseInsensitiveQueries = SqlSyntaxContext.SqlSyntaxProvider.SupportsCaseInsensitiveQueries(database);                
+
+                var message = GetResultMessageForMySql(supportsCaseInsensitiveQueries);
+
+                var schemaResult = ValidateDatabaseSchema();
+                var installedVersion = schemaResult.DetermineInstalledVersion();
+                
+                //DO the upgrade!
+
+                var configuredVersion = string.IsNullOrEmpty(GlobalSettings.ConfigurationStatus)
                                                 ? installedVersion
                                                 : new Version(GlobalSettings.ConfigurationStatus);
-                    var targetVersion = UmbracoVersion.Current;
-                    var runner = new MigrationRunner(configuredVersion, targetVersion, GlobalSettings.UmbracoMigrationName);
-                    var upgraded = runner.Execute(database, true);
-                    message = message + "<p>Upgrade completed!</p>";
-                }
+                var targetVersion = UmbracoVersion.Current;
+                var runner = new MigrationRunner(configuredVersion, targetVersion, GlobalSettings.UmbracoMigrationName);
+                var upgraded = runner.Execute(database, true);
+                message = message + "<p>Upgrade completed!</p>";
 
                 //now that everything is done, we need to determine the version of SQL server that is executing
 
@@ -518,26 +536,72 @@ namespace Umbraco.Core
             }
             catch (Exception ex)
             {
-                LogHelper.Info<DatabaseContext>("Database configuration failed with the following error and stack trace: " + ex.Message + "\n" + ex.StackTrace);
-
-                if (_result != null)
-                {
-                    LogHelper.Info<DatabaseContext>("The database schema validation produced the following summary: \n" + _result.GetSummary());
-                }
-
-                return new Result
-                           {
-                               Message =
-                                   "The database configuration failed with the following message: " + ex.Message +
-                                   "\n Please check log file for additional information (can be found in '/App_Data/Logs/UmbracoTraceLog.txt')",
-                               Success = false,
-                               Percentage = "90"
-                           };
+                return HandleInstallException(ex);
             }
         }
 
+        private string GetResultMessageForMySql(bool? supportsCaseInsensitiveQueries)
+        {
+            if (supportsCaseInsensitiveQueries == null)
+            {
+                return "<p>&nbsp;</p><p>Warning! Could not check if your database type supports case insensitive queries. <br />We currently do not support these databases that do not support case insensitive queries.</p>" +
+                          "<p>You can check this by looking for the following setting in your my.ini file in your MySQL installation directory:</p>" +
+                          "<pre>lower_case_table_names=1</pre><br />" +
+                          "<p>Note: Make sure to check with your hosting provider if they support case insensitive queries as well.</p>" +
+                          "<p>For more technical information on case sensitivity in MySQL, have a look at " +
+                          "<a href='http://dev.mysql.com/doc/refman/5.0/en/identifier-case-sensitivity.html'>the documentation on the subject</a></p>";
+            }
+            if (SqlSyntaxContext.SqlSyntaxProvider.GetType() == typeof(MySqlSyntaxProvider))
+            {
+                return "<p>&nbsp;</p><p>Congratulations, the database step ran successfully!</p>" +
+                       "<p>Note: You're using MySQL and the database instance you're connecting to seems to support case insensitive queries.</p>" +
+                       "<p>However, your hosting provider may not support this option. Umbraco does not currently support MySQL installs that do not support case insensitive queries</p>" +
+                       "<p>Make sure to check with your hosting provider if they support case insensitive queries as well.</p>" +
+                       "<p>They can check this by looking for the following setting in the my.ini file in their MySQL installation directory:</p>" +
+                       "<pre>lower_case_table_names=1</pre><br />" +
+                       "<p>For more technical information on case sensitivity in MySQL, have a look at " +
+                       "<a href='http://dev.mysql.com/doc/refman/5.0/en/identifier-case-sensitivity.html'>the documentation on the subject</a></p>";
+            }
+            return string.Empty;
+        }
+
+        private Attempt<Result> CheckReadyForInstall()
+        {
+            if (_configured == false || (string.IsNullOrEmpty(_connectionString) || string.IsNullOrEmpty(ProviderName)))
+            {
+                return Attempt.Fail(new Result
+                {
+                    Message =
+                        "Database configuration is invalid. Please check that the entered database exists and that the provided username and password has write access to the database.",
+                    Success = false,
+                    Percentage = "10"
+                });
+            }
+            return Attempt<Result>.Succeed();
+        }
+
+        private Result HandleInstallException(Exception ex)
+        {
+            LogHelper.Info<DatabaseContext>("Database configuration failed with the following error and stack trace: " + ex.Message + "\n" + ex.StackTrace);
+
+            if (_result != null)
+            {
+                LogHelper.Info<DatabaseContext>("The database schema validation produced the following summary: \n" + _result.GetSummary());
+            }
+
+            return new Result
+            {
+                Message =
+                    "The database configuration failed with the following message: " + ex.Message +
+                    "\n Please check log file for additional information (can be found in '/App_Data/Logs/UmbracoTraceLog.txt')",
+                Success = false,
+                Percentage = "90"
+            };
+        }
+
         internal class Result
         {
+            public bool RequiresUpgrade { get; set; }
             public string Message { get; set; }
             public bool Success { get; set; }
             public string Percentage { get; set; }

src/Umbraco.Core/DateTimeExtensions.cs

@@ -18,5 +18,30 @@ namespace Umbraco.Core
             return dt.ToString("yyyy-MM-dd HH:mm:ss");
         }
 
+        public static DateTime TruncateTo(this DateTime dt, DateTruncate truncateTo)
+        {
+            if (truncateTo == DateTruncate.Year)
+                return new DateTime(dt.Year, 0, 0);
+            if (truncateTo == DateTruncate.Month)
+                return new DateTime(dt.Year, dt.Month, 0);
+            if (truncateTo == DateTruncate.Day)
+                return new DateTime(dt.Year, dt.Month, dt.Day);
+            if (truncateTo == DateTruncate.Hour)
+                return new DateTime(dt.Year, dt.Month, dt.Day, dt.Hour, 0, 0);
+            if (truncateTo == DateTruncate.Minute)
+                return new DateTime(dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, 0);
+            return new DateTime(dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, dt.Second);
+        }
+
+        public enum DateTruncate
+        {
+            Year,
+            Month,
+            Day,
+            Hour,
+            Minute,
+            Second
+        }
+
     }
 }

src/Umbraco.Core/IO/FileSystemExtensions.cs

@@ -1,4 +1,5 @@
-using System.IO;
+using System;
+using System.IO;
 using Umbraco.Core.CodeAnnotations;
 
 namespace Umbraco.Core.IO
@@ -30,5 +31,17 @@ namespace Umbraco.Core.IO
 		{
 			return Path.GetFileName(fs.GetFullPath(path));
 		}
+
+        //TODO: Currently this is the only way to do this
+        internal static void CreateFolder(this IFileSystem fs, string folderPath)
+        {
+            var path = fs.GetRelativePath(folderPath);
+            var tempFile = Path.Combine(path, Guid.NewGuid().ToString("N") + ".tmp");
+            using (var s = new MemoryStream())
+            {
+                fs.AddFile(tempFile, s);
+            }
+            fs.DeleteFile(tempFile);
+        }
     }
 }

src/Umbraco.Core/IO/IFileSystem.cs

@@ -5,6 +5,8 @@ using Umbraco.Core.CodeAnnotations;
 
 namespace Umbraco.Core.IO
 {
+    //TODO: There is no way to create a directory here without creating a file in a directory and then deleting it
+
 	public interface IFileSystem
     {
         IEnumerable<string> GetDirectories(string path);

src/Umbraco.Core/IO/IOHelper.cs

@@ -43,7 +43,7 @@ namespace Umbraco.Core.IO
         //Replaces tildes with the root dir
         public static string ResolveUrl(string virtualPath)
         {
-            if (virtualPath.StartsWith("~"))
+             if (virtualPath.StartsWith("~"))
                 return virtualPath.Replace("~", SystemDirectories.Root).Replace("//", "/");
             else if (Uri.IsWellFormedUriString(virtualPath, UriKind.Absolute))
                 return virtualPath;

src/Umbraco.Core/Models/ContentBase.cs

@@ -306,10 +306,8 @@ namespace Umbraco.Core.Models
         /// <returns><see cref="Property"/> Value as a <see cref="TPassType"/></returns>
         public virtual TPassType GetValue<TPassType>(string propertyTypeAlias)
         {
-            if (Properties[propertyTypeAlias].Value is TPassType)
-                return (TPassType)Properties[propertyTypeAlias].Value;
-
-            return (TPassType)Convert.ChangeType(Properties[propertyTypeAlias].Value, typeof(TPassType));
+            var convertAttempt = Properties[propertyTypeAlias].Value.TryConvertTo<TPassType>();
+            return convertAttempt.Success ? convertAttempt.Result : default(TPassType);
         }
 
         /// <summary>

src/Umbraco.Core/Models/ContentExtensions.cs

@@ -25,6 +25,20 @@ namespace Umbraco.Core.Models
     {
         #region IContent
 
+        /// <summary>
+        /// Returns true if this entity was just published as part of a recent save operation (i.e. it wasn't previously published)
+        /// </summary>
+        /// <param name="entity"></param>
+        /// <returns></returns>
+        /// <remarks>
+        /// This is helpful for determining if the published event will execute during the saved event for a content item.
+        /// </remarks>
+        internal static bool JustPublished(this IContent entity)
+        {
+            var dirty = (IRememberBeingDirty)entity;
+            return dirty.WasPropertyDirty("Published") && entity.Published;
+        }
+
         /// <summary>
         /// Determines if a new version should be created
         /// </summary>
@@ -613,11 +627,16 @@ namespace Umbraco.Core.Models
             return ApplicationContext.Current.Services.PackagingService.Export(media);
         }
 
+        /// <summary>
+        /// Creates the full xml representation for the <see cref="IMedia"/> object and all of it's descendants
+        /// </summary>
+        /// <param name="media"><see cref="IMedia"/> to generate xml for</param>
+        /// <returns>Xml representation of the passed in <see cref="IMedia"/></returns>
         internal static XElement ToDeepXml(this IMedia media)
         {
             return ApplicationContext.Current.Services.PackagingService.Export(media, true);
         }
-
+        
         /// <summary>
         /// Creates the xml representation for the <see cref="IContent"/> object
         /// </summary>
@@ -630,5 +649,15 @@ namespace Umbraco.Core.Models
             //If current IContent is published we should get latest unpublished version
             return content.ToXml();
         }
+
+        /// <summary>
+        /// Creates the xml representation for the <see cref="IMember"/> object
+        /// </summary>
+        /// <param name="member"><see cref="IMember"/> to generate xml for</param>
+        /// <returns>Xml representation of the passed in <see cref="IContent"/></returns>
+        public static XElement ToXml(this IMember member)
+        {
+            return ApplicationContext.Current.Services.PackagingService.Export(member);
+        }
     }
 }

src/Umbraco.Core/Models/ContentTypeBase.cs

@@ -43,6 +43,7 @@ namespace Umbraco.Core.Models
             _allowedContentTypes = new List<ContentTypeSort>();
             _propertyGroups = new PropertyGroupCollection();
             _propertyTypes = new PropertyTypeCollection();
+            _propertyTypes.CollectionChanged += PropertyTypesChanged;
             _additionalData = new Dictionary<string, object>();
         }
 
@@ -54,6 +55,7 @@ namespace Umbraco.Core.Models
 			_allowedContentTypes = new List<ContentTypeSort>();
 			_propertyGroups = new PropertyGroupCollection();
             _propertyTypes = new PropertyTypeCollection();
+            _propertyTypes.CollectionChanged += PropertyTypesChanged;
             _additionalData = new Dictionary<string, object>();
 		}
 
@@ -428,8 +430,7 @@ namespace Umbraco.Core.Models
         {
             if (PropertyTypeExists(propertyType.Alias) == false)
             {
-                _propertyTypes.Add(propertyType);
-                _propertyTypes.CollectionChanged += PropertyTypesChanged;
+                _propertyTypes.Add(propertyType);                
                 return true;
             }
 

src/Umbraco.Core/Models/DictionaryItem.cs

@@ -3,7 +3,6 @@ using System.Collections.Generic;
 using System.Reflection;
 using System.Runtime.Serialization;
 using Umbraco.Core.Models.EntityBase;
-using Umbraco.Core.Persistence.Mappers;
 
 namespace Umbraco.Core.Models
 {

src/Umbraco.Core/Models/EntityExtensions.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Umbraco.Core.Models.EntityBase;
+
+namespace Umbraco.Core.Models
+{
+    public static class EntityExtensions
+    {
+
+        /// <summary>
+        /// Returns true if this entity has just been created and persisted to the data store
+        /// </summary>
+        /// <param name="entity"></param>
+        /// <returns></returns>
+        /// <remarks>
+        /// This is useful when handling events to determine if an entity is a brand new entity or was
+        /// already existing.
+        /// </remarks>
+        public static bool IsNewEntity(this IEntity entity)
+        {
+            var dirty = (IRememberBeingDirty)entity;
+            return dirty.WasPropertyDirty("Id");
+        }
+        }
+}

src/Umbraco.Core/Models/File.cs

@@ -6,6 +6,16 @@ using Umbraco.Core.Models.EntityBase;
 
 namespace Umbraco.Core.Models
 {
+    internal sealed class Folder : Entity
+    {
+        public Folder(string folderPath)
+        {
+            Path = folderPath;
+        }
+
+        public string Path { get; set; }
+    }
+
     /// <summary>
     /// Represents an abstract file which provides basic functionality for a File with an Alias and Name
     /// </summary>
@@ -23,6 +33,8 @@ namespace Umbraco.Core.Models
 
         private static readonly PropertyInfo ContentSelector = ExpressionHelper.GetPropertyInfo<File, string>(x => x.Content);
         private static readonly PropertyInfo PathSelector = ExpressionHelper.GetPropertyInfo<File, string>(x => x.Path);
+        private string _alias;
+        private string _name;
 
         /// <summary>
         /// Gets or sets the Name of the File including extension
@@ -32,7 +44,11 @@ namespace Umbraco.Core.Models
         {
             get
             {
-                return new FileInfo(Path).Name;
+                if (_name == null)
+                {
+                    _name = System.IO.Path.GetFileName(Path);
+                }
+                return _name;
             }
         }
 
@@ -44,10 +60,14 @@ namespace Umbraco.Core.Models
         {
             get
             {
-                var fileInfo = new FileInfo(Path);
-                var name = fileInfo.Name;
-                int lastIndexOf = name.LastIndexOf(".", StringComparison.InvariantCultureIgnoreCase);
-                return name.Substring(0, lastIndexOf);
+                if (_alias == null)
+                {                   
+                    var name = System.IO.Path.GetFileName(Path);
+                    if (name == null) return string.Empty;
+                    var lastIndexOf = name.LastIndexOf(".", StringComparison.InvariantCultureIgnoreCase);
+                    _alias = name.Substring(0, lastIndexOf);
+                }
+                return _alias;
             }
         }
 
@@ -60,6 +80,10 @@ namespace Umbraco.Core.Models
             get { return _path; }
             set
             {
+                //reset
+                _alias = null;
+                _name = null;
+
                 SetPropertyValueAndDetectChanges(o =>
                 {
                     _path = value;

src/Umbraco.Core/Models/IMember.cs

@@ -1,106 +1,10 @@
 using System;
+using Umbraco.Core.Models.Membership;
 
 namespace Umbraco.Core.Models
 {
-    public interface IMember : IContentBase
+    public interface IMember : IContentBase, IMembershipUser
     {
-        /// <summary>
-        /// Gets or sets the Username
-        /// </summary>
-        string Username { get; set; }
-
-        /// <summary>
-        /// Gets or sets the Email
-        /// </summary>
-        string Email { get; set; }
-
-        /// <summary>
-        /// Gets or sets the Password
-        /// </summary>
-        string Password { get; set; }
-
-        /// <summary>
-        /// Gets or sets the Password Question
-        /// </summary>
-        /// <remarks>
-        /// Alias: umbracoPasswordRetrievalQuestionPropertyTypeAlias
-        /// Part of the standard properties collection.
-        /// </remarks>
-        string PasswordQuestion { get; set; }
-
-        /// <summary>
-        /// Gets or sets the Password Answer
-        /// </summary>
-        /// <remarks>
-        /// Alias: umbracoPasswordRetrievalAnswerPropertyTypeAlias
-        /// Part of the standard properties collection.
-        /// </remarks>
-        string PasswordAnswer { get; set; }
-
-        /// <summary>
-        /// Gets or set the comments for the member
-        /// </summary>
-        /// <remarks>
-        /// Alias: umbracoCommentPropertyTypeAlias
-        /// Part of the standard properties collection.
-        /// </remarks>
-        string Comments { get; set; }
-
-        /// <summary>
-        /// Gets or sets a boolean indicating whether the Member is approved
-        /// </summary>
-        /// <remarks>
-        /// Alias: umbracoApprovePropertyTypeAlias
-        /// Part of the standard properties collection.
-        /// </remarks>
-        bool IsApproved { get; set; }
-
-        /// <summary>
-        /// Gets or sets a boolean indicating whether the Member is locked out
-        /// </summary>
-        /// <remarks>
-        /// Alias: umbracoLockPropertyTypeAlias
-        /// Part of the standard properties collection.
-        /// </remarks>
-        bool IsLockedOut { get; set; }
-
-        /// <summary>
-        /// Gets or sets the date for last login
-        /// </summary>
-        /// <remarks>
-        /// Alias: umbracoLastLoginPropertyTypeAlias
-        /// Part of the standard properties collection.
-        /// </remarks>
-        DateTime LastLoginDate { get; set; }
-
-        /// <summary>
-        /// Gest or sets the date for last password change
-        /// </summary>
-        /// <remarks>
-        /// Alias: umbracoMemberLastPasswordChange
-        /// Part of the standard properties collection.
-        /// </remarks>
-        DateTime LastPasswordChangeDate { get; set; }
-
-        /// <summary>
-        /// Gets or sets the date for when Member was locked out
-        /// </summary>
-        /// <remarks>
-        /// Alias: umbracoMemberLastLockout
-        /// Part of the standard properties collection.
-        /// </remarks>
-        DateTime LastLockoutDate { get; set; }
-
-        /// <summary>
-        /// Gets or sets the number of failed password attempts.
-        /// This is the number of times the password was entered incorrectly upon login.
-        /// </summary>
-        /// <remarks>
-        /// Alias: umbracoFailedPasswordAttemptsPropertyTypeAlias
-        /// Part of the standard properties collection.
-        /// </remarks>
-        int FailedPasswordAttempts { get; set; }
-
         /// <summary>
         /// String alias of the default ContentType
         /// </summary>

src/Umbraco.Core/Models/IMemberGroup.cs

@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+using Umbraco.Core.Models.EntityBase;
+
+namespace Umbraco.Core.Models
+{
+    /// <summary>
+    /// Represents a member type
+    /// </summary>
+    public interface IMemberGroup : IAggregateRoot
+    {
+        /// <summary>
+        /// The name of the member group
+        /// </summary>
+        string Name { get; set; }
+
+        /// <summary>
+        /// Profile of the user who created this Entity
+        /// </summary>
+        int CreatorId { get; set; }
+
+        /// <summary>
+        /// Some entities may expose additional data that other's might not, this custom data will be available in this collection
+        /// </summary>
+        IDictionary<string, object> AdditionalData { get; }
+    }
+}

src/Umbraco.Core/Models/IRelation.cs

@@ -0,0 +1,38 @@
+using System.Runtime.Serialization;
+using Umbraco.Core.Models.EntityBase;
+
+namespace Umbraco.Core.Models
+{
+    public interface IRelation : IAggregateRoot
+    {
+        /// <summary>
+        /// Gets or sets the Parent Id of the Relation (Source)
+        /// </summary>
+        [DataMember]
+        int ParentId { get; set; }
+
+        /// <summary>
+        /// Gets or sets the Child Id of the Relation (Destination)
+        /// </summary>
+        [DataMember]
+        int ChildId { get; set; }
+
+        /// <summary>
+        /// Gets or sets the <see cref="RelationType"/> for the Relation
+        /// </summary>
+        [DataMember]
+        IRelationType RelationType { get; set; }
+
+        /// <summary>
+        /// Gets or sets a comment for the Relation
+        /// </summary>
+        [DataMember]
+        string Comment { get; set; }
+
+        /// <summary>
+        /// Gets the Id of the <see cref="RelationType"/> that this Relation is based on.
+        /// </summary>
+        [IgnoreDataMember]
+        int RelationTypeId { get; }
+    }
+}

src/Umbraco.Core/Models/IRelationType.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Runtime.Serialization;
+using Umbraco.Core.Models.EntityBase;
+
+namespace Umbraco.Core.Models
+{
+    public interface IRelationType : IAggregateRoot
+    {
+        /// <summary>
+        /// Gets or sets the Name of the RelationType
+        /// </summary>
+        [DataMember]
+        string Name { get; set; }
+
+        /// <summary>
+        /// Gets or sets the Alias of the RelationType
+        /// </summary>
+        [DataMember]
+        string Alias { get; set; }
+
+        /// <summary>
+        /// Gets or sets a boolean indicating whether the RelationType is Bidirectional (true) or Parent to Child (false)
+        /// </summary>
+        [DataMember]
+        bool IsBidirectional { get; set; }
+
+        /// <summary>
+        /// Gets or sets the Parents object type id
+        /// </summary>
+        /// <remarks>Corresponds to the NodeObjectType in the umbracoNode table</remarks>
+        [DataMember]
+        Guid ParentObjectType { get; set; }
+
+        /// <summary>
+        /// Gets or sets the Childs object type id
+        /// </summary>
+        /// <remarks>Corresponds to the NodeObjectType in the umbracoNode table</remarks>
+        [DataMember]
+        Guid ChildObjectType { get; set; }
+    }
+}

src/Umbraco.Core/Models/ITemplate.cs

@@ -10,5 +10,11 @@
         /// </summary>
         /// <returns><see cref="RenderingEngine"/></returns>
         RenderingEngine GetTypeOfRenderingEngine();
+
+        /// <summary>
+        /// Set the mastertemplate
+        /// </summary>
+        /// <param name="masterTemplate"></param>
+        void SetMasterTemplate(ITemplate masterTemplate);
     }
 }

src/Umbraco.Core/Models/Language.cs

@@ -3,7 +3,6 @@ using System.Globalization;
 using System.Reflection;
 using System.Runtime.Serialization;
 using Umbraco.Core.Models.EntityBase;
-using Umbraco.Core.Persistence.Mappers;
 
 namespace Umbraco.Core.Models
 {

src/Umbraco.Core/Models/Member.cs

@@ -1,7 +1,9 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Reflection;
 using System.Runtime.Serialization;
+using Umbraco.Core.Logging;
 
 namespace Umbraco.Core.Models
 {
@@ -20,7 +22,20 @@ namespace Umbraco.Core.Models
         private object _providerUserKey;
         private Type _userTypeKey;
 
-        public Member(string name, string email, string username, string password, int parentId, IMemberType contentType)
+        /// <summary>
+        /// Constructor for creating a Member object
+        /// </summary>
+        /// <param name="name">Name of the content</param>
+        /// <param name="contentType">ContentType for the current Content object</param>
+        public Member(string name, IMemberType contentType)
+            : base(name, -1, contentType, new PropertyCollection())
+        {
+            _contentType = contentType;
+            IsApproved = true;
+        }
+
+        //TODO: Should we just get rid of this one? no reason to have a level set.
+        internal Member(string name, string email, string username, string password, int parentId, IMemberType contentType)
             : base(name, parentId, contentType, new PropertyCollection())
         {
             Mandate.ParameterNotNull(contentType, "contentType");
@@ -29,10 +44,11 @@ namespace Umbraco.Core.Models
             _email = email;
             _username = username;
             _password = password;
+            IsApproved = true;
         }
 
-        public Member(string name, string email, string username, string password, IContentBase parent, IMemberType contentType)
-            : base(name, parent, contentType, new PropertyCollection())
+        public Member(string name, string email, string username, string password, IMemberType contentType)
+            : this(name, email, username, password, -1, contentType)
         {
             Mandate.ParameterNotNull(contentType, "contentType");
 
@@ -40,8 +56,20 @@ namespace Umbraco.Core.Models
             _email = email;
             _username = username;
             _password = password;
+            IsApproved = true;
         }
 
+        //public Member(string name, string email, string username, string password, IContentBase parent, IMemberType contentType)
+        //    : base(name, parent, contentType, new PropertyCollection())
+        //{
+        //    Mandate.ParameterNotNull(contentType, "contentType");
+
+        //    _contentType = contentType;
+        //    _email = email;
+        //    _username = username;
+        //    _password = password;
+        //}
+
         private static readonly PropertyInfo DefaultContentTypeAliasSelector = ExpressionHelper.GetPropertyInfo<Member, string>(x => x.ContentTypeAlias);
         private static readonly PropertyInfo UsernameSelector = ExpressionHelper.GetPropertyInfo<Member, string>(x => x.Username);
         private static readonly PropertyInfo EmailSelector = ExpressionHelper.GetPropertyInfo<Member, string>(x => x.Email);
@@ -118,12 +146,19 @@ namespace Umbraco.Core.Models
         {
             get
             {
+                var a = WarnIfPropertyTypeNotFoundOnGet(Constants.Conventions.Member.PasswordQuestion, "PasswordQuestion", default(string));
+                if (a.Success == false) return a.Result;
+
                 return Properties[Constants.Conventions.Member.PasswordQuestion].Value == null
                     ? string.Empty
                     : Properties[Constants.Conventions.Member.PasswordQuestion].Value.ToString();
             }
             set
             {
+                if (WarnIfPropertyTypeNotFoundOnSet(
+                    Constants.Conventions.Member.PasswordQuestion,
+                    "PasswordQuestion") == false) return;
+
                 Properties[Constants.Conventions.Member.PasswordQuestion].Value = value;
             }
         }
@@ -140,12 +175,19 @@ namespace Umbraco.Core.Models
         {
             get
             {
+                var a = WarnIfPropertyTypeNotFoundOnGet(Constants.Conventions.Member.PasswordAnswer, "PasswordAnswer", default(string));
+                if (a.Success == false) return a.Result;
+
                 return Properties[Constants.Conventions.Member.PasswordAnswer].Value == null
                     ? string.Empty
                     : Properties[Constants.Conventions.Member.PasswordAnswer].Value.ToString();
             }
             set
             {
+                if (WarnIfPropertyTypeNotFoundOnSet(
+                    Constants.Conventions.Member.PasswordAnswer,
+                    "PasswordAnswer") == false) return;
+
                 Properties[Constants.Conventions.Member.PasswordAnswer].Value = value;
             }
         }
@@ -162,12 +204,19 @@ namespace Umbraco.Core.Models
         {
             get
             {
+                var a = WarnIfPropertyTypeNotFoundOnGet(Constants.Conventions.Member.Comments, "Comments", default(string));
+                if (a.Success == false) return a.Result;
+
                 return Properties[Constants.Conventions.Member.Comments].Value == null
                     ? string.Empty
                     : Properties[Constants.Conventions.Member.Comments].Value.ToString();
             }
             set
             {
+                if (WarnIfPropertyTypeNotFoundOnSet(
+                    Constants.Conventions.Member.Comments,
+                    "Comments") == false) return;
+
                 Properties[Constants.Conventions.Member.Comments].Value = value;
             }
         }
@@ -184,16 +233,25 @@ namespace Umbraco.Core.Models
         {
             get
             {
-                if (Properties[Constants.Conventions.Member.IsApproved].Value == null)
-                    return default(bool);
+                var a = WarnIfPropertyTypeNotFoundOnGet(Constants.Conventions.Member.IsApproved, "IsApproved", 
+                    //This is the default value if the prop is not found
+                    true);
+                if (a.Success == false) return a.Result;
 
-                if (Properties[Constants.Conventions.Member.IsApproved].Value is bool)
-                    return (bool)Properties[Constants.Conventions.Member.IsApproved].Value;
-
-                return (bool)Convert.ChangeType(Properties[Constants.Conventions.Member.IsApproved].Value, typeof(bool));
+                var tryConvert = Properties[Constants.Conventions.Member.IsApproved].Value.TryConvertTo<bool>();
+                if (tryConvert.Success)
+                {
+                    return tryConvert.Result;
+                }
+                //if the property exists but it cannot be converted, we will assume true
+                return true;
             }
             set
             {
+                if (WarnIfPropertyTypeNotFoundOnSet(
+                    Constants.Conventions.Member.IsApproved,
+                    "IsApproved") == false) return;
+
                 Properties[Constants.Conventions.Member.IsApproved].Value = value;
             }
         }
@@ -210,16 +268,22 @@ namespace Umbraco.Core.Models
         {
             get
             {
-                if (Properties[Constants.Conventions.Member.IsLockedOut].Value == null)
-                    return default(bool);
-
-                if (Properties[Constants.Conventions.Member.IsLockedOut].Value is bool)
-                    return (bool)Properties[Constants.Conventions.Member.IsLockedOut].Value;
-
-                return (bool)Convert.ChangeType(Properties[Constants.Conventions.Member.IsLockedOut].Value, typeof(bool));
+                var a = WarnIfPropertyTypeNotFoundOnGet(Constants.Conventions.Member.IsLockedOut, "IsLockedOut", false);
+                if (a.Success == false) return a.Result;
+                
+                var tryConvert = Properties[Constants.Conventions.Member.IsLockedOut].Value.TryConvertTo<bool>();
+                if (tryConvert.Success)
+                {
+                    return tryConvert.Result;
+                }
+                return false;
             }
             set
             {
+                if (WarnIfPropertyTypeNotFoundOnSet(
+                    Constants.Conventions.Member.IsLockedOut,
+                    "IsLockedOut") == false) return;
+
                 Properties[Constants.Conventions.Member.IsLockedOut].Value = value;
             }
         }
@@ -236,16 +300,22 @@ namespace Umbraco.Core.Models
         {
             get
             {
-                if (Properties[Constants.Conventions.Member.LastLoginDate].Value == null)
-                    return default(DateTime);
-
-                if (Properties[Constants.Conventions.Member.LastLoginDate].Value is DateTime)
-                    return (DateTime)Properties[Constants.Conventions.Member.LastLoginDate].Value;
-
-                return (DateTime)Convert.ChangeType(Properties[Constants.Conventions.Member.LastLoginDate].Value, typeof(DateTime));
+                var a = WarnIfPropertyTypeNotFoundOnGet(Constants.Conventions.Member.LastLoginDate, "LastLoginDate", default(DateTime));
+                if (a.Success == false) return a.Result;
+                
+                var tryConvert = Properties[Constants.Conventions.Member.LastLoginDate].Value.TryConvertTo<DateTime>();
+                if (tryConvert.Success)
+                {
+                    return tryConvert.Result;
+                }
+                return default(DateTime);
             }
             set
             {
+                if (WarnIfPropertyTypeNotFoundOnSet(
+                    Constants.Conventions.Member.LastLoginDate,
+                    "LastLoginDate") == false) return;
+
                 Properties[Constants.Conventions.Member.LastLoginDate].Value = value;
             }
         }
@@ -262,16 +332,22 @@ namespace Umbraco.Core.Models
         {
             get
             {
-                if (Properties[Constants.Conventions.Member.LastPasswordChangeDate].Value == null)
-                    return default(DateTime);
+                var a = WarnIfPropertyTypeNotFoundOnGet(Constants.Conventions.Member.LastPasswordChangeDate, "LastPasswordChangeDate", default(DateTime));
+                if (a.Success == false) return a.Result;
 
-                if (Properties[Constants.Conventions.Member.LastPasswordChangeDate].Value is DateTime)
-                    return (DateTime)Properties[Constants.Conventions.Member.LastPasswordChangeDate].Value;
-
-                return (DateTime)Convert.ChangeType(Properties[Constants.Conventions.Member.LastPasswordChangeDate].Value, typeof(DateTime));
+                var tryConvert = Properties[Constants.Conventions.Member.LastPasswordChangeDate].Value.TryConvertTo<DateTime>();
+                if (tryConvert.Success)
+                {
+                    return tryConvert.Result;
+                }
+                return default(DateTime);
             }
             set
             {
+                if (WarnIfPropertyTypeNotFoundOnSet(
+                    Constants.Conventions.Member.LastPasswordChangeDate,
+                    "LastPasswordChangeDate") == false) return;
+
                 Properties[Constants.Conventions.Member.LastPasswordChangeDate].Value = value;
             }
         }
@@ -288,16 +364,22 @@ namespace Umbraco.Core.Models
         {
             get
             {
-                if (Properties[Constants.Conventions.Member.LastLockoutDate].Value == null)
-                    return default(DateTime);
-
-                if (Properties[Constants.Conventions.Member.LastLockoutDate].Value is DateTime)
-                    return (DateTime)Properties[Constants.Conventions.Member.LastLockoutDate].Value;
-
-                return (DateTime)Convert.ChangeType(Properties[Constants.Conventions.Member.LastLockoutDate].Value, typeof(DateTime));
+                var a = WarnIfPropertyTypeNotFoundOnGet(Constants.Conventions.Member.LastLockoutDate, "LastLockoutDate", default(DateTime));
+                if (a.Success == false) return a.Result;
+                
+                var tryConvert = Properties[Constants.Conventions.Member.LastLockoutDate].Value.TryConvertTo<DateTime>();
+                if (tryConvert.Success)
+                {
+                    return tryConvert.Result;
+                }
+                return default(DateTime);
             }
             set
             {
+                if (WarnIfPropertyTypeNotFoundOnSet(
+                    Constants.Conventions.Member.LastLockoutDate,
+                    "LastLockoutDate") == false) return;
+
                 Properties[Constants.Conventions.Member.LastLockoutDate].Value = value;
             }
         }
@@ -315,17 +397,23 @@ namespace Umbraco.Core.Models
         {
             get
             {
-                if (Properties[Constants.Conventions.Member.FailedPasswordAttempts].Value == null)
-                    return default(int);
-
-                if (Properties[Constants.Conventions.Member.FailedPasswordAttempts].Value is int)
-                    return (int)Properties[Constants.Conventions.Member.FailedPasswordAttempts].Value;
-
-                return (int)Convert.ChangeType(Properties[Constants.Conventions.Member.FailedPasswordAttempts].Value, typeof(int));
+                var a = WarnIfPropertyTypeNotFoundOnGet(Constants.Conventions.Member.FailedPasswordAttempts, "FailedPasswordAttempts", 0);
+                if (a.Success == false) return a.Result;
+                
+                var tryConvert = Properties[Constants.Conventions.Member.FailedPasswordAttempts].Value.TryConvertTo<int>();
+                if (tryConvert.Success)
+                {
+                    return tryConvert.Result;
+                }
+                return default(int);
             }
             set
             {
-                Properties[Constants.Conventions.Member.LastLockoutDate].Value = value;
+                if (WarnIfPropertyTypeNotFoundOnSet(
+                    Constants.Conventions.Member.FailedPasswordAttempts,
+                    "FailedPasswordAttempts") == false) return;
+
+                Properties[Constants.Conventions.Member.FailedPasswordAttempts].Value = value;
             }
         }
 
@@ -356,7 +444,7 @@ namespace Umbraco.Core.Models
         /// membership provider.
         /// </remarks>
         [DataMember]
-        internal virtual object ProviderUserKey
+        public virtual object ProviderUserKey
         {
             get
             {
@@ -439,5 +527,73 @@ namespace Umbraco.Core.Models
         internal bool BoolPropertyValue { get; set; }
         internal DateTime DateTimePropertyValue { get; set; }
         internal string PropertyTypeAlias { get; set; }
+
+        private Attempt<T> WarnIfPropertyTypeNotFoundOnGet<T>(string propertyAlias, string propertyName, T defaultVal)
+        {
+            Action doLog = () => LogHelper.Warn<Member>(
+                        "Trying to access the '"
+                        + propertyName
+                        + "' property on "
+                        + typeof(Member)
+                        + " but the "
+                        + propertyAlias
+                        + " property does not exist on the member type so a default value is returned. Ensure that you have a property type with alias: "
+                        + propertyAlias
+                        + " configured on your member type in order to use the '"
+                        + propertyName
+                        + "' property on the model correctly.");     
+
+            //if the property doesn't exist, then do the logging and return a failure
+            if (Properties.Contains(propertyAlias) == false)
+            {
+                //we'll put a warn in the log if this entity has been persisted
+                if (HasIdentity)
+                {
+                    doLog();
+                }
+                return Attempt<T>.Fail(defaultVal);
+            }
+
+            //if the property doesn't have an identity but we do, then do logging and return failure
+            var prop = Properties.Single(x => x.Alias == propertyAlias);
+            if (prop.HasIdentity == false && HasIdentity)
+            {
+                doLog();
+                return Attempt<T>.Fail(defaultVal);
+            }
+
+            return Attempt<T>.Succeed();
+        }
+
+        private bool WarnIfPropertyTypeNotFoundOnSet(string propertyAlias, string propertyname)
+        {
+            Action doLog = () => LogHelper.Warn<Member>("An attempt was made to set a value on the property '"
+                        + propertyname
+                        + "' on type "
+                        + typeof(Member)
+                        + " but the property type "
+                        + propertyAlias
+                        + " does not exist on the member type, ensure that this property type exists so that setting this property works correctly.");
+
+            //if the property doesn't exist, then do the logging and return a failure
+            if (Properties.Contains(propertyAlias) == false)
+            {
+                if (HasIdentity)
+                {
+                    doLog();
+                }
+                return false;
+            }
+
+            //if the property doesn't have an identity but we do, then do logging and return failure
+            var prop = Properties.Single(x => x.Alias == propertyAlias);
+            if (prop.HasIdentity == false && HasIdentity)
+            {
+                doLog();
+                return false;
+            }
+
+            return true;
+        }
     }
 }

src/Umbraco.Core/Models/MemberGroup.cs

@@ -0,0 +1,76 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Runtime.Serialization;
+using Umbraco.Core.Models.EntityBase;
+
+namespace Umbraco.Core.Models
+{
+    /// <summary>
+    /// Represents a member type
+    /// </summary>
+    [Serializable]
+    [DataContract(IsReference = true)]
+    public class MemberGroup : Entity, IMemberGroup
+    {
+        public MemberGroup()
+        {
+            AdditionalData = new Dictionary<string, object>();
+        }
+
+        private string _name;
+        private int _creatorId;
+
+        private static readonly PropertyInfo NameSelector = ExpressionHelper.GetPropertyInfo<MemberGroup, string>(x => x.Name);
+        private static readonly PropertyInfo CreatorIdSelector = ExpressionHelper.GetPropertyInfo<MemberGroup, int>(x => x.CreatorId);
+
+        [DataMember]
+        public string Name
+        {
+            get { return _name; }
+            set
+            {
+                SetPropertyValueAndDetectChanges(o =>
+                {
+                    if (_name != value)
+                    {
+                        //if the name has changed, add the value to the additional data,
+                        //this is required purely for event handlers to know the previous name of the group
+                        //so we can keep the public access up to date.
+                        AdditionalData["previousName"] = _name;
+                    }
+
+                    _name = value;
+                    return _name;
+                }, _name, NameSelector);
+            }
+        }
+
+        public int CreatorId
+        {
+            get { return _creatorId; }
+            set
+            {
+                SetPropertyValueAndDetectChanges(o =>
+                {
+                    _creatorId = value;
+                    return _creatorId;
+                }, _creatorId, CreatorIdSelector);
+            }
+        }
+
+        public IDictionary<string, object> AdditionalData { get; private set; }
+
+        /// <summary>
+        /// Method to call when Entity is being saved
+        /// </summary>
+        /// <remarks>Created date is set and a Unique key is assigned</remarks>
+        internal override void AddingEntity()
+        {
+            base.AddingEntity();
+
+            if (Key == Guid.Empty)
+                Key = Guid.NewGuid();
+        }
+    }
+}

src/Umbraco.Core/Models/MemberType.cs

@@ -14,37 +14,48 @@ namespace Umbraco.Core.Models
     public class MemberType : ContentTypeCompositionBase, IMemberType
     {
         //Dictionary is divided into string: PropertyTypeAlias, Tuple: MemberCanEdit, VisibleOnProfile, PropertyTypeId
-        private IDictionary<string, Tuple<bool, bool, int>> _memberTypePropertyTypes;
+        private string _alias;
 
         public MemberType(int parentId) : base(parentId)
         {
-            _memberTypePropertyTypes = new Dictionary<string, Tuple<bool, bool, int>>();
+            MemberTypePropertyTypes = new Dictionary<string, MemberTypePropertyProfileAccess>();
         }
 
         public MemberType(IContentTypeComposition parent) : base(parent)
         {
-            _memberTypePropertyTypes = new Dictionary<string, Tuple<bool, bool, int>>();
+            MemberTypePropertyTypes = new Dictionary<string, MemberTypePropertyProfileAccess>();
         }
 
-        private static readonly PropertyInfo MemberTypePropertyTypesSelector = ExpressionHelper.GetPropertyInfo<MemberType, IDictionary<string, Tuple<bool, bool, int>>>(x => x.MemberTypePropertyTypes);
+        private static readonly PropertyInfo AliasSelector = ExpressionHelper.GetPropertyInfo<MemberType, string>(x => x.Alias);
 
         /// <summary>
-        /// Gets or Sets a Dictionary of Tuples (MemberCanEdit, VisibleOnProfile, PropertyTypeId) by the PropertyTypes' alias.
+        /// The Alias of the ContentType
         /// </summary>
         [DataMember]
-        internal IDictionary<string, Tuple<bool, bool, int>> MemberTypePropertyTypes
+        public override string Alias
         {
-            get { return _memberTypePropertyTypes; }
+            get { return _alias; }
             set
             {
+                //NOTE: WE are overriding this because we don't want to do a ToSafeAlias when the alias is the special case of
+                // "_umbracoSystemDefaultProtectType" which is used internally, currently there is an issue with the safe alias as it strips
+                // leading underscores which we don't want in this case.
+                // see : http://issues.umbraco.org/issue/U4-3968
+
                 SetPropertyValueAndDetectChanges(o =>
                 {
-                    _memberTypePropertyTypes = value;
-                    return _memberTypePropertyTypes;
-                }, _memberTypePropertyTypes, MemberTypePropertyTypesSelector);
+                    _alias = value == "_umbracoSystemDefaultProtectType" ? value : value.ToSafeAlias();
+                    return _alias;
+                }, _alias, AliasSelector);
             }
         }
 
+        /// <summary>
+        /// Gets or Sets a Dictionary of Tuples (MemberCanEdit, VisibleOnProfile) by the PropertyTypes' alias.
+        /// </summary>
+        [DataMember]
+        internal IDictionary<string, MemberTypePropertyProfileAccess> MemberTypePropertyTypes { get; private set; }
+
         /// <summary>
         /// Gets a boolean indicating whether a Property is editable by the Member.
         /// </summary>
@@ -54,7 +65,7 @@ namespace Umbraco.Core.Models
         {
             if (MemberTypePropertyTypes.ContainsKey(propertyTypeAlias))
             {
-                return MemberTypePropertyTypes[propertyTypeAlias].Item1;
+                return MemberTypePropertyTypes[propertyTypeAlias].IsEditable;
             }
 
             return false;
@@ -69,7 +80,7 @@ namespace Umbraco.Core.Models
         {
             if (MemberTypePropertyTypes.ContainsKey(propertyTypeAlias))
             {
-                return MemberTypePropertyTypes[propertyTypeAlias].Item2;
+                return MemberTypePropertyTypes[propertyTypeAlias].IsVisible;
             }
 
             return false;
@@ -84,13 +95,11 @@ namespace Umbraco.Core.Models
         {
             if (MemberTypePropertyTypes.ContainsKey(propertyTypeAlias))
             {
-                var tuple = MemberTypePropertyTypes[propertyTypeAlias];
-                MemberTypePropertyTypes[propertyTypeAlias] = new Tuple<bool, bool, int>(value, tuple.Item2, tuple.Item3);
+                MemberTypePropertyTypes[propertyTypeAlias].IsEditable = value;
             }
             else
             {
-                var propertyType = PropertyTypes.First(x => x.Alias.Equals(propertyTypeAlias));
-                var tuple = new Tuple<bool, bool, int>(value, false, propertyType.Id);
+                var tuple = new MemberTypePropertyProfileAccess(false, value);
                 MemberTypePropertyTypes.Add(propertyTypeAlias, tuple);
             }
         }
@@ -104,13 +113,11 @@ namespace Umbraco.Core.Models
         {
             if (MemberTypePropertyTypes.ContainsKey(propertyTypeAlias))
             {
-                var tuple = MemberTypePropertyTypes[propertyTypeAlias];
-                MemberTypePropertyTypes[propertyTypeAlias] = new Tuple<bool, bool, int>(tuple.Item1, value, tuple.Item3);
+                MemberTypePropertyTypes[propertyTypeAlias].IsVisible = value;
             }
             else
             {
-                var propertyType = PropertyTypes.First(x => x.Alias.Equals(propertyTypeAlias));
-                var tuple = new Tuple<bool, bool, int>(false, value, propertyType.Id);
+                var tuple = new MemberTypePropertyProfileAccess(value, false);
                 MemberTypePropertyTypes.Add(propertyTypeAlias, tuple);
             }
         }

src/Umbraco.Core/Models/MemberTypePropertyProfileAccess.cs

@@ -0,0 +1,17 @@
+namespace Umbraco.Core.Models
+{
+    /// <summary>
+    /// Used to track the property types that are visible/editable on member profiles
+    /// </summary>
+    internal class MemberTypePropertyProfileAccess
+    {
+        public MemberTypePropertyProfileAccess(bool isVisible, bool isEditable)
+        {
+            IsVisible = isVisible;
+            IsEditable = isEditable;
+        }
+
+        public bool IsVisible { get; set; }
+        public bool IsEditable { get; set; }
+    }
+}

src/Umbraco.Core/Models/Membership/EntityPermission.cs

@@ -0,0 +1,24 @@
+namespace Umbraco.Core.Models.Membership
+{
+    /// <summary>
+    /// Represents a user -> entity permission
+    /// </summary>
+    public class EntityPermission
+    {
+        public EntityPermission(int userId, int entityId, string[] assignedPermissions)
+        {
+            UserId = userId;
+            EntityId = entityId;
+            AssignedPermissions = assignedPermissions;
+        }
+
+        public int UserId { get; private set; }
+        public int EntityId { get; private set; }
+
+        /// <summary>
+        /// The assigned permissions for the user/entity combo
+        /// </summary>
+        public string[] AssignedPermissions { get; private set; }
+    }
+
+}

src/Umbraco.Core/Models/Membership/IMembershipUser.cs

@@ -4,9 +4,9 @@ using Umbraco.Core.Models.EntityBase;
 
 namespace Umbraco.Core.Models.Membership
 {
-    internal interface IMembershipUser : IMembershipUserId, IAggregateRoot
-    {
-        /*new object Id { get; set; }*/
+    public interface IMembershipUser : IAggregateRoot
+    {        
+        object ProviderUserKey { get; set; }
         string Username { get; set; }
         string Email { get; set; }
         string Password { get; set; }
@@ -14,13 +14,22 @@ namespace Umbraco.Core.Models.Membership
         string PasswordAnswer { get; set; }
         string Comments { get; set; }
         bool IsApproved { get; set; }
-        bool IsOnline { get; set; }
         bool IsLockedOut { get; set; }
         DateTime LastLoginDate { get; set; }
         DateTime LastPasswordChangeDate { get; set; }
         DateTime LastLockoutDate { get; set; }
 
-        object ProfileId { get; set; }
-        IEnumerable<object> Groups { get; set; }
+        /// <summary>
+        /// Gets or sets the number of failed password attempts.
+        /// This is the number of times the password was entered incorrectly upon login.
+        /// </summary>
+        /// <remarks>
+        /// Alias: umbracoFailedPasswordAttemptsPropertyTypeAlias
+        /// Part of the standard properties collection.
+        /// </remarks>
+        int FailedPasswordAttempts { get; set; }
+
+        //object ProfileId { get; set; }
+        //IEnumerable<object> Groups { get; set; }
     }
 }

src/Umbraco.Core/Models/Membership/IMembershipUserId.cs

@@ -1,7 +0,0 @@
-namespace Umbraco.Core.Models.Membership
-{
-    internal interface IMembershipUserId
-    {
-        object ProviderUserKey { get; set; }
-    }
-}

src/Umbraco.Core/Models/Membership/IProfile.cs

@@ -3,6 +3,10 @@
     /// <summary>
     /// Defines the the Profile interface
     /// </summary>
+    /// <remarks>
+    /// This interface is pretty useless but has been exposed publicly from 6.x so we're stuck with it. It would make more sense 
+    /// if the Id was an int but since it's not people have to cast it to int all of the time!
+    /// </remarks>
     public interface IProfile
     {
         object Id { get; set; }

src/Umbraco.Core/Models/Membership/IUser.cs

@@ -7,25 +7,34 @@ namespace Umbraco.Core.Models.Membership
     /// Defines the interface for a <see cref="User"/>
     /// </summary>
     /// <remarks>Will be left internal until a proper Membership implementation is part of the roadmap</remarks>
-    internal interface IUser : IMembershipUser, IUserProfile
+    public interface IUser : IMembershipUser
     {
-        new object Id { get; set; }
-        //string Name { get; set; }
+        string Name { get; set; }
         int SessionTimeout { get; set; }
         int StartContentId { get; set; }
         int StartMediaId { get; set; }
         string Language { get; set; }
-        bool DefaultToLiveEditing { get; set; }
+        
+        /// <summary>
+        /// Gets/sets the user type for the user
+        /// </summary>
+        IUserType UserType { get; set; }
 
-        bool NoConsole { get; set; }
-        IUserType UserType { get; }
-        string DefaultPermissions { get; set; }
-    }
+        /// <summary>
+        /// The default permission set for the user
+        /// </summary>
+        /// <remarks>
+        /// Currently in umbraco each permission is a single char but with an Enumerable{string} collection this allows for flexible changes to this in the future
+        /// </remarks>
+        IEnumerable<string> DefaultPermissions { get; set; }
 
-    internal interface IUserProfile : IProfile
-    {
         IEnumerable<string> AllowedSections { get; }
         void RemoveAllowedSection(string sectionAlias);
         void AddAllowedSection(string sectionAlias);
+
+        /// <summary>
+        /// Exposes the basic profile data
+        /// </summary>
+        IProfile ProfileData { get; }
     }
 }

src/Umbraco.Core/Models/Membership/IUserType.cs

@@ -1,13 +1,28 @@
+using System.Collections.Generic;
 using Umbraco.Core.Models.EntityBase;
 using Umbraco.Core.Persistence.Mappers;
 
 namespace Umbraco.Core.Models.Membership
 {
 
-    internal interface IUserType : IAggregateRoot
+    public interface IUserType : IAggregateRoot
     {
+        /// <summary>
+        /// The user type alias
+        /// </summary>
         string Alias { get; set; }
+
+        /// <summary>
+        /// The user type name
+        /// </summary>
         string Name { get; set; }
-        string Permissions { get; set; }
+
+        /// <summary>
+        /// The set of default permissions for the user type
+        /// </summary>
+        /// <remarks>
+        /// By default each permission is simply a single char but we've made this an enumerable{string} to support a more flexible permissions structure in the future.
+        /// </remarks>
+        IEnumerable<string> Permissions { get; set; }
     }
 }

src/Umbraco.Core/Models/Membership/MembershipExtensions.cs

@@ -5,15 +5,15 @@ namespace Umbraco.Core.Models.Membership
 {
     internal static class MembershipExtensions
     {
-        internal static MembershipUser AsConcreteMembershipUser(this IMember member)
+        internal static UmbracoMembershipMember AsConcreteMembershipUser(this IMembershipUser member, string providerName)
         {
-            var membershipMember = new UmbracoMembershipMember(member);
+            var membershipMember = new UmbracoMembershipMember(member, providerName);
             return membershipMember;
         }
 
-        internal static IMember AsIMember(this MembershipUser membershipMember)
+        internal static IMembershipUser AsIMember(this UmbracoMembershipMember membershipMember)
         {
-            var member = membershipMember as UmbracoMembershipMember;
+            var member = membershipMember;
             if (member != null)
             {
                 return member.Member;

src/Umbraco.Core/Models/Membership/Profile.cs

@@ -1,123 +0,0 @@
-using System;
-using System.Reflection;
-using System.Runtime.Serialization;
-using Umbraco.Core.Models.EntityBase;
-
-namespace Umbraco.Core.Models.Membership
-{
-    /// <summary>
-    /// Represents a Profile which is shared between Members and Users
-    /// </summary>
-    [Serializable]
-    [DataContract(IsReference = true)]
-    internal class Profile : TracksChangesEntityBase, IProfile, IRememberBeingDirty
-    {
-        /// <summary>
-        /// Initializes a new instance of the <see cref="Profile"/> class.
-        /// </summary>
-        protected Profile()
-        {
-            ProviderUserKeyType = typeof(int);
-        }
-
-        public Profile(object id, string name)
-        {
-            ProviderUserKeyType = typeof(int);
-            Id = id;
-            Name = name;
-        }
-
-        private object _id;
-        private string _name;
-        private object _providerUserKey;
-        private Type _userTypeKey;
-
-        private static readonly PropertyInfo IdSelector = ExpressionHelper.GetPropertyInfo<Profile, object>(x => x.Id);
-        private static readonly PropertyInfo NameSelector = ExpressionHelper.GetPropertyInfo<Profile, string>(x => x.Name);
-        private static readonly PropertyInfo ProviderUserKeySelector = ExpressionHelper.GetPropertyInfo<Profile, object>(x => x.ProviderUserKey);
-        private static readonly PropertyInfo UserTypeKeySelector = ExpressionHelper.GetPropertyInfo<Profile, Type>(x => x.ProviderUserKeyType);
-
-        [DataMember]
-        public virtual object Id
-        {
-            get
-            {
-                return _id;
-            }
-            set
-            {
-                SetPropertyValueAndDetectChanges(o =>
-                {
-                    _id = value;
-                    return _id;
-                }, _id, IdSelector);
-            }
-        }
-
-        [DataMember]
-        public virtual string Name
-        {
-            get
-            {
-                return _name;
-            }
-            set
-            {
-                SetPropertyValueAndDetectChanges(o =>
-                {
-                    _name = value;
-                    return _name;
-                }, _name, NameSelector);
-            }
-        }
-
-        [IgnoreDataMember]
-        public virtual object ProviderUserKey
-        {
-            get
-            {
-                return _providerUserKey;
-            }
-            set
-            {
-                SetPropertyValueAndDetectChanges(o =>
-                {
-                    _providerUserKey = value;
-                    return _id;
-                }, _providerUserKey, ProviderUserKeySelector);
-            }
-        }
-
-        /// <summary>
-        /// Gets or sets the type of the provider user key.
-        /// </summary>
-        /// <value>
-        /// The type of the provider user key.
-        /// </value>
-        [IgnoreDataMember]
-        internal Type ProviderUserKeyType
-        {
-            get
-            {
-                return _userTypeKey;
-            }
-            private set
-            {
-                SetPropertyValueAndDetectChanges(o =>
-                {
-                    _userTypeKey = value;
-                    return _userTypeKey;
-                }, _userTypeKey, UserTypeKeySelector);
-            }
-        }
-
-        /// <summary>
-        /// Sets the type of the provider user key.
-        /// </summary>
-        /// <param name="type">The type.</param>
-        internal void SetProviderUserKeyType(Type type)
-        {
-            ProviderUserKeyType = type;
-        }
-    }
-}

src/Umbraco.Core/Models/Membership/UmbracoMembershipMember.cs

@@ -1,66 +1,127 @@
-using System.Web.Security;
+using System;
+using System.Web.Security;
 
 namespace Umbraco.Core.Models.Membership
 {
-    //TODO: THere's still a bunch of properties that don't exist in this use that need to be mapped somehow. 
 
     internal class UmbracoMembershipMember : MembershipUser
     {
-        private readonly IMember _member;
+        private readonly IMembershipUser _member;
+        private readonly string _userName;
+        private readonly object _providerUserKey;
+        private readonly string _passwordQuestion;
+        private readonly bool _isLockedOut;
+        private readonly DateTime _lastLockoutDate;
+        private readonly DateTime _creationDate;
+        private DateTime _lastLoginDate;
+        private readonly DateTime _lastPasswordChangedDate;
+        private readonly string _providerName;
+        private string _email;
+        private string _comment;
+        private bool _isApproved;
+        private DateTime _lastActivityDate;
 
-        public UmbracoMembershipMember(IMember member)
+        //NOTE: We are only overriding the properties that matter, we don't override things like IsOnline since that is handled with the sub-class and the membership providers.
+
+        //NOTE: We are not calling the base constructor which will validate that a provider with the specified name exists which causes issues with unit tests. The ctor
+        // validation for that doesn't need to be there anyways (have checked the source).
+        public UmbracoMembershipMember(IMembershipUser member, string providerName)
         {
             _member = member;
+            //NOTE: We are copying the values here so that everything is consistent with how the underlying built-in ASP.Net membership user
+            // handles data! We don't want to do anything differently there but since we cannot use their ctor we'll need to handle this logic ourselves.
+            if (member.Username != null)
+                _userName = member.Username.Trim();
+            if (member.Email != null)
+                _email = member.Email.Trim();
+            if (member.PasswordQuestion != null)
+                _passwordQuestion = member.PasswordQuestion.Trim();
+            _providerName = providerName;
+            _providerUserKey = member.ProviderUserKey;
+            _comment = member.Comments;
+            _isApproved = member.IsApproved;
+            _isLockedOut = member.IsLockedOut;
+            _creationDate = member.CreateDate.ToUniversalTime();
+            _lastLoginDate = member.LastLoginDate.ToUniversalTime();
+            //TODO: We currently don't really have any place to store this data!!
+            _lastActivityDate = member.LastLoginDate.ToUniversalTime();
+            _lastPasswordChangedDate = member.LastPasswordChangeDate.ToUniversalTime();
+            _lastLockoutDate = member.LastLockoutDate.ToUniversalTime();
         }
-
-        internal IMember Member
+        
+        internal IMembershipUser Member
         {
             get { return _member; }
         }
 
-        public override string Email
+        public override string UserName
         {
-            get { return _member.Email; }
-            set { _member.Email = value; }
+            get { return _userName; }
         }
 
         public override object ProviderUserKey
         {
-            get { return _member.Key; }
+            get { return _providerUserKey; }
         }
 
-        public override System.DateTime CreationDate
+        public override string Email
         {
-            get { return _member.CreateDate; }
+            get { return _email; }
+            set { _email = value; }
         }
 
-        public override string UserName
+        public override string PasswordQuestion
         {
-            get { return _member.Username; }
+            get { return _passwordQuestion; }
         }
 
         public override string Comment
         {
-            get { return _member.Comments; }
-            set { _member.Comments = value; }
+            get { return _comment; }
+            set { _comment = value; }
         }
 
         public override bool IsApproved
         {
-            get { return _member.IsApproved; }
-            set { _member.IsApproved = value; }
+            get { return _isApproved; }
+            set { _isApproved = value; }
         }
 
         public override bool IsLockedOut
         {
-            get { return _member.IsLockedOut; }
+            get { return _isLockedOut; }
         }
 
-        public override System.DateTime LastLoginDate
+        public override DateTime LastLockoutDate
         {
-            get { return _member.LastLoginDate; }
-            set { _member.LastLoginDate = value; }
+            get { return _lastLockoutDate; }
         }
 
+        public override DateTime CreationDate
+        {
+            get { return _creationDate; }
+        }
+
+        public override DateTime LastLoginDate
+        {
+            get { return _lastLoginDate; }
+            set { _lastLoginDate = value; }
+        }
+
+        public override DateTime LastActivityDate
+        {
+            get { return _lastActivityDate; }
+            set { _lastActivityDate = value; }
+        }
+
+        public override DateTime LastPasswordChangedDate
+        {
+            get { return _lastPasswordChangedDate; }
+        }
+
+        public override string ProviderName
+        {
+            get { return _providerName; }
+        }
     }
 }

src/Umbraco.Core/Models/Membership/User.cs

@@ -1,7 +1,11 @@
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
 using System.Linq;
+using System.Reflection;
 using System.Runtime.Serialization;
+using Umbraco.Core.Configuration;
 using Umbraco.Core.Models.EntityBase;
 using Umbraco.Core.Persistence.Mappers;
 
@@ -16,98 +20,498 @@ namespace Umbraco.Core.Models.Membership
     /// </remarks>
     [Serializable]
     [DataContract(IsReference = true)]
-    internal class User : UserProfile, IUser
+    public class User : TracksChangesEntityBase, IUser
     {
-        private bool _hasIdentity;
-
         public User(IUserType userType)
         {
-            Groups = new List<object> { userType };
+            if (userType == null) throw new ArgumentNullException("userType");
+
+            _userType = userType;
+            //Groups = new List<object> { userType };
+            SessionTimeout = 60;
+            _sectionCollection = new ObservableCollection<string>();
+            _addedSections = new List<string>();
+            _removedSections = new List<string>();
+            _language = GlobalSettings.DefaultUILanguage;
+            _sectionCollection.CollectionChanged += SectionCollectionChanged;
+            _isApproved = true;
+            _isLockedOut = false;
+            _startContentId = -1;
+            _startMediaId = -1;
         }
 
+        public User(string name, string email, string username, string password, IUserType userType)
+            : this(userType)
+        {
+            _name = name;
+            _email = email;
+            _username = username;
+            _password = password;
+            _isApproved = true;
+            _isLockedOut = false;
+            _startContentId = -1;
+            _startMediaId = -1;
+        }
+
+        private IUserType _userType;
+        private bool _hasIdentity;
+        private int _id;
+        private string _name;
+        private Type _userTypeKey;
+        private readonly List<string> _addedSections;
+        private readonly List<string> _removedSections;
+        private readonly ObservableCollection<string> _sectionCollection;
+        private int _sessionTimeout;
+        private int _startContentId;
+        private int _startMediaId;
+
+        private string _username;
+        private string _email;
+        private string _password;
+        private bool _isApproved;
+        private bool _isLockedOut;
+        private string _language;
+        private IEnumerable<string> _defaultPermissions;
+        private bool _defaultToLiveEditing;
+
+        private static readonly PropertyInfo SessionTimeoutSelector = ExpressionHelper.GetPropertyInfo<User, int>(x => x.SessionTimeout);
+        private static readonly PropertyInfo StartContentIdSelector = ExpressionHelper.GetPropertyInfo<User, int>(x => x.StartContentId);
+        private static readonly PropertyInfo StartMediaIdSelector = ExpressionHelper.GetPropertyInfo<User, int>(x => x.StartMediaId);
+        private static readonly PropertyInfo AllowedSectionsSelector = ExpressionHelper.GetPropertyInfo<User, IEnumerable<string>>(x => x.AllowedSections);
+        private static readonly PropertyInfo IdSelector = ExpressionHelper.GetPropertyInfo<User, object>(x => x.Id);
+        private static readonly PropertyInfo NameSelector = ExpressionHelper.GetPropertyInfo<User, string>(x => x.Name);
+        private static readonly PropertyInfo UserTypeKeySelector = ExpressionHelper.GetPropertyInfo<User, Type>(x => x.ProviderUserKeyType);
+        
+        private static readonly PropertyInfo UsernameSelector = ExpressionHelper.GetPropertyInfo<User, string>(x => x.Username);
+        private static readonly PropertyInfo EmailSelector = ExpressionHelper.GetPropertyInfo<User, string>(x => x.Email);
+        private static readonly PropertyInfo PasswordSelector = ExpressionHelper.GetPropertyInfo<User, string>(x => x.Password);
+        private static readonly PropertyInfo IsLockedOutSelector = ExpressionHelper.GetPropertyInfo<User, bool>(x => x.IsLockedOut);
+        private static readonly PropertyInfo IsApprovedSelector = ExpressionHelper.GetPropertyInfo<User, bool>(x => x.IsApproved);
+        private static readonly PropertyInfo LanguageSelector = ExpressionHelper.GetPropertyInfo<User, string>(x => x.Language);
+        private static readonly PropertyInfo DefaultPermissionsSelector = ExpressionHelper.GetPropertyInfo<User, IEnumerable<string>>(x => x.DefaultPermissions);
+        private static readonly PropertyInfo DefaultToLiveEditingSelector = ExpressionHelper.GetPropertyInfo<User, bool>(x => x.DefaultToLiveEditing);
+        private static readonly PropertyInfo HasIdentitySelector = ExpressionHelper.GetPropertyInfo<User, bool>(x => x.HasIdentity);
+        private static readonly PropertyInfo UserTypeSelector = ExpressionHelper.GetPropertyInfo<User, IUserType>(x => x.UserType);
+
         #region Implementation of IEntity
 
         [IgnoreDataMember]
-        public bool HasIdentity { get { return Id != null || _hasIdentity; } }
-
-        [IgnoreDataMember]
-        int IEntity.Id
+        public bool HasIdentity
         {
             get
             {
-                return int.Parse(base.Id.ToString());
+                return _hasIdentity;
             }
-            set
+            protected set
             {
-                base.Id = value;
-                _hasIdentity = true;
+                SetPropertyValueAndDetectChanges(o =>
+                {
+                    _hasIdentity = value;
+                    return _hasIdentity;
+                }, _hasIdentity, HasIdentitySelector);
             }
         }
 
+        [DataMember]
+        public int Id
+        {
+            get
+            {
+                return _id;
+            }
+            set
+            {
+                SetPropertyValueAndDetectChanges(o =>
+                {
+                    _id = value;
+                    HasIdentity = true; //set the has Identity
+                    return _id;
+                }, _id, IdSelector);
+            }
+        }
+
+        //this doesn't get used
+        [IgnoreDataMember]
         public Guid Key { get; set; }
 
         #endregion
 
         #region Implementation of IMembershipUser
 
+        [IgnoreDataMember]
+        public object ProviderUserKey
+        {
+            get { return Id; }
+            set { throw new NotSupportedException("Cannot set the provider user key for a user"); }
+        }
+
+        /// <summary>
+        /// Gets or sets the type of the provider user key.
+        /// </summary>
+        /// <value>
+        /// The type of the provider user key.
+        /// </value>
+        [IgnoreDataMember]
+        internal Type ProviderUserKeyType
+        {
+            get
+            {
+                return _userTypeKey;
+            }
+            private set
+            {
+                SetPropertyValueAndDetectChanges(o =>
+                {
+                    _userTypeKey = value;
+                    return _userTypeKey;
+                }, _userTypeKey, UserTypeKeySelector);
+            }
+        }
+
+        /// <summary>
+        /// Sets the type of the provider user key.
+        /// </summary>
+        /// <param name="type">The type.</param>
+        internal void SetProviderUserKeyType(Type type)
+        {
+            ProviderUserKeyType = type;
+        }
+
         [DataMember]
-        public string Username { get; set; }
+        public string Username
+        {
+            get { return _username; }
+            set
+            {
+                SetPropertyValueAndDetectChanges(o =>
+                {
+                    _username = value;
+                    return _username;
+                }, _username, UsernameSelector);
+            }
+        }
         [DataMember]
-        public string Email { get; set; }
+        public string Email
+        {
+            get { return _email; }
+            set
+            {
+                SetPropertyValueAndDetectChanges(o =>
+                {
+                    _email = value;
+                    return _email;
+                }, _email, EmailSelector);
+            }
+        }
         [DataMember]
-        public string Password { get; set; }
+        public string Password
+        {
+            get { return _password; }
+            set
+            {
+                SetPropertyValueAndDetectChanges(o =>
+                {
+                    _password = value;
+                    return _password;
+                }, _password, PasswordSelector);
+            }
+        }
+
         [DataMember]
+        public bool IsApproved
+        {
+            get { return _isApproved; }
+            set
+            {
+                SetPropertyValueAndDetectChanges(o =>
+                {
+                    _isApproved = value;
+                    return _isApproved;
+                }, _isApproved, IsApprovedSelector);
+            }
+        }    
+
+        [DataMember]
+        public bool IsLockedOut
+        {
+            get { return _isLockedOut; }
+            set
+            {
+                SetPropertyValueAndDetectChanges(o =>
+                {
+                    _isLockedOut = value;
+                    return _isLockedOut;
+                }, _isLockedOut, IsLockedOutSelector);
+            }
+        }
+
+        //TODO: Figure out how to support all of this! - we cannot have NotImplementedExceptions because these get used by the IMembershipMemberService<IUser> service so
+        // we'll just have them as generic get/set which don't interact with the db.
+
+        [IgnoreDataMember]
         public string PasswordQuestion { get; set; }
-        [DataMember]
+        [IgnoreDataMember]
         public string PasswordAnswer { get; set; }
-        [DataMember]
+        [IgnoreDataMember]
         public string Comments { get; set; }
-        [DataMember]
-        public bool IsApproved { get; set; }
-        [DataMember]
-        public bool IsOnline { get; set; }
-        [DataMember]
-        public bool IsLockedOut { get; set; }
-        [DataMember]
+        [IgnoreDataMember]
         public DateTime CreateDate { get; set; }
-        [DataMember]
+        [IgnoreDataMember]
         public DateTime UpdateDate { get; set; }
-        [DataMember]
+        [IgnoreDataMember]
         public DateTime LastLoginDate { get; set; }
-        [DataMember]
+        [IgnoreDataMember]
         public DateTime LastPasswordChangeDate { get; set; }
-        [DataMember]
+        [IgnoreDataMember]
         public DateTime LastLockoutDate { get; set; }
-
-        [DataMember]
-        public object ProfileId { get; set; }
-        [DataMember]
-        public IEnumerable<object> Groups { get; set; }
-
+        [IgnoreDataMember]
+        public int FailedPasswordAttempts { get; set; }
+        
         #endregion
-
+        
         #region Implementation of IUser
 
         [DataMember]
-        public string Language { get; set; }
+        public string Name
+        {
+            get { return _name; }
+            set
+            {
+                SetPropertyValueAndDetectChanges(o =>
+                {
+                    _name = value;
+                    return _name;
+                }, _name, NameSelector);
+            }
+        }
+
+        public IEnumerable<string> AllowedSections
+        {
+            get { return _sectionCollection; }
+        }
+
+        public void RemoveAllowedSection(string sectionAlias)
+        {
+            _sectionCollection.Remove(sectionAlias);
+        }
+
+        public void AddAllowedSection(string sectionAlias)
+        {
+            if (_sectionCollection.Contains(sectionAlias) == false)
+            {
+                _sectionCollection.Add(sectionAlias);
+            }
+        }
+
+        public IProfile ProfileData
+        {
+            get { return new UserProfile(this); }
+        }
+
+        /// <summary>
+        /// Used internally to check if we need to add a section in the repository to the db
+        /// </summary>
+        internal IEnumerable<string> AddedSections
+        {
+            get { return _addedSections; }
+        }
+
+        /// <summary>
+        /// Used internally to check if we need to remove  a section in the repository to the db
+        /// </summary>
+        internal IEnumerable<string> RemovedSections
+        {
+            get { return _removedSections; }
+        }
+
+        /// <summary>
+        /// Gets or sets the session timeout.
+        /// </summary>
+        /// <value>
+        /// The session timeout.
+        /// </value>
         [DataMember]
-        public string DefaultPermissions { get; set; }
+        public int SessionTimeout
+        {
+            get { return _sessionTimeout; }
+            set
+            {
+                SetPropertyValueAndDetectChanges(o =>
+                    {
+                        _sessionTimeout = value;
+                        return _sessionTimeout;
+                    }, _sessionTimeout, SessionTimeoutSelector);
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the start content id.
+        /// </summary>
+        /// <value>
+        /// The start content id.
+        /// </value>
+        [DataMember]
+        public int StartContentId
+        {
+            get { return _startContentId; }
+            set
+            {
+                SetPropertyValueAndDetectChanges(o =>
+                    {
+                        _startContentId = value;
+                        return _startContentId;
+                    }, _startContentId, StartContentIdSelector);
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the start media id.
+        /// </summary>
+        /// <value>
+        /// The start media id.
+        /// </value>
+        [DataMember]
+        public int StartMediaId
+        {
+            get { return _startMediaId; }
+            set
+            {
+                SetPropertyValueAndDetectChanges(o =>
+                    {
+                        _startMediaId = value;
+                        return _startMediaId;
+                    }, _startMediaId, StartMediaIdSelector);
+            }
+        }
 
         [DataMember]
-        public bool DefaultToLiveEditing { get; set; }
+        public string Language
+        {
+            get { return _language; }
+            set
+            {
+                SetPropertyValueAndDetectChanges(o =>
+                {
+                    _language = value;
+                    return _language;
+                }, _language, LanguageSelector);
+            }
+        }
+        
         [DataMember]
-        public bool NoConsole { get; set; }
+        public IEnumerable<string> DefaultPermissions
+        {
+            get { return _defaultPermissions; }
+            set
+            {
+                SetPropertyValueAndDetectChanges(o =>
+                {
+                    _defaultPermissions = value;
+                    return _defaultPermissions;
+                }, _defaultPermissions, DefaultPermissionsSelector);
+            }
+        }
+
+        [IgnoreDataMember]
+        internal bool DefaultToLiveEditing
+        {
+            get { return _defaultToLiveEditing; }
+            set
+            {
+                SetPropertyValueAndDetectChanges(o =>
+                {
+                    _defaultToLiveEditing = value;
+                    return _defaultToLiveEditing;
+                }, _defaultToLiveEditing, DefaultToLiveEditingSelector);
+            }
+        }
 
         [IgnoreDataMember]
         public IUserType UserType
         {
-            get
+            get { return _userType; }
+            set
             {
-                var type = Groups.FirstOrDefault();
-                return type as IUserType;
+                if (value.HasIdentity == false)
+                {
+                    throw new InvalidOperationException("Cannot assign a User Type that has not been persisted");
+                }
+
+                SetPropertyValueAndDetectChanges(o =>
+                {
+                    _userType = value;
+                    return _userType;
+                }, _userType, UserTypeSelector);
             }
         }
 
         #endregion
+
+        /// <summary>
+        /// Whenever resetting occurs, clear the remembered add/removed collections, even if 
+        /// rememberPreviouslyChangedProperties is true, the AllowedSections property will still
+        /// be flagged as dirty.
+        /// </summary>
+        /// <param name="rememberPreviouslyChangedProperties"></param>
+        internal override void ResetDirtyProperties(bool rememberPreviouslyChangedProperties)
+        {
+            _addedSections.Clear();
+            _removedSections.Clear();
+            base.ResetDirtyProperties(rememberPreviouslyChangedProperties);
+        }
+
+        /// <summary>
+        /// Handles the collection changed event in order for us to flag the AllowedSections property as changed
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
+        void SectionCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
+        {
+            OnPropertyChanged(AllowedSectionsSelector);
+
+            if (e.Action == NotifyCollectionChangedAction.Add)
+            {
+                //remove from the removed/added sections (since people could add/remove all they want in one request)
+                _removedSections.RemoveAll(s => s == e.NewItems.Cast<string>().First());
+                _addedSections.RemoveAll(s => s == e.NewItems.Cast<string>().First());
+
+                //add to the added sections
+                _addedSections.Add(e.NewItems.Cast<string>().First());
+            }
+            else if (e.Action == NotifyCollectionChangedAction.Remove)
+            {
+                //remove from the removed/added sections (since people could add/remove all they want in one request)
+                _removedSections.RemoveAll(s => s == e.OldItems.Cast<string>().First());
+                _addedSections.RemoveAll(s => s == e.OldItems.Cast<string>().First());
+
+                //add to the added sections
+                _removedSections.Add(e.OldItems.Cast<string>().First());
+            }
+        }
+
+        /// <summary>
+        /// Internal class used to wrap the user in a profile
+        /// </summary>
+        private class UserProfile : IProfile
+        {
+            private readonly IUser _user;
+
+            public UserProfile(IUser user)
+            {
+                _user = user;
+            }
+
+            public object Id
+            {
+                get { return _user.Id; }
+                set { _user.Id = (int)value; }
+            }
+
+            public string Name
+            {
+                get { return _user.Name; }
+                set { _user.Name = value; }
+            }
+        }
     }
 }

src/Umbraco.Core/Models/Membership/UserProfile.cs

@@ -1,188 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.Collections.Specialized;
-using System.Linq;
-using System.Reflection;
-using System.Runtime.Serialization;
-
-namespace Umbraco.Core.Models.Membership
-{
-    /// <summary>
-    /// Represents the Profile implementation for a backoffice User
-    /// </summary>
-    /// <remarks>
-    /// Should be internal until a proper user/membership implementation
-    /// is part of the roadmap.
-    /// </remarks>
-    [Serializable]
-    [DataContract(IsReference = true)]
-    internal class UserProfile : Profile, IUserProfile
-    {
-        public UserProfile()
-        {
-            SessionTimeout = 60;
-            _sectionCollection = new ObservableCollection<string>();
-            _addedSections = new List<string>();
-            _removedSections = new List<string>();
-            _sectionCollection.CollectionChanged += SectionCollectionChanged;
-        }
-
-        private readonly List<string> _addedSections;
-        private readonly List<string> _removedSections;
-        private readonly ObservableCollection<string> _sectionCollection;
-        private int _sessionTimeout;
-        private int _startContentId;
-        private int _startMediaId;
-
-        private static readonly PropertyInfo SessionTimeoutSelector = ExpressionHelper.GetPropertyInfo<UserProfile, int>(x => x.SessionTimeout);
-        private static readonly PropertyInfo StartContentIdSelector = ExpressionHelper.GetPropertyInfo<UserProfile, int>(x => x.StartContentId);
-        private static readonly PropertyInfo StartMediaIdSelector = ExpressionHelper.GetPropertyInfo<UserProfile, int>(x => x.StartMediaId);
-        private static readonly PropertyInfo AllowedSectionsSelector = ExpressionHelper.GetPropertyInfo<UserProfile, IEnumerable<string>>(x => x.AllowedSections);
-
-        /// <summary>
-        /// Gets or sets the session timeout.
-        /// </summary>
-        /// <value>
-        /// The session timeout.
-        /// </value>
-        [DataMember]
-        public int SessionTimeout
-        {
-            get
-            {
-                return _sessionTimeout;
-            }
-            set
-            {
-                SetPropertyValueAndDetectChanges(o =>
-                {
-                    _sessionTimeout = value;
-                    return _sessionTimeout;
-                }, _sessionTimeout, SessionTimeoutSelector);
-            }
-        }
-
-        /// <summary>
-        /// Gets or sets the start content id.
-        /// </summary>
-        /// <value>
-        /// The start content id.
-        /// </value>
-        [DataMember]
-        public int StartContentId
-        {
-            get
-            {
-                return _startContentId;
-            }
-            set
-            {
-                SetPropertyValueAndDetectChanges(o =>
-                {
-                    _startContentId = value;
-                    return _startContentId;
-                }, _startContentId, StartContentIdSelector);
-            }
-        }
-
-        /// <summary>
-        /// Gets or sets the start media id.
-        /// </summary>
-        /// <value>
-        /// The start media id.
-        /// </value>
-        [DataMember]
-        public int StartMediaId
-        {
-            get
-            {
-                return _startMediaId;
-            }
-            set
-            {
-                SetPropertyValueAndDetectChanges(o =>
-                {
-                    _startMediaId = value;
-                    return _startMediaId;
-                }, _startMediaId, StartMediaIdSelector);
-            }
-        }
-
-        public IEnumerable<string> AllowedSections
-        {
-            get { return _sectionCollection; }
-        }
-
-        public void RemoveAllowedSection(string sectionAlias)
-        {
-            _sectionCollection.Remove(sectionAlias);
-        }
-
-        public void AddAllowedSection(string sectionAlias)
-        {
-            if (!_sectionCollection.Contains(sectionAlias))
-            {
-                _sectionCollection.Add(sectionAlias);
-            }
-        }
-
-        /// <summary>
-        /// Whenever resetting occurs, clear the remembered add/removed collections, even if 
-        /// rememberPreviouslyChangedProperties is true, the AllowedSections property will still
-        /// be flagged as dirty.
-        /// </summary>
-        /// <param name="rememberPreviouslyChangedProperties"></param>
-        internal override void ResetDirtyProperties(bool rememberPreviouslyChangedProperties)
-        {
-            _addedSections.Clear();
-            _removedSections.Clear();
-            base.ResetDirtyProperties(rememberPreviouslyChangedProperties);
-        }
-
-        /// <summary>
-        /// Used internally to check if we need to add a section in the repository to the db
-        /// </summary>
-        internal IEnumerable<string> AddedSections
-        {
-            get { return _addedSections; }
-        }
-
-        /// <summary>
-        /// Used internally to check if we need to remove  a section in the repository to the db
-        /// </summary>
-        internal IEnumerable<string> RemovedSections
-        {
-            get { return _removedSections; }
-        }
-
-        /// <summary>
-        /// Handles the collection changed event in order for us to flag the AllowedSections property as changed
-        /// </summary>
-        /// <param name="sender"></param>
-        /// <param name="e"></param>
-        void SectionCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
-        {
-            OnPropertyChanged(AllowedSectionsSelector);
-
-            if (e.Action == NotifyCollectionChangedAction.Add)
-            {
-                //remove from the removed/added sections (since people could add/remove all they want in one request)
-                _removedSections.RemoveAll(s => s == e.NewItems.Cast<string>().First());
-                _addedSections.RemoveAll(s => s == e.NewItems.Cast<string>().First());
-
-                //add to the added sections
-                _addedSections.Add(e.NewItems.Cast<string>().First());
-            }
-            else if (e.Action == NotifyCollectionChangedAction.Remove)
-            {
-                //remove from the removed/added sections (since people could add/remove all they want in one request)
-                _removedSections.RemoveAll(s => s == e.OldItems.Cast<string>().First());
-                _addedSections.RemoveAll(s => s == e.OldItems.Cast<string>().First());
-
-                //add to the added sections
-                _removedSections.Add(e.OldItems.Cast<string>().First());
-            }
-        }
-    }
-}

src/Umbraco.Core/Models/Membership/UserType.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Runtime.Serialization;
 using Umbraco.Core.Models.EntityBase;
 using Umbraco.Core.Persistence.Mappers;
@@ -22,7 +23,13 @@ namespace Umbraco.Core.Models.Membership
         [DataMember]
         public string Name { get; set; }
 
+        /// <summary>
+        /// The set of default permissions for the user type
+        /// </summary>
+        /// <remarks>
+        /// By default each permission is simply a single char but we've made this an enumerable{string} to support a more flexible permissions structure in the future.
+        /// </remarks>
         [DataMember]
-        public string Permissions { get; set; }
+        public IEnumerable<string> Permissions { get; set; }
     }
 }

src/Umbraco.Core/Models/Notification.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Umbraco.Core.Models
+{
+    internal class Notification
+    {
+        public Notification(int entityId, int userId, string action, Guid entityType)
+        {
+            EntityId = entityId;
+            UserId = userId;
+            Action = action;
+            EntityType = entityType;
+        }
+
+        public int EntityId { get; private set; }
+        public int UserId { get; private set; }
+        public string Action { get; private set; }
+        public Guid EntityType { get; private set; }
+    }
+}

src/Umbraco.Core/Models/PreValue.cs

@@ -0,0 +1,29 @@
+namespace Umbraco.Core.Models
+{
+    /// <summary>
+    /// Represents a stored pre-value field value
+    /// </summary>
+    public class PreValue
+    {
+        public PreValue(int id, string value)
+        {
+            Value = value;
+            Id = id;
+        }
+
+        public PreValue(string value)
+        {
+            Value = value;
+        }
+
+        /// <summary>
+        /// The value stored for the pre-value field
+        /// </summary>
+        public string Value { get; private set; }
+
+        /// <summary>
+        /// The database id for the pre-value field value
+        /// </summary>
+        public int Id { get; private set; }
+    }
+}

src/Umbraco.Core/Models/PreValueCollection.cs

@@ -0,0 +1,86 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Umbraco.Core.Models
+{
+    /// <summary>
+    /// Represents the pre-value data for a DataType
+    /// </summary>
+    /// <remarks>
+    /// Due to the legacy nature of the data that can be stored for pre-values, we have this class which encapsulates the 2 different
+    /// ways that pre-values are stored: A string array or a Dictionary.
+    /// 
+    /// Most legacy property editors won't support the dictionary format but new property editors should always use the dictionary format.
+    /// In order to get overrideable pre-values working we need a dictionary since we'll have to reference a pre-value by a key.
+    /// </remarks>
+    public class PreValueCollection
+    {
+        private IDictionary<string, PreValue> _preValuesAsDictionary;
+        private IEnumerable<PreValue> _preValuesAsArray;
+        public IEnumerable<PreValue> PreValuesAsArray
+        {
+            get
+            {
+                if (_preValuesAsArray == null)
+                {
+                    throw new InvalidOperationException("The current pre-value collection is dictionary based, use the PreValuesAsDictionary property instead");
+                }
+                return _preValuesAsArray;
+            }
+            set { _preValuesAsArray = value; }
+        }
+
+        public IDictionary<string, PreValue> PreValuesAsDictionary
+        {
+            get
+            {
+                if (_preValuesAsDictionary == null)
+                {
+                    throw new InvalidOperationException("The current pre-value collection is array based, use the PreValuesAsArray property instead");
+                }
+                return _preValuesAsDictionary;
+            }
+            set { _preValuesAsDictionary = value; }
+        }
+
+        /// <summary>
+        /// Check if it is a dictionary based collection
+        /// </summary>
+        public bool IsDictionaryBased
+        {
+            get { return _preValuesAsDictionary != null; }
+        }
+
+        public PreValueCollection(IEnumerable<PreValue> preVals)
+        {
+            _preValuesAsArray = preVals;
+        }
+
+        public PreValueCollection(IDictionary<string, PreValue> preVals)
+        {
+            _preValuesAsDictionary = preVals;
+        }
+
+        /// <summary>
+        /// Regardless of how the pre-values are stored this will return as a dictionary, it will convert an array based to a dictionary
+        /// </summary>
+        /// <returns></returns>
+        public IDictionary<string, PreValue> FormatAsDictionary()
+        {
+            if (IsDictionaryBased)
+            {
+                return PreValuesAsDictionary;
+            }
+
+            //it's an array so need to format it, the alias will just be an iteration
+            var result = new Dictionary<string, PreValue>();
+            var asArray = PreValuesAsArray.ToArray();
+            for (var i = 0; i < asArray.Length; i++)
+            {
+                result.Add(i.ToInvariantString(), asArray[i]);
+            }
+            return result;
+        }
+    }
+}

src/Umbraco.Core/Models/Property.cs

@@ -43,7 +43,7 @@ namespace Umbraco.Core.Models
 
         private static readonly PropertyInfo ValueSelector = ExpressionHelper.GetPropertyInfo<Property, object>(x => x.Value);
         private static readonly PropertyInfo VersionSelector = ExpressionHelper.GetPropertyInfo<Property, Guid>(x => x.Version);
-
+        
         /// <summary>
         /// Returns the Alias of the PropertyType, which this Property is based on
         /// </summary>
@@ -59,9 +59,14 @@ namespace Umbraco.Core.Models
         /// <summary>
         /// Returns the DatabaseType that the underlaying DataType is using to store its values
         /// </summary>
-        /// <remarks>Only used internally when saving the property value</remarks>
+        /// <remarks>
+        /// Only used internally when saving the property value.
+        /// </remarks>
         [IgnoreDataMember]
-        internal DataTypeDatabaseType DataTypeDatabaseType { get { return _propertyType.DataTypeDatabaseType; } }
+        internal DataTypeDatabaseType DataTypeDatabaseType
+        {
+            get { return _propertyType.DataTypeDatabaseType; }
+        }
 
         /// <summary>
         /// Returns the PropertyType, which this Property is based on

src/Umbraco.Core/Models/PropertyType.cs

@@ -14,6 +14,7 @@ namespace Umbraco.Core.Models
     [DataContract(IsReference = true)]
     public class PropertyType : Entity, IEquatable<PropertyType>
     {
+        private readonly bool _isExplicitDbType;
         private string _name;
         private string _alias;
         private string _description;
@@ -29,16 +30,28 @@ namespace Umbraco.Core.Models
         public PropertyType(IDataTypeDefinition dataTypeDefinition)
         {
             if(dataTypeDefinition.HasIdentity)
-                DataTypeDefinitionId = dataTypeDefinition.Id;
+                _dataTypeDefinitionId = dataTypeDefinition.Id;
 
-            DataTypeId = dataTypeDefinition.ControlId;
-            DataTypeDatabaseType = dataTypeDefinition.DatabaseType;
+            _dataTypeId = dataTypeDefinition.ControlId;
+            _dataTypeDatabaseType = dataTypeDefinition.DatabaseType;
         }
 
         internal PropertyType(Guid dataTypeControlId, DataTypeDatabaseType dataTypeDatabaseType)
+            : this(dataTypeControlId, dataTypeDatabaseType, false)
         {
-            DataTypeId = dataTypeControlId;
-            DataTypeDatabaseType = dataTypeDatabaseType;
+        }
+
+        /// <summary>
+        /// Used internally to assign an explicity database type for this property type regardless of what the underlying data type/property editor is.
+        /// </summary>
+        /// <param name="dataTypeControlId"></param>
+        /// <param name="dataTypeDatabaseType"></param>
+        /// <param name="isExplicitDbType"></param>
+        internal PropertyType(Guid dataTypeControlId, DataTypeDatabaseType dataTypeDatabaseType, bool isExplicitDbType)
+        {
+            _isExplicitDbType = isExplicitDbType;
+            _dataTypeId = dataTypeControlId;
+            _dataTypeDatabaseType = dataTypeDatabaseType;
         }
 
         private static readonly PropertyInfo NameSelector = ExpressionHelper.GetPropertyInfo<PropertyType, string>(x => x.Name);
@@ -149,6 +162,9 @@ namespace Umbraco.Core.Models
             get { return _dataTypeDatabaseType; }
             set
             {
+                //don't allow setting this if an explicit declaration has been made in the ctor
+                if (_isExplicitDbType) return;
+
                 SetPropertyValueAndDetectChanges(o =>
                 {
                     _dataTypeDatabaseType = value;
@@ -361,8 +377,16 @@ namespace Umbraco.Core.Models
             //Check against Regular Expression for Legacy DataTypes - Validation exists and value is not null:
             if(string.IsNullOrEmpty(ValidationRegExp) == false && (value != null && string.IsNullOrEmpty(value.ToString()) == false))
             {
-                var regexPattern = new Regex(ValidationRegExp);
-                return regexPattern.IsMatch(value.ToString());
+                try
+                {
+                    var regexPattern = new Regex(ValidationRegExp);
+                    return regexPattern.IsMatch(value.ToString());
+                }
+                catch 
+                {
+                         throw new Exception(string .Format("Invalid validation expression on property {0}",this.Alias));
+                }
+                
             }
 
             //TODO Add PropertyEditor validation when its relevant to introduce

src/Umbraco.Core/Models/PublishedContent/PublishedContentType.cs

@@ -102,7 +102,7 @@ namespace Umbraco.Core.Models.PublishedContent
             Logging.LogHelper.Debug<PublishedContentType>("Clear all.");
             // ok and faster to do it by types, assuming noone else caches PublishedContentType instances
             //ApplicationContext.Current.ApplicationCache.ClearStaticCacheByKeySearch("PublishedContentType_");
-            ApplicationContext.Current.ApplicationCache.ClearStaticCacheObjectTypes<PublishedContentType>();
+            ApplicationContext.Current.ApplicationCache.StaticCache.ClearCacheObjectTypes<PublishedContentType>();
         }
 
         internal static void ClearContentType(int id)
@@ -110,7 +110,7 @@ namespace Umbraco.Core.Models.PublishedContent
             Logging.LogHelper.Debug<PublishedContentType>("Clear content type w/id {0}.", () => id);
             // requires a predicate because the key does not contain the ID
             // faster than key strings comparisons anyway
-            ApplicationContext.Current.ApplicationCache.ClearStaticCacheObjectTypes<PublishedContentType>(
+            ApplicationContext.Current.ApplicationCache.StaticCache.ClearCacheObjectTypes<PublishedContentType>(
                 (key, value) => value.Id == id);
         }
 
@@ -121,7 +121,7 @@ namespace Umbraco.Core.Models.PublishedContent
             // properties ie both its own properties and those that were inherited (it's based upon an
             // IContentTypeComposition) and so every PublishedContentType having a property based upon
             // the cleared data type, be it local or inherited, will be cleared.
-            ApplicationContext.Current.ApplicationCache.ClearStaticCacheObjectTypes<PublishedContentType>(
+            ApplicationContext.Current.ApplicationCache.StaticCache.ClearCacheObjectTypes<PublishedContentType>(
                 (key, value) => value.PropertyTypes.Any(x => x.DataTypeId == id));
         }
 
@@ -130,7 +130,7 @@ namespace Umbraco.Core.Models.PublishedContent
             var key = string.Format("PublishedContentType_{0}_{1}",
                 itemType == PublishedItemType.Content ? "content" : "media", alias.ToLowerInvariant());
 
-            var type = ApplicationContext.Current.ApplicationCache.GetStaticCacheItem(key,
+            var type = ApplicationContext.Current.ApplicationCache.StaticCache.GetCacheItem<PublishedContentType>(key,
                 () => CreatePublishedContentType(itemType, alias));
 
             return type;
@@ -142,8 +142,8 @@ namespace Umbraco.Core.Models.PublishedContent
                 return GetPublishedContentTypeCallback(alias);
 
             var contentType = itemType == PublishedItemType.Content
-                ? (IContentTypeComposition) ApplicationContext.Current.Services.ContentTypeService.GetContentType(alias)
-                : (IContentTypeComposition) ApplicationContext.Current.Services.ContentTypeService.GetMediaType(alias);
+                ? (IContentTypeComposition)ApplicationContext.Current.Services.ContentTypeService.GetContentType(alias)
+                : (IContentTypeComposition)ApplicationContext.Current.Services.ContentTypeService.GetMediaType(alias);
 
             if (contentType == null)
                 throw new Exception(string.Format("ContentTypeService failed to find a {0} type with alias \"{1}\".",
@@ -161,7 +161,7 @@ namespace Umbraco.Core.Models.PublishedContent
             {
                 // see note above
                 //ClearAll();
-                ApplicationContext.Current.ApplicationCache.ClearStaticCacheByKeySearch("PublishedContentType_");
+                ApplicationContext.Current.ApplicationCache.StaticCache.ClearCacheByKeySearch("PublishedContentType_");
 
                 _getPublishedContentTypeCallBack = value;
             }

src/Umbraco.Core/Models/Rdbms/NodeDto.cs

@@ -9,8 +9,10 @@ namespace Umbraco.Core.Models.Rdbms
     [ExplicitColumns]
     internal class NodeDto
     {
+        public const int NodeIdSeed = 1050;
+
         [Column("id")]
-        [PrimaryKeyColumn(Name = "PK_structure", IdentitySeed = 1045)]
+        [PrimaryKeyColumn(Name = "PK_structure", IdentitySeed = NodeIdSeed)]
         public int NodeId { get; set; }
 
         [Column("trashed")]

src/Umbraco.Core/Models/Rdbms/PropertyTypeDto.cs

@@ -9,7 +9,7 @@ namespace Umbraco.Core.Models.Rdbms
     internal class PropertyTypeDto
     {
         [Column("id")]
-        [PrimaryKeyColumn(IdentitySeed = 28)]
+        [PrimaryKeyColumn(IdentitySeed = 50)]
         public int Id { get; set; }
 
         [Column("dataTypeId")]

src/Umbraco.Core/Models/Rdbms/PropertyTypeGroupDto.cs

@@ -10,7 +10,7 @@ namespace Umbraco.Core.Models.Rdbms
     internal class PropertyTypeGroupDto
     {
         [Column("id")]
-        [PrimaryKeyColumn(IdentitySeed = 6)]
+        [PrimaryKeyColumn(IdentitySeed = 12)]
         public int Id { get; set; }
 
         [Column("parentGroupId")]

src/Umbraco.Core/Models/Rdbms/ServerRegistrationDto.cs

@@ -30,7 +30,6 @@ namespace Umbraco.Core.Models.Rdbms
         public DateTime DateRegistered { get; set; }
 
         [Column("lastNotifiedDate")]
-        [Constraint(Default = "getdate()")]
         public DateTime LastNotified { get; set; }
 
         [Column("isActive")]

src/Umbraco.Core/Models/Rdbms/UserDto.cs

@@ -41,7 +41,7 @@ namespace Umbraco.Core.Models.Rdbms
         public string Login { get; set; }
 
         [Column("userPassword")]
-        [Length(125)]
+        [Length(500)]
         public string Password { get; set; }
 
         [Column("userEmail")]

src/Umbraco.Core/Models/Relation.cs

@@ -11,15 +11,15 @@ namespace Umbraco.Core.Models
     /// </summary>
     [Serializable]
     [DataContract(IsReference = true)]
-    public class Relation : Entity, IAggregateRoot
+    public class Relation : Entity, IAggregateRoot, IRelation
     {
         //NOTE: The datetime column from umbracoRelation is set on CreateDate on the Entity
         private int _parentId;
         private int _childId;
-        private RelationType _relationType;
+        private IRelationType _relationType;
         private string _comment;
 
-        public Relation(int parentId, int childId, RelationType relationType)
+        public Relation(int parentId, int childId, IRelationType relationType)
         {
             _parentId = parentId;
             _childId = childId;
@@ -28,7 +28,7 @@ namespace Umbraco.Core.Models
 
         private static readonly PropertyInfo ParentIdSelector = ExpressionHelper.GetPropertyInfo<Relation, int>(x => x.ParentId);
         private static readonly PropertyInfo ChildIdSelector = ExpressionHelper.GetPropertyInfo<Relation, int>(x => x.ChildId);
-        private static readonly PropertyInfo RelationTypeSelector = ExpressionHelper.GetPropertyInfo<Relation, RelationType>(x => x.RelationType);
+        private static readonly PropertyInfo RelationTypeSelector = ExpressionHelper.GetPropertyInfo<Relation, IRelationType>(x => x.RelationType);
         private static readonly PropertyInfo CommentSelector = ExpressionHelper.GetPropertyInfo<Relation, string>(x => x.Comment);
 
         /// <summary>
@@ -69,7 +69,7 @@ namespace Umbraco.Core.Models
         /// Gets or sets the <see cref="RelationType"/> for the Relation
         /// </summary>
         [DataMember]
-        public RelationType RelationType
+        public IRelationType RelationType
         {
             get { return _relationType; }
             set

src/Umbraco.Core/Models/RelationType.cs

@@ -11,7 +11,7 @@ namespace Umbraco.Core.Models
     /// </summary>
     [Serializable]
     [DataContract(IsReference = true)]
-    public class RelationType : Entity, IAggregateRoot
+    public class RelationType : Entity, IAggregateRoot, IRelationType
     {
         private string _name;
         private string _alias;

src/Umbraco.Core/Models/Template.cs

@@ -191,5 +191,11 @@ namespace Umbraco.Core.Models
             if (Key == Guid.Empty)
                 Key = Guid.NewGuid();
         }
+
+
+        public void SetMasterTemplate(ITemplate masterTemplate)
+        {
+            MasterTemplateId = new Lazy<int>(() => masterTemplate.Id);
+        }
     }
-}
+}

src/Umbraco.Core/Models/TemplateNode.cs

@@ -0,0 +1,34 @@
+using System.Collections.Generic;
+
+namespace Umbraco.Core.Models
+{
+    /// <summary>
+    /// Represents a template in a template tree
+    /// </summary>
+    public class TemplateNode
+    {
+        public TemplateNode(ITemplate template)
+        {
+            Template = template;
+            Children = new List<TemplateNode>();
+        }
+
+        /// <summary>
+        /// The current template
+        /// </summary>
+        public ITemplate Template { get; set; }
+
+        /// <summary>
+        /// The children of the current template
+        /// </summary>
+        public IEnumerable<TemplateNode> Children { get; set; }
+
+        /// <summary>
+        /// The parent template to the current template
+        /// </summary>
+        /// <remarks>
+        /// Will be null if there is no parent
+        /// </remarks>
+        public TemplateNode Parent { get; set; }
+    }
+}

src/Umbraco.Core/Models/UmbracoEntity.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Reflection;
 using Umbraco.Core.Models.EntityBase;
 
@@ -53,6 +54,13 @@ namespace Umbraco.Core.Models
             Trashed = trashed;
         }
 
+        // for MySql
+        public UmbracoEntity(UInt64 trashed)
+        {
+            AdditionalData = new Dictionary<string, object>();
+            Trashed = trashed == 1;
+        }
+
         public int CreatorId
         {
             get { return _creatorId; }

src/Umbraco.Core/NameValueCollectionExtensions.cs

@@ -13,5 +13,23 @@ namespace Umbraco.Core
 		{
 			return collection.Keys.Cast<object>().Any(k => (string) k == key);
 		}
+
+        public static T GetValue<T>(this NameValueCollection collection, string key, T defaultIfNotFound)
+        {
+            if (collection.ContainsKey(key) == false)
+            {
+                return defaultIfNotFound;
+            }
+
+            var val = collection[key];
+            if (val == null)
+            {
+                return defaultIfNotFound;
+            }
+
+            var result = val.TryConvertTo<T>();
+            
+            return result.Success ? result.Result : defaultIfNotFound;
+        }
 	}
 }

src/Umbraco.Core/ObjectExtensions.cs

@@ -237,12 +237,14 @@ namespace Umbraco.Core
 			    else if (destinationType == typeof(Double))
 			    {
 			        Double value;
-			        return Double.TryParse(input, out value) ? Attempt<object>.Succeed(value) : Attempt<object>.Fail();
+			        var input2 = NormalizeNumberDecimalSeparator(input);
+			        return Double.TryParse(input2, out value) ? Attempt<object>.Succeed(value) : Attempt<object>.Fail();
 			    }
 			    else if (destinationType == typeof(Single))
 			    {
 			        Single value;
-			        return Single.TryParse(input, out value) ? Attempt<object>.Succeed(value) : Attempt<object>.Fail();
+                    var input2 = NormalizeNumberDecimalSeparator(input);
+                    return Single.TryParse(input2, out value) ? Attempt<object>.Succeed(value) : Attempt<object>.Fail();
 			    }
 			    else if (destinationType == typeof(Char))
 			    {
@@ -283,7 +285,20 @@ namespace Umbraco.Core
 			else if (destinationType == typeof(DateTime))
 			{
 				DateTime value;
-				return DateTime.TryParse(input, out value) ? Attempt<object>.Succeed(value) : Attempt<object>.Fail();
+			    if (DateTime.TryParse(input, out value))
+			    {
+			        switch (value.Kind)
+			        {
+			            case DateTimeKind.Unspecified:
+			            case DateTimeKind.Utc:
+                            return Attempt<object>.Succeed(value);
+			            case DateTimeKind.Local:
+			                return Attempt<object>.Succeed(value.ToUniversalTime());
+			            default:
+			                throw new ArgumentOutOfRangeException();
+			        }
+			    }
+			    return Attempt<object>.Fail();
 			}
 			else if (destinationType == typeof(DateTimeOffset))
 			{
@@ -298,7 +313,8 @@ namespace Umbraco.Core
 			else if (destinationType == typeof(Decimal))
 			{
 				Decimal value;
-				return Decimal.TryParse(input, out value) ? Attempt<object>.Succeed(value) : Attempt<object>.Fail();
+                var input2 = NormalizeNumberDecimalSeparator(input);
+                return Decimal.TryParse(input2, out value) ? Attempt<object>.Succeed(value) : Attempt<object>.Fail();
 			}
 			else if (destinationType == typeof(Version))
 			{
@@ -310,6 +326,14 @@ namespace Umbraco.Core
 			return null; // we can't decide...
 		}
 
+        private readonly static char[] NumberDecimalSeparatorsToNormalize = new[] {'.', ','};
+
+	    private static string NormalizeNumberDecimalSeparator(string s)
+	    {
+	        var normalized = System.Threading.Thread.CurrentThread.CurrentUICulture.NumberFormat.NumberDecimalSeparator[0];
+            return s.ReplaceMany(NumberDecimalSeparatorsToNormalize, normalized);
+	    }
+
 		internal static void CheckThrowObjectDisposed(this IDisposable disposable, bool isDisposed, string objectname)
 		{
 			//TODO: Localise this exception
@@ -516,7 +540,7 @@ namespace Umbraco.Core
 			if (type == typeof(bool)) return XmlConvert.ToString((bool)value);
 			if (type == typeof(byte)) return XmlConvert.ToString((byte)value);
 			if (type == typeof(char)) return XmlConvert.ToString((char)value);
-			if (type == typeof(DateTime)) return XmlConvert.ToString((DateTime)value, XmlDateTimeSerializationMode.RoundtripKind);
+            if (type == typeof(DateTime)) return XmlConvert.ToString((DateTime)value, XmlDateTimeSerializationMode.Unspecified);
 			if (type == typeof(DateTimeOffset)) return XmlConvert.ToString((DateTimeOffset)value);
 			if (type == typeof(decimal)) return XmlConvert.ToString((decimal)value);
 			if (type == typeof(double)) return XmlConvert.ToString((double)value);

src/Umbraco.Core/Persistence/Caching/RuntimeCacheProvider.cs

@@ -151,6 +151,21 @@ namespace Umbraco.Core.Persistence.Caching
             _keyTracker.Remove(key);
         }
 
+        public void Delete(Type type, int entityId)
+        {
+            var key = GetCompositeId(type, entityId);
+            if (_memoryCache != null)
+            {
+                _memoryCache.Remove(key);
+            }
+            else
+            {
+                HttpRuntime.Cache.Remove(key);
+            }
+
+            _keyTracker.Remove(key);
+        }
+
         /// <summary>
         /// Clear cache by type
         /// </summary>

src/Umbraco.Core/Persistence/Factories/MemberGroupFactory.cs

@@ -0,0 +1,64 @@
+using System;
+using Umbraco.Core.Models;
+using Umbraco.Core.Models.Rdbms;
+
+namespace Umbraco.Core.Persistence.Factories
+{
+    internal class MemberGroupFactory : IEntityFactory<IMemberGroup, NodeDto>
+    {
+        
+        private readonly Guid _nodeObjectTypeId;
+
+        public MemberGroupFactory()
+        {
+            _nodeObjectTypeId = new Guid(Constants.ObjectTypes.MemberGroup);
+        }
+
+        #region Implementation of IEntityFactory<ITemplate,TemplateDto>
+
+        public IMemberGroup BuildEntity(NodeDto dto)
+        {
+            var template = new MemberGroup
+            {
+                CreateDate = dto.CreateDate,
+                Id = dto.NodeId,
+                Key = dto.UniqueId.Value,
+                Name = dto.Text                
+            };
+
+            //on initial construction we don't want to have dirty properties tracked
+            // http://issues.umbraco.org/issue/U4-1946
+            template.ResetDirtyProperties(false);
+            return template;
+        }
+
+        public NodeDto BuildDto(IMemberGroup entity)
+        {
+            var dto = new NodeDto
+            {
+                CreateDate = entity.CreateDate,
+                NodeId = entity.Id,
+                Level = 0,
+                NodeObjectType = _nodeObjectTypeId,
+                ParentId = -1,
+                Path = "",
+                SortOrder = 0,
+                Text = entity.Name,
+                Trashed = false,
+                UniqueId = entity.Key,
+                UserId = entity.CreatorId
+            };
+
+            if (entity.HasIdentity)
+            {
+                dto.NodeId = entity.Id;
+                dto.Path = "-1," + entity.Id;
+            }
+
+            return dto;
+        }
+
+        #endregion
+
+    }
+}

src/Umbraco.Core/Persistence/Factories/MemberReadOnlyFactory.cs

@@ -25,7 +25,7 @@ namespace Umbraco.Core.Persistence.Factories
                              CreateDate = dto.CreateDate,
                              UpdateDate = dto.UpdateDate,
                              Name = dto.Text,
-                             ProviderUserKey = dto.UniqueId,
+                             ProviderUserKey = dto.NodeId,
                              Trashed = dto.Trashed,
                              Key = dto.UniqueId.Value,
                              CreatorId = dto.UserId.HasValue ? dto.UserId.Value : 0,

src/Umbraco.Core/Persistence/Factories/MemberTypeReadOnlyFactory.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.Rdbms;
+using Umbraco.Core.Persistence.Repositories;
 
 namespace Umbraco.Core.Persistence.Factories
 {
@@ -10,6 +11,8 @@ namespace Umbraco.Core.Persistence.Factories
     {
         public IMemberType BuildEntity(MemberTypeReadOnlyDto dto)
         {
+            var standardPropertyTypes = Constants.Conventions.Member.GetStandardPropertyTypeStubs();
+            
             var memberType = new MemberType(dto.ParentId)
                              {
                                  Alias = dto.Alias,
@@ -31,12 +34,12 @@ namespace Umbraco.Core.Persistence.Factories
                                  AllowedContentTypes = Enumerable.Empty<ContentTypeSort>()
                              };
 
-            var propertyTypeGroupCollection = GetPropertyTypeGroupCollection(dto, memberType);
+            var propertyTypeGroupCollection = GetPropertyTypeGroupCollection(dto, memberType, standardPropertyTypes);
             memberType.PropertyGroups = propertyTypeGroupCollection;
 
-            var propertyTypes = GetPropertyTypes(dto, memberType);
-            //By Convention we add 9 stnd PropertyTypes - This is only here to support loading of types that didn't have these conventions before.
-            var standardPropertyTypes = Constants.Conventions.Member.StandardPropertyTypeStubs;
+            var propertyTypes = GetPropertyTypes(dto, memberType, standardPropertyTypes);
+
+            //By Convention we add 9 stnd PropertyTypes - This is only here to support loading of types that didn't have these conventions before.            
             foreach (var standardPropertyType in standardPropertyTypes)
             {
                 if(dto.PropertyTypes.Any(x => x.Alias.Equals(standardPropertyType.Key))) continue;
@@ -46,16 +49,17 @@ namespace Umbraco.Core.Persistence.Factories
 
                 //Internal dictionary for adding "MemberCanEdit" and "VisibleOnProfile" properties to each PropertyType
                 memberType.MemberTypePropertyTypes.Add(standardPropertyType.Key,
-                    new Tuple<bool, bool, int>(false, false, default(int)));
+                    new MemberTypePropertyProfileAccess(false, false));
             }
             memberType.PropertyTypes = propertyTypes;
 
             return memberType;
         }
 
-        private PropertyGroupCollection GetPropertyTypeGroupCollection(MemberTypeReadOnlyDto dto, MemberType memberType)
+        private PropertyGroupCollection GetPropertyTypeGroupCollection(MemberTypeReadOnlyDto dto, MemberType memberType, Dictionary<string, PropertyType> standardProps)
         {
-            var propertyGroups = new PropertyGroupCollection();
+            var propertyGroups = new PropertyGroupCollection();            
+            
             foreach (var groupDto in dto.PropertyTypeGroups.Where(x => x.Id.HasValue))
             {
                 var group = new PropertyGroup();
@@ -84,11 +88,23 @@ namespace Umbraco.Core.Persistence.Factories
                 {
                     //Internal dictionary for adding "MemberCanEdit" and "VisibleOnProfile" properties to each PropertyType
                     memberType.MemberTypePropertyTypes.Add(typeDto.Alias,
-                        new Tuple<bool, bool, int>(typeDto.CanEdit, typeDto.ViewOnProfile, typeDto.Id.Value));
+                        new MemberTypePropertyProfileAccess(typeDto.ViewOnProfile, typeDto.CanEdit));
 
                     var tempGroupDto = groupDto;
-                    var propertyType = new PropertyType(typeDto.ControlId,
-                                                             typeDto.DbType.EnumParse<DataTypeDatabaseType>(true))
+
+                    //ensures that any built-in membership properties have their correct dbtype assigned no matter
+                    //what the underlying data type is
+                    var propDbType = MemberTypeRepository.GetDbTypeForBuiltInProperty(
+                        typeDto.Alias,
+                        typeDto.DbType.EnumParse<DataTypeDatabaseType>(true),
+                        standardProps);
+                    
+                    var propertyType = new PropertyType(
+                        typeDto.ControlId,
+                        propDbType.Result,
+                        //This flag tells the property type that it has an explicit dbtype and that it cannot be changed
+                        // which is what we want for the built-in properties.
+                        propDbType.Success)
                     {
                         Alias = typeDto.Alias,
                         DataTypeDefinitionId = typeDto.DataTypeId,
@@ -117,32 +133,47 @@ namespace Umbraco.Core.Persistence.Factories
             return propertyGroups;
         }
 
-        private List<PropertyType> GetPropertyTypes(MemberTypeReadOnlyDto dto, MemberType memberType)
+
+
+        private List<PropertyType> GetPropertyTypes(MemberTypeReadOnlyDto dto, MemberType memberType, Dictionary<string, PropertyType> standardProps)
         {
             //Find PropertyTypes that does not belong to a PropertyTypeGroup
             var propertyTypes = new List<PropertyType>();
-            foreach (var propertyType in dto.PropertyTypes.Where(x => (x.PropertyTypeGroupId.HasValue == false || x.PropertyTypeGroupId.Value == 0) && x.Id.HasValue))
+            foreach (var typeDto in dto.PropertyTypes.Where(x => (x.PropertyTypeGroupId.HasValue == false || x.PropertyTypeGroupId.Value == 0) && x.Id.HasValue))
             {
                 //Internal dictionary for adding "MemberCanEdit" and "VisibleOnProfile" properties to each PropertyType
-                memberType.MemberTypePropertyTypes.Add(propertyType.Alias,
-                    new Tuple<bool, bool, int>(propertyType.CanEdit, propertyType.ViewOnProfile, propertyType.Id.Value));
-                //PropertyType Collection
-                propertyTypes.Add(new PropertyType(propertyType.ControlId,
-                    propertyType.DbType.EnumParse<DataTypeDatabaseType>(true))
-                                  {
-                                      Alias = propertyType.Alias,
-                                      DataTypeDefinitionId = propertyType.DataTypeId,
-                                      Description = propertyType.Description,
-                                      HelpText = propertyType.HelpText,
-                                      Id = propertyType.Id.Value,
-                                      Mandatory = propertyType.Mandatory,
-                                      Name = propertyType.Name,
-                                      SortOrder = propertyType.SortOrder,
-                                      ValidationRegExp = propertyType.ValidationRegExp,
-                                      PropertyGroupId = new Lazy<int>(() => default(int)),
-                                      CreateDate = dto.CreateDate,
-                                      UpdateDate = dto.CreateDate
-                                  });
+                memberType.MemberTypePropertyTypes.Add(typeDto.Alias,
+                    new MemberTypePropertyProfileAccess(typeDto.ViewOnProfile, typeDto.CanEdit));
+
+                //ensures that any built-in membership properties have their correct dbtype assigned no matter
+                //what the underlying data type is
+                var propDbType = MemberTypeRepository.GetDbTypeForBuiltInProperty(
+                    typeDto.Alias,
+                    typeDto.DbType.EnumParse<DataTypeDatabaseType>(true),
+                    standardProps);
+
+                var propertyType = new PropertyType(
+                    typeDto.ControlId,
+                    propDbType.Result,
+                    //This flag tells the property type that it has an explicit dbtype and that it cannot be changed
+                    // which is what we want for the built-in properties.
+                    propDbType.Success)
+                {
+                    Alias = typeDto.Alias,
+                    DataTypeDefinitionId = typeDto.DataTypeId,
+                    Description = typeDto.Description,
+                    HelpText = typeDto.HelpText,
+                    Id = typeDto.Id.Value,
+                    Mandatory = typeDto.Mandatory,
+                    Name = typeDto.Name,
+                    SortOrder = typeDto.SortOrder,
+                    ValidationRegExp = typeDto.ValidationRegExp,
+                    PropertyGroupId = new Lazy<int>(() => default(int)),
+                    CreateDate = dto.CreateDate,
+                    UpdateDate = dto.CreateDate
+                };
+                
+                propertyTypes.Add(propertyType);
             }
             return propertyTypes;
         }

src/Umbraco.Core/Persistence/Factories/PropertyGroupFactory.cs

@@ -11,17 +11,21 @@ namespace Umbraco.Core.Persistence.Factories
         private readonly int _id;
         private readonly DateTime _createDate;
         private readonly DateTime _updateDate;
+        //a callback to create a property type which can be injected via a contructor
+        private readonly Func<Guid, DataTypeDatabaseType, string, PropertyType> _propertyTypeCtor;
 
         public PropertyGroupFactory(int id)
         {
             _id = id;
+            _propertyTypeCtor = (guid, dbType, alias) => new PropertyType(guid, dbType);
         }
-
-        public PropertyGroupFactory(int id, DateTime createDate, DateTime updateDate)
+        
+        public PropertyGroupFactory(int id, DateTime createDate, DateTime updateDate, Func<Guid, DataTypeDatabaseType, string, PropertyType> propertyTypeCtor)
         {
             _id = id;
             _createDate = createDate;
             _updateDate = updateDate;
+            _propertyTypeCtor = propertyTypeCtor;
         }
 
         #region Implementation of IEntityFactory<IEnumerable<PropertyGroup>,IEnumerable<TabDto>>
@@ -55,22 +59,23 @@ namespace Umbraco.Core.Persistence.Factories
                 foreach (var typeDto in typeDtos)
                 {
                     var tempGroupDto = groupDto;
-                    var propertyType = new PropertyType(typeDto.DataTypeDto.ControlId,
-                                                             typeDto.DataTypeDto.DbType.EnumParse<DataTypeDatabaseType>(true))
-                                                {
-                                                    Alias = typeDto.Alias,
-                                                    DataTypeDefinitionId = typeDto.DataTypeId,
-                                                    Description = typeDto.Description,
-                                                    Id = typeDto.Id,
-                                                    Name = typeDto.Name,
-                                                    HelpText = typeDto.HelpText,
-                                                    Mandatory = typeDto.Mandatory,
-                                                    SortOrder = typeDto.SortOrder,
-                                                    ValidationRegExp = typeDto.ValidationRegExp,
-                                                    PropertyGroupId = new Lazy<int>(() => tempGroupDto.Id),
-                                                    CreateDate = _createDate,
-                                                    UpdateDate = _updateDate
-                                                };
+                    var propertyType = _propertyTypeCtor(typeDto.DataTypeDto.ControlId,
+                        typeDto.DataTypeDto.DbType.EnumParse<DataTypeDatabaseType>(true),
+                        typeDto.Alias);
+
+                    propertyType.Alias = typeDto.Alias;
+                    propertyType.DataTypeDefinitionId = typeDto.DataTypeId;
+                    propertyType.Description = typeDto.Description;
+                    propertyType.Id = typeDto.Id;
+                    propertyType.Name = typeDto.Name;
+                    propertyType.HelpText = typeDto.HelpText;
+                    propertyType.Mandatory = typeDto.Mandatory;
+                    propertyType.SortOrder = typeDto.SortOrder;
+                    propertyType.ValidationRegExp = typeDto.ValidationRegExp;
+                    propertyType.PropertyGroupId = new Lazy<int>(() => tempGroupDto.Id);
+                    propertyType.CreateDate = _createDate;
+                    propertyType.UpdateDate = _updateDate;
+
                     //on initial construction we don't want to have dirty properties tracked
                     // http://issues.umbraco.org/issue/U4-1946
                     propertyType.ResetDirtyProperties(false);

src/Umbraco.Core/Persistence/Factories/RelationFactory.cs

@@ -3,42 +3,42 @@ using Umbraco.Core.Models.Rdbms;
 
 namespace Umbraco.Core.Persistence.Factories
 {
-    internal class RelationFactory : IEntityFactory<Relation, RelationDto>
+    internal class RelationFactory : IEntityFactory<IRelation, RelationDto>
     {
-        private readonly RelationType _relationType;
+        private readonly IRelationType _relationType;
 
-        public RelationFactory(RelationType relationType)
+        public RelationFactory(IRelationType relationType)
         {
             _relationType = relationType;
         }
 
         #region Implementation of IEntityFactory<Relation,RelationDto>
 
-        public Relation BuildEntity(RelationDto dto)
+        public IRelation BuildEntity(RelationDto dto)
         {
             var entity = new Relation(dto.ParentId, dto.ChildId, _relationType)
-                             {
-                                 Comment = dto.Comment,
-                                 CreateDate = dto.Datetime,
-                                 Id = dto.Id,
-                                 UpdateDate = dto.Datetime
-                             };
+            {
+                Comment = dto.Comment,
+                CreateDate = dto.Datetime,
+                Id = dto.Id,
+                UpdateDate = dto.Datetime
+            };
             //on initial construction we don't want to have dirty properties tracked
             // http://issues.umbraco.org/issue/U4-1946
             entity.ResetDirtyProperties(false);
             return entity;
         }
 
-        public RelationDto BuildDto(Relation entity)
+        public RelationDto BuildDto(IRelation entity)
         {
             var dto = new RelationDto
-                          {
-                              ChildId = entity.ChildId,
-                              Comment = string.IsNullOrEmpty(entity.Comment) ? string.Empty : entity.Comment,
-                              Datetime = entity.CreateDate,
-                              ParentId = entity.ParentId,
-                              RelationType = entity.RelationType.Id
-                          };
+            {
+                ChildId = entity.ChildId,
+                Comment = string.IsNullOrEmpty(entity.Comment) ? string.Empty : entity.Comment,
+                Datetime = entity.CreateDate,
+                ParentId = entity.ParentId,
+                RelationType = entity.RelationType.Id
+            };
 
             if (entity.HasIdentity)
                 dto.Id = entity.Id;

src/Umbraco.Core/Persistence/Factories/RelationTypeFactory.cs

@@ -3,35 +3,35 @@ using Umbraco.Core.Models.Rdbms;
 
 namespace Umbraco.Core.Persistence.Factories
 {
-    internal class RelationTypeFactory : IEntityFactory<RelationType, RelationTypeDto>
+    internal class RelationTypeFactory : IEntityFactory<IRelationType, RelationTypeDto>
     {
         #region Implementation of IEntityFactory<RelationType,RelationTypeDto>
 
-        public RelationType BuildEntity(RelationTypeDto dto)
+        public IRelationType BuildEntity(RelationTypeDto dto)
         {
             var entity = new RelationType(dto.ChildObjectType, dto.ParentObjectType, dto.Alias)
-                             {
-                                 Id = dto.Id,
-                                 IsBidirectional = dto.Dual,
-                                 Name = dto.Name
-                             };
+            {
+                Id = dto.Id,
+                IsBidirectional = dto.Dual,
+                Name = dto.Name
+            };
             //on initial construction we don't want to have dirty properties tracked
             // http://issues.umbraco.org/issue/U4-1946
             entity.ResetDirtyProperties(false);
             return entity;
         }
 
-        public RelationTypeDto BuildDto(RelationType entity)
+        public RelationTypeDto BuildDto(IRelationType entity)
         {
             var dto = new RelationTypeDto
-                          {
-                              Alias = entity.Alias,
-                              ChildObjectType = entity.ChildObjectType,
-                              Dual = entity.IsBidirectional,
-                              Name = entity.Name,
-                              ParentObjectType = entity.ParentObjectType
-                          };
-            if(entity.HasIdentity)
+            {
+                Alias = entity.Alias,
+                ChildObjectType = entity.ChildObjectType,
+                Dual = entity.IsBidirectional,
+                Name = entity.Name,
+                ParentObjectType = entity.ParentObjectType
+            };
+            if (entity.HasIdentity)
                 dto.Id = entity.Id;
 
             return dto;

src/Umbraco.Core/Persistence/Factories/UserFactory.cs

@@ -1,4 +1,6 @@
 using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
 using Umbraco.Core.Models.Membership;
 using Umbraco.Core.Models.Rdbms;
 
@@ -17,23 +19,24 @@ namespace Umbraco.Core.Persistence.Factories
 
         public IUser BuildEntity(UserDto dto)
         {
+            var guidId = dto.Id.ToGuid();
             var user = new User(_userType)
-                       {
-                           Id = dto.Id,
-                           ProfileId = dto.Id,
-                           StartContentId = dto.ContentStartId,
-                           StartMediaId = dto.MediaStartId.HasValue ? dto.MediaStartId.Value : -1,
-                           Password = dto.Password,
-                           Username = dto.Login,
-                           Name = dto.UserName,
-                           IsLockedOut = dto.Disabled,
-                           IsApproved = dto.Disabled == false,
-                           Email = dto.Email,
-                           Language = dto.UserLanguage,
-                           DefaultToLiveEditing = dto.DefaultToLiveEditing,
-                           NoConsole = dto.NoConsole,
-                           DefaultPermissions = dto.DefaultPermissions
-                       };
+                {
+                    Id = dto.Id,
+                    Key = guidId,
+                    StartContentId = dto.ContentStartId,
+                    StartMediaId = dto.MediaStartId.HasValue ? dto.MediaStartId.Value : -1,
+                    Password = dto.Password,
+                    Username = dto.Login,
+                    Name = dto.UserName,
+                    IsLockedOut = dto.NoConsole,
+                    IsApproved = dto.Disabled == false,
+                    Email = dto.Email,
+                    Language = dto.UserLanguage,
+                    DefaultToLiveEditing = dto.DefaultToLiveEditing,
+                    //NOTE: The default permission come from the user type's default permissions
+                    DefaultPermissions = _userType.Permissions
+                };
 
             foreach (var app in dto.User2AppDtos)
             {
@@ -53,16 +56,15 @@ namespace Umbraco.Core.Persistence.Factories
                           {
                               ContentStartId = entity.StartContentId,
                               MediaStartId = entity.StartMediaId,
-                              DefaultToLiveEditing = entity.DefaultToLiveEditing,
+                              DefaultToLiveEditing = ((User)entity).DefaultToLiveEditing,
                               Disabled = entity.IsApproved == false,
                               Email = entity.Email,
                               Login = entity.Username,
-                              NoConsole = entity.NoConsole,
+                              NoConsole = entity.IsLockedOut,
                               Password = entity.Password,
                               UserLanguage = entity.Language,
                               UserName = entity.Name,
-                              Type = short.Parse(entity.UserType.Id.ToString()),
-                              DefaultPermissions = entity.DefaultPermissions,
+                              Type = short.Parse(entity.UserType.Id.ToString(CultureInfo.InvariantCulture)),
                               User2AppDtos = new List<User2AppDto>()
                           };
 

src/Umbraco.Core/Persistence/Factories/UserTypeFactory.cs

@@ -1,4 +1,6 @@
-using Umbraco.Core.Models.Membership;
+using System.Globalization;
+using System.Linq;
+using Umbraco.Core.Models.Membership;
 using Umbraco.Core.Models.Rdbms;
 
 namespace Umbraco.Core.Persistence.Factories
@@ -10,12 +12,14 @@ namespace Umbraco.Core.Persistence.Factories
         public IUserType BuildEntity(UserTypeDto dto)
         {
             var userType = new UserType
-                       {
-                           Alias = dto.Alias,
-                           Id = dto.Id,
-                           Name = dto.Name,
-                           Permissions = dto.DefaultPermissions
-                       };
+                {
+                    Alias = dto.Alias,
+                    Id = dto.Id,
+                    Name = dto.Name,
+                    Permissions = dto.DefaultPermissions.IsNullOrWhiteSpace()
+                                      ? Enumerable.Empty<string>()
+                                      : dto.DefaultPermissions.ToCharArray().Select(x => x.ToString(CultureInfo.InvariantCulture))
+                };
             //on initial construction we don't want to have dirty properties tracked
             // http://issues.umbraco.org/issue/U4-1946
             userType.ResetDirtyProperties(false);
@@ -27,7 +31,7 @@ namespace Umbraco.Core.Persistence.Factories
             var userType = new UserTypeDto
                                {
                                    Alias = entity.Alias,
-                                   DefaultPermissions = entity.Permissions,
+                                   DefaultPermissions = entity.Permissions == null ? "" : string.Join("", entity.Permissions),
                                    Name = entity.Name
                                };
 

src/Umbraco.Core/Persistence/Mappers/MemberGroupMapper.cs

@@ -0,0 +1,34 @@
+using System.Collections.Concurrent;
+using Umbraco.Core.Models;
+using Umbraco.Core.Models.Rdbms;
+
+namespace Umbraco.Core.Persistence.Mappers
+{
+    [MapperFor(typeof (IMemberGroup))]
+    [MapperFor(typeof (MemberGroup))]
+    public sealed class MemberGroupMapper : BaseMapper
+    {
+        private static readonly ConcurrentDictionary<string, DtoMapModel> PropertyInfoCacheInstance = new ConcurrentDictionary<string, DtoMapModel>();
+
+        //NOTE: its an internal class but the ctor must be public since we're using Activator.CreateInstance to create it
+        // otherwise that would fail because there is no public constructor.
+        public MemberGroupMapper()
+        {
+            BuildMap();
+        }
+
+        internal override ConcurrentDictionary<string, DtoMapModel> PropertyInfoCache
+        {
+            get { return PropertyInfoCacheInstance; }
+        }
+
+        internal override void BuildMap()
+        {
+            CacheMap<MemberGroup, NodeDto>(src => src.Id, dto => dto.NodeId);
+            CacheMap<MemberGroup, NodeDto>(src => src.CreateDate, dto => dto.CreateDate);
+            CacheMap<MemberGroup, NodeDto>(src => src.CreatorId, dto => dto.UserId);
+            CacheMap<MemberGroup, NodeDto>(src => src.Name, dto => dto.Text);
+            CacheMap<MemberGroup, NodeDto>(src => src.Key, dto => dto.UniqueId);
+        }
+    }
+}

src/Umbraco.Core/Persistence/Mappers/RelationMapper.cs

@@ -10,6 +10,7 @@ namespace Umbraco.Core.Persistence.Mappers
     /// Represents a <see cref="Relation"/> to DTO mapper used to translate the properties of the public api 
     /// implementation to that of the database's DTO as sql: [tableName].[columnName].
     /// </summary>
+    [MapperFor(typeof(IRelation))]
     [MapperFor(typeof(Relation))]
     public sealed class RelationMapper : BaseMapper
     {
@@ -38,7 +39,7 @@ namespace Umbraco.Core.Persistence.Mappers
             CacheMap<Relation, RelationDto>(src => src.ParentId, dto => dto.ParentId);
             CacheMap<Relation, RelationDto>(src => src.RelationTypeId, dto => dto.RelationType);
         }
-        
+
         #endregion
     }
 }

src/Umbraco.Core/Persistence/Mappers/RelationTypeMapper.cs

@@ -11,6 +11,7 @@ namespace Umbraco.Core.Persistence.Mappers
     /// implementation to that of the database's DTO as sql: [tableName].[columnName].
     /// </summary>
     [MapperFor(typeof(RelationType))]
+    [MapperFor(typeof(IRelationType))]
     public sealed class RelationTypeMapper : BaseMapper
     {
         private static readonly ConcurrentDictionary<string, DtoMapModel> PropertyInfoCacheInstance = new ConcurrentDictionary<string, DtoMapModel>();
@@ -38,7 +39,7 @@ namespace Umbraco.Core.Persistence.Mappers
             CacheMap<RelationType, RelationTypeDto>(src => src.Name, dto => dto.Name);
             CacheMap<RelationType, RelationTypeDto>(src => src.ParentObjectType, dto => dto.ParentObjectType);
         }
-        
+
         #endregion
     }
 }

src/Umbraco.Core/Persistence/Mappers/UserMapper.cs

@@ -38,7 +38,7 @@ namespace Umbraco.Core.Persistence.Mappers
             CacheMap<User, UserDto>(src => src.StartContentId, dto => dto.ContentStartId);
             CacheMap<User, UserDto>(src => src.DefaultToLiveEditing, dto => dto.DefaultToLiveEditing);
             CacheMap<User, UserDto>(src => src.IsApproved, dto => dto.Disabled);
-            CacheMap<User, UserDto>(src => src.NoConsole, dto => dto.NoConsole);
+            CacheMap<User, UserDto>(src => src.IsLockedOut, dto => dto.NoConsole);
             CacheMap<User, UserDto>(src => src.UserType, dto => dto.Type);
             CacheMap<User, UserDto>(src => src.Language, dto => dto.UserLanguage);
         }

src/Umbraco.Core/Persistence/Migrations/Initial/BaseDataCreation.cs

@@ -189,6 +189,8 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
             _database.Insert("cmsPropertyTypeGroup", "id", false, new PropertyTypeGroupDto { Id = 3, ContentTypeNodeId = 1032, Text = "Image", SortOrder = 1 });
             _database.Insert("cmsPropertyTypeGroup", "id", false, new PropertyTypeGroupDto { Id = 4, ContentTypeNodeId = 1033, Text = "File", SortOrder = 1 });
             _database.Insert("cmsPropertyTypeGroup", "id", false, new PropertyTypeGroupDto { Id = 5, ContentTypeNodeId = 1031, Text = "Contents", SortOrder = 1 });
+            //membership property group
+            _database.Insert("cmsPropertyTypeGroup", "id", false, new PropertyTypeGroupDto { Id = 11, ContentTypeNodeId = 1044, Text = "Membership", SortOrder = 1 });
         }
 
         private void CreateCmsPropertyTypeData()
@@ -202,6 +204,19 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
             _database.Insert("cmsPropertyType", "id", false, new PropertyTypeDto { Id = 25, DataTypeId = -92, ContentTypeId = 1033, PropertyTypeGroupId = 4, Alias = Constants.Conventions.Media.Extension, Name = "Type", HelpText = null, SortOrder = 0, Mandatory = false, ValidationRegExp = null, Description = null });
             _database.Insert("cmsPropertyType", "id", false, new PropertyTypeDto { Id = 26, DataTypeId = -92, ContentTypeId = 1033, PropertyTypeGroupId = 4, Alias = Constants.Conventions.Media.Bytes, Name = "Size", HelpText = null, SortOrder = 0, Mandatory = false, ValidationRegExp = null, Description = null });
             _database.Insert("cmsPropertyType", "id", false, new PropertyTypeDto { Id = 27, DataTypeId = -38, ContentTypeId = 1031, PropertyTypeGroupId = 5, Alias = "contents", Name = "Contents:", HelpText = null, SortOrder = 0, Mandatory = false, ValidationRegExp = null, Description = null });
+            //membership property types
+            _database.Insert("cmsPropertyType", "id", false, new PropertyTypeDto { Id = 28, DataTypeId = -89, ContentTypeId = 1044, PropertyTypeGroupId = 11, Alias = Constants.Conventions.Member.Comments, Name = Constants.Conventions.Member.CommentsLabel, HelpText = null, SortOrder = 0, Mandatory = false, ValidationRegExp = null, Description = null });
+            _database.Insert("cmsPropertyType", "id", false, new PropertyTypeDto { Id = 29, DataTypeId = -92, ContentTypeId = 1044, PropertyTypeGroupId = 11, Alias = Constants.Conventions.Member.FailedPasswordAttempts, Name = Constants.Conventions.Member.FailedPasswordAttemptsLabel, HelpText = null, SortOrder = 1, Mandatory = false, ValidationRegExp = null, Description = null });
+            _database.Insert("cmsPropertyType", "id", false, new PropertyTypeDto { Id = 30, DataTypeId = -49, ContentTypeId = 1044, PropertyTypeGroupId = 11, Alias = Constants.Conventions.Member.IsApproved, Name = Constants.Conventions.Member.IsApprovedLabel, HelpText = null, SortOrder = 2, Mandatory = false, ValidationRegExp = null, Description = null });
+            _database.Insert("cmsPropertyType", "id", false, new PropertyTypeDto { Id = 31, DataTypeId = -49, ContentTypeId = 1044, PropertyTypeGroupId = 11, Alias = Constants.Conventions.Member.IsLockedOut, Name = Constants.Conventions.Member.IsLockedOutLabel, HelpText = null, SortOrder = 3, Mandatory = false, ValidationRegExp = null, Description = null });
+            _database.Insert("cmsPropertyType", "id", false, new PropertyTypeDto { Id = 32, DataTypeId = -92, ContentTypeId = 1044, PropertyTypeGroupId = 11, Alias = Constants.Conventions.Member.LastLockoutDate, Name = Constants.Conventions.Member.LastLockoutDateLabel, HelpText = null, SortOrder = 4, Mandatory = false, ValidationRegExp = null, Description = null });
+            _database.Insert("cmsPropertyType", "id", false, new PropertyTypeDto { Id = 33, DataTypeId = -92, ContentTypeId = 1044, PropertyTypeGroupId = 11, Alias = Constants.Conventions.Member.LastLoginDate, Name = Constants.Conventions.Member.LastLoginDateLabel, HelpText = null, SortOrder = 5, Mandatory = false, ValidationRegExp = null, Description = null });
+            _database.Insert("cmsPropertyType", "id", false, new PropertyTypeDto { Id = 34, DataTypeId = -92, ContentTypeId = 1044, PropertyTypeGroupId = 11, Alias = Constants.Conventions.Member.LastPasswordChangeDate, Name = Constants.Conventions.Member.LastPasswordChangeDateLabel, HelpText = null, SortOrder = 6, Mandatory = false, ValidationRegExp = null, Description = null });
+            
+            //TODO: The member editor doesn't currently support providers that have question/answer so we'll leave these out for now.
+            // Also, it's worth noting that the built in ASP.Net providers encrypt the answer so that admins cannot see it for added security which is something we should actually do!
+            //_database.Insert("cmsPropertyType", "id", false, new PropertyTypeDto { Id = 35, DataTypeId = -92, ContentTypeId = 1044, PropertyTypeGroupId = 11, Alias = Constants.Conventions.Member.PasswordAnswer, Name = Constants.Conventions.Member.PasswordAnswerLabel, HelpText = null, SortOrder = 0, Mandatory = false, ValidationRegExp = null, Description = null });
+            //_database.Insert("cmsPropertyType", "id", false, new PropertyTypeDto { Id = 36, DataTypeId = -92, ContentTypeId = 1044, PropertyTypeGroupId = 11, Alias = Constants.Conventions.Member.PasswordQuestion, Name = Constants.Conventions.Member.PasswordQuestionLabel, HelpText = null, SortOrder = 0, Mandatory = false, ValidationRegExp = null, Description = null });
         }
 
         private void CreateUmbracoLanguageData()

src/Umbraco.Core/Persistence/Migrations/Initial/DatabaseSchemaCreation.cs

@@ -80,7 +80,10 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
 
                 try
                 {
-                    _database.DropTable(tableName);
+                    if (_database.TableExist(tableName))
+                    {
+                        _database.DropTable(tableName);    
+                    }
                 }
                 catch (Exception ex)
                 {

src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/DeleteBuilder.cs

@@ -27,7 +27,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete
 
         public IDeleteColumnFromTableSyntax Column(string columnName)
         {
-            var expression = _databaseProviders == null 
+            var expression = _databaseProviders == null
                 ? new DeleteColumnExpression { ColumnNames = { columnName } }
                 : new DeleteColumnExpression(_context.CurrentDatabaseProvider, _databaseProviders) { ColumnNames = { columnName } };
             _context.Expressions.Add(expression);
@@ -36,7 +36,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete
 
         public IDeleteForeignKeyFromTableSyntax ForeignKey()
         {
-            var expression = _databaseProviders == null 
+            var expression = _databaseProviders == null
                 ? new DeleteForeignKeyExpression()
                 : new DeleteForeignKeyExpression(_context.CurrentDatabaseProvider, _databaseProviders);
             _context.Expressions.Add(expression);
@@ -45,7 +45,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete
 
         public IDeleteForeignKeyOnTableSyntax ForeignKey(string foreignKeyName)
         {
-            var expression = _databaseProviders == null 
+            var expression = _databaseProviders == null
                 ? new DeleteForeignKeyExpression { ForeignKey = { Name = foreignKeyName } }
                 : new DeleteForeignKeyExpression(_context.CurrentDatabaseProvider, _databaseProviders) { ForeignKey = { Name = foreignKeyName } };
             _context.Expressions.Add(expression);
@@ -68,17 +68,17 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete
 
         public IDeleteIndexForTableSyntax Index(string indexName)
         {
-            var expression = new DeleteIndexExpression {Index = {Name = indexName}};
+            var expression = new DeleteIndexExpression { Index = { Name = indexName } };
             _context.Expressions.Add(expression);
             return new DeleteIndexBuilder(expression);
         }
 
         public IDeleteConstraintOnTableSyntax PrimaryKey(string primaryKeyName)
         {
-            var expression = new DeleteConstraintExpression(ConstraintType.PrimaryKey)
-                                 {
-                                     Constraint = { ConstraintName = primaryKeyName }
-                                 };
+            var expression = new DeleteConstraintExpression(_context.CurrentDatabaseProvider, _databaseProviders, ConstraintType.PrimaryKey)
+            {
+                Constraint = { ConstraintName = primaryKeyName }
+            };
             _context.Expressions.Add(expression);
             return new DeleteConstraintBuilder(expression);
         }
@@ -86,16 +86,16 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete
         public IDeleteConstraintOnTableSyntax UniqueConstraint(string constraintName)
         {
             var expression = new DeleteConstraintExpression(ConstraintType.Unique)
-                                 {
-                                     Constraint = { ConstraintName = constraintName }
-                                 };
+            {
+                Constraint = { ConstraintName = constraintName }
+            };
             _context.Expressions.Add(expression);
             return new DeleteConstraintBuilder(expression);
         }
 
         public IDeleteDefaultConstraintOnTableSyntax DefaultConstraint()
         {
-            var expression = _databaseProviders == null 
+            var expression = _databaseProviders == null
                 ? new DeleteDefaultConstraintExpression()
                 : new DeleteDefaultConstraintExpression(_context.CurrentDatabaseProvider, _databaseProviders);
             _context.Expressions.Add(expression);

src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteConstraintExpression.cs

@@ -10,13 +10,40 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete.Expressions
             Constraint = new ConstraintDefinition(type);
         }
 
+        public DeleteConstraintExpression(DatabaseProviders current, DatabaseProviders[] databaseProviders, ConstraintType type)
+            : base(current, databaseProviders)
+        {
+            Constraint = new ConstraintDefinition(type);
+        }
+
         public ConstraintDefinition Constraint { get; private set; }
 
         public override string ToString()
         {
-            return string.Format(SqlSyntaxContext.SqlSyntaxProvider.DeleteConstraint,
+            // Test for MySQL primary key situation.
+            if (CurrentDatabaseProvider == DatabaseProviders.MySql)
+            {
+                if (Constraint.IsPrimaryKeyConstraint)
+                {
+                    return string.Format(SqlSyntaxContext.SqlSyntaxProvider.DeleteConstraint,
+                                     SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(Constraint.TableName),
+                                     "PRIMARY KEY",
+                                     "");
+                }
+                else
+                {
+                    return string.Format(SqlSyntaxContext.SqlSyntaxProvider.DeleteConstraint,
+                                     SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(Constraint.TableName),
+                                     "FOREIGN KEY",
+                                     "");
+                }
+            }
+            else
+            {
+                return string.Format(SqlSyntaxContext.SqlSyntaxProvider.DeleteConstraint,
                                  SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(Constraint.TableName),
                                  SqlSyntaxContext.SqlSyntaxProvider.GetQuotedName(Constraint.ConstraintName));
+            }
         }
     }
 }

src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteForeignKeyExpression.cs

@@ -27,7 +27,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete.Expressions
             if (ForeignKey.ForeignTable == null)
                 throw new ArgumentNullException("Table name not specified, ensure you have appended the OnTable extension. Format should be Delete.ForeignKey(KeyName).OnTable(TableName)");
 
-            if(CurrentDatabaseProvider == DatabaseProviders.MySql)
+            if (CurrentDatabaseProvider == DatabaseProviders.MySql)
             {
                 //MySql naming "convention" for foreignkeys, which aren't explicitly named
                 if (string.IsNullOrEmpty(ForeignKey.Name))
@@ -35,7 +35,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete.Expressions
 
                 return string.Format(SqlSyntaxContext.SqlSyntaxProvider.DeleteConstraint,
                                  SqlSyntaxContext.SqlSyntaxProvider.GetQuotedTableName(ForeignKey.ForeignTable),
-                                 "FOREIGN KEY ",
+                                 "FOREIGN KEY",
                                  SqlSyntaxContext.SqlSyntaxProvider.GetQuotedName(ForeignKey.Name));
             }
 

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSixTwoZero/AdditionalIndexesAndKeys.cs

@@ -19,4 +19,19 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSixTwoZero
             throw new NotImplementedException();
         }
     }
+
+    [Migration("6.2.0", 2, GlobalSettings.UmbracoMigrationName)]
+    public class ChangePasswordColumn : MigrationBase
+    {
+        public override void Up()
+        {
+            //up to 500 chars
+            Alter.Table("umbracoUser").AlterColumn("userPassword").AsString(500).NotNullable();
+        }
+
+        public override void Down()
+        {
+            throw new NotImplementedException();
+        }
+    }
 }

src/Umbraco.Core/Persistence/PetaPocoExtensions.cs

@@ -21,14 +21,18 @@ namespace Umbraco.Core.Persistence
         /// <summary>
         /// This will escape single @ symbols for peta poco values so it doesn't think it's a parameter
         /// </summary>
-        /// <param name="db"></param>
         /// <param name="value"></param>
         /// <returns></returns>
-        public static string EscapeAtSymbols(this Database db, string value)
+        public static string EscapeAtSymbols(string value)
         {
-            //this fancy regex will only match a single @ not a double, etc...
-            var regex = new Regex("(?<!@)@(?!@)");
-            return regex.Replace(value, "@@");
+            if (value.Contains("@"))
+            {
+                //this fancy regex will only match a single @ not a double, etc...
+                var regex = new Regex("(?<!@)@(?!@)");
+                return regex.Replace(value, "@@");    
+            }
+            return value;
+
         }
 
         public static void CreateTable<T>(this Database db)
@@ -53,11 +57,20 @@ namespace Umbraco.Core.Persistence
 
             using (var tr = db.GetTransaction())
             {
-                db.BulkInsertRecords(collection, tr);
+                db.BulkInsertRecords(collection, tr, true);
             }
         }
 
-        public static void BulkInsertRecords<T>(this Database db, IEnumerable<T> collection, Transaction tr)
+        /// <summary>
+        /// Performs the bulk insertion in the context of a current transaction with an optional parameter to complete the transaction
+        /// when finished
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="db"></param>
+        /// <param name="collection"></param>
+        /// <param name="tr"></param>
+        /// <param name="commitTrans"></param>
+        public static void BulkInsertRecords<T>(this Database db, IEnumerable<T> collection, Transaction tr, bool commitTrans = false)
         {
             //don't do anything if there are no records.
             if (collection.Any() == false)
@@ -91,11 +104,17 @@ namespace Umbraco.Core.Persistence
                     }
                 }
 
-                tr.Complete();
+                if (commitTrans)
+                {
+                    tr.Complete();    
+                }
             }
             catch
             {
-                tr.Dispose();
+                if (commitTrans)
+                {
+                    tr.Dispose();    
+                }
                 throw;
             }
         }
@@ -336,6 +355,14 @@ namespace Umbraco.Core.Persistence
             creation.UninstallDatabaseSchema();
         }
 
+        internal static void CreateDatabaseSchemaDo(this Database db, bool guardConfiguration)
+        {
+            if (guardConfiguration && ApplicationContext.Current.IsConfigured)
+                throw new Exception("Umbraco is already configured!");
+
+            CreateDatabaseSchemaDo(db);
+        }
+
         internal static void CreateDatabaseSchemaDo(this Database db)
         {
             NewTable += PetaPocoExtensions_NewTable;

src/Umbraco.Core/Persistence/Querying/BaseExpressionHelper.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Globalization;
+using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Querying
 {
@@ -25,7 +26,7 @@ namespace Umbraco.Core.Persistence.Querying
             {
                 //if (TypeSerializer.CanCreateFromString(fieldType))
                 //{
-                //    return "'" + EscapeParam(TypeSerializer.SerializeToString(value)) + "'";
+                //    return "'" + escapeCallback(TypeSerializer.SerializeToString(value)) + "'";
                 //}
 
                 throw new NotSupportedException(
@@ -46,33 +47,24 @@ namespace Umbraco.Core.Persistence.Querying
 
             if (fieldType == typeof(DateTime))
             {
-                return "'" + EscapeParam(((DateTime)value).ToIsoString()) + "'";
+                return "'" + escapeCallback(((DateTime)value).ToIsoString()) + "'";
             }
 
             if (fieldType == typeof(bool))
                 return ((bool)value) ? Convert.ToString(1, CultureInfo.InvariantCulture) : Convert.ToString(0, CultureInfo.InvariantCulture);
 
-            return ShouldQuoteValue(fieldType)
-                       ? "'" + EscapeParam(value) + "'"
+            return shouldQuoteCallback(fieldType)
+                       ? "'" + escapeCallback(value) + "'"
                        : value.ToString();
         }
 
         public virtual string EscapeParam(object paramValue)
         {
-            return paramValue.ToString().Replace("'", "''");
+            return paramValue == null 
+                ? string.Empty 
+                : SqlSyntaxContext.SqlSyntaxProvider.EscapeString(paramValue.ToString());
         }
-
-        public virtual string EscapeAtArgument(string exp)
-        {
-            /*if (exp.StartsWith("@"))
-                return string.Concat("@", exp);*/
-
-            if (exp.Contains("@"))
-                return exp.Replace("@", "@@");
-
-            return exp;
-        }
-
+        
         public virtual bool ShouldQuoteValue(Type fieldType)
         {
             return true;