reverts IQuery

U4-4249 - PetaPocoExtensions CreateTable doesn't recreate the table

build/Build.bat

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

build/NuSpecs/UmbracoCms.Core.nuspec

@@ -2,7 +2,7 @@
 <package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
     <metadata>
         <id>UmbracoCms.Core</id>
-        <version>6.2.0</version>
+        <version>6.2.3</version>
         <title>Umbraco Cms Core Binaries</title>
         <authors>Umbraco HQ</authors>
         <owners>Umbraco HQ</owners>
@@ -15,11 +15,13 @@
         <language>en-US</language>
         <tags>umbraco</tags>
         <dependencies>
-            <dependency id="Microsoft.AspNet.Mvc" version="[4.0.0,5.0.0)" />
+            <dependency id="Microsoft.AspNet.Mvc" version="[4.0.30506.0,5.0.0)" />
             <dependency id="Microsoft.AspNet.WebApi" version="[4.0.30506,5.0.0)" />
+            <dependency id="Microsoft.AspNet.WebApi.WebHost" version="[4.0.30506, 5.0.0)" />
+            <dependency id="Microsoft.AspNet.WebApi.Core" version="[4.0.30506, 5.0.0)" />
             <dependency id="Microsoft.AspNet.WebApi.Client" version="[4.0.30506, 5.0.0)" />
-            <dependency id="Microsoft.AspNet.Mvc.FixedDisplayModes" version="1.0.0" />
-            <dependency id="Microsoft.Net.Http" version="[2.0.0, 3.0.0)" />
+            <dependency id="Microsoft.AspNet.Mvc.FixedDisplayModes" version="1.0.1" />
+            <dependency id="Microsoft.Net.Http" version="[2.0.20710.0, 3.0.0)" />
             <dependency id="MiniProfiler" version="[2.1.0, 3.0.0)" />
             <dependency id="HtmlAgilityPack" version="[1.4.6, 2.0.0)" />
             <dependency id="Lucene.Net" version="[2.9.4.1, 3.0.0.0)" />
@@ -28,7 +30,8 @@
             <dependency id="xmlrpcnet" version="[2.5.0, 3.0.0)" />
             <dependency id="ClientDependency" version="[1.7.1.2, 2.0.0)" />
             <dependency id="ClientDependency-Mvc" version="[1.7.0.4, 2.0.0)" />
-            <dependency id="Newtonsoft.Json" version="[4.5.11, 5.0.0)" />
+            <dependency id="Newtonsoft.Json" version="[4.5.11, 6.0.0)" />
+            <dependency id="Examine" version="[0.1.57, 1.0.0)" />
         </dependencies>
     </metadata>
     <files>
@@ -38,7 +41,6 @@
         <file src="..\_BuildOutput\WebApp\bin\cms.xml" target="lib\cms.xml" />
         <file src="..\_BuildOutput\WebApp\bin\controls.dll" target="lib\controls.dll" />
         <file src="..\_BuildOutput\WebApp\bin\controls.xml" target="lib\controls.xml" />
-        <file src="..\_BuildOutput\WebApp\bin\Examine.dll" target="lib\Examine.dll" />
         <file src="..\_BuildOutput\WebApp\bin\interfaces.dll" target="lib\interfaces.dll" />
         <file src="..\_BuildOutput\WebApp\bin\interfaces.xml" target="lib\interfaces.xml" />
         <file src="..\_BuildOutput\WebApp\bin\log4net.dll" target="lib\log4net.dll" />
@@ -69,5 +71,6 @@
         <file src="..\_BuildOutput\WebApp\bin\umbraco.XmlSerializers.dll" target="lib\umbraco.XmlSerializers.dll" />
         <file src="..\_BuildOutput\WebApp\bin\UmbracoExamine.dll" target="lib\UmbracoExamine.dll" />
         <file src="..\_BuildOutput\WebApp\bin\UrlRewritingNet.UrlRewriter.dll" target="lib\UrlRewritingNet.UrlRewriter.dll" />
+		<file src="tools\install.core.ps1" target="tools\install.ps1" />
     </files>
 </package>

build/NuSpecs/UmbracoCms.nuspec

@@ -2,7 +2,7 @@
 <package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
     <metadata>
         <id>UmbracoCms</id>
-        <version>6.1.2</version>
+        <version>6.2.3</version>
         <title>Umbraco Cms</title>
         <authors>Umbraco HQ</authors>
         <owners>Umbraco HQ</owners>

build/NuSpecs/build/UmbracoCms.targets

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
-    <UmbracoVersion>6.2.0-RC</UmbracoVersion>
+    <UmbracoVersion>6.2.4</UmbracoVersion>
   </PropertyGroup>
   <Target Name="CopyUmbracoFilesToWebRoot" BeforeTargets="AfterBuild">
     <PropertyGroup>

build/NuSpecs/tools/install.core.ps1

@@ -0,0 +1,24 @@
+param($rootPath, $toolsPath, $package, $project)
+
+if ($project) {
+	$dateTime = Get-Date -Format yyyyMMdd-HHmmss
+	$backupPath = Join-Path (Split-Path $project.FullName -Parent) "\App_Data\NuGetBackup\$dateTime"
+	$copyLogsPath = Join-Path $backupPath "CopyLogs"
+	$projectDestinationPath = Split-Path $project.FullName -Parent
+	
+	# Create backup folder and logs folder if it doesn't exist yet
+	New-Item -ItemType Directory -Force -Path $backupPath
+	New-Item -ItemType Directory -Force -Path $copyLogsPath
+	
+	# After backing up, remove all dlls from bin folder in case dll files are included in the VS project
+	# See: http://issues.umbraco.org/issue/U4-4930
+	$umbracoBinFolder = Join-Path $projectDestinationPath "bin"
+	if(Test-Path $umbracoBinFolder) {
+		$umbracoBinBackupPath = Join-Path $backupPath "bin"
+		
+		New-Item -ItemType Directory -Force -Path $umbracoBinBackupPath
+		
+		robocopy $umbracoBinFolder $umbracoBinBackupPath /e /LOG:$copyLogsPath\UmbracoBinBackup.log
+		Remove-Item $umbracoBinFolder\*.dll -Force -Confirm:$false
+	}
+}

build/NuSpecs/tools/install.ps1

@@ -3,9 +3,11 @@ param($rootPath, $toolsPath, $package, $project)
 if ($project) {	
     $dateTime = Get-Date -Format yyyyMMdd-HHmmss
 	$backupPath = Join-Path (Split-Path $project.FullName -Parent) "\App_Data\NuGetBackup\$dateTime"
+	$copyLogsPath = Join-Path $backupPath "CopyLogs"
 	
-	# Create backup folder if it doesn't exist yet
+	# Create backup folder and logs folder if it doesn't exist yet
 	New-Item -ItemType Directory -Force -Path $backupPath
+	New-Item -ItemType Directory -Force -Path $copyLogsPath
 	
 	# Create a backup of original web.config
 	$projectDestinationPath = Split-Path $project.FullName -Parent
@@ -19,18 +21,26 @@ if ($project) {
 	# Copy umbraco and umbraco_files from package to project folder
 	# This is only done when these folders already exist because we 
 	# only want to do this for upgrades
-	$umbracoFolder = Join-Path $projectDestinationPath "Umbraco\"
+	$umbracoFolder = Join-Path $projectDestinationPath "Umbraco"
 	if(Test-Path $umbracoFolder) {
 		$umbracoFolderSource = Join-Path $rootPath "UmbracoFiles\Umbraco"
-		Copy-Item $umbracoFolder $backupPath -Force
-		robocopy $umbracoFolderSource $umbracoFolder /e /xf UI.xml
+		
+		$umbracoBackupPath = Join-Path $backupPath "Umbraco"
+		New-Item -ItemType Directory -Force -Path $umbracoBackupPath
+		
+		robocopy $umbracoFolder $umbracoBackupPath /e /LOG:$copyLogsPath\UmbracoBackup.log
+		robocopy $umbracoFolderSource $umbracoFolder /is /it /e /xf UI.xml /LOG:$copyLogsPath\UmbracoCopy.log
 	}
 
 	$umbracoClientFolder = Join-Path $projectDestinationPath "Umbraco_Client"	
 	if(Test-Path $umbracoClientFolder) {
 		$umbracoClientFolderSource = Join-Path $rootPath "UmbracoFiles\Umbraco_Client"
-		Copy-Item $umbracoClientFolder $backupPath -Force
-		robocopy $umbracoFolderSource $umbracoClientFolder /e
+		
+		$umbracoClientBackupPath = Join-Path $backupPath "Umbraco_Client"
+		New-Item -ItemType Directory -Force -Path $umbracoClientBackupPath
+		
+		robocopy $umbracoClientFolder $umbracoClientBackupPath /e /LOG:$copyLogsPath\UmbracoClientBackup.log
+		robocopy $umbracoClientFolderSource $umbracoClientFolder /is /it /e /LOG:$copyLogsPath\UmbracoClientCopy.log		
 	}
 	# Open readme.txt file
 	$DTE.ItemOperations.OpenFile($toolsPath + '\Readme.txt')

src/SQLCE4Umbraco/SqlCE4Umbraco.csproj

@@ -80,6 +80,7 @@
   </ItemGroup>
   <ItemGroup>
     <Content Include="Sql\Total.sql" />
+    <None Include="app.config" />
     <None Include="packages.config" />
     <None Include="Sql\Version4_1_Upgrade.sql" />
   </ItemGroup>

src/SQLCE4Umbraco/app.config

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <runtime>
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly>
+        <assemblyIdentity name="System.Web.Mvc" publicKeyToken="31bf3856ad364e35" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.0.0.0" newVersion="4.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Web.WebPages" publicKeyToken="31bf3856ad364e35" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-2.0.0.0" newVersion="2.0.0.0" />
+      </dependentAssembly>
+    </assemblyBinding>
+  </runtime>
+</configuration>

src/Umbraco.Core/AssemblyExtensions.cs

@@ -1,5 +1,7 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Reflection;
 
 namespace Umbraco.Core

src/Umbraco.Core/Cache/CacheKeys.cs

@@ -53,5 +53,6 @@ namespace Umbraco.Core.Cache
         public const string StylesheetPropertyCacheKey = "UmbracoStylesheetProperty";
 
         public const string DataTypeCacheKey = "UmbracoDataTypeDefinition";
+        public const string DataTypePreValuesCacheKey = "UmbracoPreVal";
     }
 }

src/Umbraco.Core/Cache/CacheProviderExtensions.cs

@@ -41,6 +41,12 @@ namespace Umbraco.Core.Cache
             return result.Select(x => x.TryConvertTo<T>().Result);
         }
 
+        public static IEnumerable<T> GetCacheItemsByKeyExpression<T>(this ICacheProvider provider, string regexString)
+        {
+            var result = provider.GetCacheItemsByKeyExpression(regexString);
+            return result.Select(x => x.TryConvertTo<T>().Result);
+        }
+
         public static T GetCacheItem<T>(this ICacheProvider provider, string cacheKey)
         {
             var result = provider.GetCacheItem(cacheKey);

src/Umbraco.Core/Cache/DictionaryCacheProviderBase.cs

@@ -1,198 +1,204 @@
 using System;
+using System.Collections;
 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>
+        // prefix cache keys so we know which one are ours
         protected const string CacheItemPrefix = "umbrtmche";
 
+        // an object that represent a value that has not been created yet
+        protected readonly object ValueNotCreated = new object();
+
+        // manupulate the underlying cache entries
+        // these *must* be called from within the appropriate locks
+        // and use the full prefixed cache keys
+        protected abstract IEnumerable<DictionaryEntry> GetDictionaryEntries();
+        protected abstract void RemoveEntry(string key);
+        protected abstract object GetEntry(string key);
+
+        // read-write lock the underlying cache
+        protected abstract IDisposable ReadLock { get; }
+        protected abstract IDisposable WriteLock { get; }
+
         protected string GetCacheKey(string key)
         {
             return string.Format("{0}-{1}", CacheItemPrefix, key);
         }
+
+        protected object GetSafeLazyValue(Lazy<object> lazy, bool onlyIfValueIsCreated = false)
+        {
+            try
+            {
+                // if onlyIfValueIsCreated, do not trigger value creation
+                // must return something, though, to differenciate from null values
+                if (onlyIfValueIsCreated && lazy.IsValueCreated == false) return ValueNotCreated;
+                return lazy.Value;
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
+        #region Clear
+
+        public virtual void ClearAllCache()
+        {
+            using (WriteLock)
+            {
+                foreach (var entry in GetDictionaryEntries()
+                    .ToArray())
+                    RemoveEntry((string) entry.Key);
+            }
+        }
+
+        public virtual void ClearCacheItem(string key)
+        {
+            var cacheKey = GetCacheKey(key);
+            using (WriteLock)
+            {
+                RemoveEntry(cacheKey);
+            }
+        }
+
+        public virtual void ClearCacheObjectTypes(string typeName)
+        {
+            using (WriteLock)
+            {
+                foreach (var entry in GetDictionaryEntries()
+                    .Where(x =>
+                    {
+                        // entry.Value is Lazy<object> and not null, its value may be null
+                        // remove null values as well, does not hurt
+                        // get non-created as NonCreatedValue & exceptions as null
+                        var value = GetSafeLazyValue((Lazy<object>)x.Value, true);
+                        return value == null || value.GetType().ToString().InvariantEquals(typeName);
+                    })
+                    .ToArray())
+                    RemoveEntry((string) entry.Key);
+            }
+        }
+
+        public virtual void ClearCacheObjectTypes<T>()
+        {
+            var typeOfT = typeof(T);
+            using (WriteLock)
+            {
+                foreach (var entry in GetDictionaryEntries()
+                    .Where(x =>
+                    {
+                        // entry.Value is Lazy<object> and not null, its value may be null
+                        // remove null values as well, does not hurt
+                        // compare on exact type, don't use "is"
+                        // get non-created as NonCreatedValue & exceptions as null
+                        var value = GetSafeLazyValue((Lazy<object>)x.Value, true);
+                        return value == null || value.GetType() == typeOfT;
+                    })
+                    .ToArray())
+                    RemoveEntry((string) entry.Key);
+            }
+        }
+
+        public virtual void ClearCacheObjectTypes<T>(Func<string, T, bool> predicate)
+        {
+            var typeOfT = typeof(T);
+            var plen = CacheItemPrefix.Length + 1;
+            using (WriteLock)
+            {
+                foreach (var entry in GetDictionaryEntries()
+                    .Where(x =>
+                    {
+                        // entry.Value is Lazy<object> and not null, its value may be null
+                        // remove null values as well, does not hurt
+                        // compare on exact type, don't use "is"
+                        // get non-created as NonCreatedValue & exceptions as null
+                        var value = GetSafeLazyValue((Lazy<object>)x.Value, true);
+                        if (value == null) return true;
+                        return value.GetType() == typeOfT
+                            // run predicate on the 'public key' part only, ie without prefix
+                            && predicate(((string)x.Key).Substring(plen), (T)value);
+                    }))
+                    RemoveEntry((string) entry.Key);
+            }
+        }
+
+        public virtual void ClearCacheByKeySearch(string keyStartsWith)
+        {
+            var plen = CacheItemPrefix.Length + 1;
+            using (WriteLock)
+            {
+                foreach (var entry in GetDictionaryEntries()
+                    .Where(x => ((string)x.Key).Substring(plen).InvariantStartsWith(keyStartsWith))
+                    .ToArray())
+                    RemoveEntry((string) entry.Key);
+            }
+        }
+
+        public virtual void ClearCacheByKeyExpression(string regexString)
+        {
+            var plen = CacheItemPrefix.Length + 1;
+            using (WriteLock)
+            {
+                foreach (var entry in GetDictionaryEntries()
+                    .Where(x => Regex.IsMatch(((string)x.Key).Substring(plen), regexString))
+                    .ToArray())
+                    RemoveEntry((string) entry.Key);
+            }
+        }
+
+        #endregion
+
+        #region Get
+
+        public virtual IEnumerable<object> GetCacheItemsByKeySearch(string keyStartsWith)
+        {
+            var plen = CacheItemPrefix.Length + 1;
+            IEnumerable<DictionaryEntry> entries;
+            using (ReadLock)
+            {
+                entries = GetDictionaryEntries()
+                    .Where(x => ((string)x.Key).Substring(plen).InvariantStartsWith(keyStartsWith))
+                    .ToArray(); // evaluate while locked
+            }
+            return entries
+                    .Select(x => GetSafeLazyValue((Lazy<object>)x.Value)) // return exceptions as null
+                    .Where(x => x != null); // backward compat, don't store null values in the cache
+        }
+
+        public virtual IEnumerable<object> GetCacheItemsByKeyExpression(string regexString)
+        {
+            const string prefix = CacheItemPrefix + "-";
+            var plen = prefix.Length;
+            IEnumerable<DictionaryEntry> entries;
+            using (ReadLock)
+            {
+                entries = GetDictionaryEntries()
+                    .Where(x => Regex.IsMatch(((string)x.Key).Substring(plen), regexString))
+                    .ToArray(); // evaluate while locked
+            }
+            return entries
+                    .Select(x => GetSafeLazyValue((Lazy<object>)x.Value)) // return exceptions as null
+                    .Where(x => x != null); // backward compat, don't store null values in the cache
+        }
+
+        public virtual object GetCacheItem(string cacheKey)
+        {
+            cacheKey = GetCacheKey(cacheKey);
+            Lazy<object> result;
+            using (ReadLock)
+            {
+                result = GetEntry(cacheKey) as Lazy<object>; // null if key not found
+            }
+            return result == null ? null : GetSafeLazyValue(result); // return exceptions as null
+        }
+
+        public abstract object GetCacheItem(string cacheKey, Func<object> getCacheItem);
+
+        #endregion
     }
 }

src/Umbraco.Core/Cache/DictionaryCacheWrapper.cs

@@ -1,45 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -2,7 +2,6 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text.RegularExpressions;
 using System.Web;
 
 namespace Umbraco.Core.Cache
@@ -12,36 +11,115 @@ namespace Umbraco.Core.Cache
     /// </summary>
     internal class HttpRequestCacheProvider : DictionaryCacheProviderBase
     {
-        private readonly Func<HttpContextBase> _context;
+        // context provider
+        // the idea is that there is only one, application-wide HttpRequestCacheProvider instance,
+        // that is initialized with a method that returns the "current" context.
+        // NOTE
+        //   but then it is initialized with () => new HttpContextWrapper(HttpContent.Current)
+        //   which is higly inefficient because it creates a new wrapper each time we refer to _context()
+        //   so replace it with _context1 and _context2 below + a way to get context.Items.
+        //private readonly Func<HttpContextBase> _context;
 
-        public HttpRequestCacheProvider(HttpContext context)
+        // NOTE
+        //   and then in almost 100% cases _context2 will be () => HttpContext.Current
+        //   so why not bring that logic in here and fallback on to HttpContext.Current when
+        //   _context1 is null?
+        //private readonly HttpContextBase _context1;
+        //private readonly Func<HttpContext> _context2;
+        private readonly HttpContextBase _context;
+
+        private IDictionary ContextItems
         {
-            _context = () => new HttpContextWrapper(context);
+            //get { return _context1 != null ? _context1.Items : _context2().Items; }
+            get { return _context != null ? _context.Items : HttpContext.Current.Items; }
         }
 
-        public HttpRequestCacheProvider(Func<HttpContextBase> context)
+        // for unit tests
+        public HttpRequestCacheProvider(HttpContextBase context)
         {
             _context = context;
         }
 
-        protected override DictionaryCacheWrapper DictionaryCache
+        // main constructor
+        // will use HttpContext.Current
+        public HttpRequestCacheProvider(/*Func<HttpContext> context*/)
         {
+            //_context2 = context;
+        }
+
+        protected override IEnumerable<DictionaryEntry> GetDictionaryEntries()
+        {
+            const string prefix = CacheItemPrefix + "-";
+            return ContextItems.Cast<DictionaryEntry>()
+                .Where(x => x.Key is string && ((string)x.Key).StartsWith(prefix));
+        }
+
+        protected override void RemoveEntry(string key)
+        {
+            ContextItems.Remove(key);
+        }
+
+        protected override object GetEntry(string key)
+        {
+            return ContextItems[key];
+        }
+
+        #region Lock
+
+        protected override IDisposable ReadLock
+        {
+            // there's no difference between ReadLock and WriteLock here
+            get { return WriteLock; }
+        }
+
+        protected override IDisposable WriteLock
+        {
+            // NOTE
+            //   could think about just overriding base.Locker to return a different
+            //   object but then we'd create a ReaderWriterLockSlim per request,
+            //   which is less efficient than just using a basic monitor lock.
+
             get
             {
-                var ctx = _context();
-                return new DictionaryCacheWrapper(
-                    ctx.Items,
-                    o => ctx.Items[o],
-                    o => ctx.Items.Remove(o));
+                return new MonitorLock(ContextItems.SyncRoot);
             }
         }
 
+        #endregion
+
+        #region Get
+
         public override object GetCacheItem(string cacheKey, Func<object> getCacheItem)
         {
-            var ctx = _context();
-            var ck = GetCacheKey(cacheKey);
-            return ctx.Items[ck] ?? (ctx.Items[ck] = getCacheItem());
+            cacheKey = GetCacheKey(cacheKey);
+
+            Lazy<object> result;
+
+            using (WriteLock)
+            {
+                result = ContextItems[cacheKey] as Lazy<object>; // null if key not found
+
+                // cannot create value within the lock, so if result.IsValueCreated is false, just
+                // do nothing here - means that if creation throws, a race condition could cause
+                // more than one thread to reach the return statement below and throw - accepted.
+                
+                if (result == null || GetSafeLazyValue(result, true) == null) // get non-created as NonCreatedValue & exceptions as null
+                {
+                    result = new Lazy<object>(getCacheItem);
+                    ContextItems[cacheKey] = result;
+                }
+            }
+
+            // this may throw if getCacheItem throws, but this is the only place where
+            // it would throw as everywhere else we use GetLazySaveValue() to hide exceptions
+            // and pretend exceptions were never inserted into cache to begin with.
+            return result.Value;
         }
+        
+        #endregion
+
+        #region Insert
+        #endregion
 
     }
 }

src/Umbraco.Core/Cache/HttpRuntimeCacheProvider.cs

@@ -1,10 +1,9 @@
 using System;
 using System.Collections;
+using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
-using System.Web;
 using System.Web.Caching;
-using Umbraco.Core.Logging;
 using CacheItemPriority = System.Web.Caching.CacheItemPriority;
 
 namespace Umbraco.Core.Cache
@@ -14,47 +13,51 @@ namespace Umbraco.Core.Cache
     /// </summary>
     internal class HttpRuntimeCacheProvider : DictionaryCacheProviderBase, IRuntimeCacheProvider
     {
+        // locker object that supports upgradeable read locking
+        // does not need to support recursion if we implement the cache correctly and ensure
+        // that methods cannot be reentrant, ie we do NOT create values while holding a lock.
+        private readonly ReaderWriterLockSlim _locker = new ReaderWriterLockSlim(LockRecursionPolicy.NoRecursion);
+
         private readonly System.Web.Caching.Cache _cache;
-        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()));
         }
 
-        protected override DictionaryCacheWrapper DictionaryCache
+        protected override IEnumerable<DictionaryEntry> GetDictionaryEntries()
         {
-            get { return _wrapper; }
+            const string prefix = CacheItemPrefix + "-";
+            return _cache.Cast<DictionaryEntry>()
+                .Where(x => x.Key is string && ((string) x.Key).StartsWith(prefix));
         }
 
-        /// <summary>
-        /// Clears all objects in the System.Web.Cache with the System.Type specified that satisfy the predicate
-        /// </summary>
-        public override void ClearCacheObjectTypes<T>(Func<string, T, bool> predicate)
+        protected override void RemoveEntry(string key)
         {
-            try
-            {
-                lock (Locker)
-                {
-                    foreach (DictionaryEntry c in _cache)
-                    {
-                        var key = c.Key.ToString();
-                        if (_cache[key] != null
-                            && _cache[key] is T
-                            && predicate(key, (T)_cache[key]))
-                        {
-                            _cache.Remove(c.Key.ToString());
-                        }
-                    }
-                }
-            }
-            catch (Exception e)
-            {
-                LogHelper.Error<CacheHelper>("Cache clearing error", e);
-            }
+            _cache.Remove(key);
         }
 
+        protected override object GetEntry(string key)
+        {
+            return _cache.Get(key);
+        }
+
+        #region Lock
+
+        protected override IDisposable ReadLock
+        {
+            get { return new ReadLock(_locker); }
+        }
+
+        protected override IDisposable WriteLock
+        {
+            get { return new WriteLock(_locker); }
+        }
+
+        #endregion
+
+        #region Get
+
         /// <summary>
         /// Gets (and adds if necessary) an item from the cache with all of the default parameters
         /// </summary>
@@ -81,25 +84,64 @@ namespace Umbraco.Core.Cache
         {
             cacheKey = GetCacheKey(cacheKey);
 
-            using (var lck = new UpgradeableReadLock(Locker))
+            // NOTE - because we don't know what getCacheItem does, how long it will take and whether it will hang,
+            // getCacheItem should run OUTSIDE of the global application lock else we run into lock contention and
+            // nasty performance issues.
+
+            // So.... we insert a Lazy<object> in the cache while holding the global application lock, and then rely
+            // on the Lazy lock to ensure that getCacheItem runs once and everybody waits on it, while the global
+            // application lock has been released.
+
+            // NOTE 
+            //   The Lazy value creation may produce a null value.
+            //   Must make sure (for backward compatibility) that we pretend they are not in the cache.
+            //   So if we find an entry in the cache that already has its value created and is null,
+            //   pretend it was not there. If value is not already created, wait... and return null, that's
+            //   what prior code did.
+
+            // NOTE
+            //   The Lazy value creation may throw.
+
+            // So... the null value _will_ be in the cache but never returned
+
+            Lazy<object> result;
+
+            // Fast!
+            // Only one thread can enter an UpgradeableReadLock at a time, but it does not prevent other
+            // threads to enter a ReadLock in the meantime -- only upgrading to WriteLock will prevent all
+            // reads. We first try with a normal ReadLock for maximum concurrency and take the penalty of
+            // having to re-lock in case there's no value. Would need to benchmark to figure out whether
+            // it's worth it, though...
+            using (new ReadLock(_locker))
             {
-                var result = DictionaryCache.Get(cacheKey);
-                if (result == null)
-                {
-                    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;
+                result = _cache.Get(cacheKey) as Lazy<object>; // null if key not found
             }
+            var value = result == null ? null : GetSafeLazyValue(result);
+            if (value != null) return value;
+
+            using (var lck = new UpgradeableReadLock(_locker))
+            {
+                result = _cache.Get(cacheKey) as Lazy<object>; // null if key not found
+
+                // cannot create value within the lock, so if result.IsValueCreated is false, just
+                // do nothing here - means that if creation throws, a race condition could cause
+                // more than one thread to reach the return statement below and throw - accepted.
+
+                if (result == null || GetSafeLazyValue(result, true) == null) // get non-created as NonCreatedValue & exceptions as null
+                {
+                    result = new Lazy<object>(getCacheItem);
+                    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);
+
+                    lck.UpgradeToWriteLock();
+                    _cache.Insert(cacheKey, result, dependency, absolute, sliding, priority, removedCallback);
+                }
+            }
+
+            // this may throw if getCacheItem throws, but this is the only place where
+            // it would throw as everywhere else we use GetLazySaveValue() to hide exceptions
+            // and pretend exceptions were never inserted into cache to begin with.
+            return result.Value;
         }
 
         public object GetCacheItem(string cacheKey, Func<object> getCacheItem, TimeSpan? timeout, bool isSliding = false, CacheItemPriority priority = CacheItemPriority.Normal, CacheItemRemovedCallback removedCallback = null, string[] dependentFiles = null)
@@ -112,6 +154,10 @@ namespace Umbraco.Core.Cache
             return GetCacheItem(cacheKey, getCacheItem, timeout, isSliding, priority, removedCallback, dependency);
         }
 
+        #endregion
+
+        #region Insert
+
         /// <summary>
         /// This overload is here for legacy purposes
         /// </summary>
@@ -124,15 +170,22 @@ namespace Umbraco.Core.Cache
         /// <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;
+            // NOTE - here also we must insert a Lazy<object> but we can evaluate it right now
+            // and make sure we don't store a null value.
+
+            var result = new Lazy<object>(getCacheItem);
+            var value = result.Value; // force evaluation now - this may throw if cacheItem throws, and then nothing goes into cache
+            if (value == null) return; // do not store null values (backward compat)
 
             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);
+            using (new WriteLock(_locker))
+            {
+                _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)
@@ -144,5 +197,7 @@ namespace Umbraco.Core.Cache
             }
             InsertCacheItem(cacheKey, getCacheItem, timeout, isSliding, priority, removedCallback, dependency);
         }
+
+        #endregion
     }
 }

src/Umbraco.Core/Cache/ICacheProvider.cs

@@ -16,7 +16,15 @@ namespace Umbraco.Core.Cache
         void ClearCacheByKeySearch(string keyStartsWith);
         void ClearCacheByKeyExpression(string regexString);
         IEnumerable<object> GetCacheItemsByKeySearch(string keyStartsWith);
+        IEnumerable<object> GetCacheItemsByKeyExpression(string regexString);
+        
+        /// <summary>
+        /// Returns an item with a given key
+        /// </summary>
+        /// <param name="cacheKey"></param>
+        /// <returns></returns>
         object GetCacheItem(string cacheKey);
+
         object GetCacheItem(string cacheKey, Func<object> getCacheItem);
     }
 }

src/Umbraco.Core/Cache/NullCacheProvider.cs

@@ -43,6 +43,11 @@ namespace Umbraco.Core.Cache
             return Enumerable.Empty<object>();
         }
 
+        public IEnumerable<object> GetCacheItemsByKeyExpression(string regexString)
+        {
+            return Enumerable.Empty<object>();
+        }
+
         public virtual object GetCacheItem(string cacheKey)
         {
             return default(object);

src/Umbraco.Core/Cache/ObjectCacheRuntimeCacheProvider.cs

@@ -16,17 +16,37 @@ namespace Umbraco.Core.Cache
     /// </summary>
     internal class ObjectCacheRuntimeCacheProvider : IRuntimeCacheProvider
     {
-        private static readonly ReaderWriterLockSlim Locker = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
+        private readonly ReaderWriterLockSlim _locker = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
         internal ObjectCache MemoryCache;
 
+        // an object that represent a value that has not been created yet
+        protected readonly object ValueNotCreated = new object();
+
         public ObjectCacheRuntimeCacheProvider()
         {
             MemoryCache = new MemoryCache("in-memory");
         }
 
+        protected object GetSafeLazyValue(Lazy<object> lazy, bool onlyIfValueIsCreated = false)
+        {
+            try
+            {
+                // if onlyIfValueIsCreated, do not trigger value creation
+                // must return something, though, to differenciate from null values
+                if (onlyIfValueIsCreated && lazy.IsValueCreated == false) return ValueNotCreated;
+                return lazy.Value;
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
+        #region Clear
+
         public virtual void ClearAllCache()
         {
-            using (new WriteLock(Locker))
+            using (new WriteLock(_locker))
             {
                 MemoryCache.DisposeIfDisposable();
                 MemoryCache = new MemoryCache("in-memory");
@@ -35,7 +55,7 @@ namespace Umbraco.Core.Cache
 
         public virtual void ClearCacheItem(string key)
         {
-            using (new WriteLock(Locker))
+            using (new WriteLock(_locker))
             {
                 if (MemoryCache[key] == null) return;
                 MemoryCache.Remove(key);
@@ -44,124 +64,179 @@ namespace Umbraco.Core.Cache
 
         public virtual void ClearCacheObjectTypes(string typeName)
         {
-            using (new WriteLock(Locker))
+            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);
+                foreach (var key in MemoryCache
+                    .Where(x =>
+                    {
+                        // x.Value is Lazy<object> and not null, its value may be null
+                        // remove null values as well, does not hurt
+                        // get non-created as NonCreatedValue & exceptions as null
+                        var value = GetSafeLazyValue((Lazy<object>)x.Value, true);
+                        return value == null || value.GetType().ToString().InvariantEquals(typeName);
+                    })
+                    .Select(x => x.Key)
+                    .ToArray()) // ToArray required to remove
+                    MemoryCache.Remove(key);
             }
         }
 
         public virtual void ClearCacheObjectTypes<T>()
         {
-            using (new WriteLock(Locker))
+            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);
+                foreach (var key in MemoryCache
+                    .Where(x =>
+                    {
+                        // x.Value is Lazy<object> and not null, its value may be null
+                        // remove null values as well, does not hurt
+                        // get non-created as NonCreatedValue & exceptions as null
+                        var value = GetSafeLazyValue((Lazy<object>)x.Value, true);
+                        return value == null || value.GetType() == typeOfT;
+                    })
+                    .Select(x => x.Key)
+                    .ToArray()) // ToArray required to remove
+                    MemoryCache.Remove(key);
             }
         }
 
         public virtual void ClearCacheObjectTypes<T>(Func<string, T, bool> predicate)
         {
-            using (new WriteLock(Locker))
+            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);
+                foreach (var key in MemoryCache
+                    .Where(x =>
+                    {
+                        // x.Value is Lazy<object> and not null, its value may be null
+                        // remove null values as well, does not hurt
+                        // get non-created as NonCreatedValue & exceptions as null
+                        var value = GetSafeLazyValue((Lazy<object>)x.Value, true);
+                        if (value == null) return true;
+                        return value.GetType() == typeOfT
+                            && predicate(x.Key, (T) value);
+                    })
+                    .Select(x => x.Key)
+                    .ToArray()) // ToArray required to remove
+                    MemoryCache.Remove(key);
             }
         }
 
         public virtual void ClearCacheByKeySearch(string keyStartsWith)
         {
-            using (new WriteLock(Locker))
+            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);
-                }
+                foreach (var key in MemoryCache
+                    .Where(x => x.Key.InvariantStartsWith(keyStartsWith))
+                    .Select(x => x.Key)
+                    .ToArray()) // ToArray required to remove
+                    MemoryCache.Remove(key);
             }            
         }
 
         public virtual void ClearCacheByKeyExpression(string regexString)
         {
-            using (new WriteLock(Locker))
+            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);
-                }
+                foreach (var key in MemoryCache
+                    .Where(x => Regex.IsMatch(x.Key, regexString))
+                    .Select(x => x.Key)
+                    .ToArray()) // ToArray required to remove
+                    MemoryCache.Remove(key);
             }     
         }
 
-        public virtual IEnumerable<object> GetCacheItemsByKeySearch(string keyStartsWith)
+        #endregion
+
+        #region Get
+
+        public IEnumerable<object> GetCacheItemsByKeySearch(string keyStartsWith)
         {
-            return (from c in MemoryCache
-                    where c.Key.InvariantStartsWith(keyStartsWith)
-                    select c.Value).ToList();
+            KeyValuePair<string, object>[] entries;
+            using (new ReadLock(_locker))
+            {
+                entries = MemoryCache
+                    .Where(x => x.Key.InvariantStartsWith(keyStartsWith))
+                    .ToArray(); // evaluate while locked
+            }
+            return entries
+                .Select(x => GetSafeLazyValue((Lazy<object>)x.Value)) // return exceptions as null
+                .Where(x => x != null) // backward compat, don't store null values in the cache
+                .ToList();
         }
 
-        public virtual object GetCacheItem(string cacheKey)
+        public IEnumerable<object> GetCacheItemsByKeyExpression(string regexString)
         {
-            var result = MemoryCache.Get(cacheKey);
-            return result;
+            KeyValuePair<string, object>[] entries;
+            using (new ReadLock(_locker))
+            {
+                entries = MemoryCache
+                    .Where(x => Regex.IsMatch(x.Key, regexString))
+                    .ToArray(); // evaluate while locked
+            }
+            return entries
+                .Select(x => GetSafeLazyValue((Lazy<object>)x.Value)) // return exceptions as null
+                .Where(x => x != null) // backward compat, don't store null values in the cache
+                .ToList();
         }
 
-        public virtual object GetCacheItem(string cacheKey, Func<object> getCacheItem)
+        public object GetCacheItem(string cacheKey)
+        {
+            Lazy<object> result;
+            using (new ReadLock(_locker))
+            {
+                result = MemoryCache.Get(cacheKey) as Lazy<object>; // null if key not found
+            }
+            return result == null ? null : GetSafeLazyValue(result); // return exceptions as null
+        }
+
+        public 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)
+        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();
+            // see notes in HttpRuntimeCacheProvider
 
-                    result = getCacheItem();
-                    if (result != null)
-                    {
-                        var policy = GetPolicy(timeout, isSliding, removedCallback, dependentFiles);
-                        MemoryCache.Set(cacheKey, result, policy);
-                    }
+            Lazy<object> result;
+
+            using (var lck = new UpgradeableReadLock(_locker))
+            {
+                result = MemoryCache.Get(cacheKey) as Lazy<object>;
+                if (result == null || GetSafeLazyValue(result, true) == null) // get non-created as NonCreatedValue & exceptions as null
+                {
+                    result = new Lazy<object>(getCacheItem);
+                    var policy = GetPolicy(timeout, isSliding, removedCallback, dependentFiles);
+
+                    lck.UpgradeToWriteLock();
+                    MemoryCache.Set(cacheKey, result, policy);
                 }
-                return result;
             }
+
+            return result.Value;
         }
 
+        #endregion
+
+        #region Insert
+
         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);
-            }
+            // NOTE - here also we must insert a Lazy<object> but we can evaluate it right now
+            // and make sure we don't store a null value.
+
+            var result = new Lazy<object>(getCacheItem);
+            var value = result.Value; // force evaluation now
+            if (value == null) return; // do not store null values (backward compat)
+
+            var policy = GetPolicy(timeout, isSliding, removedCallback, dependentFiles);
+            MemoryCache.Set(cacheKey, result, policy);
         }
 
+        #endregion
+
         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));

src/Umbraco.Core/Cache/StaticCacheProvider.cs

@@ -59,6 +59,13 @@ namespace Umbraco.Core.Cache
                     select c.Value).ToList();
         }
 
+        public IEnumerable<object> GetCacheItemsByKeyExpression(string regexString)
+        {
+            return (from KeyValuePair<string, object> c in StaticCache
+                    where Regex.IsMatch(c.Key, regexString) 
+                    select c.Value).ToList();
+        }
+
         public virtual object GetCacheItem(string cacheKey)
         {
             var result = StaticCache[cacheKey];

src/Umbraco.Core/CacheHelper.cs

@@ -44,7 +44,7 @@ namespace Umbraco.Core
             : this(
                 new HttpRuntimeCacheProvider(HttpRuntime.Cache),
                 new StaticCacheProvider(),
-                new HttpRequestCacheProvider(() => new HttpContextWrapper(HttpContext.Current)))
+                new HttpRequestCacheProvider())
         {
         }
 
@@ -56,7 +56,7 @@ namespace Umbraco.Core
             : this(
                 new HttpRuntimeCacheProvider(cache),
                 new StaticCacheProvider(),
-                new HttpRequestCacheProvider(() => new HttpContextWrapper(HttpContext.Current)))
+                new HttpRequestCacheProvider())
         {
         }
 

src/Umbraco.Core/Configuration/UmbracoSettings.cs

@@ -1083,7 +1083,7 @@ namespace Umbraco.Core.Configuration
 					bool globalPreviewEnabled = false;
 					string value = GetKey("/settings/content/GlobalPreviewStorageEnabled");
 					if (bool.TryParse(value, out globalPreviewEnabled))
-						return !globalPreviewEnabled;
+						return globalPreviewEnabled;
 					// Return default
 					return false;
 				}

src/Umbraco.Core/Configuration/UmbracoVersion.cs

@@ -5,7 +5,7 @@ namespace Umbraco.Core.Configuration
 {
     public class UmbracoVersion
     {
-        private static readonly Version Version = new Version("6.2.0");
+        private static readonly Version Version = new Version("6.2.4");
 
         /// <summary>
         /// Gets the current version of Umbraco.
@@ -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 "RC"; } }
+        public static string CurrentComment { get { return ""; } }
 
         // 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/DatabaseContext.cs

@@ -456,6 +456,11 @@ namespace Umbraco.Core
                 string message;
 
                 var database = new UmbracoDatabase(_connectionString, ProviderName);
+
+                // If MySQL, we're going to ensure that database calls are maintaining proper casing as to remove the necessity for checks
+                // for case insensitive queries. In an ideal situation (which is what we're striving for), all calls would be case sensitive.
+
+                /*                
                 var supportsCaseInsensitiveQueries = SqlSyntaxContext.SqlSyntaxProvider.SupportsCaseInsensitiveQueries(database);
                 if (supportsCaseInsensitiveQueries  == false)
                 {
@@ -468,8 +473,9 @@ namespace Umbraco.Core
 
                     return new Result { Message = message, Success = false, Percentage = "15" };
                 }
+                */
 
-                message = GetResultMessageForMySql(supportsCaseInsensitiveQueries);
+                message = GetResultMessageForMySql();
 
                 var schemaResult = ValidateDatabaseSchema();
                 var installedVersion = schemaResult.DetermineInstalledVersion();
@@ -520,9 +526,9 @@ namespace Umbraco.Core
                 LogHelper.Info<DatabaseContext>("Database upgrade started");
 
                 var database = new UmbracoDatabase(_connectionString, ProviderName);
-                var supportsCaseInsensitiveQueries = SqlSyntaxContext.SqlSyntaxProvider.SupportsCaseInsensitiveQueries(database);                
+                //var supportsCaseInsensitiveQueries = SqlSyntaxContext.SqlSyntaxProvider.SupportsCaseInsensitiveQueries(database);                
 
-                var message = GetResultMessageForMySql(supportsCaseInsensitiveQueries);
+                var message = GetResultMessageForMySql();
 
                 var schemaResult = ValidateDatabaseSchema();
                 var installedVersion = schemaResult.DetermineInstalledVersion();
@@ -549,6 +555,23 @@ namespace Umbraco.Core
             }
         }
 
+        private string GetResultMessageForMySql()
+        {
+            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 string GetResultMessageForMySql(bool? supportsCaseInsensitiveQueries)
         {
             if (supportsCaseInsensitiveQueries == null)
@@ -572,7 +595,7 @@ namespace Umbraco.Core
                        "<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()
         {

src/Umbraco.Core/Dynamics/ExtensionMethods.cs

@@ -36,42 +36,22 @@ namespace Umbraco.Core.Dynamics
         [Obsolete("This method should not be used and will be removed in the future")]
         public static bool ContainsAny(this string haystack, IEnumerable<string> needles)
         {
-        	if (haystack == null) throw new ArgumentNullException("haystack");
-        	if (!string.IsNullOrEmpty(haystack) || needles.Any())
-            {
-            	return needles.Any(haystack.Contains);
-            }
-            return false;
+            return StringExtensions.ContainsAny(haystack, needles);
         }
         [Obsolete("This method should not be used and will be removed in the future")]
         public static bool ContainsAny(this string haystack, params string[] needles)
         {
-        	if (haystack == null) throw new ArgumentNullException("haystack");
-        	if (!string.IsNullOrEmpty(haystack) || needles.Length > 0)
-            {
-            	return needles.Any(haystack.Contains);
-            }
-            return false;
+        	return StringExtensions.ContainsAny(haystack, needles);
         }
         [Obsolete("This method should not be used and will be removed in the future")]
 		public static bool ContainsAny(this string haystack, StringComparison comparison, IEnumerable<string> needles)
         {
-        	if (haystack == null) throw new ArgumentNullException("haystack");
-        	if (!string.IsNullOrEmpty(haystack) || needles.Any())
-            {
-            	return needles.Any(value => haystack.IndexOf(value, comparison) >= 0);
-            }
-            return false;
+            return StringExtensions.ContainsAny(haystack, needles, comparison);
         }
         [Obsolete("This method should not be used and will be removed in the future")]
         public static bool ContainsAny(this string haystack, StringComparison comparison, params string[] needles)
         {
-        	if (haystack == null) throw new ArgumentNullException("haystack");
-        	if (!string.IsNullOrEmpty(haystack) || needles.Length > 0)
-            {
-            	return needles.Any(value => haystack.IndexOf(value, comparison) >= 0);
-            }
-            return false;
+            return StringExtensions.ContainsAny(haystack, needles, comparison);
         }
         [Obsolete("This method should not be used and will be removed in the future")]
         public static bool ContainsInsensitive(this string haystack, string needle)

src/Umbraco.Core/Dynamics/PropertyResult.cs

@@ -4,14 +4,14 @@ using System.Web;
 
 namespace Umbraco.Core.Dynamics
 {
-	internal class PropertyResult : IPublishedProperty, IHtmlString
+	internal class PropertyResult : IPublishedContentProperty, IHtmlString
 	{
-	    private readonly IPublishedProperty _source;
+	    private readonly IPublishedContentProperty _source;
 	    private readonly string _alias;
 	    private readonly object _value;
         private readonly PropertyResultType _type;
 
-		internal PropertyResult(IPublishedProperty source, PropertyResultType type)
+		internal PropertyResult(IPublishedContentProperty source, PropertyResultType type)
         {
     		if (source == null) throw new ArgumentNullException("source");
             
@@ -37,6 +37,9 @@ namespace Umbraco.Core.Dynamics
         public object Value { get { return _source == null ? _value : _source.Value; } }
         public object XPathValue { get { return Value == null ? null : Value.ToString(); } }
 
+        public string Alias { get { return PropertyTypeAlias; }}
+        public Guid Version { get { return Guid.Empty; }}
+
         // implements IHtmlString.ToHtmlString
         public string ToHtmlString()
         {

src/Umbraco.Core/EnumerableExtensions.cs

@@ -15,43 +15,13 @@ namespace Umbraco.Core
         public static IEnumerable<IEnumerable<T>> InGroupsOf<T>(this IEnumerable<T> source, int groupSize)
         {
             if (source == null)
-                throw new NullReferenceException("source");
+                throw new ArgumentNullException("source");
+            if (groupSize <= 0)
+                throw new ArgumentException("Must be greater than zero.", "groupSize");
 
-            // enumerate the source only once!
-            return new InGroupsEnumerator<T>(source, groupSize).Groups();
-        }
-
-        // this class makes sure that the source is enumerated only ONCE
-        // which means that when it is enumerated, the actual groups content
-        // has to be evaluated at the same time, and stored in an array.
-        private class InGroupsEnumerator<T>
-        {
-            private readonly IEnumerator<T> _source;
-            private readonly int _count;
-            private bool _mightHaveNext;
-
-            public InGroupsEnumerator(IEnumerable<T> source, int count)
-            {
-                _source = source.GetEnumerator();
-                _count = count;
-                _mightHaveNext = true;
-            }
-
-            public IEnumerable<IEnumerable<T>> Groups()
-            {
-                while (_mightHaveNext && _source.MoveNext())
-                    yield return Group().ToArray(); // see note above
-            }
-
-            private IEnumerable<T> Group()
-            {
-                var c = 0;
-                do
-                {
-                    yield return _source.Current;
-                } while (++c < _count && _source.MoveNext());
-                _mightHaveNext = c == _count;
-            }
+            return source
+                .Select((x, i) => Tuple.Create(i / groupSize, x))
+                .GroupBy(t => t.Item1, t => t.Item2);
         }
 
         /// <summary>The distinct by.</summary>

src/Umbraco.Core/Events/CancellableObjectEventArgs.cs

@@ -29,7 +29,7 @@ namespace Umbraco.Core.Events
 		/// <remarks>
 		/// This is protected so that inheritors can expose it with their own name
 		/// </remarks>
-		protected T EventObject { get; private set; }
+		protected T EventObject { get; set; }
 
 	}
 }

src/Umbraco.Core/Events/MoveEventArgs.cs

@@ -1,28 +1,98 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
 namespace Umbraco.Core.Events
 {
-	public class MoveEventArgs<TEntity> : CancellableObjectEventArgs<TEntity>
-	{
-		public MoveEventArgs(TEntity eventObject, bool canCancel, int parentId) : base(eventObject, canCancel)
-		{
-			ParentId = parentId;
-		}
+    public class MoveEventInfo<TEntity>
+    {
+        public MoveEventInfo(TEntity entity, string originalPath, int newParentId)
+        {
+            Entity = entity;
+            OriginalPath = originalPath;
+            NewParentId = newParentId;
+        }
 
-		public MoveEventArgs(TEntity eventObject, int parentId) : base(eventObject)
-		{
-			ParentId = parentId;
-		}
+        public TEntity Entity { get; set; }
+        public string OriginalPath { get; set; }
+        public int NewParentId { get; set; }
+    }
 
-		/// <summary>
-		/// The entity being moved
-		/// </summary>
-		public TEntity Entity
-		{
-			get { return EventObject; }
-		}
+    public class MoveEventArgs<TEntity> : CancellableObjectEventArgs<TEntity>
+    {
+        /// <summary>
+        /// Constructor accepting a collection of MoveEventInfo objects
+        /// </summary>
+        /// <param name="canCancel"></param>
+        /// <param name="moveInfo">
+        /// A colleciton of MoveEventInfo objects that exposes all entities that have been moved during a single move operation
+        /// </param>
+        public MoveEventArgs(bool canCancel, params MoveEventInfo<TEntity>[] moveInfo)
+            : base(default(TEntity), canCancel)
+        {
+            if (moveInfo.FirstOrDefault() == null)
+            {
+                throw new ArgumentException("moveInfo argument must contain at least one item");
+            }
 
-		/// <summary>
-		/// Gets or Sets the Id of the objects new parent.
-		/// </summary>
-		public int ParentId { get; private set; }
-	}
+            MoveInfoCollection = moveInfo;
+            //assign the legacy props
+            EventObject = moveInfo.First().Entity;
+            ParentId = moveInfo.First().NewParentId;
+        }
+
+        /// <summary>
+        /// Constructor accepting a collection of MoveEventInfo objects
+        /// </summary>
+        /// <param name="moveInfo">
+        /// A colleciton of MoveEventInfo objects that exposes all entities that have been moved during a single move operation
+        /// </param>
+        public MoveEventArgs(params MoveEventInfo<TEntity>[] moveInfo)
+            : base(default(TEntity))
+        {
+            if (moveInfo.FirstOrDefault() == null)
+            {
+                throw new ArgumentException("moveInfo argument must contain at least one item");
+            }
+
+            MoveInfoCollection = moveInfo;
+            //assign the legacy props
+            EventObject = moveInfo.First().Entity;
+            ParentId = moveInfo.First().NewParentId;
+        }
+
+        [Obsolete("Use the overload that specifies the MoveEventInfo object")]
+        public MoveEventArgs(TEntity eventObject, bool canCancel, int parentId)
+            : base(eventObject, canCancel)
+        {
+            ParentId = parentId;
+        }
+
+        [Obsolete("Use the overload that specifies the MoveEventInfo object")]
+        public MoveEventArgs(TEntity eventObject, int parentId)
+            : base(eventObject)
+        {
+            ParentId = parentId;
+        }
+
+        /// <summary>
+        /// Gets all MoveEventInfo objects used to create the object
+        /// </summary>
+        public IEnumerable<MoveEventInfo<TEntity>> MoveInfoCollection { get; private set; }
+
+        /// <summary>
+        /// The entity being moved
+        /// </summary>
+        [Obsolete("Retrieve the entity object from the MoveInfoCollection property instead")]
+        public TEntity Entity
+        {
+            get { return EventObject; }
+        }
+
+        /// <summary>
+        /// Gets the Id of the object's new parent
+        /// </summary>
+        [Obsolete("Retrieve the ParentId from the MoveInfoCollection property instead")]
+        public int ParentId { get; private set; }
+    }
 }

src/Umbraco.Core/HashCodeCombiner.cs

@@ -34,6 +34,12 @@ namespace Umbraco.Core
 			AddInt(d.GetHashCode());
 		}
 
+        internal void AddString(string s)
+        {
+            if (s != null)
+                AddInt((StringComparer.InvariantCulture).GetHashCode(s));
+        }
+
 		internal void AddCaseInsensitiveString(string s)
 		{
 			if (s != null)

src/Umbraco.Core/IO/FileSystemExtensions.cs

@@ -19,7 +19,10 @@ namespace Umbraco.Core.IO
 
         public static void CopyFile(this IFileSystem fs, string path, string newPath)
         {
-            fs.AddFile(newPath, fs.OpenFile(path));
+            using (var stream = fs.OpenFile(path))
+            {
+                fs.AddFile(newPath, stream);
+            }
         }
 
         public static string GetExtension(this IFileSystem fs, string path)

src/Umbraco.Core/IO/PhysicalFileSystem.cs

@@ -93,8 +93,9 @@ namespace Umbraco.Core.IO
 
         public void AddFile(string path, Stream stream, bool overrideIfExists)
         {
-            if (FileExists(path) && !overrideIfExists) throw new InvalidOperationException(string.Format("A file at path '{0}' already exists", path));
-
+            var exists = FileExists(path);
+            if (exists && overrideIfExists == false) throw new InvalidOperationException(string.Format("A file at path '{0}' already exists", path));
+            
             EnsureDirectory(Path.GetDirectoryName(path));
 
             if (stream.CanSeek)

src/Umbraco.Core/IO/UmbracoMediaFile.cs

@@ -133,16 +133,23 @@ namespace Umbraco.Core.IO
         {
             if (_size == null)
             {
-                EnsureFileSupportsResizing();
+                if (_fs.FileExists(Path))
+                {
+                    EnsureFileSupportsResizing();
 
-                var fs = _fs.OpenFile(Path);
-                var image = Image.FromStream(fs);
-                var fileWidth = image.Width;
-                var fileHeight = image.Height;
-                fs.Close();
-                image.Dispose();
+                    using (var fs = _fs.OpenFile(Path))
+                    using (var image = Image.FromStream(fs))
+                    {
 
-                _size = new Size(fileWidth, fileHeight);    
+                        var fileWidth = image.Width;
+                        var fileHeight = image.Height;
+                        _size = new Size(fileWidth, fileHeight);
+                    }
+                }
+                else
+                {
+                    _size = new Size(-1, -1);
+                }
             }
             return _size.Value;
         }

src/Umbraco.Core/Models/Content.cs

@@ -232,6 +232,7 @@ namespace Umbraco.Core.Models
         /// <remarks>
         /// This Property is kept internal until localization is introduced.
         /// </remarks>
+        [DataMember]
         internal string NodeName
         {
             get { return _nodeName; }
@@ -248,6 +249,7 @@ namespace Umbraco.Core.Models
         /// <summary>
         /// Used internally to track if permissions have been changed during the saving process for this entity
         /// </summary>
+        [IgnoreDataMember]
         internal bool PermissionsChanged
         {
             get { return _permissionsChanged; }
@@ -314,6 +316,7 @@ namespace Umbraco.Core.Models
             PublishedState = state;
         }
 
+        [DataMember]
         internal PublishedState PublishedState { get; set; }
 
         /// <summary>
@@ -333,26 +336,6 @@ namespace Umbraco.Core.Models
             }
         }
 
-        /// <summary>
-        /// Creates a clone of the current entity
-        /// </summary>
-        /// <returns></returns>
-        public IContent Clone()
-        {
-            var clone = (Content)this.MemberwiseClone();
-            clone.Key = Guid.Empty;
-            clone.Version = Guid.NewGuid();
-            clone.ResetIdentity();
-
-            foreach (var property in clone.Properties)
-            {
-                property.ResetIdentity();
-                property.Version = clone.Version;
-            }
-
-            return clone;
-        }
-
         /// <summary>
         /// Indicates whether a specific property on the current <see cref="IContent"/> entity is dirty.
         /// </summary>
@@ -432,5 +415,47 @@ namespace Umbraco.Core.Models
             base.UpdatingEntity();
             Version = Guid.NewGuid();
         }
+
+        /// <summary>
+        /// Creates a deep clone of the current entity with its identity and it's property identities reset
+        /// </summary>
+        /// <returns></returns>
+        [Obsolete("Use DeepCloneWithResetIdentities instead")]
+        public IContent Clone()
+        {
+            return DeepCloneWithResetIdentities();
+        }
+
+        /// <summary>
+        /// Creates a deep clone of the current entity with its identity and it's property identities reset
+        /// </summary>
+        /// <returns></returns>
+        public IContent DeepCloneWithResetIdentities()
+        {
+            var clone = (Content)DeepClone();
+            clone.Key = Guid.Empty;
+            clone.Version = Guid.NewGuid();
+            clone.ResetIdentity();
+
+            foreach (var property in clone.Properties)
+            {
+                property.ResetIdentity();
+                property.Version = clone.Version;
+            }
+
+            return clone;
+        }
+
+        public override object DeepClone()
+        {
+            var clone = (Content)base.DeepClone();
+
+            //need to manually clone this since it's not settable
+            clone._contentType = (IContentType)ContentType.DeepClone();
+            clone.ResetDirtyProperties(false);
+
+            return clone;
+
+        }
     }
 }

src/Umbraco.Core/Models/ContentBase.cs

@@ -15,10 +15,13 @@ namespace Umbraco.Core.Models
     /// <summary>
     /// Represents an abstract class for base Content properties and methods
     /// </summary>
+    [Serializable]
+    [DataContract(IsReference = true)]
     [DebuggerDisplay("Id: {Id}, Name: {Name}, ContentType: {ContentTypeBase.Alias}")]
     public abstract class ContentBase : Entity, IContentBase
     {
         protected IContentTypeComposition ContentTypeBase;
+        
         private Lazy<int> _parentId;
         private string _name;//NOTE Once localization is introduced this will be the localized Name of the Content/Media.
         private int _sortOrder;
@@ -257,6 +260,7 @@ namespace Umbraco.Core.Models
         }
 
         private readonly IDictionary<string, object> _additionalData;
+
         /// <summary>
         /// Some entities may expose additional data that other's might not, this custom data will be available in this collection
         /// </summary>
@@ -444,6 +448,7 @@ namespace Umbraco.Core.Models
         /// <summary>
         /// Returns a collection of the result of the last validation process, this collection contains all invalid properties.
         /// </summary>
+        [IgnoreDataMember]
         internal IEnumerable<Property> LastInvalidProperties
         {
             get { return _lastInvalidProperties; }
@@ -465,5 +470,6 @@ namespace Umbraco.Core.Models
                 prop.ResetDirtyProperties(rememberPreviouslyChangedProperties);
             }
         }
+        
     }
 }

src/Umbraco.Core/Models/ContentExtensions.cs

@@ -222,6 +222,28 @@ namespace Umbraco.Core.Models
         }
         #endregion
 
+        
+        /// <summary>
+        /// Removes characters that are not valide XML characters from all entity properties 
+        /// of type string. See: http://stackoverflow.com/a/961504/5018
+        /// </summary>
+        /// <returns></returns>
+        /// <remarks>
+        /// If this is not done then the xml cache can get corrupt and it will throw YSODs upon reading it.
+        /// </remarks>
+        /// <param name="entity"></param>
+        public static void SanitizeEntityPropertiesForXmlStorage(this IContentBase entity)
+        {
+            entity.Name = entity.Name.ToValidXmlString();
+            foreach (var property in entity.Properties)
+            {
+                if (property.Value is string)
+                {
+                    var value = (string)property.Value;
+                    property.Value = value.ToValidXmlString();
+                }
+            }
+        }
         /// <summary>
         /// Checks if the IContentBase has children
         /// </summary>

src/Umbraco.Core/Models/ContentPreviewEntity.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Xml.Linq;
+
+namespace Umbraco.Core.Models
+{
+    /// <summary>
+    /// Used content repository in order to add an entity to the persisted collection to be saved
+    /// in a single transaction during saving an entity
+    /// </summary>
+    internal class ContentPreviewEntity<TContent> : ContentXmlEntity<TContent> 
+        where TContent : IContentBase
+    {
+        public ContentPreviewEntity(bool previewExists, TContent content, Func<TContent, XElement> xml)
+            : base(previewExists, content, xml)
+        {
+            Version = content.Version;
+        }
+
+        public Guid Version { get; private set; }
+    }
+}

src/Umbraco.Core/Models/ContentType.cs

@@ -120,38 +120,6 @@ namespace Umbraco.Core.Models
 
             return result;
         }
-        
-        /// <summary>
-        /// Creates a clone of the current entity
-        /// </summary>
-        /// <returns></returns>
-        public IContentType Clone(string alias)
-        {
-            var clone = (ContentType)this.MemberwiseClone();
-            clone.Alias = alias;
-            clone.Key = Guid.Empty;
-            var propertyGroups = this.PropertyGroups.Select(x => x.Clone()).ToList();
-            clone.PropertyGroups = new PropertyGroupCollection(propertyGroups);
-            clone.PropertyTypes = this.PropertyTypeCollection.Select(x => x.Clone()).ToList();
-            clone.ResetIdentity();
-            clone.ResetDirtyProperties(false);
-
-            foreach (var propertyGroup in clone.PropertyGroups)
-            {
-                propertyGroup.ResetIdentity();
-                foreach (var propertyType in propertyGroup.PropertyTypes)
-                {
-                    propertyType.ResetIdentity();
-                }
-            }
-
-            foreach (var propertyType in clone.PropertyTypes.Where(x => x.HasIdentity))
-            {
-                propertyType.ResetIdentity();
-            }
-
-            return clone;
-        }
 
         /// <summary>
         /// Method to call when Entity is being saved
@@ -165,13 +133,41 @@ namespace Umbraco.Core.Models
                 Key = Guid.NewGuid();
         }
 
+
         /// <summary>
-        /// Method to call when Entity is being updated
+        /// Creates a deep clone of the current entity with its identity/alias and it's property identities reset
         /// </summary>
-        /// <remarks>Modified Date is set and a new Version guid is set</remarks>
-        internal override void UpdatingEntity()
-        {
-            base.UpdatingEntity();
+        /// <returns></returns>
+        [Obsolete("Use DeepCloneWithResetIdentities instead")]
+        public IContentType Clone(string alias)
+        {            
+            return DeepCloneWithResetIdentities(alias);
         }
+
+        /// <summary>
+        /// Creates a deep clone of the current entity with its identity/alias and it's property identities reset
+        /// </summary>
+        /// <returns></returns>
+        public IContentType DeepCloneWithResetIdentities(string alias)
+        {
+            var clone = (ContentType)DeepClone();
+            clone.Alias = alias;
+            clone.Key = Guid.Empty;
+            foreach (var propertyGroup in clone.PropertyGroups)
+            {
+                propertyGroup.ResetIdentity();
+                propertyGroup.ResetDirtyProperties(false);
+            }
+            foreach (var propertyType in clone.PropertyTypes)
+            {
+                propertyType.ResetIdentity();
+                propertyType.ResetDirtyProperties(false);
+            }
+
+            clone.ResetIdentity();
+            clone.ResetDirtyProperties(false);
+            return clone;
+        }
+
     }
 }

src/Umbraco.Core/Models/ContentTypeBase.cs

@@ -6,6 +6,7 @@ using System.Linq;
 using System.Reflection;
 using System.Runtime.Serialization;
 using Umbraco.Core.Models.EntityBase;
+using Umbraco.Core.Strings;
 
 namespace Umbraco.Core.Models
 {
@@ -173,7 +174,8 @@ namespace Umbraco.Core.Models
             {
                 SetPropertyValueAndDetectChanges(o =>
                     {
-                        _alias = value.ToSafeAlias();
+                        //_alias = value.ToSafeAlias();
+                        _alias = value.ToCleanString(CleanStringType.Alias | CleanStringType.UmbracoCase);
                         return _alias;
                     }, _alias, AliasSelector);
             }
@@ -319,7 +321,7 @@ namespace Umbraco.Core.Models
             }
         }
 
-        private readonly IDictionary<string, object> _additionalData;
+        private IDictionary<string, object> _additionalData;
         /// <summary>
         /// Some entities may expose additional data that other's might not, this custom data will be available in this collection
         /// </summary>
@@ -349,7 +351,9 @@ namespace Umbraco.Core.Models
         /// <summary>
         /// List of PropertyGroups available on this ContentType
         /// </summary>
-        /// <remarks>A PropertyGroup corresponds to a Tab in the UI</remarks>
+        /// <remarks>
+        /// A PropertyGroup corresponds to a Tab in the UI
+        /// </remarks>
         [DataMember]
         public virtual PropertyGroupCollection PropertyGroups
         {
@@ -365,7 +369,13 @@ namespace Umbraco.Core.Models
         /// List of PropertyTypes available on this ContentType.
         /// This list aggregates PropertyTypes across the PropertyGroups.
         /// </summary>
+        /// <remarks>
+        /// Marked as DoNotClone because the result of this property is not the natural result of the data, it is 
+        /// a union of data so when auto-cloning if the setter is used it will be setting the unnatural result of the 
+        /// data. We manually clone this instead. 
+        /// </remarks>
         [IgnoreDataMember]
+        [DoNotClone]
         public virtual IEnumerable<PropertyType> PropertyTypes
         {
             get
@@ -381,6 +391,14 @@ namespace Umbraco.Core.Models
         }
 
         /// <summary>
+        /// Returns the property type collection containing types that are non-groups - used for tests
+        /// </summary>
+        internal IEnumerable<PropertyType> NonGroupedPropertyTypes
+        {
+            get { return _propertyTypes; }
+        }
+
+            /// <summary>
         /// A boolean flag indicating if a property type has been removed from this instance.
         /// </summary>
         /// <remarks>
@@ -577,5 +595,19 @@ namespace Umbraco.Core.Models
                 propertyType.ResetDirtyProperties();
             }
         }
+
+        public override object DeepClone()
+        {
+            var clone = (ContentTypeBase)base.DeepClone();
+
+            //need to manually wire up the event handlers for the property type collections - we've ensured
+            // its ignored from the auto-clone process because its return values are unions, not raw and 
+            // we end up with duplicates, see: http://issues.umbraco.org/issue/U4-4842
+
+            clone._propertyTypes = (PropertyTypeCollection)_propertyTypes.DeepClone();
+            clone._propertyTypes.CollectionChanged += clone.PropertyTypesChanged;
+
+            return clone;
+        }
     }
 }

src/Umbraco.Core/Models/ContentTypeCompositionBase.cs

@@ -13,7 +13,7 @@ namespace Umbraco.Core.Models
     [DataContract(IsReference = true)]
     public abstract class ContentTypeCompositionBase : ContentTypeBase, IContentTypeComposition
     {
-        private readonly List<IContentTypeComposition> _contentTypeComposition = new List<IContentTypeComposition>();
+        private List<IContentTypeComposition> _contentTypeComposition = new List<IContentTypeComposition>();
         internal List<int> RemovedContentTypeKeyTracker = new List<int>();
 
         protected ContentTypeCompositionBase(int parentId) : base(parentId)
@@ -217,5 +217,17 @@ namespace Umbraco.Core.Models
                 .Select(x => x.Id)
                 .Union(ContentTypeComposition.SelectMany(x => x.CompositionIds()));
         }
+
+        public override object DeepClone()
+        {
+            var clone = (ContentTypeCompositionBase)base.DeepClone();
+
+            //need to manually assign since this is an internal field and will not be automatically mapped
+            clone.RemovedContentTypeKeyTracker = new List<int>();
+            clone._contentTypeComposition = ContentTypeComposition.Select(x => (IContentTypeComposition)x.DeepClone()).ToList();
+            clone.ResetDirtyProperties(false);
+
+            return clone;
+        }
     }
 }

src/Umbraco.Core/Models/ContentTypeSort.cs

@@ -6,7 +6,7 @@ namespace Umbraco.Core.Models
     /// <summary>
     /// Represents a POCO for setting sort order on a ContentType reference
     /// </summary>
-    public class ContentTypeSort : IValueObject
+    public class ContentTypeSort : IValueObject, IDeepCloneable
     {
         public ContentTypeSort()
         {
@@ -33,5 +33,36 @@ namespace Umbraco.Core.Models
         /// Gets or sets the Alias of the ContentType
         /// </summary>
         public string Alias { get; set; }
+
+
+        public object DeepClone()
+        {
+            var clone = (ContentTypeSort)MemberwiseClone();
+            var id = Id.Value;
+            clone.Id = new Lazy<int>(() => id);
+            return clone;
+        }
+
+        protected bool Equals(ContentTypeSort other)
+        {
+            return Id.Value.Equals(other.Id.Value) && string.Equals(Alias, other.Alias);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((ContentTypeSort) obj);
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                return (Id.GetHashCode()*397) ^ Alias.GetHashCode();
+            }
+        }
+
     }
 }

src/Umbraco.Core/Models/ContentXmlEntity.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Xml.Linq;
+using Umbraco.Core.Models.EntityBase;
+
+namespace Umbraco.Core.Models
+{
+    /// <summary>
+    /// Used in content/media/member repositories in order to add this type of entity to the persisted collection to be saved
+    /// in a single transaction during saving an entity
+    /// </summary>
+    internal class ContentXmlEntity<TContent> : IAggregateRoot
+        where TContent : IContentBase
+    {
+        private readonly bool _entityExists;
+        private readonly Func<TContent, XElement> _xml;
+
+        public ContentXmlEntity(bool entityExists, TContent content, Func<TContent, XElement> xml)
+        {            
+            if (content == null) throw new ArgumentNullException("content");
+            _entityExists = entityExists;
+            _xml = xml;            
+            Content = content;
+        }
+
+        public ContentXmlEntity(TContent content)
+        {
+            if (content == null) throw new ArgumentNullException("content");
+            Content = content;
+        }
+
+        public XElement Xml
+        {
+            get { return _xml(Content); }
+        }
+        public TContent Content { get; private set; }
+
+        public int Id
+        {
+            get { return Content.Id; }
+            set { throw new NotSupportedException(); }
+        }
+
+        public Guid Key { get; set; }
+        public DateTime CreateDate { get; set; }
+        public DateTime UpdateDate { get; set; }
+
+        public bool HasIdentity
+        {
+            get { return _entityExists; }         
+        }
+
+        public object DeepClone()
+        {
+            var clone = (ContentXmlEntity<TContent>)MemberwiseClone();
+            //Automatically deep clone ref properties that are IDeepCloneable
+            DeepCloneHelper.DeepCloneRefProperties(this, clone);
+            return clone;
+        }
+    }
+}

src/Umbraco.Core/Models/DeepCloneHelper.cs

@@ -0,0 +1,174 @@
+using System;
+using System.Collections;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+namespace Umbraco.Core.Models
+{
+    /// <summary>
+    /// Used to attribute properties that have a setter and are a reference type
+    /// that should be ignored for cloning when using the DeepCloneHelper
+    /// </summary>
+    /// <remarks>
+    /// 
+    /// This attribute must be used:
+    /// * when the property is backed by a field but the result of the property is the un-natural data stored in the field
+    ///  
+    /// This attribute should not be used:
+    /// * when the property is virtual
+    /// * when the setter performs additional required logic other than just setting the underlying field
+    /// 
+    /// </remarks>
+    internal class DoNotCloneAttribute : Attribute
+    {
+        
+    }
+
+    public static class DeepCloneHelper
+    {
+        /// <summary>
+        /// Used to avoid constant reflection (perf)
+        /// </summary>
+        private static readonly ConcurrentDictionary<Type, PropertyInfo[]> PropCache = new ConcurrentDictionary<Type, PropertyInfo[]>(); 
+
+        /// <summary>
+        /// Used to deep clone any reference properties on the object (should be done after a MemberwiseClone for which the outcome is 'output')
+        /// </summary>
+        /// <param name="input"></param>
+        /// <param name="output"></param>
+        /// <returns></returns>        
+        public static void DeepCloneRefProperties(IDeepCloneable input, IDeepCloneable output)
+        {
+            var inputType = input.GetType();
+            var outputType = output.GetType();
+
+            if (inputType != outputType)
+            {
+                throw new InvalidOperationException("Both the input and output types must be the same");
+            }
+
+            var refProperties = PropCache.GetOrAdd(inputType, type =>
+                inputType.GetProperties()
+                    .Where(x =>
+                        //is not attributed with the ignore clone attribute
+                    Attribute.GetCustomAttribute(x, typeof(DoNotCloneAttribute)) == null
+                            //reference type but not string
+                        && x.PropertyType.IsValueType == false && x.PropertyType != typeof (string)
+                            //settable
+                        && x.CanWrite
+                            //non-indexed
+                        && x.GetIndexParameters().Any() == false)
+                    .ToArray());
+
+            foreach (var propertyInfo in refProperties)
+            {
+                if (TypeHelper.IsTypeAssignableFrom<IDeepCloneable>(propertyInfo.PropertyType))
+                {
+                    //this ref property is also deep cloneable so clone it
+                    var result = (IDeepCloneable)propertyInfo.GetValue(input, null);
+
+                    if (result != null)
+                    {
+                        //set the cloned value to the property
+                        propertyInfo.SetValue(output, result.DeepClone(), null);
+                    }
+                }
+                else if (TypeHelper.IsTypeAssignableFrom<IEnumerable>(propertyInfo.PropertyType)
+                    && TypeHelper.IsTypeAssignableFrom<string>(propertyInfo.PropertyType) == false)
+                {
+                    IList newList;
+                    if (propertyInfo.PropertyType.IsGenericType
+                        && (propertyInfo.PropertyType.GetGenericTypeDefinition() == typeof(IEnumerable<>)
+                            || propertyInfo.PropertyType.GetGenericTypeDefinition() == typeof(ICollection<>)
+                            || propertyInfo.PropertyType.GetGenericTypeDefinition() == typeof(IList<>)))
+                    {
+                        //if it is a IEnumerable<>, IList<T> or ICollection<> we'll use a List<>
+                        var genericType = typeof(List<>).MakeGenericType(propertyInfo.PropertyType.GetGenericArguments());
+                        newList = (IList)Activator.CreateInstance(genericType);
+                    }
+                    else if (propertyInfo.PropertyType.IsArray
+                             || (propertyInfo.PropertyType.IsInterface && propertyInfo.PropertyType.IsGenericType == false))
+                    {
+                        //if its an array, we'll create a list to work with first and then convert to array later
+                        //otherwise if its just a regular derivitave of IEnumerable, we can use a list too
+                        newList = new List<object>();
+                    }
+                    else
+                    {
+                        //its a custom IEnumerable, we'll try to create it
+                        try
+                        {
+                            var custom = Activator.CreateInstance(propertyInfo.PropertyType);
+                            //if it's an IList we can work with it, otherwise we cannot
+                            newList = custom as IList;
+                            if (newList == null)
+                            {
+                                continue;
+                            }
+                        }
+                        catch (Exception)
+                        {
+                            //could not create this type so we'll skip it
+                            continue;
+                        }
+                    }
+
+                    var enumerable = (IEnumerable)propertyInfo.GetValue(input, null);
+                    if (enumerable == null) continue;
+
+                    var isUsableType = true;
+
+                    //now clone each item
+                    foreach (var o in enumerable)
+                    {
+                        //first check if the item is deep cloneable and copy that way
+                        var dc = o as IDeepCloneable;
+                        if (dc != null)
+                        {
+                            newList.Add(dc.DeepClone());
+                        }
+                        else if (o is string || o.GetType().IsValueType)
+                        {
+                            //check if the item is a value type or a string, then we can just use it                         
+                            newList.Add(o);
+                        }
+                        else
+                        {
+                            //this will occur if the item is not a string or value type or IDeepCloneable, in this case we cannot
+                            // clone each element, we'll need to skip this property, people will have to manually clone this list
+                            isUsableType = false;
+                            break;
+                        }
+                    }
+
+                    //if this was not usable, skip this property
+                    if (isUsableType == false)
+                    {
+                        continue;
+                    }
+
+                    if (propertyInfo.PropertyType.IsArray)
+                    {
+                        //need to convert to array
+                        var arr = (object[])Activator.CreateInstance(propertyInfo.PropertyType, newList.Count);
+                        for (int i = 0; i < newList.Count; i++)
+                        {
+                            arr[i] = newList[i];
+                        }
+                        //set the cloned collection
+                        propertyInfo.SetValue(output, arr, null);
+                    }
+                    else
+                    {
+                        //set the cloned collection
+                        propertyInfo.SetValue(output, newList, null);
+                    }
+
+                }
+            }
+        }
+
+    }
+}

src/Umbraco.Core/Models/DictionaryItem.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Reflection;
 using System.Runtime.Serialization;
 using Umbraco.Core.Models.EntityBase;
@@ -96,5 +97,6 @@ namespace Umbraco.Core.Models
             if(ParentId == Guid.Empty)
                 _parentId = new Guid("41c7638d-f529-4bff-853e-59a0c2fb1bde");
         }
+        
     }
 }

src/Umbraco.Core/Models/DictionaryTranslation.cs

@@ -65,5 +65,6 @@ namespace Umbraco.Core.Models
                 }, _value, ValueSelector);
             }
         }
+
     }
 }

src/Umbraco.Core/Models/EntityBase/Entity.cs

@@ -1,7 +1,10 @@
 using System;
 using System.Diagnostics;
+using System.IO;
 using System.Reflection;
 using System.Runtime.Serialization;
+using System.Runtime.Serialization.Formatters.Binary;
+using System.Text;
 
 namespace Umbraco.Core.Models.EntityBase
 {
@@ -93,7 +96,7 @@ namespace Umbraco.Core.Models.EntityBase
         }
 
         /// <summary>
-        /// /// Gets or sets the WasCancelled flag, which is used to track
+        /// Gets or sets the WasCancelled flag, which is used to track
         /// whether some action against an entity was cancelled through some event.
         /// This only exists so we have a way to check if an event was cancelled through
         /// the new api, which also needs to take effect in the legacy api.
@@ -155,6 +158,7 @@ namespace Umbraco.Core.Models.EntityBase
         /// <summary>
         /// Indicates whether the current entity has an identity, eg. Id.
         /// </summary>
+        [DataMember]
         public virtual bool HasIdentity
         {
             get
@@ -226,5 +230,62 @@ namespace Umbraco.Core.Models.EntityBase
                 _hash = !HasIdentity ? new int?(base.GetHashCode()) : new int?(Id.GetHashCode() * 397 ^ GetType().GetHashCode());
             return _hash.Value;
         }
+
+        public virtual object DeepClone()
+        {
+            //Memberwise clone on Entity will work since it doesn't have any deep elements
+            // for any sub class this will work for standard properties as well that aren't complex object's themselves.
+            var clone = (Entity)MemberwiseClone();
+            //Automatically deep clone ref properties that are IDeepCloneable
+            DeepCloneHelper.DeepCloneRefProperties(this, clone);
+            clone.ResetDirtyProperties(false);
+            return clone;
+
+            //Using data contract serializer - has issues
+
+            //var s = Serialize(this);
+            //var d = Deserialize(s, this.GetType());
+            //return d;
+
+            //Using binary serializer - has issues
+
+            //using (var memoryStream = new MemoryStream(10))
+            //{
+            //IFormatter formatter = new BinaryFormatter();
+            //formatter.Serialize(memoryStream, this);
+            //memoryStream.Seek(0, SeekOrigin.Begin);
+            //return formatter.Deserialize(memoryStream);
+            //}
+        }
+
+        // serialize/deserialize with data contracts: 
+
+        //public static string Serialize(object obj)
+        //{
+        //    using (var memoryStream = new MemoryStream())
+        //    using (var reader = new StreamReader(memoryStream))
+        //    {
+        //        var serializer = new DataContractSerializer(obj.GetType());
+        //        serializer.WriteObject(memoryStream, obj);
+        //        memoryStream.Position = 0;
+        //        return reader.ReadToEnd();
+        //    }
+        //}
+
+        //public static object Deserialize(string xml, Type toType)
+        //{
+        //    using (Stream stream = new MemoryStream())
+        //    {
+        //        using (var writer = new StreamWriter(stream, Encoding.UTF8))
+        //        {
+        //            writer.Write(xml);
+        //            //byte[] data = Encoding.UTF8.GetBytes(xml);
+        //            //stream.Write(data, 0, data.Length);
+        //            stream.Position = 0;
+        //            var deserializer = new DataContractSerializer(toType);
+        //            return deserializer.ReadObject(stream);
+        //        }
+        //    }
+        //}
     }
 }

src/Umbraco.Core/Models/EntityBase/IEntity.cs

@@ -9,7 +9,7 @@ namespace Umbraco.Core.Models.EntityBase
     /// </summary>
     /// <remarks>The current database schema doesn't provide a modified date
     /// for all entities, so this will have to be changed at a later stage.</remarks>
-    public interface IEntity
+    public interface IEntity : IDeepCloneable
     {
         /// <summary>
         /// The Id of the entity

src/Umbraco.Core/Models/EntityBase/TracksChangesEntityBase.cs

@@ -3,18 +3,21 @@ using System.Collections.Generic;
 using System.ComponentModel;
 using System.Linq;
 using System.Reflection;
+using System.Runtime.Serialization;
 
 namespace Umbraco.Core.Models.EntityBase
 {
     /// <summary>
     /// A base class for use to implement IRememberBeingDirty/ICanBeDirty
     /// </summary>
+    [Serializable]
+    [DataContract(IsReference = true)]
     public abstract class TracksChangesEntityBase : IRememberBeingDirty
     {
         /// <summary>
         /// Tracks the properties that have changed
         /// </summary>
-        private readonly IDictionary<string, bool> _propertyChangedInfo = new Dictionary<string, bool>();
+        private IDictionary<string, bool> _propertyChangedInfo = new Dictionary<string, bool>();
 
         /// <summary>
         /// Tracks the properties that we're changed before the last commit (or last call to ResetDirtyProperties)
@@ -83,7 +86,9 @@ namespace Umbraco.Core.Models.EntityBase
         /// </summary>
         public void ForgetPreviouslyDirtyProperties()
         {
-            _lastPropertyChangedInfo.Clear();
+            //NOTE: We cannot .Clear() because when we memberwise clone this will be the SAME
+            // instance as the one on the clone, so we need to create a new instance.
+            _lastPropertyChangedInfo = new Dictionary<string, bool>();
         }
 
         /// <summary>
@@ -116,7 +121,9 @@ namespace Umbraco.Core.Models.EntityBase
                 _lastPropertyChangedInfo = _propertyChangedInfo.ToDictionary(v => v.Key, v => v.Value);
             }
 
-            _propertyChangedInfo.Clear();
+            //NOTE: We cannot .Clear() because when we memberwise clone this will be the SAME
+            // instance as the one on the clone, so we need to create a new instance.
+            _propertyChangedInfo = new Dictionary<string, bool>();
         }
 
         /// <summary>

src/Umbraco.Core/Models/EntityExtensions.cs

@@ -1,7 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
+using System.Linq;
 using Umbraco.Core.Models.EntityBase;
 
 namespace Umbraco.Core.Models
@@ -23,5 +20,5 @@ namespace Umbraco.Core.Models
             var dirty = (IRememberBeingDirty)entity;
             return dirty.WasPropertyDirty("Id");
         }
-        }
-}
+    }
+}

src/Umbraco.Core/Models/File.cs

@@ -6,16 +6,6 @@ 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>
@@ -114,5 +104,18 @@ namespace Umbraco.Core.Models
         /// </summary>
         /// <returns>True if file is valid, otherwise false</returns>
         public abstract bool IsValid();
+
+        public override object DeepClone()
+        {
+            var clone = (File)base.DeepClone();
+
+            //need to manually assign since they are readonly properties
+            clone._alias = Alias;
+            clone._name = Name;
+
+            clone.ResetDirtyProperties(false);
+
+            return clone;
+        }
     }
 }

src/Umbraco.Core/Models/Folder.cs

@@ -0,0 +1,14 @@
+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; }
+    }
+}

src/Umbraco.Core/Models/IContent.cs

@@ -72,5 +72,11 @@ namespace Umbraco.Core.Models
         /// Changes the Published state of the content object
         /// </summary>
         void ChangePublishedState(PublishedState state);
+
+        /// <summary>
+        /// Creates a deep clone of the current entity with its identity/alias and it's property identities reset
+        /// </summary>
+        /// <returns></returns>
+        IContent DeepCloneWithResetIdentities();
     }
 }

src/Umbraco.Core/Models/IContentType.cs

@@ -29,5 +29,12 @@ namespace Umbraco.Core.Models
         /// <param name="template"><see cref="ITemplate"/> to remove</param>
         /// <returns>True if template was removed, otherwise False</returns>
         bool RemoveTemplate(ITemplate template);
+
+        /// <summary>
+        /// Creates a deep clone of the current entity with its identity/alias and it's property identities reset
+        /// </summary>
+        /// <param name="newAlias"></param>
+        /// <returns></returns>
+        IContentType DeepCloneWithResetIdentities(string newAlias);
     }
 }

src/Umbraco.Core/Models/IDeepCloneable.cs

@@ -0,0 +1,9 @@
+using System.Reflection;
+
+namespace Umbraco.Core.Models
+{
+    public interface IDeepCloneable
+    {
+        object DeepClone();
+    }
+}

src/Umbraco.Core/Models/IPublishedContent.cs

@@ -107,7 +107,7 @@ namespace Umbraco.Core.Models
         /// <para>The properties collection of an IPublishedContent instance should be read-only ie it is illegal
         /// to add properties to the collection.</para>
         /// </remarks>
-		ICollection<IPublishedProperty> Properties { get; }
+		ICollection<IPublishedContentProperty> Properties { get; }
 
         /// <summary>
         /// Gets a property identified by its alias.
@@ -119,7 +119,7 @@ namespace Umbraco.Core.Models
         /// <para>otherwise return a property -- that may have no value (ie <c>HasValue</c> is <c>false</c>).</para>
         /// <para>The alias is case-insensitive.</para>
         /// </remarks>
-        IPublishedProperty GetProperty(string alias);
+        IPublishedContentProperty GetProperty(string alias);
 
         /// <summary>
         /// Gets a property identified by its alias.
@@ -133,7 +133,7 @@ namespace Umbraco.Core.Models
         /// return the first property that was found with the alias but had no value (ie <c>HasValue</c> is <c>false</c>).</para>
         /// <para>The alias is case-insensitive.</para>
         /// </remarks>
-        IPublishedProperty GetProperty(string alias, bool recurse);
+        IPublishedContentProperty GetProperty(string alias, bool recurse);
 
         /// <summary>
 		/// Gets the value of a property identified by its alias.

src/Umbraco.Core/Models/IPublishedContentProperty.cs

@@ -1,9 +1,11 @@
+using System;
+
 namespace Umbraco.Core.Models
 {
     /// <summary>
     /// Represents a property of an <c>IPublishedContent</c>.
     /// </summary>
-	public interface IPublishedProperty
+	public interface IPublishedContentProperty
 	{
         /// <summary>
         /// Gets the alias of the property.
@@ -56,5 +58,8 @@ namespace Umbraco.Core.Models
         /// <para>It has been fully prepared and processed by the appropriate converter.</para>
         /// </remarks>
         object XPathValue { get; }
+
+        string Alias { get; }
+        Guid Version { get; }
 	}
 }

src/Umbraco.Core/Models/Member.cs

@@ -14,7 +14,7 @@ namespace Umbraco.Core.Models
     [DataContract(IsReference = true)]
     public class Member : ContentBase, IMember
     {
-        private readonly IMemberType _contentType;
+        private IMemberType _contentType;
         private readonly string _contentTypeAlias;
         private string _username;
         private string _email;
@@ -153,7 +153,7 @@ namespace Umbraco.Core.Models
         /// <summary>
         /// Gets or sets the raw password value
         /// </summary>
-        [DataMember]
+        [IgnoreDataMember]
         public string RawPasswordValue
         {
             get { return _rawPasswordValue; }
@@ -180,7 +180,7 @@ namespace Umbraco.Core.Models
         /// Alias: umbracoPasswordRetrievalQuestionPropertyTypeAlias
         /// Part of the standard properties collection.
         /// </remarks>
-        [IgnoreDataMember]
+        [DataMember]
         public string PasswordQuestion
         {
             get
@@ -240,7 +240,7 @@ namespace Umbraco.Core.Models
         /// Alias: umbracoCommentPropertyTypeAlias
         /// Part of the standard properties collection.
         /// </remarks>
-        [IgnoreDataMember]
+        [DataMember]
         public string Comments
         {
             get
@@ -269,7 +269,7 @@ namespace Umbraco.Core.Models
         /// Alias: umbracoApprovePropertyTypeAlias
         /// Part of the standard properties collection.
         /// </remarks>
-        [IgnoreDataMember]
+        [DataMember]
         public bool IsApproved
         {
             get
@@ -304,7 +304,7 @@ namespace Umbraco.Core.Models
         /// Alias: umbracoLockPropertyTypeAlias
         /// Part of the standard properties collection.
         /// </remarks>
-        [IgnoreDataMember]
+        [DataMember]
         public bool IsLockedOut
         {
             get
@@ -336,7 +336,7 @@ namespace Umbraco.Core.Models
         /// Alias: umbracoLastLoginPropertyTypeAlias
         /// Part of the standard properties collection.
         /// </remarks>
-        [IgnoreDataMember]
+        [DataMember]
         public DateTime LastLoginDate
         {
             get
@@ -368,7 +368,7 @@ namespace Umbraco.Core.Models
         /// Alias: umbracoMemberLastPasswordChange
         /// Part of the standard properties collection.
         /// </remarks>
-        [IgnoreDataMember]
+        [DataMember]
         public DateTime LastPasswordChangeDate
         {
             get
@@ -400,7 +400,7 @@ namespace Umbraco.Core.Models
         /// Alias: umbracoMemberLastLockout
         /// Part of the standard properties collection.
         /// </remarks>
-        [IgnoreDataMember]
+        [DataMember]
         public DateTime LastLockoutDate
         {
             get
@@ -433,7 +433,7 @@ namespace Umbraco.Core.Models
         /// Alias: umbracoFailedPasswordAttemptsPropertyTypeAlias
         /// Part of the standard properties collection.
         /// </remarks>
-        [IgnoreDataMember]
+        [DataMember]
         public int FailedPasswordAttempts
         {
             get
@@ -554,11 +554,17 @@ namespace Umbraco.Core.Models
         /* Internal experiment - only used for mapping queries. 
          * Adding these to have first level properties instead of the Properties collection.
          */
+        [IgnoreDataMember]
         internal string LongStringPropertyValue { get; set; }
+        [IgnoreDataMember]
         internal string ShortStringPropertyValue { get; set; }
+        [IgnoreDataMember]
         internal int IntegerropertyValue { get; set; }
+        [IgnoreDataMember]
         internal bool BoolPropertyValue { get; set; }
+        [IgnoreDataMember]
         internal DateTime DateTimePropertyValue { get; set; }
+        [IgnoreDataMember]
         internal string PropertyTypeAlias { get; set; }
 
         private Attempt<T> WarnIfPropertyTypeNotFoundOnGet<T>(string propertyAlias, string propertyName, T defaultVal)
@@ -628,5 +634,17 @@ namespace Umbraco.Core.Models
 
             return true;
         }
+
+        public override object DeepClone()
+        {
+            var clone = (Member)base.DeepClone();
+
+            //need to manually clone this since it's not settable
+            clone._contentType = (IMemberType)ContentType.DeepClone();
+            clone.ResetDirtyProperties(false);
+
+            return clone;
+
+        }
     }
 }

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

@@ -7,7 +7,7 @@ using System.Reflection;
 using System.Runtime.Serialization;
 using Umbraco.Core.Configuration;
 using Umbraco.Core.Models.EntityBase;
-using Umbraco.Core.Persistence.Mappers;
+
 
 namespace Umbraco.Core.Models.Membership
 {
@@ -20,7 +20,7 @@ namespace Umbraco.Core.Models.Membership
     /// </remarks>
     [Serializable]
     [DataContract(IsReference = true)]
-    public class User : TracksChangesEntityBase, IUser
+    public class User : Entity, IUser
     {
         public User(IUserType userType)
         {
@@ -57,13 +57,11 @@ namespace Umbraco.Core.Models.Membership
         }
 
         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 List<string> _addedSections;
+        private List<string> _removedSections;
+        private ObservableCollection<string> _sectionCollection;
         private int _sessionTimeout;
         private int _startContentId;
         private int _startMediaId;
@@ -81,7 +79,6 @@ namespace Umbraco.Core.Models.Membership
         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);
         
@@ -93,52 +90,8 @@ namespace Umbraco.Core.Models.Membership
         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 _hasIdentity;
-            }
-            protected set
-            {
-                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]
@@ -256,11 +209,7 @@ namespace Umbraco.Core.Models.Membership
         [IgnoreDataMember]
         public string RawPasswordAnswerValue { get; set; }
         [IgnoreDataMember]
-        public string Comments { get; set; }
-        [IgnoreDataMember]
-        public DateTime CreateDate { get; set; }
-        [IgnoreDataMember]
-        public DateTime UpdateDate { get; set; }
+        public string Comments { get; set; }        
         [IgnoreDataMember]
         public DateTime LastLoginDate { get; set; }
         [IgnoreDataMember]
@@ -295,7 +244,10 @@ namespace Umbraco.Core.Models.Membership
 
         public void RemoveAllowedSection(string sectionAlias)
         {
-            _sectionCollection.Remove(sectionAlias);
+            if (_sectionCollection.Contains(sectionAlias))
+            {
+                _sectionCollection.Remove(sectionAlias);
+            }
         }
 
         public void AddAllowedSection(string sectionAlias)
@@ -474,24 +426,41 @@ namespace Umbraco.Core.Models.Membership
 
             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());
+                var item = e.NewItems.Cast<string>().First();
 
-                //add to the added sections
-                _addedSections.Add(e.NewItems.Cast<string>().First());
+                if (_addedSections.Contains(item) == false)
+                {
+                    _addedSections.Add(item);
+                }
             }
             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());
+                var item = e.OldItems.Cast<string>().First();
+
+                if (_removedSections.Contains(item) == false)
+                {
+                    _removedSections.Add(item);    
+                }
 
-                //add to the added sections
-                _removedSections.Add(e.OldItems.Cast<string>().First());
             }
         }
 
+        public override object DeepClone()
+        {
+            var clone = (User)base.DeepClone();
+
+            //need to create new collections otherwise they'll get copied by ref
+            clone._addedSections = new List<string>();
+            clone._removedSections = new List<string>();
+            clone._sectionCollection = new ObservableCollection<string>(_sectionCollection.ToList());
+            //re-create the event handler
+            clone._sectionCollection.CollectionChanged += clone.SectionCollectionChanged;
+
+            clone.ResetDirtyProperties(false);
+
+            return clone;
+        }
+
         /// <summary>
         /// Internal class used to wrap the user in a profile
         /// </summary>
@@ -515,6 +484,24 @@ namespace Umbraco.Core.Models.Membership
                 get { return _user.Name; }
                 set { _user.Name = value; }
             }
+
+            protected bool Equals(UserProfile other)
+            {
+                return _user.Equals(other._user);
+            }
+
+            public override bool Equals(object obj)
+            {
+                if (ReferenceEquals(null, obj)) return false;
+                if (ReferenceEquals(this, obj)) return true;
+                if (obj.GetType() != this.GetType()) return false;
+                return Equals((UserProfile) obj);
+            }
+
+            public override int GetHashCode()
+            {
+                return _user.GetHashCode();
+            }
         }
     }
 }

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

@@ -1,27 +1,55 @@
 using System;
 using System.Collections.Generic;
+using System.Reflection;
 using System.Runtime.Serialization;
 using Umbraco.Core.Models.EntityBase;
 using Umbraco.Core.Persistence.Mappers;
+using Umbraco.Core.Strings;
 
 namespace Umbraco.Core.Models.Membership
 {
     /// <summary>
     /// Represents the Type for a Backoffice User
-    /// </summary>
-    /// <remarks>
-    /// Should be internal until a proper user/membership implementation
-    /// is part of the roadmap.
-    /// </remarks>
+    /// </summary>    
     [Serializable]
     [DataContract(IsReference = true)]
     internal class UserType : Entity, IUserType
     {
-        [DataMember]
-        public string Alias { get; set; }
+        private string _alias;
+        private string _name;
+        private IEnumerable<string> _permissions;
+
+        private static readonly PropertyInfo NameSelector = ExpressionHelper.GetPropertyInfo<UserType, string>(x => x.Name);
+        private static readonly PropertyInfo AliasSelector = ExpressionHelper.GetPropertyInfo<UserType, string>(x => x.Alias);
+        private static readonly PropertyInfo PermissionsSelector = ExpressionHelper.GetPropertyInfo<UserType, IEnumerable<string>>(x => x.Permissions);
 
         [DataMember]
-        public string Name { get; set; }
+        public string Alias
+        {
+            get { return _alias; }
+            set
+            {
+                SetPropertyValueAndDetectChanges(o =>
+                {
+                    _alias = value.ToCleanString(CleanStringType.Alias | CleanStringType.UmbracoCase);
+                    return _alias;
+                }, _alias, AliasSelector);
+            }
+        }
+
+        [DataMember]
+        public string Name
+        {
+            get { return _name; }
+            set
+            {
+                SetPropertyValueAndDetectChanges(o =>
+                {
+                    _name = value;
+                    return _name;
+                }, _name, NameSelector);
+            }
+        }
 
         /// <summary>
         /// The set of default permissions for the user type
@@ -30,6 +58,17 @@ namespace Umbraco.Core.Models.Membership
         /// 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 IEnumerable<string> Permissions { get; set; }
+        public IEnumerable<string> Permissions
+        {
+            get { return _permissions; }
+            set
+            {
+                SetPropertyValueAndDetectChanges(o =>
+                {
+                    _permissions = value;
+                    return _permissions;
+                }, _permissions, PermissionsSelector);
+            }
+        }
     }
 }

src/Umbraco.Core/Models/PreValue.cs

@@ -3,8 +3,15 @@
     /// <summary>
     /// Represents a stored pre-value field value
     /// </summary>
-    public class PreValue
+    public class PreValue : IDeepCloneable
     {
+        public PreValue(int id, string value, int sortOrder)
+        {
+            Id = id;
+            Value = value;       
+            SortOrder = sortOrder;
+        }
+
         public PreValue(int id, string value)
         {
             Value = value;
@@ -19,11 +26,23 @@
         /// <summary>
         /// The value stored for the pre-value field
         /// </summary>
-        public string Value { get; private set; }
+        public string Value { get; set; }
 
         /// <summary>
         /// The database id for the pre-value field value
         /// </summary>
         public int Id { get; private set; }
+
+        /// <summary>
+        /// The sort order stored for the pre-value field value
+        /// </summary>
+        public int SortOrder { get; private set; }
+
+        public virtual object DeepClone()
+        {
+            //Memberwise clone on PreValue will work since it doesn't have any deep elements
+            var clone = (PreValue)MemberwiseClone();            
+            return clone;
+        }
     }
 }

src/Umbraco.Core/Models/PreValueCollection.cs

@@ -14,7 +14,7 @@ namespace Umbraco.Core.Models
     /// 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
+    public class PreValueCollection : IDeepCloneable
     {
         private IDictionary<string, PreValue> _preValuesAsDictionary;
         private IEnumerable<PreValue> _preValuesAsArray;
@@ -82,5 +82,21 @@ namespace Umbraco.Core.Models
             }
             return result;
         }
+
+        public object DeepClone()
+        {
+            var clone = (PreValueCollection) MemberwiseClone();
+            if (_preValuesAsArray != null)
+            {
+                clone._preValuesAsArray = _preValuesAsArray.Select(x => (PreValue)x.DeepClone()).ToArray();    
+            }
+            if (_preValuesAsDictionary != null)
+            {
+                clone._preValuesAsDictionary = _preValuesAsDictionary.ToDictionary(x => x.Key, x => (PreValue)x.Value.DeepClone());    
+            }
+            
+
+            return clone;
+        }
     }
 }

src/Umbraco.Core/Models/Property.cs

@@ -13,7 +13,7 @@ namespace Umbraco.Core.Models
     [DataContract(IsReference = true)]
     public class Property : Entity
     {
-        private readonly PropertyType _propertyType;
+        private PropertyType _propertyType;
         private Guid _version;
         private object _value;
 
@@ -147,5 +147,16 @@ namespace Umbraco.Core.Models
         {
             return _propertyType.IsPropertyValueValid(value);
         }
+
+        public override object DeepClone()
+        {
+            var clone = (Property)base.DeepClone();
+
+            //need to manually assign since this is a readonly property
+            clone._propertyType = (PropertyType)PropertyType.DeepClone();
+            clone.ResetDirtyProperties(false);
+            
+            return clone;
+        }
     }
 }

src/Umbraco.Core/Models/PropertyCollection.cs

@@ -5,6 +5,7 @@ using System.Collections.Specialized;
 using System.Linq;
 using System.Runtime.Serialization;
 using System.Threading;
+using Umbraco.Core.Models.EntityBase;
 
 namespace Umbraco.Core.Models
 {
@@ -13,7 +14,7 @@ namespace Umbraco.Core.Models
     /// </summary>
     [Serializable]
     [DataContract(IsReference = true)]
-    public class PropertyCollection : KeyedCollection<string, Property>, INotifyCollectionChanged
+    public class PropertyCollection : KeyedCollection<string, Property>, INotifyCollectionChanged, IDeepCloneable
     {
         private readonly ReaderWriterLockSlim _addLocker = new ReaderWriterLockSlim();
         internal Action OnAdd;
@@ -195,5 +196,19 @@ namespace Umbraco.Core.Models
                 }
             }
         }
+
+        /// <summary>
+        /// Create a deep clone of this property collection
+        /// </summary>
+        /// <returns></returns>
+        public object DeepClone()
+        {
+            var newList = new PropertyCollection();
+            foreach (var p in this)
+            {
+                newList.Add((Property)p.DeepClone());
+            }
+            return newList;
+        }
     }
 }

src/Umbraco.Core/Models/PropertyExtensions.cs

@@ -22,42 +22,10 @@ namespace Umbraco.Core.Models
         /// <returns>Xml of the property and its value</returns>
         public static XElement ToXml(this Property property)
         {
-            return property.ToXml(ApplicationContext.Current.Services.DataTypeService);
+            var xmlSerializer = new EntityXmlSerializer();
+            return xmlSerializer.Serialize(ApplicationContext.Current.Services.DataTypeService, property);
         }
 
-        internal static XElement ToXml(this Property property, IDataTypeService dataTypeService)
-        {
-            var nodeName = UmbracoSettings.UseLegacyXmlSchema ? "data" : property.Alias.ToSafeAlias();
-
-            var xd = new XmlDocument();
-            var xmlNode = xd.CreateNode(XmlNodeType.Element, nodeName, "");
-
-            //Add the property alias to the legacy schema
-            if (UmbracoSettings.UseLegacyXmlSchema)
-            {
-                var alias = xd.CreateAttribute("alias");
-                alias.Value = property.Alias.ToSafeAlias();
-                xmlNode.Attributes.Append(alias);
-            }
-
-            //This seems to fail during testing 
-            //SD: With the new null checks below, this shouldn't fail anymore.
-            var dt = property.PropertyType.DataType(property.Id, dataTypeService);
-            if (dt != null && dt.Data != null)
-            {
-                //We've already got the value for the property so we're going to give it to the 
-                // data type's data property so it doesn't go re-look up the value from the db again.
-                var defaultData = dt.Data as IDataValueSetter;
-                if (defaultData != null)
-                {
-                    defaultData.SetValue(property.Value, property.PropertyType.DataTypeDatabaseType.ToString());
-                }
-
-                xmlNode.AppendChild(dt.Data.ToXMl(xd));
-            }
-
-            var element = xmlNode.GetXElement();
-            return element;
-        }
+        
     }
 }

src/Umbraco.Core/Models/PropertyGroup.cs

@@ -107,23 +107,6 @@ namespace Umbraco.Core.Models
             }
         }
 
-        internal PropertyGroup Clone()
-        {
-            var clone = (PropertyGroup) this.MemberwiseClone();
-            var collection = new PropertyTypeCollection();
-            foreach (var propertyType in this.PropertyTypes)
-            {
-                var property = propertyType.Clone();
-                property.ResetIdentity();
-                property.ResetDirtyProperties(false);
-                collection.Add(property);
-            }
-            clone.PropertyTypes = collection;
-            clone.ResetIdentity();
-            clone.ResetDirtyProperties(false);
-            return clone;
-        }
-
         /// <summary>
         /// Sets the ParentId from the lazy integer id
         /// </summary>
@@ -157,5 +140,6 @@ namespace Umbraco.Core.Models
             //Calculate the hash code for the product. 
             return hashName ^ hashId;
         }
+
     }
 }

src/Umbraco.Core/Models/PropertyGroupCollection.cs

@@ -5,6 +5,7 @@ using System.Collections.Specialized;
 using System.Linq;
 using System.Runtime.Serialization;
 using System.Threading;
+using Umbraco.Core.Models.EntityBase;
 
 namespace Umbraco.Core.Models
 {
@@ -13,9 +14,10 @@ namespace Umbraco.Core.Models
     /// </summary>
     [Serializable]
     [DataContract]
-    public class PropertyGroupCollection : KeyedCollection<string, PropertyGroup>, INotifyCollectionChanged
+    public class PropertyGroupCollection : KeyedCollection<string, PropertyGroup>, INotifyCollectionChanged, IDeepCloneable
     {
         private readonly ReaderWriterLockSlim _addLocker = new ReaderWriterLockSlim();
+        
         internal Action OnAdd;
 
         internal PropertyGroupCollection()
@@ -131,5 +133,15 @@ namespace Umbraco.Core.Models
                 CollectionChanged(this, args);
             }
         }
+
+        public object DeepClone()
+        {
+            var newGroup = new PropertyGroupCollection();
+            foreach (var p in this)
+            {
+                newGroup.Add((PropertyGroup)p.DeepClone());
+            }            
+            return newGroup;
+        }
     }
 }

src/Umbraco.Core/Models/PropertyType.cs

@@ -4,6 +4,7 @@ using System.Runtime.Serialization;
 using System.Text.RegularExpressions;
 using Umbraco.Core.Models.EntityBase;
 using Umbraco.Core.Persistence.Mappers;
+using Umbraco.Core.Strings;
 
 namespace Umbraco.Core.Models
 {
@@ -94,7 +95,7 @@ namespace Umbraco.Core.Models
             {
                 SetPropertyValueAndDetectChanges(o =>
                 {
-                    _alias = value;
+                    _alias = value.ToCleanString(CleanStringType.Alias | CleanStringType.UmbracoCase);
                     return _alias;
                 }, _alias, AliasSelector);
             }
@@ -388,7 +389,9 @@ namespace Umbraco.Core.Models
                 }
                 
             }
-
+            
+            //TODO: We must ensure that the property value can actually be saved based on the specified database type
+            
             //TODO Add PropertyEditor validation when its relevant to introduce
             /*if (value is IEditorModel && DataTypeControlId != Guid.Empty)
             {
@@ -402,14 +405,6 @@ namespace Umbraco.Core.Models
             return true;
         }
 
-        internal PropertyType Clone()
-        {
-            var clone = (PropertyType) this.MemberwiseClone();
-            clone.ResetIdentity();
-            clone.ResetDirtyProperties(false);
-            return clone;
-        }
-
         public bool Equals(PropertyType other)
         {
             //Check whether the compared object is null. 
@@ -433,5 +428,20 @@ namespace Umbraco.Core.Models
             //Calculate the hash code for the product. 
             return hashName ^ hashAlias;
         }
+
+        public override object DeepClone()
+        {
+            var clone = (PropertyType)base.DeepClone();
+
+            //need to manually assign the Lazy value as it will not be automatically mapped
+            if (PropertyGroupId != null)
+            {
+                clone._propertyGroupId = new Lazy<int>(() => PropertyGroupId.Value);    
+            }
+
+            clone.ResetDirtyProperties(false);
+
+            return clone;
+        }
     }
 }

src/Umbraco.Core/Models/PropertyTypeCollection.cs

@@ -5,6 +5,7 @@ using System.Collections.Specialized;
 using System.Linq;
 using System.Runtime.Serialization;
 using System.Threading;
+using Umbraco.Core.Models.EntityBase;
 
 namespace Umbraco.Core.Models
 {
@@ -13,9 +14,12 @@ namespace Umbraco.Core.Models
     /// </summary>
     [Serializable]
     [DataContract]
-    public class PropertyTypeCollection : KeyedCollection<string, PropertyType>, INotifyCollectionChanged
+    public class PropertyTypeCollection : KeyedCollection<string, PropertyType>, INotifyCollectionChanged, IDeepCloneable
     {
+        [IgnoreDataMember]
         private readonly ReaderWriterLockSlim _addLocker = new ReaderWriterLockSlim();
+
+        [IgnoreDataMember]
         internal Action OnAdd;
 
         internal PropertyTypeCollection()
@@ -131,5 +135,15 @@ namespace Umbraco.Core.Models
                 CollectionChanged(this, args);
             }
         }
+
+        public object DeepClone()
+        {
+            var newGroup = new PropertyTypeCollection();
+            foreach (var p in this)
+            {
+                newGroup.Add((PropertyType)p.DeepClone());
+            }
+            return newGroup;
+        }
     }
 }

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

@@ -14,7 +14,7 @@ namespace Umbraco.Core.Models.PublishedContent
         /// Adds a property to the extended content.
         /// </summary>
         /// <param name="property">The property to add.</param>
-        void AddProperty(IPublishedProperty property);
+        void AddProperty(IPublishedContentProperty property);
 
         /// <summary>
         /// Gets a value indicating whether properties were added to the extended content.

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

@@ -66,10 +66,10 @@ namespace Umbraco.Core.Models.PublishedContent
 
         #region IPublishedContentExtended
 
-        void IPublishedContentExtended.AddProperty(IPublishedProperty property)
+        void IPublishedContentExtended.AddProperty(IPublishedContentProperty property)
         {
             if (_properties == null)
-                _properties = new Collection<IPublishedProperty>();
+                _properties = new Collection<IPublishedContentProperty>();
             _properties.Add(property);
         }
 
@@ -113,9 +113,9 @@ namespace Umbraco.Core.Models.PublishedContent
 
         #region Properties
 
-        private ICollection<IPublishedProperty> _properties;
+        private ICollection<IPublishedContentProperty> _properties;
 
-        public override ICollection<IPublishedProperty> Properties
+        public override ICollection<IPublishedContentProperty> Properties
         {
             get
             {
@@ -138,7 +138,7 @@ namespace Umbraco.Core.Models.PublishedContent
             }
         }
 
-        public override IPublishedProperty GetProperty(string alias)
+        public override IPublishedContentProperty GetProperty(string alias)
         {
             return _properties == null
                 ? Content.GetProperty(alias)

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

@@ -183,7 +183,7 @@ namespace Umbraco.Core.Models.PublishedContent
 
         #region Properties
 
-        public virtual ICollection<IPublishedProperty> Properties
+        public virtual ICollection<IPublishedContentProperty> Properties
         {
             get { return Content.Properties; }
         }
@@ -193,12 +193,12 @@ namespace Umbraco.Core.Models.PublishedContent
             get { return Content[alias]; }
         }
 
-        public virtual IPublishedProperty GetProperty(string alias)
+        public virtual IPublishedContentProperty GetProperty(string alias)
         {
             return Content.GetProperty(alias);
         }
 
-        public virtual IPublishedProperty GetProperty(string alias, bool recurse)
+        public virtual IPublishedContentProperty GetProperty(string alias, bool recurse)
         {
             return Content.GetProperty(alias, recurse);
         }

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

@@ -6,7 +6,7 @@ namespace Umbraco.Core.Models.PublishedContent
     /// Provides a base class for <c>IPublishedProperty</c> implementations which converts and caches
     /// the value source to the actual value to use when rendering content.
     /// </summary>
-    internal abstract class PublishedPropertyBase : IPublishedProperty
+    internal abstract class PublishedPropertyBase : IPublishedContentProperty
     {
         public readonly PublishedPropertyType PropertyType;
 
@@ -27,5 +27,8 @@ namespace Umbraco.Core.Models.PublishedContent
         public abstract object DataValue { get; }
         public abstract object Value { get; }
         public abstract object XPathValue { get; }
+
+        public string Alias { get { return PropertyTypeAlias; } }
+        public Guid Version { get { return Guid.Empty; } }
     }
 }

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

@@ -10,7 +10,7 @@ using Umbraco.Core.PropertyEditors;
 namespace Umbraco.Core.Models.PublishedContent
 {
     /// <summary>
-    /// Represents an <see cref="IPublishedProperty"/> type.
+    /// Represents an <see cref="IPublishedContentProperty"/> type.
     /// </summary>
     /// <remarks>Instances of the <see cref="PublishedPropertyType"/> class are immutable, ie
     /// if the property type changes, then a new class needs to be created.</remarks>

src/Umbraco.Core/Models/Relation.cs

@@ -107,5 +107,6 @@ namespace Umbraco.Core.Models
         {
             get { return _relationType.Id; }
         }
+
     }
 }

src/Umbraco.Core/Models/RelationType.cs

@@ -127,5 +127,6 @@ namespace Umbraco.Core.Models
                 }, _childObjectType, ChildObjectTypeSelector);
             }
         }
+
     }
 }

src/Umbraco.Core/Models/ServerRegistration.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Globalization;
 using System.Reflection;
 using Umbraco.Core.Models.EntityBase;
 using Umbraco.Core.Persistence.Mappers;
@@ -34,7 +35,7 @@ namespace Umbraco.Core.Models
         {
             UpdateDate = updateDate;
             CreateDate = createDate;
-            Key = Id.ToString().EncodeAsGuid();
+            Key = Id.ToString(CultureInfo.InvariantCulture).EncodeAsGuid();
             Id = id;
             ServerAddress = serverAddress;
             ComputerName = computerName;
@@ -51,7 +52,7 @@ namespace Umbraco.Core.Models
         {
             CreateDate = createDate;
             UpdateDate = createDate;
-            Key = 0.ToString().EncodeAsGuid();
+            Key = 0.ToString(CultureInfo.InvariantCulture).EncodeAsGuid();
             ServerAddress = serverAddress;
             ComputerName = computerName;
         }

src/Umbraco.Core/Models/Task.cs

@@ -132,5 +132,6 @@ namespace Umbraco.Core.Models
                 }, _comment, CommentSelector);    
             }
         }
+
     }
 }

src/Umbraco.Core/Models/Template.cs

@@ -4,6 +4,8 @@ using System.Reflection;
 using System.Runtime.Serialization;
 using Umbraco.Core.Configuration;
 using Umbraco.Core.IO;
+using Umbraco.Core.Models.EntityBase;
+using Umbraco.Core.Strings;
 
 namespace Umbraco.Core.Models
 {
@@ -14,20 +16,18 @@ namespace Umbraco.Core.Models
     [DataContract(IsReference = true)]
     public class Template : File, ITemplate
     {
-        private readonly string _alias;
-        private readonly string _name;
+        private string _alias;
+        private string _name;
         private int _creatorId;
         private int _level;
         private int _sortOrder;
         private int _parentId;
-        private int _masterTemplateId;
         private string _masterTemplateAlias;
 
         private static readonly PropertyInfo CreatorIdSelector = ExpressionHelper.GetPropertyInfo<Template, int>(x => x.CreatorId);
         private static readonly PropertyInfo LevelSelector = ExpressionHelper.GetPropertyInfo<Template, int>(x => x.Level);
         private static readonly PropertyInfo SortOrderSelector = ExpressionHelper.GetPropertyInfo<Template, int>(x => x.SortOrder);
         private static readonly PropertyInfo ParentIdSelector = ExpressionHelper.GetPropertyInfo<Template, int>(x => x.ParentId);
-        //private static readonly PropertyInfo MasterTemplateIdSelector = ExpressionHelper.GetPropertyInfo<Template, int>(x => x.MasterTemplateId);
         private static readonly PropertyInfo MasterTemplateAliasSelector = ExpressionHelper.GetPropertyInfo<Template, string>(x => x.MasterTemplateAlias);
         
 
@@ -43,8 +43,8 @@ namespace Umbraco.Core.Models
         {
             base.Path = path;
             ParentId = -1;
-            _name = name.Replace("/", ".").Replace("\\", "");
-            _alias = alias.ToSafeAlias();
+            _name = name; //.Replace("/", ".").Replace("\\", ""); // why? that's just the name!
+            _alias = alias.ToCleanString(CleanStringType.UnderscoreAlias);
         }
 
         [DataMember]
@@ -197,5 +197,18 @@ namespace Umbraco.Core.Models
         {
             MasterTemplateId = new Lazy<int>(() => masterTemplate.Id);
         }
+
+        public override object DeepClone()
+        {
+            var clone = (Template)base.DeepClone();
+
+            //need to manually assign since they are readonly properties
+            clone._alias = Alias;
+            clone._name = Name;
+
+            clone.ResetDirtyProperties(false);
+
+            return clone;
+        }
     }
 }

src/Umbraco.Core/Models/UmbracoEntity.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Globalization;
+using System.Linq;
 using System.Reflection;
 using Umbraco.Core.Models.EntityBase;
 
@@ -46,11 +47,13 @@ namespace Umbraco.Core.Models
         public UmbracoEntity()
         {
             AdditionalData = new Dictionary<string, object>();
+            UmbracoProperties = new List<UmbracoProperty>();
         }
 
         public UmbracoEntity(bool trashed)
         {
             AdditionalData = new Dictionary<string, object>();
+            UmbracoProperties = new List<UmbracoProperty>();
             Trashed = trashed;
         }
 
@@ -58,6 +61,7 @@ namespace Umbraco.Core.Models
         public UmbracoEntity(UInt64 trashed)
         {
             AdditionalData = new Dictionary<string, object>();
+            UmbracoProperties = new List<UmbracoProperty>();
             Trashed = trashed == 1;
         }
 
@@ -287,11 +291,39 @@ namespace Umbraco.Core.Models
         /// Some entities may expose additional data that other's might not, this custom data will be available in this collection
         /// </summary>
         public IList<UmbracoProperty> UmbracoProperties { get; set; }
-
-        internal class UmbracoProperty
+        
+        internal class UmbracoProperty : IDeepCloneable
         {
             public Guid DataTypeControlId { get; set; }
             public string Value { get; set; }
+            public object DeepClone()
+            {
+                //Memberwise clone on Entity will work since it doesn't have any deep elements
+                // for any sub class this will work for standard properties as well that aren't complex object's themselves.
+                var clone = MemberwiseClone();
+                return clone;
+            }
+
+            protected bool Equals(UmbracoProperty other)
+            {
+                return DataTypeControlId.Equals(other.DataTypeControlId) && string.Equals(Value, other.Value);
+            }
+
+            public override bool Equals(object obj)
+            {
+                if (ReferenceEquals(null, obj)) return false;
+                if (ReferenceEquals(this, obj)) return true;
+                if (obj.GetType() != this.GetType()) return false;
+                return Equals((UmbracoProperty) obj);
+            }
+
+            public override int GetHashCode()
+            {
+                unchecked
+                {
+                    return (DataTypeControlId.GetHashCode()*397) ^ (Value != null ? Value.GetHashCode() : 0);
+                }
+            }
         }
     }
 }

src/Umbraco.Core/MonitorLock.cs

@@ -0,0 +1,32 @@
+using System;
+
+namespace Umbraco.Core
+{
+    /// <summary>
+    /// Provides an equivalent to the c# lock statement, to be used in a using block.
+    /// </summary>
+    /// <remarks>Ie replace <c>lock (o) {...}</c> by <c>using (new MonitorLock(o)) { ... }</c></remarks>
+    public class MonitorLock : IDisposable
+    {
+        private readonly object _locker;
+        private readonly bool _entered;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MonitorLock"/> class with an object to lock.
+        /// </summary>
+        /// <param name="locker">The object to lock.</param>
+        /// <remarks>Should always be used within a using block.</remarks>
+        public MonitorLock(object locker)
+        {
+            _locker = locker;
+            _entered = false;
+            System.Threading.Monitor.Enter(_locker, ref _entered);
+        }
+
+        void IDisposable.Dispose()
+        {
+            if (_entered)
+                System.Threading.Monitor.Exit(_locker);
+        }
+    }
+}

src/Umbraco.Core/ObjectResolution/LazyManyObjectsResolverbase.cs

@@ -49,6 +49,7 @@ namespace Umbraco.Core.ObjectResolution
         /// Initializes a new instance of the <see cref="LazyManyObjectsResolverBase{TResolver, TResolved}"/> class with an initial list
         /// <remarks>If <paramref name="scope"/> is per HttpRequest then there must be a current HttpContext.</remarks>
         /// <exception cref="InvalidOperationException"><paramref name="scope"/> is per HttpRequest but the current HttpContext is null.</exception>
+        /// </summary>
         protected LazyManyObjectsResolverBase(IEnumerable<Lazy<Type>> lazyTypeList, ObjectLifetimeScope scope = ObjectLifetimeScope.Application)
 			: this(scope)
 		{			
@@ -108,7 +109,7 @@ namespace Umbraco.Core.ObjectResolution
 		/// Gets a value indicating whether the resolver has resolved types to create instances from.
 		/// </summary>
         /// <remarks>To be used in unit tests.</remarks>
-		internal bool HasResolvedTypes
+		public bool HasResolvedTypes
 		{
 			get
             {

src/Umbraco.Core/ObjectResolution/Resolution.cs

@@ -63,6 +63,11 @@ namespace Umbraco.Core.ObjectResolution
 			}
 		}
 
+        // NOTE - the ugly code below exists only because of umbraco.BusinessLogic.Actions.Action.ReRegisterActionsAndHandlers
+        // which wants to re-register actions and handlers instead of properly restarting the application. Don't even think
+        // about using it for anything else. Also, while the backdoor is open, the resolution system is locked so nothing
+        // can work properly => deadlocks. Therefore, open the backdoor, do resolution changes EXCLUSIVELY, and close the door!
+
         /// <summary>
         /// Returns a disposable object that reprents dirty access to temporarily unfrozen resolution configuration.
         /// </summary>

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

@@ -37,7 +37,10 @@ namespace Umbraco.Core.Persistence.Caching
             var containsKey = _cache.ContainsKey(compositeKey);
             if (containsKey)
             {
-                return _cache[compositeKey];
+                var result = _cache[compositeKey];
+
+                //IMPORTANT: we must clone to resolve, see: http://issues.umbraco.org/issue/U4-4259
+                return (IEntity)result.DeepClone();
             }
 
             return null;
@@ -56,7 +59,12 @@ namespace Umbraco.Core.Persistence.Caching
                             into key
                             let containsKey = _cache.ContainsKey(key)
                             where containsKey
-                            select _cache[key]).ToList();
+                            select _cache[key]
+                            into result 
+                            //don't return null objects
+                            where result != null
+                            //IMPORTANT: we must clone to resolve, see: http://issues.umbraco.org/issue/U4-4259
+                            select (IEntity)result.DeepClone()).ToList();
             return list;
         }
 
@@ -67,7 +75,14 @@ namespace Umbraco.Core.Persistence.Caching
         /// <returns></returns>
         public IEnumerable<IEntity> GetAllByType(Type type)
         {
-            var list = _cache.Keys.Where(key => key.Contains(type.Name)).Select(key => _cache[key]).ToList();
+            var list = _cache.Keys
+                .Where(key => key.Contains(type.Name))
+                .Select(key => _cache[key])
+                //don't return null objects
+                .Where(result => result != null)
+                //IMPORTANT: we must clone to resolve, see: http://issues.umbraco.org/issue/U4-4259
+                .Select(result => (IEntity)result.DeepClone())
+                .ToList();
             return list;
         }
 
@@ -78,6 +93,9 @@ namespace Umbraco.Core.Persistence.Caching
         /// <param name="entity"></param>
         public void Save(Type type, IEntity entity)
         {
+            //IMPORTANT: we must clone to store, see: http://issues.umbraco.org/issue/U4-4259
+            entity = (IEntity)entity.DeepClone();
+
             _cache.AddOrUpdate(GetCompositeId(type, entity.Id), entity, (x, y) => entity);
         }
 

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

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
@@ -29,6 +29,9 @@ namespace Umbraco.Core.Persistence.Caching
     /// when there are async requests being made even in the context of a web request, the HttpContext.Current will be null but the HttpRuntime.Cache will
     /// always be available.
     /// 
+    /// TODO: Each item that get's added to this cache will be a clone of the original with it's dirty properties reset, and every item that is resolved from the cache
+    /// is a clone of the item that is in there, otherwise we end up with thread safety issues since multiple thread would be working on the exact same entity at the same time.
+    /// 
     /// </remarks>
     internal sealed class RuntimeCacheProvider : IRepositoryCacheProvider
     {
@@ -64,8 +67,11 @@ namespace Umbraco.Core.Persistence.Caching
             {
                 //ensure the key doesn't exist anymore in the tracker
                 _keyTracker.Remove(key);
+                return null;
             }
-            return result;
+
+            //IMPORTANT: we must clone to resolve, see: http://issues.umbraco.org/issue/U4-4259
+            return (IEntity)result.DeepClone();
         }
 
         public IEnumerable<IEntity> GetByIds(Type type, List<Guid> ids)
@@ -85,7 +91,8 @@ namespace Umbraco.Core.Persistence.Caching
                 }
                 else
                 {
-                    collection.Add(result);
+                    //IMPORTANT: we must clone to resolve, see: http://issues.umbraco.org/issue/U4-4259
+                    collection.Add((IEntity)result.DeepClone());
                 }
             }
             return collection;
@@ -110,7 +117,8 @@ namespace Umbraco.Core.Persistence.Caching
                     }
                     else
                     {
-                        collection.Add(result);
+                        //IMPORTANT: we must clone to resolve, see: http://issues.umbraco.org/issue/U4-4259
+                        collection.Add((IEntity)result.DeepClone());
                     }
                 }
             }
@@ -119,7 +127,10 @@ namespace Umbraco.Core.Persistence.Caching
 
         public void Save(Type type, IEntity entity)
         {
-            var key = GetCompositeId(type, entity.Id);
+            //IMPORTANT: we must clone to store, see: http://issues.umbraco.org/issue/U4-4259
+            var clone = (IEntity)entity.DeepClone();
+
+            var key = GetCompositeId(type, clone.Id);
             
             _keyTracker.TryAdd(key);
 
@@ -128,11 +139,11 @@ namespace Umbraco.Core.Persistence.Caching
 
             if (_memoryCache != null)
             {
-                _memoryCache.Set(key, entity, new CacheItemPolicy { SlidingExpiration = TimeSpan.FromMinutes(5) });
+                _memoryCache.Set(key, clone, new CacheItemPolicy { SlidingExpiration = TimeSpan.FromMinutes(5) });
             }
             else
             {
-                HttpRuntime.Cache.Insert(key, entity, null, System.Web.Caching.Cache.NoAbsoluteExpiration, TimeSpan.FromMinutes(5));
+                HttpRuntime.Cache.Insert(key, clone, null, System.Web.Caching.Cache.NoAbsoluteExpiration, TimeSpan.FromMinutes(5));
             }
         }
 

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

@@ -29,7 +29,7 @@ namespace Umbraco.Core.Persistence.Factories
                     ComputerName = entity.ComputerName
                 };
             if (entity.HasIdentity)
-                dto.Id = short.Parse(entity.Id.ToString(CultureInfo.InvariantCulture));
+                dto.Id = int.Parse(entity.Id.ToString(CultureInfo.InvariantCulture));
 
             return dto;
         }

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

@@ -99,11 +99,13 @@ namespace Umbraco.Core.Persistence.Factories
                 foreach (var propertyDto in dto.UmbracoPropertyDtos)
                 {
                     entity.UmbracoProperties.Add(new UmbracoEntity.UmbracoProperty
-                                                      {
-                                                          DataTypeControlId =
-                                                              propertyDto.DataTypeControlId,
-                                                          Value = propertyDto.UmbracoFile
-                                                      });
+                    {
+                        DataTypeControlId =
+                            propertyDto.DataTypeControlId,
+                        Value = propertyDto.NTextValue.IsNullOrWhiteSpace()
+                            ? propertyDto.NVarcharValue
+                            : propertyDto.NTextValue
+                    });
                 }
             }
 

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

@@ -74,7 +74,7 @@ namespace Umbraco.Core.Persistence.Factories
                     {
                         AppAlias = app
                     };
-                if (entity.Id != null)
+                if (entity.HasIdentity)
                 {
                     appDto.UserId = (int) entity.Id;
                 }

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

@@ -176,6 +176,8 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
                 .Where(x => x.IsNullOrWhiteSpace() == false).ToList();
 
             //Add valid and invalid foreign key differences to the result object
+            // We'll need to do invariant contains with case insensitivity because foreign key, primary key, and even index naming w/ MySQL is not standardized
+            // In theory you could have: FK_ or fk_ ...or really any standard that your development department (or developer) chooses to use.
             foreach (var unknown in unknownConstraintsInDatabase)
             {
                 if (foreignKeysInSchema.InvariantContains(unknown) || primaryKeysInSchema.InvariantContains(unknown) || indexesInSchema.InvariantContains(unknown))

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

@@ -65,7 +65,7 @@ namespace Umbraco.Core.Persistence.Migrations.Initial
                     return new Version(4, 7, 0);
                 }
 
-                return new Version(4, 9, 0);
+                return new Version(4, 8, 0);
             }
 
             //if the error is for umbracoServer

src/Umbraco.Core/Persistence/Migrations/MigrationAttribute.cs

@@ -16,8 +16,21 @@ namespace Umbraco.Core.Persistence.Migrations
             ProductName = product;
         }
 
+        public MigrationAttribute(string minimumCurrentVersion, string targetVersion, int sortOrder, string product)
+        {
+            TargetVersion = new Version(targetVersion);
+            MinimumCurrentVersion = new Version(minimumCurrentVersion);
+            SortOrder = sortOrder;
+            ProductName = product;
+        }
+
         /// <summary>
-        /// Gets or sets the target version of this migration.
+        /// Gets the minimum current version for which this migration is allowed to execute
+        /// </summary>
+        public Version MinimumCurrentVersion { get; private set; }
+
+        /// <summary>
+        /// Gets the target version of this migration.
         /// </summary>
         public Version TargetVersion { get; private set; }
 

src/Umbraco.Core/Persistence/Migrations/MigrationRunner.cs

@@ -13,13 +13,13 @@ namespace Umbraco.Core.Persistence.Migrations
     /// </summary>
     public class MigrationRunner
     {
-        private readonly Version _configuredVersion;
+        private readonly Version _currentVersion;
         private readonly Version _targetVersion;
         private readonly string _productName;
 
-        public MigrationRunner(Version configuredVersion, Version targetVersion, string productName)
+        public MigrationRunner(Version currentVersion, Version targetVersion, string productName)
         {
-            _configuredVersion = configuredVersion;
+            _currentVersion = currentVersion;
             _targetVersion = targetVersion;
             _productName = productName;
         }
@@ -46,20 +46,20 @@ namespace Umbraco.Core.Persistence.Migrations
         {
             LogHelper.Info<MigrationRunner>("Initializing database migrations");
 
-	        var foundMigrations = MigrationResolver.Current.Migrations.ToArray();
+            var foundMigrations = MigrationResolver.Current.Migrations.ToArray();
 
             //filter all non-schema migrations
             var migrations = isUpgrade
                                  ? OrderedUpgradeMigrations(foundMigrations).ToList()
                                  : OrderedDowngradeMigrations(foundMigrations).ToList();
-            
+
             //SD: Why do we want this?
-            if (Migrating.IsRaisedEventCancelled(new MigrationEventArgs(migrations, _configuredVersion, _targetVersion, true), this))
+            if (Migrating.IsRaisedEventCancelled(new MigrationEventArgs(migrations, _currentVersion, _targetVersion, true), this))
                 return false;
 
             //Loop through migrations to generate sql
             var migrationContext = InitializeMigrations(migrations, database, databaseProvider, isUpgrade);
-            
+
             try
             {
                 ExecuteMigrations(migrationContext, database);
@@ -81,13 +81,13 @@ namespace Umbraco.Core.Persistence.Migrations
                 throw;
             }
 
-            Migrated.RaiseEvent(new MigrationEventArgs(migrations, migrationContext, _configuredVersion, _targetVersion, false), this);
+            Migrated.RaiseEvent(new MigrationEventArgs(migrations, migrationContext, _currentVersion, _targetVersion, false), this);
 
             return true;
         }
 
-	    private void ExecuteMigrations(IMigrationContext context, Database database)
-	    {
+        private void ExecuteMigrations(IMigrationContext context, Database database)
+        {
             //Transactional execution of the sql that was generated from the found migrations
             using (var transaction = database.GetTransaction())
             {
@@ -108,13 +108,13 @@ namespace Umbraco.Core.Persistence.Migrations
 
                 transaction.Complete();
             }
-	    }
+        }
 
         internal MigrationContext InitializeMigrations(List<IMigration> migrations, Database database, DatabaseProviders databaseProvider, bool isUpgrade = true)
-	    {
+        {
             //Loop through migrations to generate sql
             var context = new MigrationContext(databaseProvider, database);
-            
+
             foreach (var migration in migrations)
             {
                 var baseMigration = migration as MigrationBase;
@@ -148,35 +148,49 @@ namespace Umbraco.Core.Persistence.Migrations
             }
 
             return context;
-	    }
+        }
 
+        /// <summary>
+        /// Filters and orders migrations based on the migrations listed and the currently configured version and the target installation version
+        /// </summary>
+        /// <param name="foundMigrations"></param>
+        /// <returns></returns>
         internal IEnumerable<IMigration> OrderedUpgradeMigrations(IEnumerable<IMigration> foundMigrations)
         {
             var migrations = (from migration in foundMigrations
-                let migrationAttributes = migration.GetType().GetCustomAttributes<MigrationAttribute>(false)                   
-                from migrationAttribute in migrationAttributes
-                where migrationAttribute != null
-                where
-                    migrationAttribute.TargetVersion > _configuredVersion &&
-                    migrationAttribute.TargetVersion <= _targetVersion &&
-                    migrationAttribute.ProductName == _productName
-                orderby migrationAttribute.TargetVersion, migrationAttribute.SortOrder ascending
-                select migration).Distinct();
+                              let migrationAttributes = migration.GetType().GetCustomAttributes<MigrationAttribute>(false)
+                              from migrationAttribute in migrationAttributes
+                              where migrationAttribute != null
+                              where
+                                  migrationAttribute.TargetVersion > _currentVersion &&
+                                  migrationAttribute.TargetVersion <= _targetVersion &&
+                                  migrationAttribute.ProductName == _productName &&
+                                  //filter if the migration specifies a minimum current version for which to execute
+                                  (migrationAttribute.MinimumCurrentVersion == null || _currentVersion >= migrationAttribute.MinimumCurrentVersion)
+                              orderby migrationAttribute.TargetVersion, migrationAttribute.SortOrder ascending
+                              select migration).Distinct();
             return migrations;
         }
 
+        /// <summary>
+        /// Filters and orders migrations based on the migrations listed and the currently configured version and the target installation version
+        /// </summary>
+        /// <param name="foundMigrations"></param>
+        /// <returns></returns>
         public IEnumerable<IMigration> OrderedDowngradeMigrations(IEnumerable<IMigration> foundMigrations)
         {
             var migrations = (from migration in foundMigrations
-                let migrationAttributes = migration.GetType().GetCustomAttributes<MigrationAttribute>(false)
-                from migrationAttribute in migrationAttributes
-                where migrationAttribute != null
-                where
-                    migrationAttribute.TargetVersion > _configuredVersion &&
-                    migrationAttribute.TargetVersion <= _targetVersion &&
-                    migrationAttribute.ProductName == _productName
-                orderby migrationAttribute.TargetVersion, migrationAttribute.SortOrder descending
-                select migration).Distinct();
+                              let migrationAttributes = migration.GetType().GetCustomAttributes<MigrationAttribute>(false)
+                              from migrationAttribute in migrationAttributes
+                              where migrationAttribute != null
+                              where
+                                  migrationAttribute.TargetVersion > _currentVersion &&
+                                  migrationAttribute.TargetVersion <= _targetVersion &&
+                                  migrationAttribute.ProductName == _productName &&
+                                  //filter if the migration specifies a minimum current version for which to execute
+                                  (migrationAttribute.MinimumCurrentVersion == null || _currentVersion >= migrationAttribute.MinimumCurrentVersion)
+                              orderby migrationAttribute.TargetVersion, migrationAttribute.SortOrder descending
+                              select migration).Distinct();
             return migrations;
         }
 

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionFourNineZero/RemoveUmbracoAppConstraints.cs

@@ -1,5 +1,7 @@
 using System.Data;
+using System.Linq;
 using Umbraco.Core.Configuration;
+using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionFourNineZero
 {
@@ -18,9 +20,18 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionFourNineZero
             }
             else
             {
-                //These are the old aliases
-                Delete.ForeignKey("FK_umbracoUser2app_umbracoApp").OnTable("umbracoUser2app");
-                Delete.ForeignKey("FK_umbracoUser2app_umbracoUser").OnTable("umbracoUser2app");
+                //These are the old aliases, before removing them, check they exist
+                var constraints = SqlSyntaxContext.SqlSyntaxProvider.GetConstraintsPerColumn(Context.Database).Distinct().ToArray();
+
+                if (constraints.Any(x => x.Item1.InvariantEquals("umbracoUser2app") && x.Item3.InvariantEquals("FK_umbracoUser2app_umbracoApp")))
+                {
+                    Delete.ForeignKey("FK_umbracoUser2app_umbracoApp").OnTable("umbracoUser2app");    
+                }
+                if (constraints.Any(x => x.Item1.InvariantEquals("umbracoUser2app") && x.Item3.InvariantEquals("FK_umbracoUser2app_umbracoUser")))
+                {
+                    Delete.ForeignKey("FK_umbracoUser2app_umbracoUser").OnTable("umbracoUser2app");
+                }
+                
             }
             
         }

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

@@ -5,6 +5,7 @@ using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSixTwoZero
 {
+    
     //see: http://issues.umbraco.org/issue/U4-4430
     [Migration("6.2.0", 0, GlobalSettings.UmbracoMigrationName)]
     public class AssignMissingPrimaryForMySqlKeys : MigrationBase
@@ -14,15 +15,7 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSixTwoZero
             if (Context.CurrentDatabaseProvider == DatabaseProviders.MySql)
             {
                 var constraints = SqlSyntaxContext.SqlSyntaxProvider.GetConstraintsPerColumn(Context.Database).Distinct().ToArray();
-
-                //This should be 2 because this table has 2 keys
-                if (constraints.Count(x => x.Item1.InvariantEquals("cmsContentType2ContentType") && x.Item3.InvariantEquals("PRIMARY")) == 0)
-                {
-                    Create.PrimaryKey("PK_cmsContentType2ContentType")
-                        .OnTable("cmsContentType2ContentType")
-                        .Columns(new[] {"parentContentTypeId", "childContentTypeId"});
-                }
-
+                
                 //This should be 2 because this table has 2 keys
                 if (constraints.Count(x => x.Item1.InvariantEquals("cmsContentTypeAllowedContentType") && x.Item3.InvariantEquals("PRIMARY")) == 0)
                 {

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

@@ -0,0 +1,34 @@
+using System.Linq;
+using Umbraco.Core.Configuration;
+using Umbraco.Core.Persistence.SqlSyntax;
+
+namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSixTwoZero
+{    
+    //We have to target this specifically to ensure this DOES NOT execute if upgrading from a version previous to 6.0,
+    // this is because when the 6.0.0 migrations are executed, this primary key get's created so if this migration is also executed
+    // we will get exceptions because it is trying to create the PK two times.
+    [Migration("6.0.0", "6.2.0", 0, GlobalSettings.UmbracoMigrationName)]
+    public class AssignMissingPrimaryForMySqlKeys2 : MigrationBase
+    {
+        public override void Up()
+        {
+            if (Context.CurrentDatabaseProvider == DatabaseProviders.MySql)
+            {
+                var constraints = SqlSyntaxContext.SqlSyntaxProvider.GetConstraintsPerColumn(Context.Database).Distinct().ToArray();
+
+                //This should be 2 because this table has 2 keys
+                if (constraints.Count(x => x.Item1.InvariantEquals("cmsContentType2ContentType") && x.Item3.InvariantEquals("PRIMARY")) == 0)
+                {
+                    Create.PrimaryKey("PK_cmsContentType2ContentType")
+                        .OnTable("cmsContentType2ContentType")
+                        .Columns(new[] {"parentContentTypeId", "childContentTypeId"});
+                }
+            }
+        }
+
+        public override void Down()
+        {
+            //don't do anything, these keys should have always existed!
+        }
+    }
+}

src/Umbraco.Core/Persistence/PetaPoco.cs

@@ -13,6 +13,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.Caching;
 using System.Security;
 using System.Security.Permissions;
 using System.Text;
@@ -1709,8 +1710,32 @@ namespace Umbraco.Core.Persistence
 			}
 			public override object ChangeType(object val) { return val; }
 		}
-		public class PocoData
-		{
+
+        /// <summary>
+        /// Container for a Memory cache object
+        /// </summary>
+        /// <remarks>
+        /// Better to have one memory cache instance than many so it's memory management can be handled more effectively
+        /// http://stackoverflow.com/questions/8463962/using-multiple-instances-of-memorycache
+        /// </remarks>
+        internal class ManagedCache
+        {
+            public ObjectCache GetCache()
+            {
+                return ObjectCache;
+            }
+
+            static readonly ObjectCache ObjectCache = new MemoryCache("NPoco");
+            
+        }
+
+        public class PocoData
+        {
+            //USE ONLY FOR TESTING
+            internal static bool UseLongKeys = false;
+            //USE ONLY FOR TESTING - default is one hr
+            internal static int SlidingExpirationSeconds = 3600;
+            
 			public static PocoData ForObject(object o, string primaryKeyName)
 			{
 				var t = o.GetType();
@@ -1734,7 +1759,7 @@ namespace Umbraco.Core.Persistence
 #endif
 					return ForType(t);
 			}
-			static System.Threading.ReaderWriterLockSlim RWLock = new System.Threading.ReaderWriterLockSlim();
+            
 			public static PocoData ForType(Type t)
 			{
 #if !PETAPOCO_NO_DYNAMIC
@@ -1742,7 +1767,7 @@ namespace Umbraco.Core.Persistence
 					throw new InvalidOperationException("Can't use dynamic types with this method");
 #endif
 				// Check cache
-				RWLock.EnterReadLock();
+				InnerLock.EnterReadLock();
 				PocoData pd;
 				try
 				{
@@ -1751,12 +1776,12 @@ namespace Umbraco.Core.Persistence
 				}
 				finally
 				{
-					RWLock.ExitReadLock();
+					InnerLock.ExitReadLock();
 				}
 
 				
 				// Cache it
-				RWLock.EnterWriteLock();
+				InnerLock.EnterWriteLock();
 				try
 				{
 					// Check again
@@ -1770,7 +1795,7 @@ namespace Umbraco.Core.Persistence
 				}
 				finally
 				{
-					RWLock.ExitWriteLock();
+					InnerLock.ExitWriteLock();
 				}
 
 				return pd;
@@ -1851,224 +1876,237 @@ namespace Umbraco.Core.Persistence
 				return tc >= TypeCode.SByte && tc <= TypeCode.UInt64;
 			}
 
+
+
 			// Create factory function that can convert a IDataReader record into a POCO
 			public Delegate GetFactory(string sql, string connString, bool ForceDateTimesToUtc, int firstColumn, int countColumns, IDataReader r)
 			{
-				// Check cache
-				var key = string.Format("{0}:{1}:{2}:{3}:{4}", sql, connString, ForceDateTimesToUtc, firstColumn, countColumns);
-				RWLock.EnterReadLock();
-				try
-				{
-					// Have we already created it?
-					Delegate factory;
-					if (PocoFactories.TryGetValue(key, out factory))
-						return factory;
-				}
-				finally
-				{
-					RWLock.ExitReadLock();
-				}
 
-				// Take the writer lock
-				RWLock.EnterWriteLock();
+                //TODO: It would be nice to remove the irrelevant SQL parts - for a mapping operation anything after the SELECT clause isn't required. 
+                // This would ensure less duplicate entries that get cached, currently both of these queries would be cached even though they are
+                // returning the same structured data:
+                // SELECT * FROM MyTable ORDER BY MyColumn
+                // SELECT * FROM MyTable ORDER BY MyColumn DESC
 
-				try
-				{
+			    string key;
+			    if (UseLongKeys)
+			    {
+                    key = string.Format("{0}:{1}:{2}:{3}:{4}", sql, connString, ForceDateTimesToUtc, firstColumn, countColumns);
+			    }
+			    else
+			    {
+                    //Create a hashed key, we don't want to store so much string data in memory
+                    var combiner = new HashCodeCombiner();
+                    combiner.AddCaseInsensitiveString(sql);
+                    combiner.AddCaseInsensitiveString(connString);
+                    combiner.AddObject(ForceDateTimesToUtc);
+                    combiner.AddInt(firstColumn);
+                    combiner.AddInt(countColumns);
+                    key = combiner.GetCombinedHashCode();
+			    }
+                
 
-					// Check again, just in case
-					Delegate factory;
-					if (PocoFactories.TryGetValue(key, out factory))
-						return factory;
+			    var objectCache = _managedCache.GetCache();
 
-					// Create the method
-					var m = new DynamicMethod("petapoco_factory_" + PocoFactories.Count.ToString(), type, new Type[] { typeof(IDataReader) }, true);
-					var il = m.GetILGenerator();
+			    Func<Delegate> factory = () =>
+			    {
+                    // Create the method
+                    var m = new DynamicMethod("petapoco_factory_" + objectCache.GetCount(), type, new Type[] { typeof(IDataReader) }, true);
+                    var il = m.GetILGenerator();
 
 #if !PETAPOCO_NO_DYNAMIC
-					if (type == typeof(object))
-					{
-						// var poco=new T()
-						il.Emit(OpCodes.Newobj, typeof(System.Dynamic.ExpandoObject).GetConstructor(Type.EmptyTypes));			// obj
+                    if (type == typeof(object))
+                    {
+                        // var poco=new T()
+                        il.Emit(OpCodes.Newobj, typeof(System.Dynamic.ExpandoObject).GetConstructor(Type.EmptyTypes));			// obj
 
-						MethodInfo fnAdd = typeof(IDictionary<string, object>).GetMethod("Add");
+                        MethodInfo fnAdd = typeof(IDictionary<string, object>).GetMethod("Add");
 
-						// Enumerate all fields generating a set assignment for the column
-						for (int i = firstColumn; i < firstColumn + countColumns; i++)
-						{
-							var srcType = r.GetFieldType(i);
+                        // Enumerate all fields generating a set assignment for the column
+                        for (int i = firstColumn; i < firstColumn + countColumns; i++)
+                        {
+                            var srcType = r.GetFieldType(i);
 
-							il.Emit(OpCodes.Dup);						// obj, obj
-							il.Emit(OpCodes.Ldstr, r.GetName(i));		// obj, obj, fieldname
+                            il.Emit(OpCodes.Dup);						// obj, obj
+                            il.Emit(OpCodes.Ldstr, r.GetName(i));		// obj, obj, fieldname
 
-							// Get the converter
-							Func<object, object> converter = null;
-							if (Database.Mapper != null)
-								converter = Database.Mapper.GetFromDbConverter(null, srcType);
-							if (ForceDateTimesToUtc && converter == null && srcType == typeof(DateTime))
-								converter = delegate(object src) { return new DateTime(((DateTime)src).Ticks, DateTimeKind.Utc); };
+                            // Get the converter
+                            Func<object, object> converter = null;
+                            if (Database.Mapper != null)
+                                converter = Database.Mapper.GetFromDbConverter(null, srcType);
+                            if (ForceDateTimesToUtc && converter == null && srcType == typeof(DateTime))
+                                converter = delegate(object src) { return new DateTime(((DateTime)src).Ticks, DateTimeKind.Utc); };
 
-							// Setup stack for call to converter
-							AddConverterToStack(il, converter);
+                            // Setup stack for call to converter
+                            AddConverterToStack(il, converter);
 
-							// r[i]
-							il.Emit(OpCodes.Ldarg_0);					// obj, obj, fieldname, converter?,    rdr
-							il.Emit(OpCodes.Ldc_I4, i);					// obj, obj, fieldname, converter?,  rdr,i
-							il.Emit(OpCodes.Callvirt, fnGetValue);		// obj, obj, fieldname, converter?,  value
+                            // r[i]
+                            il.Emit(OpCodes.Ldarg_0);					// obj, obj, fieldname, converter?,    rdr
+                            il.Emit(OpCodes.Ldc_I4, i);					// obj, obj, fieldname, converter?,  rdr,i
+                            il.Emit(OpCodes.Callvirt, fnGetValue);		// obj, obj, fieldname, converter?,  value
 
-							// Convert DBNull to null
-							il.Emit(OpCodes.Dup);						// obj, obj, fieldname, converter?,  value, value
-							il.Emit(OpCodes.Isinst, typeof(DBNull));	// obj, obj, fieldname, converter?,  value, (value or null)
-							var lblNotNull = il.DefineLabel();
-							il.Emit(OpCodes.Brfalse_S, lblNotNull);		// obj, obj, fieldname, converter?,  value
-							il.Emit(OpCodes.Pop);						// obj, obj, fieldname, converter?
-							if (converter != null)
-								il.Emit(OpCodes.Pop);					// obj, obj, fieldname, 
-							il.Emit(OpCodes.Ldnull);					// obj, obj, fieldname, null
-							if (converter != null)
-							{
-								var lblReady = il.DefineLabel();
-								il.Emit(OpCodes.Br_S, lblReady);
-								il.MarkLabel(lblNotNull);
-								il.Emit(OpCodes.Callvirt, fnInvoke);
-								il.MarkLabel(lblReady);
-							}
-							else
-							{
-								il.MarkLabel(lblNotNull);
-							}
+                            // Convert DBNull to null
+                            il.Emit(OpCodes.Dup);						// obj, obj, fieldname, converter?,  value, value
+                            il.Emit(OpCodes.Isinst, typeof(DBNull));	// obj, obj, fieldname, converter?,  value, (value or null)
+                            var lblNotNull = il.DefineLabel();
+                            il.Emit(OpCodes.Brfalse_S, lblNotNull);		// obj, obj, fieldname, converter?,  value
+                            il.Emit(OpCodes.Pop);						// obj, obj, fieldname, converter?
+                            if (converter != null)
+                                il.Emit(OpCodes.Pop);					// obj, obj, fieldname, 
+                            il.Emit(OpCodes.Ldnull);					// obj, obj, fieldname, null
+                            if (converter != null)
+                            {
+                                var lblReady = il.DefineLabel();
+                                il.Emit(OpCodes.Br_S, lblReady);
+                                il.MarkLabel(lblNotNull);
+                                il.Emit(OpCodes.Callvirt, fnInvoke);
+                                il.MarkLabel(lblReady);
+                            }
+                            else
+                            {
+                                il.MarkLabel(lblNotNull);
+                            }
 
-							il.Emit(OpCodes.Callvirt, fnAdd);
-						}
-					}
-					else
+                            il.Emit(OpCodes.Callvirt, fnAdd);
+                        }
+                    }
+                    else
 #endif
-						if (type.IsValueType || type == typeof(string) || type == typeof(byte[]))
-						{
-							// Do we need to install a converter?
-							var srcType = r.GetFieldType(0);
-							var converter = GetConverter(ForceDateTimesToUtc, null, srcType, type);
+                        if (type.IsValueType || type == typeof(string) || type == typeof(byte[]))
+                        {
+                            // Do we need to install a converter?
+                            var srcType = r.GetFieldType(0);
+                            var converter = GetConverter(ForceDateTimesToUtc, null, srcType, type);
 
-							// "if (!rdr.IsDBNull(i))"
-							il.Emit(OpCodes.Ldarg_0);										// rdr
-							il.Emit(OpCodes.Ldc_I4_0);										// rdr,0
-							il.Emit(OpCodes.Callvirt, fnIsDBNull);							// bool
-							var lblCont = il.DefineLabel();
-							il.Emit(OpCodes.Brfalse_S, lblCont);
-							il.Emit(OpCodes.Ldnull);										// null
-							var lblFin = il.DefineLabel();
-							il.Emit(OpCodes.Br_S, lblFin);
+                            // "if (!rdr.IsDBNull(i))"
+                            il.Emit(OpCodes.Ldarg_0);										// rdr
+                            il.Emit(OpCodes.Ldc_I4_0);										// rdr,0
+                            il.Emit(OpCodes.Callvirt, fnIsDBNull);							// bool
+                            var lblCont = il.DefineLabel();
+                            il.Emit(OpCodes.Brfalse_S, lblCont);
+                            il.Emit(OpCodes.Ldnull);										// null
+                            var lblFin = il.DefineLabel();
+                            il.Emit(OpCodes.Br_S, lblFin);
 
-							il.MarkLabel(lblCont);
+                            il.MarkLabel(lblCont);
 
-							// Setup stack for call to converter
-							AddConverterToStack(il, converter);
+                            // Setup stack for call to converter
+                            AddConverterToStack(il, converter);
 
-							il.Emit(OpCodes.Ldarg_0);										// rdr
-							il.Emit(OpCodes.Ldc_I4_0);										// rdr,0
-							il.Emit(OpCodes.Callvirt, fnGetValue);							// value
+                            il.Emit(OpCodes.Ldarg_0);										// rdr
+                            il.Emit(OpCodes.Ldc_I4_0);										// rdr,0
+                            il.Emit(OpCodes.Callvirt, fnGetValue);							// value
 
-							// Call the converter
-							if (converter != null)
-								il.Emit(OpCodes.Callvirt, fnInvoke);
+                            // Call the converter
+                            if (converter != null)
+                                il.Emit(OpCodes.Callvirt, fnInvoke);
 
-							il.MarkLabel(lblFin);
-							il.Emit(OpCodes.Unbox_Any, type);								// value converted
-						}
-						else
-						{
-							// var poco=new T()
-							il.Emit(OpCodes.Newobj, type.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[0], null));
+                            il.MarkLabel(lblFin);
+                            il.Emit(OpCodes.Unbox_Any, type);								// value converted
+                        }
+                        else
+                        {
+                            // var poco=new T()
+                            il.Emit(OpCodes.Newobj, type.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[0], null));
 
-							// Enumerate all fields generating a set assignment for the column
-							for (int i = firstColumn; i < firstColumn + countColumns; i++)
-							{
-								// Get the PocoColumn for this db column, ignore if not known
-								PocoColumn pc;
-								if (!Columns.TryGetValue(r.GetName(i), out pc))
-									continue;
+                            // Enumerate all fields generating a set assignment for the column
+                            for (int i = firstColumn; i < firstColumn + countColumns; i++)
+                            {
+                                // Get the PocoColumn for this db column, ignore if not known
+                                PocoColumn pc;
+                                if (!Columns.TryGetValue(r.GetName(i), out pc))
+                                    continue;
 
-								// Get the source type for this column
-								var srcType = r.GetFieldType(i);
-								var dstType = pc.PropertyInfo.PropertyType;
+                                // Get the source type for this column
+                                var srcType = r.GetFieldType(i);
+                                var dstType = pc.PropertyInfo.PropertyType;
 
-								// "if (!rdr.IsDBNull(i))"
-								il.Emit(OpCodes.Ldarg_0);										// poco,rdr
-								il.Emit(OpCodes.Ldc_I4, i);										// poco,rdr,i
-								il.Emit(OpCodes.Callvirt, fnIsDBNull);							// poco,bool
-								var lblNext = il.DefineLabel();
-								il.Emit(OpCodes.Brtrue_S, lblNext);								// poco
+                                // "if (!rdr.IsDBNull(i))"
+                                il.Emit(OpCodes.Ldarg_0);										// poco,rdr
+                                il.Emit(OpCodes.Ldc_I4, i);										// poco,rdr,i
+                                il.Emit(OpCodes.Callvirt, fnIsDBNull);							// poco,bool
+                                var lblNext = il.DefineLabel();
+                                il.Emit(OpCodes.Brtrue_S, lblNext);								// poco
 
-								il.Emit(OpCodes.Dup);											// poco,poco
+                                il.Emit(OpCodes.Dup);											// poco,poco
 
-								// Do we need to install a converter?
-								var converter = GetConverter(ForceDateTimesToUtc, pc, srcType, dstType);
+                                // Do we need to install a converter?
+                                var converter = GetConverter(ForceDateTimesToUtc, pc, srcType, dstType);
 
-								// Fast
-								bool Handled = false;
-								if (converter == null)
-								{
-									var valuegetter = typeof(IDataRecord).GetMethod("Get" + srcType.Name, new Type[] { typeof(int) });
-									if (valuegetter != null
-											&& valuegetter.ReturnType == srcType
-											&& (valuegetter.ReturnType == dstType || valuegetter.ReturnType == Nullable.GetUnderlyingType(dstType)))
-									{
-										il.Emit(OpCodes.Ldarg_0);										// *,rdr
-										il.Emit(OpCodes.Ldc_I4, i);										// *,rdr,i
-										il.Emit(OpCodes.Callvirt, valuegetter);							// *,value
+                                // Fast
+                                bool Handled = false;
+                                if (converter == null)
+                                {
+                                    var valuegetter = typeof(IDataRecord).GetMethod("Get" + srcType.Name, new Type[] { typeof(int) });
+                                    if (valuegetter != null
+                                            && valuegetter.ReturnType == srcType
+                                            && (valuegetter.ReturnType == dstType || valuegetter.ReturnType == Nullable.GetUnderlyingType(dstType)))
+                                    {
+                                        il.Emit(OpCodes.Ldarg_0);										// *,rdr
+                                        il.Emit(OpCodes.Ldc_I4, i);										// *,rdr,i
+                                        il.Emit(OpCodes.Callvirt, valuegetter);							// *,value
 
-										// Convert to Nullable
-										if (Nullable.GetUnderlyingType(dstType) != null)
-										{
-											il.Emit(OpCodes.Newobj, dstType.GetConstructor(new Type[] { Nullable.GetUnderlyingType(dstType) }));
-										}
+                                        // Convert to Nullable
+                                        if (Nullable.GetUnderlyingType(dstType) != null)
+                                        {
+                                            il.Emit(OpCodes.Newobj, dstType.GetConstructor(new Type[] { Nullable.GetUnderlyingType(dstType) }));
+                                        }
 
-										il.Emit(OpCodes.Callvirt, pc.PropertyInfo.GetSetMethod(true));		// poco
-										Handled = true;
-									}
-								}
+                                        il.Emit(OpCodes.Callvirt, pc.PropertyInfo.GetSetMethod(true));		// poco
+                                        Handled = true;
+                                    }
+                                }
 
-								// Not so fast
-								if (!Handled)
-								{
-									// Setup stack for call to converter
-									AddConverterToStack(il, converter);
+                                // Not so fast
+                                if (!Handled)
+                                {
+                                    // Setup stack for call to converter
+                                    AddConverterToStack(il, converter);
 
-									// "value = rdr.GetValue(i)"
-									il.Emit(OpCodes.Ldarg_0);										// *,rdr
-									il.Emit(OpCodes.Ldc_I4, i);										// *,rdr,i
-									il.Emit(OpCodes.Callvirt, fnGetValue);							// *,value
+                                    // "value = rdr.GetValue(i)"
+                                    il.Emit(OpCodes.Ldarg_0);										// *,rdr
+                                    il.Emit(OpCodes.Ldc_I4, i);										// *,rdr,i
+                                    il.Emit(OpCodes.Callvirt, fnGetValue);							// *,value
 
-									// Call the converter
-									if (converter != null)
-										il.Emit(OpCodes.Callvirt, fnInvoke);
+                                    // Call the converter
+                                    if (converter != null)
+                                        il.Emit(OpCodes.Callvirt, fnInvoke);
 
-									// Assign it
-									il.Emit(OpCodes.Unbox_Any, pc.PropertyInfo.PropertyType);		// poco,poco,value
-									il.Emit(OpCodes.Callvirt, pc.PropertyInfo.GetSetMethod(true));		// poco
-								}
+                                    // Assign it
+                                    il.Emit(OpCodes.Unbox_Any, pc.PropertyInfo.PropertyType);		// poco,poco,value
+                                    il.Emit(OpCodes.Callvirt, pc.PropertyInfo.GetSetMethod(true));		// poco
+                                }
 
-								il.MarkLabel(lblNext);
-							}
+                                il.MarkLabel(lblNext);
+                            }
 
-							var fnOnLoaded = RecurseInheritedTypes<MethodInfo>(type, (x) => x.GetMethod("OnLoaded", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[0], null));
-							if (fnOnLoaded != null)
-							{
-								il.Emit(OpCodes.Dup);
-								il.Emit(OpCodes.Callvirt, fnOnLoaded);
-							}
-						}
+                            var fnOnLoaded = RecurseInheritedTypes<MethodInfo>(type, (x) => x.GetMethod("OnLoaded", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[0], null));
+                            if (fnOnLoaded != null)
+                            {
+                                il.Emit(OpCodes.Dup);
+                                il.Emit(OpCodes.Callvirt, fnOnLoaded);
+                            }
+                        }
 
-					il.Emit(OpCodes.Ret);
+                    il.Emit(OpCodes.Ret);
+
+                    // return it
+                    var del = m.CreateDelegate(Expression.GetFuncType(typeof(IDataReader), type));
+                    
+                    return del;
+			    };
+
+                //lazy usage of AddOrGetExisting ref: http://stackoverflow.com/questions/10559279/how-to-deal-with-costly-building-operations-using-memorycache/15894928#15894928
+                var newValue = new Lazy<Delegate>(factory);
+                // the line belows returns existing item or adds the new value if it doesn't exist
+                var value = (Lazy<Delegate>)objectCache.AddOrGetExisting(key, newValue, new CacheItemPolicy
+                {
+                    //sliding expiration of 1 hr, if the same key isn't used in this 
+                    // timeframe it will be removed from the cache
+                    SlidingExpiration = new TimeSpan(0, 0, SlidingExpirationSeconds)
+                });
+                return (value ?? newValue).Value; // Lazy<T> handles the locking itself
 
-					// Cache it, return it
-					var del = m.CreateDelegate(Expression.GetFuncType(typeof(IDataReader), type));
-					PocoFactories.Add(key, del);
-					return del;
-				}
-				finally
-				{
-					RWLock.ExitWriteLock();
-				}
 			}
 
 			private static void AddConverterToStack(ILGenerator il, Func<object, object> converter)
@@ -2144,7 +2182,7 @@ namespace Umbraco.Core.Persistence
 				return default(T);
 			}
 
-
+            ManagedCache _managedCache = new ManagedCache();
 			static Dictionary<Type, PocoData> m_PocoDatas = new Dictionary<Type, PocoData>();
 			static List<Func<object, object>> m_Converters = new List<Func<object, object>>();
 			static MethodInfo fnGetValue = typeof(IDataRecord).GetMethod("GetValue", new Type[] { typeof(int) });
@@ -2156,7 +2194,46 @@ namespace Umbraco.Core.Persistence
 			public string[] QueryColumns { get; private set; }
 			public TableInfo TableInfo { get; private set; }
 			public Dictionary<string, PocoColumn> Columns { get; private set; }
-			Dictionary<string, Delegate> PocoFactories = new Dictionary<string, Delegate>();
+            static System.Threading.ReaderWriterLockSlim InnerLock = new System.Threading.ReaderWriterLockSlim();
+            
+            /// <summary>
+            /// Returns a report of the current cache being utilized by PetaPoco
+            /// </summary>
+            /// <returns></returns>
+		    public static string PrintDebugCacheReport(out double totalBytes, out IEnumerable<string> allKeys)
+            {
+                var managedCache = new ManagedCache();
+
+                var sb = new StringBuilder();
+                sb.AppendLine("m_PocoDatas:");
+                foreach (var pocoData in m_PocoDatas)
+                {
+                    sb.AppendFormat("\t{0}\n", pocoData.Key);
+                    sb.AppendFormat("\t\tTable:{0} - Col count:{1}\n", pocoData.Value.TableInfo.TableName, pocoData.Value.QueryColumns.Length);              
+                }
+
+                var cache = managedCache.GetCache();
+                allKeys = cache.Select(x => x.Key).ToArray();
+
+                sb.AppendFormat("\tTotal Poco data count:{0}\n", allKeys.Count());
+
+                var keys = string.Join("", cache.Select(x => x.Key));
+                //Bytes in .Net are stored as utf-16 = unicode little endian
+                totalBytes = Encoding.Unicode.GetByteCount(keys);
+
+                sb.AppendFormat("\tTotal byte for keys:{0}\n", totalBytes);
+                
+                sb.AppendLine("\tAll Poco cache items:");
+
+                foreach (var item in cache)
+                {
+                    sb.AppendFormat("\t\t Key -> {0}\n", item.Key);
+                    sb.AppendFormat("\t\t Value -> {0}\n", item.Value);
+                }
+
+                sb.AppendLine("-------------------END REPORT------------------------");
+                return sb.ToString();
+            }
 		}
 
 

src/Umbraco.Core/Persistence/PetaPocoExtensions.cs

@@ -221,6 +221,7 @@ namespace Umbraco.Core.Persistence
             if (overwrite && tableExist)
             {
                 db.DropTable(tableName);
+                tableExist = false;
             }
 
             if (tableExist == false)

src/Umbraco.Core/Persistence/PetaPocoSqlExtensions.cs

@@ -25,7 +25,7 @@ namespace Umbraco.Core.Persistence
             var expresionist = new PocoToSqlExpressionHelper<T>();
             string whereExpression = expresionist.Visit(predicate);
 
-            return sql.Where(whereExpression);
+            return sql.Where(whereExpression, expresionist.GetSqlParameters());
         }
 
         public static Sql OrderBy<TColumn>(this Sql sql, Expression<Func<TColumn, object>> columnMember)

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

@@ -1,28 +1,562 @@
 using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.Globalization;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Text;
 using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Querying
 {
+    internal abstract class BaseExpressionHelper<T> : BaseExpressionHelper
+    {
+        protected abstract string VisitMemberAccess(MemberExpression m);
+
+        protected internal virtual string Visit(Expression exp)
+        {
+
+            if (exp == null) return string.Empty;
+            switch (exp.NodeType)
+            {
+                case ExpressionType.Lambda:
+                    return VisitLambda(exp as LambdaExpression);
+                case ExpressionType.MemberAccess:
+                    return VisitMemberAccess(exp as MemberExpression);
+                case ExpressionType.Constant:
+                    return VisitConstant(exp as ConstantExpression);
+                case ExpressionType.Add:
+                case ExpressionType.AddChecked:
+                case ExpressionType.Subtract:
+                case ExpressionType.SubtractChecked:
+                case ExpressionType.Multiply:
+                case ExpressionType.MultiplyChecked:
+                case ExpressionType.Divide:
+                case ExpressionType.Modulo:
+                case ExpressionType.And:
+                case ExpressionType.AndAlso:
+                case ExpressionType.Or:
+                case ExpressionType.OrElse:
+                case ExpressionType.LessThan:
+                case ExpressionType.LessThanOrEqual:
+                case ExpressionType.GreaterThan:
+                case ExpressionType.GreaterThanOrEqual:
+                case ExpressionType.Equal:
+                case ExpressionType.NotEqual:
+                case ExpressionType.Coalesce:
+                case ExpressionType.ArrayIndex:
+                case ExpressionType.RightShift:
+                case ExpressionType.LeftShift:
+                case ExpressionType.ExclusiveOr:
+                    return VisitBinary(exp as BinaryExpression);
+                case ExpressionType.Negate:
+                case ExpressionType.NegateChecked:
+                case ExpressionType.Not:
+                case ExpressionType.Convert:
+                case ExpressionType.ConvertChecked:
+                case ExpressionType.ArrayLength:
+                case ExpressionType.Quote:
+                case ExpressionType.TypeAs:
+                    return VisitUnary(exp as UnaryExpression);
+                case ExpressionType.Parameter:
+                    return VisitParameter(exp as ParameterExpression);
+                case ExpressionType.Call:
+                    return VisitMethodCall(exp as MethodCallExpression);
+                case ExpressionType.New:
+                    return VisitNew(exp as NewExpression);
+                case ExpressionType.NewArrayInit:
+                case ExpressionType.NewArrayBounds:
+                    return VisitNewArray(exp as NewArrayExpression);
+                default:
+                    return exp.ToString();
+            }
+        }
+
+        protected virtual string VisitLambda(LambdaExpression lambda)
+        {
+            if (lambda.Body.NodeType == ExpressionType.MemberAccess)
+            {
+                var m = lambda.Body as MemberExpression;
+
+                if (m.Expression != null)
+                {
+                    //This deals with members that are boolean (i.e. x => IsTrashed )
+                    string r = VisitMemberAccess(m);
+                    SqlParameters.Add(true);
+                    return string.Format("{0} = @{1}", r, SqlParameters.Count - 1);
+
+                    //return string.Format("{0}={1}", r, GetQuotedTrueValue());
+                }
+
+            }
+            return Visit(lambda.Body);
+        }
+
+        protected virtual string VisitBinary(BinaryExpression b)
+        {
+            string left, right;
+            var operand = BindOperant(b.NodeType); 
+            if (operand == "AND" || operand == "OR")
+            {
+                MemberExpression m = b.Left as MemberExpression;
+                if (m != null && m.Expression != null)
+                {
+                    string r = VisitMemberAccess(m);
+
+                    SqlParameters.Add(1);
+                    left = string.Format("{0} = @{1}", r, SqlParameters.Count - 1);
+
+                    //left = string.Format("{0}={1}", r, GetQuotedTrueValue());
+                }
+                else
+                {
+                    left = Visit(b.Left);
+                }
+                m = b.Right as MemberExpression;
+                if (m != null && m.Expression != null)
+                {
+                    string r = VisitMemberAccess(m);
+
+                    SqlParameters.Add(1);
+                    right = string.Format("{0} = @{1}", r, SqlParameters.Count - 1);
+
+                    //right = string.Format("{0}={1}", r, GetQuotedTrueValue());
+                }
+                else
+                {
+                    right = Visit(b.Right);
+                }
+            }
+            else
+            {
+                left = Visit(b.Left);
+                right = Visit(b.Right);
+            }
+
+            if (operand == "=" && right == "null") operand = "is";
+            else if (operand == "<>" && right == "null") operand = "is not";
+            else if (operand == "=" || operand == "<>")
+            {
+                //if (IsTrueExpression(right)) right = GetQuotedTrueValue();
+                //else if (IsFalseExpression(right)) right = GetQuotedFalseValue();
+
+                //if (IsTrueExpression(left)) left = GetQuotedTrueValue();
+                //else if (IsFalseExpression(left)) left = GetQuotedFalseValue();
+
+            }
+
+            switch (operand)
+            {
+                case "MOD":
+                case "COALESCE":
+                    return string.Format("{0}({1},{2})", operand, left, right);
+                default:
+                    return left + " " + operand + " " + right;
+            }
+        }
+
+        protected virtual List<Object> VisitExpressionList(ReadOnlyCollection<Expression> original)
+        {
+            var list = new List<Object>();
+            for (int i = 0, n = original.Count; i < n; i++)
+            {
+                if (original[i].NodeType == ExpressionType.NewArrayInit ||
+                 original[i].NodeType == ExpressionType.NewArrayBounds)
+                {
+
+                    list.AddRange(VisitNewArrayFromExpressionList(original[i] as NewArrayExpression));
+                }
+                else
+                    list.Add(Visit(original[i]));
+
+            }
+            return list;
+        }
+
+        protected virtual string VisitNew(NewExpression nex)
+        {
+            // TODO : check !
+            var member = Expression.Convert(nex, typeof(object));
+            var lambda = Expression.Lambda<Func<object>>(member);
+            try
+            {
+                var getter = lambda.Compile();
+                object o = getter();
+
+                SqlParameters.Add(o);
+                return string.Format("@{0}", SqlParameters.Count - 1);
+
+                //return GetQuotedValue(o, o.GetType());
+            }
+            catch (InvalidOperationException)
+            { 
+                // FieldName ?
+                List<Object> exprs = VisitExpressionList(nex.Arguments);
+                var r = new StringBuilder();
+                foreach (Object e in exprs)
+                {
+                    r.AppendFormat("{0}{1}",
+                        r.Length > 0 ? "," : "",
+                        e);
+                }
+                return r.ToString();
+            }
+
+        }
+
+        protected virtual string VisitParameter(ParameterExpression p)
+        {
+            return p.Name;
+        }
+
+        protected virtual string VisitConstant(ConstantExpression c)
+        {
+            if (c.Value == null)
+                return "null";
+
+            SqlParameters.Add(c.Value);
+            return string.Format("@{0}", SqlParameters.Count - 1);
+
+            //if (c.Value is bool)
+            //{
+            //    object o = GetQuotedValue(c.Value, c.Value.GetType());
+            //    return string.Format("({0}={1})", GetQuotedTrueValue(), o);
+            //}
+            //return GetQuotedValue(c.Value, c.Value.GetType());
+        }
+
+        protected virtual string VisitUnary(UnaryExpression u)
+        {
+            switch (u.NodeType)
+            {
+                case ExpressionType.Not:
+                    var o = Visit(u.Operand);
+
+                    //use a Not equal operator instead of <> since we don't know that <> works in all sql servers
+
+                    switch (u.Operand.NodeType)
+                    {
+                        case ExpressionType.MemberAccess:
+                            //In this case it wil be a false property , i.e. x => !Trashed
+                            SqlParameters.Add(true);
+                            return string.Format("NOT ({0} = @0)", o);                            
+                        default:
+                            //In this case it could be anything else, such as: x => !x.Path.StartsWith("-20")
+                            return string.Format("NOT ({0})", o);                            
+                    }
+                default:
+                    return Visit(u.Operand);
+            }
+        }
+
+        protected virtual string VisitNewArray(NewArrayExpression na)
+        {
+
+            List<Object> exprs = VisitExpressionList(na.Expressions);
+            var r = new StringBuilder();
+            foreach (Object e in exprs)
+            {
+                r.Append(r.Length > 0 ? "," + e : e);
+            }
+
+            return r.ToString();
+        }
+
+        protected virtual List<Object> VisitNewArrayFromExpressionList(NewArrayExpression na)
+        {
+
+            List<Object> exprs = VisitExpressionList(na.Expressions);
+            return exprs;
+        }
+
+        protected virtual string BindOperant(ExpressionType e)
+        {
+
+            switch (e)
+            {
+                case ExpressionType.Equal:
+                    return "=";
+                case ExpressionType.NotEqual:
+                    return "<>";
+                case ExpressionType.GreaterThan:
+                    return ">";
+                case ExpressionType.GreaterThanOrEqual:
+                    return ">=";
+                case ExpressionType.LessThan:
+                    return "<";
+                case ExpressionType.LessThanOrEqual:
+                    return "<=";
+                case ExpressionType.AndAlso:
+                    return "AND";
+                case ExpressionType.OrElse:
+                    return "OR";
+                case ExpressionType.Add:
+                    return "+";
+                case ExpressionType.Subtract:
+                    return "-";
+                case ExpressionType.Multiply:
+                    return "*";
+                case ExpressionType.Divide:
+                    return "/";
+                case ExpressionType.Modulo:
+                    return "MOD";
+                case ExpressionType.Coalesce:
+                    return "COALESCE";
+                default:
+                    return e.ToString();
+            }
+        }
+
+        protected virtual string VisitMethodCall(MethodCallExpression m)
+        {
+            //Here's what happens with a MethodCallExpression:
+            //  If a method is called that contains a single argument, 
+            //      then m.Object is the object on the left hand side of the method call, example:
+            //      x.Path.StartsWith(content.Path)
+            //          m.Object = x.Path
+            //          and m.Arguments.Length == 1, therefor m.Arguments[0] == content.Path
+            //  If a method is called that contains multiple arguments, then m.Object == null and the 
+            //      m.Arguments collection contains the left hand side of the method call, example:
+            //      x.Path.SqlStartsWith(content.Path, TextColumnType.NVarchar)
+            //          m.Object == null
+            //          m.Arguments.Length == 3, therefor, m.Arguments[0] == x.Path, m.Arguments[1] == content.Path, m.Arguments[2] == TextColumnType.NVarchar 
+            // So, we need to cater for these scenarios.
+
+            var objectForMethod = m.Object ?? m.Arguments[0];
+            var visitedObjectForMethod = Visit(objectForMethod);
+            var methodArgs = m.Object == null 
+                ? m.Arguments.Skip(1).ToArray() 
+                : m.Arguments.ToArray();
+
+            switch (m.Method.Name)
+            {
+                case "ToString":
+                    SqlParameters.Add(objectForMethod.ToString());
+                    return string.Format("@{0}", SqlParameters.Count - 1);
+                case "ToUpper":
+                    return string.Format("upper({0})", visitedObjectForMethod);
+                case "ToLower":
+                    return string.Format("lower({0})", visitedObjectForMethod);
+                case "SqlWildcard":
+                case "StartsWith":
+                case "EndsWith":
+                case "Contains":
+                case "Equals":
+                case "SqlStartsWith":
+                case "SqlEndsWith":
+                case "SqlContains":
+                case "SqlEquals":
+                case "InvariantStartsWith":
+                case "InvariantEndsWith":
+                case "InvariantContains":
+                case "InvariantEquals":
+                    
+                    string compareValue;
+
+                    if (methodArgs[0].NodeType != ExpressionType.Constant)
+                    {
+                        //This occurs when we are getting a value from a non constant such as: x => x.Path.StartsWith(content.Path)
+                        // So we'll go get the value:
+                        var member = Expression.Convert(methodArgs[0], typeof(object));
+                        var lambda = Expression.Lambda<Func<object>>(member);
+                        var getter = lambda.Compile();
+                        compareValue = getter().ToString();
+                    }
+                    else
+                    {
+                        compareValue = methodArgs[0].ToString();
+                    }
+
+                    //special case, if it is 'Contains' and the member that Contains is being called on is not a string, then
+                    // we should be doing an 'In' clause - but we currently do not support this
+                    if (methodArgs[0].Type != typeof(string) && TypeHelper.IsTypeAssignableFrom<IEnumerable>(methodArgs[0].Type))
+                    {
+                        throw new NotSupportedException("An array Contains method is not supported");
+                    }
+
+                    //default column type
+                    var colType = TextColumnType.NVarchar;
+
+                    //then check if the col type argument has been passed to the current method (this will be the case for methods like
+                    // SqlContains and other Sql methods)
+                    if (methodArgs.Length > 1)
+                    {
+                        var colTypeArg = methodArgs.FirstOrDefault(x => x is ConstantExpression && x.Type == typeof(TextColumnType));
+                        if (colTypeArg != null)
+                        {
+                            colType = (TextColumnType)((ConstantExpression)colTypeArg).Value;
+                        }
+                    }
+
+                    return HandleStringComparison(visitedObjectForMethod, compareValue, m.Method.Name, colType);
+                //case "Substring":
+                //    var startIndex = Int32.Parse(args[0].ToString()) + 1;
+                //    if (args.Count == 2)
+                //    {
+                //        var length = Int32.Parse(args[1].ToString());
+                //        return string.Format("substring({0} from {1} for {2})",
+                //                         r,
+                //                         startIndex,
+                //                         length);
+                //    }
+                //    else
+                //        return string.Format("substring({0} from {1})",
+                //                         r,
+                //                         startIndex);
+                //case "Round":
+                //case "Floor":
+                //case "Ceiling":
+                //case "Coalesce":
+                //case "Abs":
+                //case "Sum":
+                //    return string.Format("{0}({1}{2})",
+                //                         m.Method.Name,
+                //                         r,
+                //                         args.Count == 1 ? string.Format(",{0}", args[0]) : "");
+                //case "Concat":
+                //    var s = new StringBuilder();
+                //    foreach (Object e in args)
+                //    {
+                //        s.AppendFormat(" || {0}", e);
+                //    }
+                //    return string.Format("{0}{1}", r, s);
+
+                //case "In":
+
+                //    var member = Expression.Convert(m.Arguments[0], typeof(object));
+                //    var lambda = Expression.Lambda<Func<object>>(member);
+                //    var getter = lambda.Compile();
+
+                //    var inArgs = (object[])getter();
+
+                //    var sIn = new StringBuilder();
+                //    foreach (var e in inArgs)
+                //    {
+                //        SqlParameters.Add(e);
+
+                //        sIn.AppendFormat("{0}{1}",
+                //                     sIn.Length > 0 ? "," : "",
+                //                                    string.Format("@{0}", SqlParameters.Count - 1));
+
+                //        //sIn.AppendFormat("{0}{1}",
+                //        //             sIn.Length > 0 ? "," : "",
+                //        //                            GetQuotedValue(e, e.GetType()));
+                //    }
+
+                //    return string.Format("{0} {1} ({2})", r, m.Method.Name, sIn.ToString());
+                //case "Desc":
+                //    return string.Format("{0} DESC", r);
+                //case "Alias":
+                //case "As":
+                //    return string.Format("{0} As {1}", r,
+                //                                GetQuotedColumnName(RemoveQuoteFromAlias(RemoveQuote(args[0].ToString()))));
+                
+                default:
+
+                    throw new ArgumentOutOfRangeException("No logic supported for " + m.Method.Name);
+
+                //var s2 = new StringBuilder();
+                //foreach (Object e in args)
+                //{
+                //    s2.AppendFormat(",{0}", GetQuotedValue(e, e.GetType()));
+                //}
+                //return string.Format("{0}({1}{2})", m.Method.Name, r, s2.ToString());
+            }
+        }
+
+        public virtual string GetQuotedTableName(string tableName)
+        {
+            return string.Format("\"{0}\"", tableName);
+        }
+
+        public virtual string GetQuotedColumnName(string columnName)
+        {
+            return string.Format("\"{0}\"", columnName);
+        }
+
+        public virtual string GetQuotedName(string name)
+        {
+            return string.Format("\"{0}\"", name);
+        }
+
+        //private string GetQuotedTrueValue()
+        //{
+        //    return GetQuotedValue(true, typeof(bool));
+        //}
+
+        //private string GetQuotedFalseValue()
+        //{
+        //    return GetQuotedValue(false, typeof(bool));
+        //}
+
+        //public virtual string GetQuotedValue(object value, Type fieldType)
+        //{
+        //    return GetQuotedValue(value, fieldType, EscapeParam, ShouldQuoteValue);
+        //}
+
+        //private string GetTrueExpression()
+        //{
+        //    object o = GetQuotedTrueValue();
+        //    return string.Format("({0}={1})", o, o);
+        //}
+
+        //private string GetFalseExpression()
+        //{
+
+        //    return string.Format("({0}={1})",
+        //        GetQuotedTrueValue(),
+        //        GetQuotedFalseValue());
+        //}
+
+        //private bool IsTrueExpression(string exp)
+        //{
+        //    return (exp == GetTrueExpression());
+        //}
+
+        //private bool IsFalseExpression(string exp)
+        //{
+        //    return (exp == GetFalseExpression());
+        //}
+    }
+
     /// <summary>
     /// Logic that is shared with the expression helpers
     /// </summary>
-    internal class BaseExpressionHelper
+    internal class BaseExpressionHelper 
     {
+        protected List<object> SqlParameters = new List<object>();
+
+        public object[] GetSqlParameters()
+        {
+            return SqlParameters.ToArray();
+        }
+
         protected string HandleStringComparison(string col, string val, string verb, TextColumnType columnType)
         {
             switch (verb)
             {
                 case "SqlWildcard":
-                    return SqlSyntaxContext.SqlSyntaxProvider.GetStringColumnWildcardComparison(col, RemoveQuote(val), columnType);
+                    SqlParameters.Add(RemoveQuote(val));
+                    return SqlSyntaxContext.SqlSyntaxProvider.GetStringColumnWildcardComparison(col, SqlParameters.Count - 1, columnType);
                 case "Equals":
-                    return SqlSyntaxContext.SqlSyntaxProvider.GetStringColumnEqualComparison(col, RemoveQuote(val), columnType);
+                    SqlParameters.Add(RemoveQuote(val));
+                    return SqlSyntaxContext.SqlSyntaxProvider.GetStringColumnEqualComparison(col, SqlParameters.Count - 1, columnType);
                 case "StartsWith":
-                    return SqlSyntaxContext.SqlSyntaxProvider.GetStringColumnStartsWithComparison(col, RemoveQuote(val), columnType);
+                    SqlParameters.Add(string.Format("{0}{1}",
+                        RemoveQuote(val),
+                        SqlSyntaxContext.SqlSyntaxProvider.GetWildcardPlaceholder()));
+                    return SqlSyntaxContext.SqlSyntaxProvider.GetStringColumnWildcardComparison(col, SqlParameters.Count - 1, columnType);
                 case "EndsWith":
-                    return SqlSyntaxContext.SqlSyntaxProvider.GetStringColumnEndsWithComparison(col, RemoveQuote(val), columnType);
+                    SqlParameters.Add(string.Format("{0}{1}",
+                        SqlSyntaxContext.SqlSyntaxProvider.GetWildcardPlaceholder(),
+                        RemoveQuote(val)));
+                    return SqlSyntaxContext.SqlSyntaxProvider.GetStringColumnWildcardComparison(col, SqlParameters.Count - 1, columnType);
                 case "Contains":
-                    return SqlSyntaxContext.SqlSyntaxProvider.GetStringColumnContainsComparison(col, RemoveQuote(val), columnType);
+                    SqlParameters.Add(string.Format("{0}{1}{0}",
+                        SqlSyntaxContext.SqlSyntaxProvider.GetWildcardPlaceholder(),
+                        RemoveQuote(val)));
+                    return SqlSyntaxContext.SqlSyntaxProvider.GetStringColumnWildcardComparison(col, SqlParameters.Count - 1, columnType);
                 case "InvariantEquals":
                 case "SqlEquals":
                     //recurse
@@ -44,61 +578,54 @@ namespace Umbraco.Core.Persistence.Querying
             }
         }
 
-        public virtual string GetQuotedValue(object value, Type fieldType, Func<object, string> escapeCallback = null, Func<Type, bool> shouldQuoteCallback = null)
-        {
-            if (value == null) return "NULL";
+        //public virtual string GetQuotedValue(object value, Type fieldType, Func<object, string> escapeCallback = null, Func<Type, bool> shouldQuoteCallback = null)
+        //{
+        //    if (value == null) return "NULL";
 
-            if (escapeCallback == null)
-            {
-                escapeCallback = EscapeParam;
-            }
-            if (shouldQuoteCallback == null)
-            {
-                shouldQuoteCallback = ShouldQuoteValue;
-            }
+        //    if (escapeCallback == null)
+        //    {
+        //        escapeCallback = EscapeParam;
+        //    }
+        //    if (shouldQuoteCallback == null)
+        //    {
+        //        shouldQuoteCallback = ShouldQuoteValue;
+        //    }
 
-            if (!fieldType.UnderlyingSystemType.IsValueType && fieldType != typeof(string))
-            {
-                //if (TypeSerializer.CanCreateFromString(fieldType))
-                //{
-                //    return "'" + escapeCallback(TypeSerializer.SerializeToString(value)) + "'";
-                //}
+        //    if (!fieldType.UnderlyingSystemType.IsValueType && fieldType != typeof(string))
+        //    {
+        //        //if (TypeSerializer.CanCreateFromString(fieldType))
+        //        //{
+        //        //    return "'" + escapeCallback(TypeSerializer.SerializeToString(value)) + "'";
+        //        //}
 
-                throw new NotSupportedException(
-                    string.Format("Property of type: {0} is not supported", fieldType.FullName));
-            }
+        //        throw new NotSupportedException(
+        //            string.Format("Property of type: {0} is not supported", fieldType.FullName));
+        //    }
 
-            if (fieldType == typeof(int))
-                return ((int)value).ToString(CultureInfo.InvariantCulture);
+        //    if (fieldType == typeof(int))
+        //        return ((int)value).ToString(CultureInfo.InvariantCulture);
 
-            if (fieldType == typeof(float))
-                return ((float)value).ToString(CultureInfo.InvariantCulture);
+        //    if (fieldType == typeof(float))
+        //        return ((float)value).ToString(CultureInfo.InvariantCulture);
 
-            if (fieldType == typeof(double))
-                return ((double)value).ToString(CultureInfo.InvariantCulture);
+        //    if (fieldType == typeof(double))
+        //        return ((double)value).ToString(CultureInfo.InvariantCulture);
 
-            if (fieldType == typeof(decimal))
-                return ((decimal)value).ToString(CultureInfo.InvariantCulture);
+        //    if (fieldType == typeof(decimal))
+        //        return ((decimal)value).ToString(CultureInfo.InvariantCulture);
 
-            if (fieldType == typeof(DateTime))
-            {
-                return "'" + escapeCallback(((DateTime)value).ToIsoString()) + "'";
-            }
+        //    if (fieldType == typeof(DateTime))
+        //    {
+        //        return "'" + escapeCallback(((DateTime)value).ToIsoString()) + "'";
+        //    }
 
-            if (fieldType == typeof(bool))
-                return ((bool)value) ? Convert.ToString(1, CultureInfo.InvariantCulture) : Convert.ToString(0, CultureInfo.InvariantCulture);
+        //    if (fieldType == typeof(bool))
+        //        return ((bool)value) ? Convert.ToString(1, CultureInfo.InvariantCulture) : Convert.ToString(0, CultureInfo.InvariantCulture);
 
-            return shouldQuoteCallback(fieldType)
-                       ? "'" + escapeCallback(value) + "'"
-                       : value.ToString();
-        }
-
-        public virtual string EscapeParam(object paramValue)
-        {
-            return paramValue == null 
-                ? string.Empty 
-                : SqlSyntaxContext.SqlSyntaxProvider.EscapeString(paramValue.ToString());
-        }
+        //    return shouldQuoteCallback(fieldType)
+        //               ? "'" + escapeCallback(value) + "'"
+        //               : value.ToString();
+        //}
         
         public virtual bool ShouldQuoteValue(Type fieldType)
         {
@@ -107,16 +634,12 @@ namespace Umbraco.Core.Persistence.Querying
 
         protected virtual string RemoveQuote(string exp)
         {
-            if (exp.StartsWith("'") && exp.EndsWith("'"))
-            {
-                exp = exp.Remove(0, 1);
-                exp = exp.Remove(exp.Length - 1, 1);
-            }
-            return exp;
-        }
-
-        protected virtual string RemoveQuoteFromAlias(string exp)
-        {
+            //if (exp.StartsWith("'") && exp.EndsWith("'"))
+            //{
+            //    exp = exp.Remove(0, 1);
+            //    exp = exp.Remove(exp.Length - 1, 1);
+            //}
+            //return exp;
 
             if ((exp.StartsWith("\"") || exp.StartsWith("`") || exp.StartsWith("'"))
                 &&
@@ -127,5 +650,18 @@ namespace Umbraco.Core.Persistence.Querying
             }
             return exp;
         }
+
+        //protected virtual string RemoveQuoteFromAlias(string exp)
+        //{
+
+        //    if ((exp.StartsWith("\"") || exp.StartsWith("`") || exp.StartsWith("'"))
+        //        &&
+        //        (exp.EndsWith("\"") || exp.EndsWith("`") || exp.EndsWith("'")))
+        //    {
+        //        exp = exp.Remove(0, 1);
+        //        exp = exp.Remove(exp.Length - 1, 1);
+        //    }
+        //    return exp;
+        //}
     }
 }

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

@@ -1,10 +1,44 @@
 using System;
+using System.Collections.Generic;
 using System.Linq.Expressions;
 
 namespace Umbraco.Core.Persistence.Querying
 {
+    /// <summary>
+    /// SD: This is a horrible hack but unless we break compatibility with anyone who's actually implemented IQuery{T} there's not much we can do.
+    /// The IQuery{T} interface is useless without having a GetWhereClauses method and cannot be used for tests.
+    /// We have to wait till v8 to make this change I suppose.
+    /// </summary>
+    internal static class QueryExtensions
+    {
+        /// <summary>
+        /// Returns all translated where clauses and their sql parameters
+        /// </summary>
+        /// <returns></returns>
+        public static IEnumerable<Tuple<string, object[]>> GetWhereClauses<T>(this IQuery<T> query)
+        {
+            var q = query as Query<T>;
+            if (q == null)
+            {
+                throw new NotSupportedException(typeof(IQuery<T>) + " cannot be cast to " + typeof(Query<T>));
+            }
+            return q.GetWhereClauses();
+        }
+    }
+
+    /// <summary>
+    /// Represents a query for building Linq translatable SQL queries
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
     public interface IQuery<T>
     {
+        /// <summary>
+        /// Adds a where clause to the query
+        /// </summary>
+        /// <param name="predicate"></param>
+        /// <returns>This instance so calls to this method are chainable</returns>
         IQuery<T> Where(Expression<Func<T, bool>> predicate);
+
+        
     }
 }

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

@@ -10,149 +10,21 @@ using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Querying
 {
-    internal class ModelToSqlExpressionHelper<T> : BaseExpressionHelper
+    internal class ModelToSqlExpressionHelper<T> : BaseExpressionHelper<T>
     {
-        private string sep = " ";
-        private BaseMapper _mapper;
+
+        private readonly BaseMapper _mapper;
 
         public ModelToSqlExpressionHelper()
         {
             _mapper = MappingResolver.Current.ResolveMapperByType(typeof(T));
         }
-
-        protected internal virtual string Visit(Expression exp)
+        
+        protected override string VisitMemberAccess(MemberExpression m)
         {
-
-            if (exp == null) return string.Empty;
-            switch (exp.NodeType)
-            {
-                case ExpressionType.Lambda:
-                    return VisitLambda(exp as LambdaExpression);
-                case ExpressionType.MemberAccess:
-                    return VisitMemberAccess(exp as MemberExpression);
-                case ExpressionType.Constant:
-                    return VisitConstant(exp as ConstantExpression);
-                case ExpressionType.Add:
-                case ExpressionType.AddChecked:
-                case ExpressionType.Subtract:
-                case ExpressionType.SubtractChecked:
-                case ExpressionType.Multiply:
-                case ExpressionType.MultiplyChecked:
-                case ExpressionType.Divide:
-                case ExpressionType.Modulo:
-                case ExpressionType.And:
-                case ExpressionType.AndAlso:
-                case ExpressionType.Or:
-                case ExpressionType.OrElse:
-                case ExpressionType.LessThan:
-                case ExpressionType.LessThanOrEqual:
-                case ExpressionType.GreaterThan:
-                case ExpressionType.GreaterThanOrEqual:
-                case ExpressionType.Equal:
-                case ExpressionType.NotEqual:
-                case ExpressionType.Coalesce:
-                case ExpressionType.ArrayIndex:
-                case ExpressionType.RightShift:
-                case ExpressionType.LeftShift:
-                case ExpressionType.ExclusiveOr:
-                    return VisitBinary(exp as BinaryExpression);
-                case ExpressionType.Negate:
-                case ExpressionType.NegateChecked:
-                case ExpressionType.Not:
-                case ExpressionType.Convert:
-                case ExpressionType.ConvertChecked:
-                case ExpressionType.ArrayLength:
-                case ExpressionType.Quote:
-                case ExpressionType.TypeAs:
-                    return VisitUnary(exp as UnaryExpression);
-                case ExpressionType.Parameter:
-                    return VisitParameter(exp as ParameterExpression);
-                case ExpressionType.Call:
-                    return VisitMethodCall(exp as MethodCallExpression);
-                case ExpressionType.New:
-                    return VisitNew(exp as NewExpression);
-                case ExpressionType.NewArrayInit:
-                case ExpressionType.NewArrayBounds:
-                    return VisitNewArray(exp as NewArrayExpression);
-                default:
-                    return exp.ToString();
-            }
-        }
-
-        protected virtual string VisitLambda(LambdaExpression lambda)
-        {
-            if (lambda.Body.NodeType == ExpressionType.MemberAccess && sep == " ")
-            {
-                MemberExpression m = lambda.Body as MemberExpression;
-
-                if (m.Expression != null)
-                {
-                    string r = VisitMemberAccess(m);
-                    return string.Format("{0}={1}", r, GetQuotedTrueValue());
-                }
-
-            }
-            return Visit(lambda.Body);
-        }
-
-        protected virtual string VisitBinary(BinaryExpression b)
-        {
-            string left, right;
-            var operand = BindOperant(b.NodeType);   //sep= " " ??
-            if (operand == "AND" || operand == "OR")
-            {
-                MemberExpression m = b.Left as MemberExpression;
-                if (m != null && m.Expression != null)
-                {
-                    string r = VisitMemberAccess(m);
-                    left = string.Format("{0}={1}", r, GetQuotedTrueValue());
-                }
-                else
-                {
-                    left = Visit(b.Left);
-                }
-                m = b.Right as MemberExpression;
-                if (m != null && m.Expression != null)
-                {
-                    string r = VisitMemberAccess(m);
-                    right = string.Format("{0}={1}", r, GetQuotedTrueValue());
-                }
-                else
-                {
-                    right = Visit(b.Right);
-                }
-            }
-            else
-            {
-                left = Visit(b.Left);
-                right = Visit(b.Right);
-            }
-
-            if (operand == "=" && right == "null") operand = "is";
-            else if (operand == "<>" && right == "null") operand = "is not";
-            else if (operand == "=" || operand == "<>")
-            {
-                if (IsTrueExpression(right)) right = GetQuotedTrueValue();
-                else if (IsFalseExpression(right)) right = GetQuotedFalseValue();
-
-                if (IsTrueExpression(left)) left = GetQuotedTrueValue();
-                else if (IsFalseExpression(left)) left = GetQuotedFalseValue();
-
-            }
-
-            switch (operand)
-            {
-                case "MOD":
-                case "COALESCE":
-                    return string.Format("{0}({1},{2})", operand, left, right);
-                default:
-                    return left + sep + operand + sep + right;
-            }
-        }
-
-        protected virtual string VisitMemberAccess(MemberExpression m)
-        {
-            if (m.Expression != null && m.Expression.NodeType == ExpressionType.Parameter && m.Expression.Type == typeof(T))
+            if (m.Expression != null && 
+                m.Expression.NodeType == ExpressionType.Parameter 
+                && m.Expression.Type == typeof(T))
             {
                 var field = _mapper.Map(m.Member.Name);
                 return field;
@@ -168,324 +40,18 @@ namespace Umbraco.Core.Persistence.Querying
             var lambda = Expression.Lambda<Func<object>>(member);
             var getter = lambda.Compile();
             object o = getter();
-            return GetQuotedValue(o, o != null ? o.GetType() : null);
+
+            SqlParameters.Add(o);
+            return string.Format("@{0}", SqlParameters.Count - 1);
+
+            //return GetQuotedValue(o, o != null ? o.GetType() : null);
 
         }
-
-        protected virtual string VisitNew(NewExpression nex)
-        {
-            // TODO : check !
-            var member = Expression.Convert(nex, typeof(object));
-            var lambda = Expression.Lambda<Func<object>>(member);
-            try
-            {
-                var getter = lambda.Compile();
-                object o = getter();
-                return GetQuotedValue(o, o.GetType());
-            }
-            catch (System.InvalidOperationException)
-            { // FieldName ?
-                List<Object> exprs = VisitExpressionList(nex.Arguments);
-                var r = new StringBuilder();
-                foreach (Object e in exprs)
-                {
-                    r.AppendFormat("{0}{1}", r.Length > 0 ? "," : "", e);
-                }
-                return r.ToString();
-            }
-
-        }
-
-        protected virtual string VisitParameter(ParameterExpression p)
-        {
-            return p.Name;
-        }
-
-        protected virtual string VisitConstant(ConstantExpression c)
-        {
-            if (c.Value == null)
-                return "null";
-            if (c.Value is bool)
-            {
-                object o = GetQuotedValue(c.Value, c.Value.GetType());
-                return string.Format("({0}={1})", GetQuotedTrueValue(), o);
-            }
-            return GetQuotedValue(c.Value, c.Value.GetType());
-        }
-
-        protected virtual string VisitUnary(UnaryExpression u)
-        {
-            switch (u.NodeType)
-            {
-                case ExpressionType.Not:
-                    string o = Visit(u.Operand);
-                    if (IsFieldName(o)) o = o + "=" + GetQuotedValue(true, typeof(bool));
-                    return "NOT (" + o + ")";
-                default:
-                    return Visit(u.Operand);
-            }
-
-        }
-
-        protected virtual string VisitMethodCall(MethodCallExpression m)
-        {
-            List<Object> args = this.VisitExpressionList(m.Arguments);
-
-            Object r;
-            if (m.Object != null)
-                r = Visit(m.Object);
-            else
-            {
-                r = args[0];
-                args.RemoveAt(0);
-            }
-
-            switch (m.Method.Name)
-            {
-                case "ToUpper":
-                    return string.Format("upper({0})", r);
-                case "ToLower":
-                    return string.Format("lower({0})", r);
-                case "SqlWildcard":
-                case "StartsWith":
-                case "EndsWith":
-                case "Contains":
-                case "Equals":
-                case "SqlStartsWith":
-                case "SqlEndsWith":
-                case "SqlContains":
-                case "SqlEquals":
-                case "InvariantStartsWith":
-                case "InvariantEndsWith":
-                case "InvariantContains":
-                case "InvariantEquals":
-                    //default
-                    var colType = TextColumnType.NVarchar;
-                    //then check if this arg has been passed in
-                    if (m.Arguments.Count > 1)
-                    {
-                        var colTypeArg = m.Arguments.FirstOrDefault(x => x is ConstantExpression && x.Type == typeof(TextColumnType));
-                        if (colTypeArg != null)
-                        {
-                            colType = (TextColumnType) ((ConstantExpression) colTypeArg).Value;
-                        }
-                    }
-                    return HandleStringComparison(r.ToString(), args[0].ToString(), m.Method.Name, colType);
-                case "Substring":
-                    var startIndex = Int32.Parse(args[0].ToString()) + 1;
-                    if (args.Count == 2)
-                    {
-                        var length = Int32.Parse(args[1].ToString());
-                        return string.Format("substring({0} from {1} for {2})",
-                                         r,
-                                         startIndex,
-                                         length);
-                    }
-                    else
-                        return string.Format("substring({0} from {1})",
-                                         r,
-                                         startIndex);
-                case "Round":
-                case "Floor":
-                case "Ceiling":
-                case "Coalesce":
-                case "Abs":
-                case "Sum":
-                    return string.Format("{0}({1}{2})",
-                                         m.Method.Name,
-                                         r,
-                                         args.Count == 1 ? string.Format(",{0}", args[0]) : "");
-                case "Concat":
-                    var s = new StringBuilder();
-                    foreach (Object e in args)
-                    {
-                        s.AppendFormat(" || {0}", e);
-                    }
-                    return string.Format("{0}{1}", r, s.ToString());
-
-                case "In":
-
-                    var member = Expression.Convert(m.Arguments[1], typeof(object));
-                    var lambda = Expression.Lambda<Func<object>>(member);
-                    var getter = lambda.Compile();
-
-                    var inArgs = getter() as object[];
-
-                    var sIn = new StringBuilder();
-                    foreach (Object e in inArgs)
-                    {
-                        if (e.GetType().ToString() != "System.Collections.Generic.List`1[System.Object]")
-                        {
-                            sIn.AppendFormat("{0}{1}",
-                                         sIn.Length > 0 ? "," : "",
-                                                        GetQuotedValue(e, e.GetType()));
-                        }
-                        else
-                        {
-                            var listArgs = e as IList<Object>;
-                            foreach (Object el in listArgs)
-                            {
-                                sIn.AppendFormat("{0}{1}",
-                                         sIn.Length > 0 ? "," : "",
-                                                        GetQuotedValue(el, el.GetType()));
-                            }
-                        }
-                    }
-
-                    return string.Format("{0} {1} ({2})", r, m.Method.Name, sIn.ToString());
-                case "Desc":
-                    return string.Format("{0} DESC", r);
-                case "Alias":
-                case "As":
-                    return string.Format("{0} As {1}", r,
-                                                GetQuotedColumnName(RemoveQuoteFromAlias(RemoveQuote(args[0].ToString()))));
-                case "ToString":
-                    return r.ToString();
-                default:
-                    var s2 = new StringBuilder();
-                    foreach (Object e in args)
-                    {
-                        s2.AppendFormat(",{0}", GetQuotedValue(e, e.GetType()));
-                    }
-                    return string.Format("{0}({1}{2})", m.Method.Name, r, s2.ToString());
-            }
-        }
-
-        protected virtual List<Object> VisitExpressionList(ReadOnlyCollection<Expression> original)
-        {
-            var list = new List<Object>();
-            for (int i = 0, n = original.Count; i < n; i++)
-            {
-                if (original[i].NodeType == ExpressionType.NewArrayInit ||
-                 original[i].NodeType == ExpressionType.NewArrayBounds)
-                {
-
-                    list.AddRange(VisitNewArrayFromExpressionList(original[i] as NewArrayExpression));
-                }
-                else
-                    list.Add(Visit(original[i]));
-
-            }
-            return list;
-        }
-
-        protected virtual string VisitNewArray(NewArrayExpression na)
-        {
-
-            List<Object> exprs = VisitExpressionList(na.Expressions);
-            var r = new StringBuilder();
-            foreach (Object e in exprs)
-            {
-                r.Append(r.Length > 0 ? "," + e : e);
-            }
-
-            return r.ToString();
-        }
-
-        protected virtual List<Object> VisitNewArrayFromExpressionList(NewArrayExpression na)
-        {
-
-            List<Object> exprs = VisitExpressionList(na.Expressions);
-            return exprs;
-        }
-
-
-        protected virtual string BindOperant(ExpressionType e)
-        {
-
-            switch (e)
-            {
-                case ExpressionType.Equal:
-                    return "=";
-                case ExpressionType.NotEqual:
-                    return "<>";
-                case ExpressionType.GreaterThan:
-                    return ">";
-                case ExpressionType.GreaterThanOrEqual:
-                    return ">=";
-                case ExpressionType.LessThan:
-                    return "<";
-                case ExpressionType.LessThanOrEqual:
-                    return "<=";
-                case ExpressionType.AndAlso:
-                    return "AND";
-                case ExpressionType.OrElse:
-                    return "OR";
-                case ExpressionType.Add:
-                    return "+";
-                case ExpressionType.Subtract:
-                    return "-";
-                case ExpressionType.Multiply:
-                    return "*";
-                case ExpressionType.Divide:
-                    return "/";
-                case ExpressionType.Modulo:
-                    return "MOD";
-                case ExpressionType.Coalesce:
-                    return "COALESCE";
-                default:
-                    return e.ToString();
-            }
-        }
-
-        public virtual string GetQuotedTableName(string tableName)
-        {
-            return string.Format("\"{0}\"", tableName);
-        }
-
-        public virtual string GetQuotedColumnName(string columnName)
-        {
-            return string.Format("\"{0}\"", columnName);
-        }
-
-        public virtual string GetQuotedName(string name)
-        {
-            return string.Format("\"{0}\"", name);
-        }
-
-        private string GetQuotedTrueValue()
-        {
-            return GetQuotedValue(true, typeof(bool));
-        }
-
-        private string GetQuotedFalseValue()
-        {
-            return GetQuotedValue(false, typeof(bool));
-        }
-
-        public virtual string GetQuotedValue(object value, Type fieldType)
-        {
-            return GetQuotedValue(value, fieldType, EscapeParam, ShouldQuoteValue);
-        }
-
-        private string GetTrueExpression()
-        {
-            object o = GetQuotedTrueValue();
-            return string.Format("({0}={1})", o, o);
-        }
-
-        private string GetFalseExpression()
-        {
-
-            return string.Format("({0}={1})",
-                GetQuotedTrueValue(),
-                GetQuotedFalseValue());
-        }
-
-        private bool IsTrueExpression(string exp)
-        {
-            return (exp == GetTrueExpression());
-        }
-
-        private bool IsFalseExpression(string exp)
-        {
-            return (exp == GetFalseExpression());
-        }
-
-        protected bool IsFieldName(string quotedExp)
-        {
-            //Not entirely sure this is reliable, but its better then simply returning true
-            return quotedExp.LastIndexOf("'", StringComparison.InvariantCultureIgnoreCase) + 1 != quotedExp.Length;
-        }
+    
+        //protected bool IsFieldName(string quotedExp)
+        //{
+        //    //Not entirely sure this is reliable, but its better then simply returning true
+        //    return quotedExp.LastIndexOf("'", StringComparison.InvariantCultureIgnoreCase) + 1 != quotedExp.Length;
+        //}
     }
 }