From bcbd4289ea3500e8815b0d98d8c927c05da24a6d Mon Sep 17 00:00:00 2001
From: Stephan <stephane@umbraco.dk>
Date: Fri, 29 Sep 2017 15:51:33 +0200
Subject: [PATCH] Facade cleanup and refactoring

---
 src/Umbraco.Compat7/Umbraco.Compat7.csproj    |   2 +
 .../Cache/DictionaryCacheProvider.cs          |  29 +-
 .../PublishedContent/IPublishedElement.cs     |   2 +-
 .../PublishedContent/PublishedModelFactory.cs |  10 +-
 src/Umbraco.Core/ReflectionUtilities.cs       |  51 +-
 src/Umbraco.Core/Umbraco.Core.csproj          |   4 +
 src/Umbraco.Examine/Umbraco.Examine.csproj    |   2 +
 src/Umbraco.Tests/Facade/ConvertersTests.cs   | 261 +++++++
 src/Umbraco.Tests/Facade/FacadeTestObjects.cs | 113 +++
 src/Umbraco.Tests/Facade/ModelTypeTests.cs    |  55 ++
 .../Facade/NestedContentTests.cs              |  35 +-
 .../Facade/PropertyCacheLevelTests.cs         | 231 ++++++
 .../ModelsAndConvertersTests.cs               | 659 ------------------
 .../PublishedContentDataTableTests.cs         |  33 +-
 .../PublishedContentTestElements.cs           |   5 +
 .../PublishedContent/PublishedContentTests.cs |   2 +-
 src/Umbraco.Tests/Umbraco.Tests.csproj        |   7 +-
 src/Umbraco.Web.UI/Umbraco.Web.UI.csproj      |   2 +
 .../PropertyEditors/NestedContentHelper.cs    |  11 +-
 .../NestedContentManyValueConverter.cs        |  12 +-
 .../NestedContentSingleValueConverter.cs      |   4 +-
 .../NestedContentValueConverterBase.cs        |  15 +-
 .../PublishedCache/FacadeServiceBase.cs       |  17 +-
 src/Umbraco.Web/PublishedCache/IFacade.cs     |  11 +
 .../PublishedCache/IFacadeService.cs          |  26 -
 .../PublishedCache/NuCache/FacadeService.cs   |  11 -
 .../NuCache/PublishedElementProperty.cs       |  55 --
 .../PublishedCache/PublishedElement.cs        |  38 +-
 .../PublishedElementProperty.cs               |  23 -
 .../PublishedElementPropertyBase.cs           |  70 +-
 .../XmlPublishedCache/Facade.cs               |  24 +-
 .../XmlPublishedCache/FacadeService.cs        |  10 -
 src/Umbraco.Web/Umbraco.Web.csproj            |   4 +-
 src/umbraco.sln.DotSettings                   |   2 +-
 34 files changed, 882 insertions(+), 954 deletions(-)
 create mode 100644 src/Umbraco.Tests/Facade/ConvertersTests.cs
 create mode 100644 src/Umbraco.Tests/Facade/FacadeTestObjects.cs
 create mode 100644 src/Umbraco.Tests/Facade/ModelTypeTests.cs
 create mode 100644 src/Umbraco.Tests/Facade/PropertyCacheLevelTests.cs
 delete mode 100644 src/Umbraco.Tests/PublishedContent/ModelsAndConvertersTests.cs
 delete mode 100644 src/Umbraco.Web/PublishedCache/NuCache/PublishedElementProperty.cs
 delete mode 100644 src/Umbraco.Web/PublishedCache/PublishedElementProperty.cs

diff --git a/src/Umbraco.Compat7/Umbraco.Compat7.csproj b/src/Umbraco.Compat7/Umbraco.Compat7.csproj
index 254f3f53d5..f0f819b176 100644
--- a/src/Umbraco.Compat7/Umbraco.Compat7.csproj
+++ b/src/Umbraco.Compat7/Umbraco.Compat7.csproj
@@ -17,6 +17,7 @@
     <DefineConstants>TRACE;DEBUG;COMPAT7</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <LangVersion>latest</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
@@ -25,6 +26,7 @@
     <DefineConstants>TRACE;COMPAT7</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <LangVersion>latest</LangVersion>
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="System" />
diff --git a/src/Umbraco.Core/Cache/DictionaryCacheProvider.cs b/src/Umbraco.Core/Cache/DictionaryCacheProvider.cs
index 5c8a44b404..22f9209acc 100644
--- a/src/Umbraco.Core/Cache/DictionaryCacheProvider.cs
+++ b/src/Umbraco.Core/Cache/DictionaryCacheProvider.cs
@@ -7,11 +7,14 @@ using Umbraco.Core.Composing;
 
 namespace Umbraco.Core.Cache
 {
-    class DictionaryCacheProvider : ICacheProvider
+    internal class DictionaryCacheProvider : ICacheProvider
     {
         private readonly ConcurrentDictionary<string, Lazy<object>> _items
             = new ConcurrentDictionary<string, Lazy<object>>();
 
+        // for tests
+        internal ConcurrentDictionary<string, Lazy<object>> Items => _items;
+
         public void ClearAllCache()
         {
             _items.Clear();
@@ -19,8 +22,7 @@ namespace Umbraco.Core.Cache
 
         public void ClearCacheItem(string key)
         {
-            Lazy<object> item;
-            _items.TryRemove(key, out item);
+            _items.TryRemove(key, out _);
         }
 
         public void ClearCacheObjectTypes(string typeName)
@@ -29,7 +31,6 @@ namespace Umbraco.Core.Cache
             if (type == null) return;
             var isInterface = type.IsInterface;
 
-            Lazy<object> item;
             foreach (var kvp in _items
                 .Where(x =>
                 {
@@ -42,7 +43,7 @@ namespace Umbraco.Core.Cache
                     // otherwise remove exact types (not inherited types)
                     return value == null || (isInterface ? (type.IsInstanceOfType(value)) : (value.GetType() == type));
                 }))
-                _items.TryRemove(kvp.Key, out item);
+                _items.TryRemove(kvp.Key, out _);
         }
 
         public void ClearCacheObjectTypes<T>()
@@ -50,7 +51,6 @@ namespace Umbraco.Core.Cache
             var typeOfT = typeof(T);
             var isInterface = typeOfT.IsInterface;
 
-            Lazy<object> item;
             foreach (var kvp in _items
                 .Where(x =>
                 {
@@ -64,7 +64,7 @@ namespace Umbraco.Core.Cache
                     // otherwise remove exact types (not inherited types)
                     return value == null || (isInterface ? (value is T) : (value.GetType() == typeOfT));
                 }))
-                _items.TryRemove(kvp.Key, out item);
+                _items.TryRemove(kvp.Key, out _);
         }
 
         public void ClearCacheObjectTypes<T>(Func<string, T, bool> predicate)
@@ -72,7 +72,6 @@ namespace Umbraco.Core.Cache
             var typeOfT = typeof(T);
             var isInterface = typeOfT.IsInterface;
 
-            Lazy<object> item;
             foreach (var kvp in _items
                 .Where(x =>
                 {
@@ -89,23 +88,21 @@ namespace Umbraco.Core.Cache
                             // run predicate on the 'public key' part only, ie without prefix
                             && predicate(x.Key, (T)value);
                 }))
-                _items.TryRemove(kvp.Key, out item);
+                _items.TryRemove(kvp.Key, out _);
         }
 
         public void ClearCacheByKeySearch(string keyStartsWith)
         {
-            Lazy<object> item;
             foreach (var ikvp in _items
                 .Where(kvp => kvp.Key.InvariantStartsWith(keyStartsWith)))
-                _items.TryRemove(ikvp.Key, out item);
+                _items.TryRemove(ikvp.Key, out _);
         }
 
         public void ClearCacheByKeyExpression(string regexString)
         {
-            Lazy<object> item;
             foreach (var ikvp in _items
                 .Where(kvp => Regex.IsMatch(kvp.Key, regexString)))
-                _items.TryRemove(ikvp.Key, out item);
+                _items.TryRemove(ikvp.Key, out _);
         }
 
         public IEnumerable<object> GetCacheItemsByKeySearch(string keyStartsWith)
@@ -126,8 +123,7 @@ namespace Umbraco.Core.Cache
 
         public object GetCacheItem(string cacheKey)
         {
-            Lazy<object> result;
-            _items.TryGetValue(cacheKey, out result); // else null
+            _items.TryGetValue(cacheKey, out var result); // else null
             return result == null ? null : DictionaryCacheProviderBase.GetSafeLazyValue(result); // return exceptions as null
         }
 
@@ -136,8 +132,7 @@ namespace Umbraco.Core.Cache
             var result = _items.GetOrAdd(cacheKey, k => DictionaryCacheProviderBase.GetSafeLazy(getCacheItem));
 
             var value = result.Value; // will not throw (safe lazy)
-            var eh = value as DictionaryCacheProviderBase.ExceptionHolder;
-            if (eh == null)
+            if (!(value is DictionaryCacheProviderBase.ExceptionHolder eh))
                 return value;
 
             // and... it's in the cache anyway - so contrary to other cache providers,
diff --git a/src/Umbraco.Core/Models/PublishedContent/IPublishedElement.cs b/src/Umbraco.Core/Models/PublishedContent/IPublishedElement.cs
index 45dcbd7c78..31325e8c3a 100644
--- a/src/Umbraco.Core/Models/PublishedContent/IPublishedElement.cs
+++ b/src/Umbraco.Core/Models/PublishedContent/IPublishedElement.cs
@@ -29,7 +29,7 @@ namespace Umbraco.Core.Models.PublishedContent
         #region Properties
 
         /// <summary>
-        /// Gets the properties of the set.
+        /// Gets the properties of the element.
         /// </summary>
         /// <remarks>Contains one <c>IPublishedProperty</c> for each property defined for the content type, including
         /// inherited properties. Some properties may have no value.</remarks>
diff --git a/src/Umbraco.Core/Models/PublishedContent/PublishedModelFactory.cs b/src/Umbraco.Core/Models/PublishedContent/PublishedModelFactory.cs
index c09d2a7a38..392508f591 100644
--- a/src/Umbraco.Core/Models/PublishedContent/PublishedModelFactory.cs
+++ b/src/Umbraco.Core/Models/PublishedContent/PublishedModelFactory.cs
@@ -14,7 +14,7 @@ namespace Umbraco.Core.Models.PublishedContent
         private class ModelInfo
         {
             public Type ParameterType { get; set; }
-            public Func<IPublishedElement, IPublishedElement> Ctor { get; set; }
+            public Func<object, object> Ctor { get; set; }
             public Type ModelType { get; set; }
         }
 
@@ -69,8 +69,9 @@ namespace Umbraco.Core.Models.PublishedContent
                 if (modelInfos.TryGetValue(typeName, out var modelInfo))
                     throw new InvalidOperationException($"Both types {type.FullName} and {modelInfo.ModelType.FullName} want to be a model type for content type with alias \"{typeName}\".");
 
-                var ctorFunc = ReflectionUtilities.EmitCtor<Func<IPublishedElement, IPublishedElement>>(constructor);
-                modelInfos[typeName] = new ModelInfo { ParameterType = parameterType, ModelType = type, Ctor = ctorFunc };
+                // have to use an unsafe ctor because we don't know the types, really
+                var modelCtor = ReflectionUtilities.EmitCtorUnsafe<Func<object, object>>(constructor);
+                modelInfos[typeName] = new ModelInfo { ParameterType = parameterType, ModelType = type, Ctor = modelCtor };
                 ModelTypeMap[typeName] = type;
             }
 
@@ -90,7 +91,8 @@ namespace Umbraco.Core.Models.PublishedContent
             if (modelInfo.ParameterType.IsAssignableFrom(element.GetType()) == false)
                 throw new InvalidOperationException($"Model {modelInfo.ModelType} expects argument of type {modelInfo.ParameterType.FullName}, but got {element.GetType().FullName}.");
 
-            return modelInfo.Ctor(element);
+            // can cast, because we checked when creating the ctor
+            return (IPublishedElement) modelInfo.Ctor(element);
         }
     }
 }
diff --git a/src/Umbraco.Core/ReflectionUtilities.cs b/src/Umbraco.Core/ReflectionUtilities.cs
index 382955f34e..002ed257cf 100644
--- a/src/Umbraco.Core/ReflectionUtilities.cs
+++ b/src/Umbraco.Core/ReflectionUtilities.cs
@@ -214,7 +214,7 @@ namespace Umbraco.Core
             }
 
             // emit
-            return EmitCtor<TLambda>(declaring, args, returned, ctor);
+            return EmitCtor<TLambda>(declaring, args, ctor);
         }
 
         /// <summary>
@@ -249,7 +249,50 @@ namespace Umbraco.Core
                 ThrowInvalidLambda<TLambda>("ctor", declaring, args);
 
             // emit
-            return EmitCtor<TLambda>(declaring, args, declaring, ctor);
+            return EmitCtor<TLambda>(declaring, args, ctor);
+        }
+
+        /// <summary>
+        /// Emits a constructor.
+        /// </summary>
+        /// <typeparam name="TLambda">A lambda representing the constructor.</typeparam>
+        /// <param name="ctor">The constructor info.</param>
+        /// <returns>A constructor function.</returns>
+        /// <remarks>
+        /// <para>The constructor is emitted in an unsafe way, using the lambda arguments without verifying
+        /// them at all. This assumes that the calling code is taking care of all verifications, in order
+        /// to avoid cast errors.</para>
+        /// </remarks>
+        /// <exception cref="ArgumentException">Occurs when <typeparamref name="TLambda"/> is not a Func or when its generic
+        /// arguments do not match those of <paramref name="ctor"/>.</exception>
+        /// <exception cref="ArgumentNullException">Occurs when <paramref name="ctor"/> is null.</exception>
+        public static TLambda EmitCtorUnsafe<TLambda>(ConstructorInfo ctor)
+        {
+            if (ctor == null)
+                throw new ArgumentNullException(nameof(ctor));
+
+            // get type and args
+            var declaring = ctor.DeclaringType;
+            var module = declaring?.Module;
+            if (module == null)
+                throw new ArgumentException("Failed to get ctor's declaring type module.", nameof(ctor));
+
+            // validate lambda type
+            ValidateCtorLambda<TLambda>();
+
+            // unsafe - use lambda's args and assume they are correct
+            //var args = ctor.GetParameters().Select(x => x.ParameterType).ToArray();
+            var genArgs = typeof(TLambda).GetGenericArguments();
+            var args = new Type[genArgs.Length - 1];
+            Array.Copy(genArgs, 0, args, 0, args.Length);
+
+            // emit
+            var dm = new DynamicMethod(string.Empty, declaring, args, module, true);
+            var ilgen = dm.GetILGenerator();
+            EmitLdargs(ilgen, args.Length);
+            ilgen.Emit(OpCodes.Newobj, ctor); // ok to just return, it's only objects
+            ilgen.Emit(OpCodes.Ret);
+            return (TLambda) (object) dm.CreateDelegate(typeof(TLambda));
         }
 
         private static void ValidateCtorLambda<TLambda>()
@@ -260,9 +303,9 @@ namespace Umbraco.Core
                 throw new ArgumentException($"Lambda {typeLambda} is not a Func.", nameof(TLambda));
         }
 
-        private static TLambda EmitCtor<TLambda>(Type declaring, Type[] args, Type returned, ConstructorInfo ctor)
+        private static TLambda EmitCtor<TLambda>(Type declaring, Type[] args, ConstructorInfo ctor)
         {
-            var dm = new DynamicMethod(string.Empty, returned, args, declaring.Module, true);
+            var dm = new DynamicMethod(string.Empty, declaring, args, declaring.Module, true);
             var ilgen = dm.GetILGenerator();
             EmitLdargs(ilgen, args.Length);
             ilgen.Emit(OpCodes.Newobj, ctor); // ok to just return, it's only objects
diff --git a/src/Umbraco.Core/Umbraco.Core.csproj b/src/Umbraco.Core/Umbraco.Core.csproj
index 7a7664f5c4..26042fb478 100644
--- a/src/Umbraco.Core/Umbraco.Core.csproj
+++ b/src/Umbraco.Core/Umbraco.Core.csproj
@@ -18,6 +18,7 @@
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <Prefer32Bit>false</Prefer32Bit>
+    <LangVersion>latest</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
@@ -79,6 +80,9 @@
     <PackageReference Include="Semver" Version="2.0.4" />
     <PackageReference Include="SharpZipLib" Version="0.86.0" />
     <PackageReference Include="SqlServerCE" Version="4.0.0.1" />
+    <PackageReference Include="System.ValueTuple">
+      <Version>4.4.0</Version>
+    </PackageReference>
   </ItemGroup>
   <ItemGroup>
     <!--
diff --git a/src/Umbraco.Examine/Umbraco.Examine.csproj b/src/Umbraco.Examine/Umbraco.Examine.csproj
index b7b8b3217a..0ddf146739 100644
--- a/src/Umbraco.Examine/Umbraco.Examine.csproj
+++ b/src/Umbraco.Examine/Umbraco.Examine.csproj
@@ -18,6 +18,7 @@
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <Prefer32Bit>false</Prefer32Bit>
+    <LangVersion>latest</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
@@ -28,6 +29,7 @@
     <WarningLevel>4</WarningLevel>
     <DocumentationFile>bin\Release\Umbraco.Examine.xml</DocumentationFile>
     <Prefer32Bit>false</Prefer32Bit>
+    <LangVersion>latest</LangVersion>
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="System" />
diff --git a/src/Umbraco.Tests/Facade/ConvertersTests.cs b/src/Umbraco.Tests/Facade/ConvertersTests.cs
new file mode 100644
index 0000000000..9c4656c22d
--- /dev/null
+++ b/src/Umbraco.Tests/Facade/ConvertersTests.cs
@@ -0,0 +1,261 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using LightInject;
+using Moq;
+using NUnit.Framework;
+using Umbraco.Core;
+using Umbraco.Core.Composing;
+using Umbraco.Core.Models.PublishedContent;
+using Umbraco.Core.PropertyEditors;
+using Umbraco.Web;
+using Umbraco.Web.PublishedCache;
+
+namespace Umbraco.Tests.Facade
+{
+    [TestFixture]
+    public class ConvertersTests
+    {
+        #region SimpleConverter1
+
+        [Test]
+        public void SimpleConverter1Test()
+        {
+            var converters = new PropertyValueConverterCollection(new IPropertyValueConverter[]
+            {
+                new SimpleConverter1(),
+            });
+
+            var elementType1 = new PublishedContentType(1000, "element1", new[]
+            {
+                new PublishedPropertyType("prop1", "editor1", converters),
+            });
+
+            var element1 = new PublishedElement(elementType1, Guid.NewGuid(), new Dictionary<string, object> { { "prop1", "1234" } }, false);
+
+            Assert.AreEqual(1234, element1.Value("prop1"));
+        }
+
+        private class SimpleConverter1 : IPropertyValueConverter
+        {
+            public bool IsConverter(PublishedPropertyType propertyType)
+                => propertyType.PropertyEditorAlias.InvariantEquals("editor1");
+
+            public Type GetPropertyValueType(PublishedPropertyType propertyType)
+                => typeof (int);
+
+            public PropertyCacheLevel GetPropertyCacheLevel(PublishedPropertyType propertyType)
+                => PropertyCacheLevel.Content;
+
+            public object ConvertSourceToInter(IPublishedElement owner, PublishedPropertyType propertyType, object source, bool preview)
+                => int.TryParse(source as string, out int i) ? i : 0;
+
+            public object ConvertInterToObject(IPublishedElement owner, PublishedPropertyType propertyType, PropertyCacheLevel referenceCacheLevel, object inter, bool preview)
+                => (int) inter;
+
+            public object ConvertInterToXPath(IPublishedElement owner, PublishedPropertyType propertyType, PropertyCacheLevel referenceCacheLevel, object inter, bool preview)
+                => ((int) inter).ToString();
+        }
+
+        #endregion
+
+        #region SimpleConverter2
+
+        [Test]
+        public void SimpleConverter2Test()
+        {
+            var cacheMock = new Mock<IPublishedContentCache>();
+            var cacheContent = new Dictionary<int, IPublishedContent>();
+            cacheMock.Setup(x => x.GetById(It.IsAny<int>())).Returns<int>(id => cacheContent.TryGetValue(id, out IPublishedContent content) ? content : null);
+            var facadeMock = new Mock<IFacade>();
+            facadeMock.Setup(x => x.ContentCache).Returns(cacheMock.Object);
+            var facadeAccessorMock = new Mock<IFacadeAccessor>();
+            facadeAccessorMock.Setup(x => x.Facade).Returns(facadeMock.Object);
+            var facadeAccessor = facadeAccessorMock.Object;
+
+            var converters = new PropertyValueConverterCollection(new IPropertyValueConverter[]
+            {
+                new SimpleConverter2(facadeAccessor),
+            });
+
+            var elementType1 = new PublishedContentType(1000, "element1", new[]
+            {
+                new PublishedPropertyType("prop1", "editor2", converters),
+            });
+
+            var element1 = new PublishedElement(elementType1, Guid.NewGuid(), new Dictionary<string, object> { { "prop1", "1234" } }, false);
+
+            var cntType1 = new PublishedContentType(1001, "cnt1", Array.Empty<PublishedPropertyType>());
+            var cnt1 = new FacadeTestObjects.TestPublishedContent(cntType1, 1234, Guid.NewGuid(), new Dictionary<string, object>(), false);
+            cacheContent[cnt1.Id] = cnt1;
+
+            Assert.AreSame(cnt1, element1.Value("prop1"));
+        }
+
+        private class SimpleConverter2 : IPropertyValueConverter
+        {
+            private readonly IFacadeAccessor _facadeAccessor;
+            private readonly PropertyCacheLevel _cacheLevel;
+
+            public SimpleConverter2(IFacadeAccessor facadeAccessor, PropertyCacheLevel cacheLevel = PropertyCacheLevel.None)
+            {
+                _facadeAccessor = facadeAccessor;
+                _cacheLevel = cacheLevel;
+            }
+
+            public bool IsConverter(PublishedPropertyType propertyType)
+                => propertyType.PropertyEditorAlias.InvariantEquals("editor2");
+
+            public Type GetPropertyValueType(PublishedPropertyType propertyType)
+                // the first version would be the "generic" version, but say we want to be more precise
+                // and return: whatever Clr type is generated for content type with alias "cnt1" -- which
+                // we cannot really typeof() at the moment because it has not been generated, hence ModelType.
+                // => typeof (IPublishedContent);
+                => ModelType.For("cnt1");
+
+            public PropertyCacheLevel GetPropertyCacheLevel(PublishedPropertyType propertyType)
+                => _cacheLevel;
+
+            public object ConvertSourceToInter(IPublishedElement owner, PublishedPropertyType propertyType, object source, bool preview)
+                => int.TryParse(source as string, out int i) ? i : -1;
+
+            public object ConvertInterToObject(IPublishedElement owner, PublishedPropertyType propertyType, PropertyCacheLevel referenceCacheLevel, object inter, bool preview)
+                => _facadeAccessor.Facade.ContentCache.GetById((int) inter);
+
+            public object ConvertInterToXPath(IPublishedElement owner, PublishedPropertyType propertyType, PropertyCacheLevel referenceCacheLevel, object inter, bool preview)
+                => ((int) inter).ToString();
+        }
+
+        #endregion
+
+        #region SimpleConverter3
+
+        [Test]
+        public void SimpleConverter3Test()
+        {
+            Current.Reset();
+            var container = new ServiceContainer();
+            container.ConfigureUmbracoCore();
+
+            Current.Container.RegisterCollectionBuilder<PropertyValueConverterCollectionBuilder>()
+                .Append<SimpleConverter3A>()
+                .Append<SimpleConverter3B>();
+
+            IPublishedModelFactory factory = new PublishedModelFactory(new[]
+            {
+                typeof (FacadeTestObjects.TestElementModel1), typeof (FacadeTestObjects.TestElementModel2),
+                typeof (FacadeTestObjects.TestContentModel1), typeof (FacadeTestObjects.TestContentModel2),
+            });
+            Current.Container.Register(f => factory);
+
+            var cacheMock = new Mock<IPublishedContentCache>();
+            var cacheContent = new Dictionary<int, IPublishedContent>();
+            cacheMock.Setup(x => x.GetById(It.IsAny<int>())).Returns<int>(id => cacheContent.TryGetValue(id, out IPublishedContent content) ? content : null);
+            var facadeMock = new Mock<IFacade>();
+            facadeMock.Setup(x => x.ContentCache).Returns(cacheMock.Object);
+            var facadeAccessorMock = new Mock<IFacadeAccessor>();
+            facadeAccessorMock.Setup(x => x.Facade).Returns(facadeMock.Object);
+            Current.Container.Register(f => facadeAccessorMock.Object);
+
+            var elementType1 = new PublishedContentType(1000, "element1", new[]
+            {
+                new PublishedPropertyType("prop1", "editor1"),
+            });
+
+            var elementType2 = new PublishedContentType(1001, "element2", new[]
+            {
+                new PublishedPropertyType("prop2", "editor2"),
+            });
+
+            var contentType1 = new PublishedContentType(1002, "content1", new[]
+            {
+                new PublishedPropertyType("prop1", "editor1"),
+            });
+
+            var contentType2 = new PublishedContentType(1003, "content2", new[]
+            {
+                new PublishedPropertyType("prop2", "editor2"),
+            });
+
+            var element1 = new PublishedElement(elementType1, Guid.NewGuid(), new Dictionary<string, object> { { "prop1", "val1" } }, false);
+            var element2 = new PublishedElement(elementType2, Guid.NewGuid(), new Dictionary<string, object> { { "prop2", "1003" } }, false);
+            var cnt1 = new FacadeTestObjects.TestPublishedContent(contentType1, 1003, Guid.NewGuid(), new Dictionary<string, object> { { "prop1", "val1" } }, false);
+            var cnt2 = new FacadeTestObjects.TestPublishedContent(contentType2, 1004, Guid.NewGuid(), new Dictionary<string, object> { { "prop2", "1003" } }, false);
+
+            cacheContent[cnt1.Id] = cnt1.CreateModel();
+            cacheContent[cnt2.Id] = cnt2.CreateModel();
+
+            // can get the actual property Clr type
+            // ie ModelType gets properly mapped by IPublishedContentModelFactory
+            // must test ModelClrType with special equals 'cos they are not ref-equals
+            Assert.IsTrue(ModelType.Equals(typeof (IEnumerable<>).MakeGenericType(ModelType.For("content1")), contentType2.GetPropertyType("prop2").ModelClrType));
+            Assert.AreEqual(typeof (IEnumerable<FacadeTestObjects.TestContentModel1>), contentType2.GetPropertyType("prop2").ClrType);
+
+            // can create a model for an element
+            var model1 = factory.CreateModel(element1);
+            Assert.IsInstanceOf<FacadeTestObjects.TestElementModel1>(model1);
+            Assert.AreEqual("val1", ((FacadeTestObjects.TestElementModel1) model1).Prop1);
+
+            // can create a model for a published content
+            var model2 = factory.CreateModel(element2);
+            Assert.IsInstanceOf<FacadeTestObjects.TestElementModel2>(model2);
+            var mmodel2 = (FacadeTestObjects.TestElementModel2) model2;
+
+            // and get direct property
+            Assert.IsInstanceOf<FacadeTestObjects.TestContentModel1[]>(model2.Value("prop2"));
+            Assert.AreEqual(1, ((FacadeTestObjects.TestContentModel1[]) model2.Value("prop2")).Length);
+
+            // and get model property
+            Assert.IsInstanceOf<IEnumerable<FacadeTestObjects.TestContentModel1>>(mmodel2.Prop2);
+            Assert.IsInstanceOf<FacadeTestObjects.TestContentModel1[]>(mmodel2.Prop2);
+            var mmodel1 = mmodel2.Prop2.First();
+
+            // and we get what we want
+            Assert.AreSame(cacheContent[mmodel1.Id], mmodel1);
+        }
+
+        public class SimpleConverter3A : PropertyValueConverterBase
+        {
+            public override bool IsConverter(PublishedPropertyType propertyType)
+                => propertyType.PropertyEditorAlias == "editor1";
+
+            public override Type GetPropertyValueType(PublishedPropertyType propertyType)
+                => typeof (string);
+
+            public override PropertyCacheLevel GetPropertyCacheLevel(PublishedPropertyType propertyType)
+                => PropertyCacheLevel.Content;
+        }
+
+        public class SimpleConverter3B : PropertyValueConverterBase
+        {
+            private readonly IFacadeAccessor _facadeAccessor;
+
+            public SimpleConverter3B(IFacadeAccessor facadeAccessor)
+            {
+                _facadeAccessor = facadeAccessor;
+            }
+
+            public override bool IsConverter(PublishedPropertyType propertyType)
+                => propertyType.PropertyEditorAlias == "editor2";
+
+            public override Type GetPropertyValueType(PublishedPropertyType propertyType)
+                => typeof (IEnumerable<>).MakeGenericType(ModelType.For("content1"));
+
+            public override PropertyCacheLevel GetPropertyCacheLevel(PublishedPropertyType propertyType)
+                => PropertyCacheLevel.Snapshot;
+
+            public override object ConvertSourceToInter(IPublishedElement owner, PublishedPropertyType propertyType, object source, bool preview)
+            {
+                var s = source as string;
+                return s?.Split(',').Select(int.Parse).ToArray() ?? Array.Empty<int>();
+            }
+
+            public override object ConvertInterToObject(IPublishedElement owner, PublishedPropertyType propertyType, PropertyCacheLevel referenceCacheLevel, object inter, bool preview)
+            {
+                return ((int[]) inter).Select(x => (FacadeTestObjects.TestContentModel1) _facadeAccessor.Facade.ContentCache.GetById(x)).ToArray();
+            }
+        }
+
+        #endregion
+    }
+}
diff --git a/src/Umbraco.Tests/Facade/FacadeTestObjects.cs b/src/Umbraco.Tests/Facade/FacadeTestObjects.cs
new file mode 100644
index 0000000000..447dd93e3a
--- /dev/null
+++ b/src/Umbraco.Tests/Facade/FacadeTestObjects.cs
@@ -0,0 +1,113 @@
+using System;
+using System.Collections.Generic;
+using Umbraco.Core.Models.PublishedContent;
+using Umbraco.Web;
+using Umbraco.Web.PublishedCache;
+
+namespace Umbraco.Tests.Facade
+{
+    public class FacadeTestObjects
+    {
+        #region Published models
+
+        [PublishedContentModel("element1")]
+        public class TestElementModel1 : PublishedElementModel
+        {
+            public TestElementModel1(IPublishedElement content)
+                : base(content)
+            { }
+
+            public string Prop1 => this.Value<string>("prop1");
+        }
+
+        [PublishedContentModel("element2")]
+        public class TestElementModel2 : PublishedElementModel
+        {
+            public TestElementModel2(IPublishedElement content)
+                : base(content)
+            { }
+
+            public IEnumerable<TestContentModel1> Prop2 => this.Value<IEnumerable<TestContentModel1>>("prop2");
+        }
+
+        [PublishedContentModel("content1")]
+        public class TestContentModel1 : PublishedContentModel
+        {
+            public TestContentModel1(IPublishedContent content)
+                : base(content)
+            { }
+
+            public string Prop1 => this.Value<string>("prop1");
+        }
+
+        [PublishedContentModel("content2")]
+        public class TestContentModel2 : PublishedContentModel
+        {
+            public TestContentModel2(IPublishedContent content)
+                : base(content)
+            { }
+
+            public IEnumerable<TestContentModel1> Prop2 => this.Value<IEnumerable<TestContentModel1>>("prop2");
+        }
+
+        #endregion
+
+        #region Support classes
+
+        internal class TestPublishedContent : PublishedElement, IPublishedContent
+        {
+            public TestPublishedContent(PublishedContentType contentType, int id, Guid key, Dictionary<string, object> values, bool previewing)
+                : base(contentType, key, values, previewing)
+            {
+                Id = id;
+            }
+
+            public int Id { get; }
+            public int TemplateId { get; set; }
+            public int SortOrder { get; set; }
+            public string Name { get; set; }
+            public string UrlName { get; set; }
+            public string DocumentTypeAlias => ContentType.Alias;
+            public int DocumentTypeId { get; set; }
+            public string WriterName { get; set; }
+            public string CreatorName { get; set; }
+            public int WriterId { get; set; }
+            public int CreatorId { get; set; }
+            public string Path { get; set; }
+            public DateTime CreateDate { get; set; }
+            public DateTime UpdateDate { get; set; }
+            public Guid Version { get; set; }
+            public int Level { get; set; }
+            public string Url { get; set; }
+            public PublishedItemType ItemType => ContentType.ItemType;
+            public bool IsDraft { get; set; }
+            public IPublishedContent Parent { get; set; }
+            public IEnumerable<IPublishedContent> Children { get; set; }
+
+            // copied from PublishedContentBase
+            public IPublishedProperty GetProperty(string alias, bool recurse)
+            {
+                var property = GetProperty(alias);
+                if (recurse == false) return property;
+
+                IPublishedContent content = this;
+                var firstNonNullProperty = property;
+                while (content != null && (property == null || property.HasValue == false))
+                {
+                    content = content.Parent;
+                    property = content?.GetProperty(alias);
+                    if (firstNonNullProperty == null && property != null) firstNonNullProperty = property;
+                }
+
+                // if we find a content with the property with a value, return that property
+                // if we find no content with the property, return null
+                // if we find a content with the property without a value, return that property
+                //   have to save that first property while we look further up, hence firstNonNullProperty
+
+                return property != null && property.HasValue ? property : firstNonNullProperty;
+            }
+        }
+
+        #endregion
+    }
+}
diff --git a/src/Umbraco.Tests/Facade/ModelTypeTests.cs b/src/Umbraco.Tests/Facade/ModelTypeTests.cs
new file mode 100644
index 0000000000..ad6bdc8598
--- /dev/null
+++ b/src/Umbraco.Tests/Facade/ModelTypeTests.cs
@@ -0,0 +1,55 @@
+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using Umbraco.Core.Models.PublishedContent;
+
+namespace Umbraco.Tests.Facade
+{
+    [TestFixture]
+    public class ModelTypeTests
+    {
+        [Test]
+        public void ModelTypeEqualityTests()
+        {
+            Assert.AreNotEqual(ModelType.For("alias1"), ModelType.For("alias1"));
+
+            Assert.IsTrue(ModelType.Equals(ModelType.For("alias1"), ModelType.For("alias1")));
+            Assert.IsFalse(ModelType.Equals(ModelType.For("alias1"), ModelType.For("alias2")));
+
+            Assert.IsTrue(ModelType.Equals(typeof(IEnumerable<>).MakeGenericType(ModelType.For("alias1")), typeof(IEnumerable<>).MakeGenericType(ModelType.For("alias1"))));
+            Assert.IsFalse(ModelType.Equals(typeof(IEnumerable<>).MakeGenericType(ModelType.For("alias1")), typeof(IEnumerable<>).MakeGenericType(ModelType.For("alias2"))));
+
+            Assert.IsTrue(ModelType.Equals(ModelType.For("alias1").MakeArrayType(), ModelType.For("alias1").MakeArrayType()));
+            Assert.IsFalse(ModelType.Equals(ModelType.For("alias1").MakeArrayType(), ModelType.For("alias2").MakeArrayType()));
+        }
+
+        [Test]
+        public void ModelTypeToStringTests()
+        {
+            Assert.AreEqual("{alias1}", ModelType.For("alias1").ToString());
+
+            // there's an "*" there because the arrays are not true SZArray - but that changes when we map
+            Assert.AreEqual("{alias1}[*]", ModelType.For("alias1").MakeArrayType().ToString());
+            Assert.AreEqual("System.Collections.Generic.IEnumerable`1[{alias1}[*]]", typeof(IEnumerable<>).MakeGenericType(ModelType.For("alias1").MakeArrayType()).ToString());
+        }
+
+        [Test]
+        public void ModelTypeMapTests()
+        {
+            var map = new Dictionary<string, Type>
+            {
+                { "alias1", typeof (FacadeTestObjects.TestElementModel1) },
+                { "alias2", typeof (FacadeTestObjects.TestElementModel2) },
+            };
+
+            Assert.AreEqual("Umbraco.Tests.Facade.FacadeTestObjects+TestElementModel1",
+                ModelType.Map(ModelType.For("alias1"), map).ToString());
+            Assert.AreEqual("Umbraco.Tests.Facade.FacadeTestObjects+TestElementModel1[]",
+                ModelType.Map(ModelType.For("alias1").MakeArrayType(), map).ToString());
+            Assert.AreEqual("System.Collections.Generic.IEnumerable`1[Umbraco.Tests.Facade.FacadeTestObjects+TestElementModel1]",
+                ModelType.Map(typeof(IEnumerable<>).MakeGenericType(ModelType.For("alias1")), map).ToString());
+            Assert.AreEqual("System.Collections.Generic.IEnumerable`1[Umbraco.Tests.Facade.FacadeTestObjects+TestElementModel1[]]",
+                ModelType.Map(typeof(IEnumerable<>).MakeGenericType(ModelType.For("alias1").MakeArrayType()), map).ToString());
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Tests/Facade/NestedContentTests.cs b/src/Umbraco.Tests/Facade/NestedContentTests.cs
index a127e739a4..2ccba2e58d 100644
--- a/src/Umbraco.Tests/Facade/NestedContentTests.cs
+++ b/src/Umbraco.Tests/Facade/NestedContentTests.cs
@@ -75,7 +75,7 @@ namespace Umbraco.Tests.Facade
                 .Setup(x => x.ModelTypeMap)
                 .Returns(new Dictionary<string, Type>
                 {
-                    { "contentN1", typeof (TestModel) }
+                    { "contentN1", typeof (TestElementModel) }
                 });
 
             // mocked model factory creates models
@@ -84,7 +84,7 @@ namespace Umbraco.Tests.Facade
                 .Returns((IPublishedElement element) =>
                 {
                     if (element.ContentType.Alias.InvariantEquals("contentN1"))
-                        return new TestModel(element);
+                        return new TestElementModel(element);
                     return element;
                 });
 
@@ -104,20 +104,10 @@ namespace Umbraco.Tests.Facade
                 .Setup(x => x.Facade)
                 .Returns(facade.Object);
 
-            var facadeService = new Mock<IFacadeService>();
-            //container.RegisterSingleton(f => facadeService.Object);
-
-            // mocked facade service creates element properties
-            facadeService
-                .Setup(x => x.CreateElementProperty(It.IsAny<PublishedPropertyType>(), It.IsAny<IPublishedElement>(), It.IsAny<bool>(), It.IsAny<PropertyCacheLevel>(), It.IsAny<object>()))
-                .Returns((PublishedPropertyType propertyType, IPublishedElement element, bool preview, PropertyCacheLevel referenceCacheLevel, object source)
-                    => new TestPublishedProperty(propertyType, element, preview, referenceCacheLevel, source));
-
-            var lazyFacadeService = new Lazy<IFacadeService>(() => facadeService.Object);
             var converters = new PropertyValueConverterCollection(new IPropertyValueConverter[]
             {
-                new NestedContentSingleValueConverter(facadeAccessor.Object, lazyFacadeService, publishedModelFactory.Object, proflog),
-                new NestedContentManyValueConverter(facadeAccessor.Object, lazyFacadeService, publishedModelFactory.Object, proflog),
+                new NestedContentSingleValueConverter(facadeAccessor.Object, publishedModelFactory.Object, proflog),
+                new NestedContentManyValueConverter(facadeAccessor.Object, publishedModelFactory.Object, proflog),
             });
 
             var propertyType1 = new PublishedPropertyType("property1", 1, Constants.PropertyEditors.NestedContentAlias, converters);
@@ -146,7 +136,7 @@ namespace Umbraco.Tests.Facade
             (var contentType1, _) = CreateContentTypes();
 
             // nested single converter returns the proper value clr type TestModel, and cache level
-            Assert.AreEqual(typeof (TestModel), contentType1.GetPropertyType("property1").ClrType);
+            Assert.AreEqual(typeof (TestElementModel), contentType1.GetPropertyType("property1").ClrType);
             Assert.AreEqual(PropertyCacheLevel.Content, contentType1.GetPropertyType("property1").CacheLevel);
 
             var key = Guid.NewGuid();
@@ -160,8 +150,8 @@ namespace Umbraco.Tests.Facade
             var value = content.Value("property1");
 
             // nested single converter returns proper TestModel value
-            Assert.IsInstanceOf<TestModel>(value);
-            var valueM = (TestModel) value;
+            Assert.IsInstanceOf<TestElementModel>(value);
+            var valueM = (TestElementModel) value;
             Assert.AreEqual("foo", valueM.PropValue);
             Assert.AreEqual(keyA, valueM.Key);
         }
@@ -172,7 +162,7 @@ namespace Umbraco.Tests.Facade
             (_, var contentType2) = CreateContentTypes();
 
             // nested many converter returns the proper value clr type IEnumerable<TestModel>, and cache level
-            Assert.AreEqual(typeof (IEnumerable<TestModel>), contentType2.GetPropertyType("property2").ClrType);
+            Assert.AreEqual(typeof (IEnumerable<TestElementModel>), contentType2.GetPropertyType("property2").ClrType);
             Assert.AreEqual(PropertyCacheLevel.Content, contentType2.GetPropertyType("property2").CacheLevel);
 
             var key = Guid.NewGuid();
@@ -189,18 +179,17 @@ namespace Umbraco.Tests.Facade
 
             // nested many converter returns proper IEnumerable<TestModel> value
             Assert.IsInstanceOf<IEnumerable<IPublishedElement>>(value);
-            Assert.IsInstanceOf<IEnumerable<TestModel>>(value);
-            var valueM = ((IEnumerable<TestModel>) value).ToArray();
+            Assert.IsInstanceOf<IEnumerable<TestElementModel>>(value);
+            var valueM = ((IEnumerable<TestElementModel>) value).ToArray();
             Assert.AreEqual("foo", valueM[0].PropValue);
             Assert.AreEqual(keyA, valueM[0].Key);
             Assert.AreEqual("bar", valueM[1].PropValue);
             Assert.AreEqual(keyB, valueM[1].Key);
         }
 
-        // note: this class needs to be public enough, for the converters to be able to instanciate it
-        public class TestModel : PublishedElementModel
+        public class TestElementModel : PublishedElementModel
         {
-            public TestModel(IPublishedElement content)
+            public TestElementModel(IPublishedElement content)
                 : base(content)
             { }
 
diff --git a/src/Umbraco.Tests/Facade/PropertyCacheLevelTests.cs b/src/Umbraco.Tests/Facade/PropertyCacheLevelTests.cs
new file mode 100644
index 0000000000..4f30986ef9
--- /dev/null
+++ b/src/Umbraco.Tests/Facade/PropertyCacheLevelTests.cs
@@ -0,0 +1,231 @@
+using System;
+using System.Collections.Generic;
+using Moq;
+using NUnit.Framework;
+using Umbraco.Core;
+using Umbraco.Core.Cache;
+using Umbraco.Core.Models.PublishedContent;
+using Umbraco.Core.PropertyEditors;
+using Umbraco.Web;
+using Umbraco.Web.PublishedCache;
+
+namespace Umbraco.Tests.Facade
+{
+    [TestFixture]
+    public class PropertyCacheLevelTests
+    {
+        [TestCase(PropertyCacheLevel.None, 2)]
+        [TestCase(PropertyCacheLevel.Content, 1)]
+        [TestCase(PropertyCacheLevel.Snapshot, 1)]
+        [TestCase(PropertyCacheLevel.Facade, 1)]
+        public void CacheLevelTest(PropertyCacheLevel cacheLevel, int interConverts)
+        {
+            var converter = new CacheConverter1(cacheLevel);
+
+            var converters = new PropertyValueConverterCollection(new IPropertyValueConverter[]
+            {
+                converter,
+            });
+
+            var setType1 = new PublishedContentType(1000, "set1", new[]
+            {
+                new PublishedPropertyType("prop1", "editor1", converters),
+            });
+
+            // PublishedElementPropertyBase.GetCacheLevels:
+            //
+            //   if property level is > reference level, or both are None
+            //     use None for property & new reference
+            //   else
+            //     use Content for property, & keep reference
+            //
+            // PublishedElement creates properties with reference being None
+            // if converter specifies None, keep using None
+            // anything else is not > None, use Content
+            //
+            // for standalone elements, it's only None or Content
+
+            var set1 = new PublishedElement(setType1, Guid.NewGuid(), new Dictionary<string, object> { { "prop1", "1234" } }, false);
+
+            Assert.AreEqual(1234, set1.Value("prop1"));
+            Assert.AreEqual(1, converter.SourceConverts);
+            Assert.AreEqual(1, converter.InterConverts);
+
+            // source is always converted once and cached per content
+            // inter conversion depends on the specified cache level
+
+            Assert.AreEqual(1234, set1.Value("prop1"));
+            Assert.AreEqual(1, converter.SourceConverts);
+            Assert.AreEqual(interConverts, converter.InterConverts);
+        }
+
+        // property is not cached, converted cached at Content, exept
+        //  /None = not cached at all
+        [TestCase(PropertyCacheLevel.None, PropertyCacheLevel.None, 2, 0, 0, 0, 0)]
+        [TestCase(PropertyCacheLevel.None, PropertyCacheLevel.Content, 1, 0, 0, 0, 0)]
+        [TestCase(PropertyCacheLevel.None, PropertyCacheLevel.Snapshot, 1, 0, 0, 0, 0)]
+        [TestCase(PropertyCacheLevel.None, PropertyCacheLevel.Facade, 1, 0, 0, 0, 0)]
+
+        // property is cached at content level, converted cached at
+        //  /None = not at all
+        //  /Content = in content
+        //  /Facade = in facade
+        //  /Snapshot = in snapshot
+        [TestCase(PropertyCacheLevel.Content, PropertyCacheLevel.None, 2, 0, 0, 0, 0)]
+        [TestCase(PropertyCacheLevel.Content, PropertyCacheLevel.Content, 1, 0, 0, 0, 0)]
+        [TestCase(PropertyCacheLevel.Content, PropertyCacheLevel.Snapshot, 1, 1, 0, 1, 0)]
+        [TestCase(PropertyCacheLevel.Content, PropertyCacheLevel.Facade, 1, 0, 1, 0, 1)]
+
+        // property is cached at snapshot level, converted cached at Content, exept
+        //  /None = not cached at all
+        //  /Facade = cached in facade
+        [TestCase(PropertyCacheLevel.Snapshot, PropertyCacheLevel.None, 2, 0, 0, 0, 0)]
+        [TestCase(PropertyCacheLevel.Snapshot, PropertyCacheLevel.Content, 1, 0, 0, 0, 0)]
+        [TestCase(PropertyCacheLevel.Snapshot, PropertyCacheLevel.Snapshot, 1, 0, 0, 0, 0)]
+        [TestCase(PropertyCacheLevel.Snapshot, PropertyCacheLevel.Facade, 1, 0, 1, 0, 1)]
+
+        // property is cached at facade level, converted cached at Content, exept
+        //  /None = not cached at all
+        [TestCase(PropertyCacheLevel.Facade, PropertyCacheLevel.None, 2, 0, 0, 0, 0)]
+        [TestCase(PropertyCacheLevel.Facade, PropertyCacheLevel.Content, 1, 0, 0, 0, 0)]
+        [TestCase(PropertyCacheLevel.Facade, PropertyCacheLevel.Snapshot, 1, 0, 0, 0, 0)]
+        [TestCase(PropertyCacheLevel.Facade, PropertyCacheLevel.Facade, 1, 0, 0, 0, 0)]
+
+        public void CacheFacadeTest(PropertyCacheLevel referenceCacheLevel, PropertyCacheLevel converterCacheLevel, int interConverts,
+            int snapshotCount1, int facadeCount1, int snapshotCount2, int facadeCount2)
+        {
+            var converter = new CacheConverter1(converterCacheLevel);
+
+            var converters = new PropertyValueConverterCollection(new IPropertyValueConverter[]
+            {
+                converter,
+            });
+
+            var setType1 = new PublishedContentType(1000, "set1", new[]
+            {
+                new PublishedPropertyType("prop1", "editor1", converters),
+            });
+
+            var snapshotCache = new DictionaryCacheProvider();
+            var facadeCache = new DictionaryCacheProvider();
+
+            var facade = new Mock<IFacade>();
+            facade.Setup(x => x.FacadeCache).Returns(facadeCache);
+            facade.Setup(x => x.SnapshotCache).Returns(snapshotCache);
+
+            var facadeAccessor = new Mock<IFacadeAccessor>();
+            facadeAccessor.Setup(x => x.Facade).Returns(facade.Object);
+
+            // pretend we're creating this set as a value for a property
+            // referenceCacheLevel is the cache level for this fictious property
+            // converterCacheLevel is the cache level specified by the converter
+
+            var set1 = new PublishedElement(setType1, Guid.NewGuid(), new Dictionary<string, object> { { "prop1", "1234" } }, false, referenceCacheLevel, facadeAccessor.Object);
+
+            Assert.AreEqual(1234, set1.Value("prop1"));
+            Assert.AreEqual(1, converter.SourceConverts);
+            Assert.AreEqual(1, converter.InterConverts);
+
+            Assert.AreEqual(snapshotCount1, snapshotCache.Items.Count);
+            Assert.AreEqual(facadeCount1, facadeCache.Items.Count);
+
+            Assert.AreEqual(1234, set1.Value("prop1"));
+            Assert.AreEqual(1, converter.SourceConverts);
+            Assert.AreEqual(interConverts, converter.InterConverts);
+
+            Assert.AreEqual(snapshotCount2, snapshotCache.Items.Count);
+            Assert.AreEqual(facadeCount2, facadeCache.Items.Count);
+
+            var oldFacadeCache = facadeCache;
+            facadeCache.Items.Clear();
+
+            Assert.AreEqual(1234, set1.Value("prop1"));
+            Assert.AreEqual(1, converter.SourceConverts);
+
+            Assert.AreEqual(snapshotCount2, snapshotCache.Items.Count);
+            Assert.AreEqual(facadeCount2, facadeCache.Items.Count);
+            Assert.AreEqual(facadeCount2, oldFacadeCache.Items.Count);
+
+            Assert.AreEqual((interConverts == 1 ? 1 : 3) + facadeCache.Items.Count, converter.InterConverts);
+
+            var oldSnapshotCache = snapshotCache;
+            snapshotCache.Items.Clear();
+
+            Assert.AreEqual(1234, set1.Value("prop1"));
+            Assert.AreEqual(1, converter.SourceConverts);
+
+            Assert.AreEqual(snapshotCount2, snapshotCache.Items.Count);
+            Assert.AreEqual(snapshotCount2, oldSnapshotCache.Items.Count);
+            Assert.AreEqual(facadeCount2, facadeCache.Items.Count);
+
+            Assert.AreEqual((interConverts == 1 ? 1 : 4) + facadeCache.Items.Count + snapshotCache.Items.Count, converter.InterConverts);
+        }
+
+        [Test]
+        public void CacheUnknownTest()
+        {
+            var converter = new CacheConverter1(PropertyCacheLevel.Unknown);
+
+            var converters = new PropertyValueConverterCollection(new IPropertyValueConverter[]
+            {
+                converter,
+            });
+
+            var setType1 = new PublishedContentType(1000, "set1", new[]
+            {
+                new PublishedPropertyType("prop1", "editor1", converters),
+            });
+
+            Assert.Throws<Exception>(() =>
+            {
+                var unused = new PublishedElement(setType1, Guid.NewGuid(), new Dictionary<string, object> { { "prop1", "1234" } }, false);
+            });
+        }
+
+        private class CacheConverter1 : IPropertyValueConverter
+        {
+            private readonly PropertyCacheLevel _cacheLevel;
+
+            public CacheConverter1(PropertyCacheLevel cacheLevel)
+            {
+                _cacheLevel = cacheLevel;
+            }
+
+            public int SourceConverts { get; private set; }
+            public int InterConverts { get; private set; }
+
+            public bool IsConverter(PublishedPropertyType propertyType)
+                => propertyType.PropertyEditorAlias.InvariantEquals("editor1");
+
+            public Type GetPropertyValueType(PublishedPropertyType propertyType)
+                => typeof(int);
+
+            public PropertyCacheLevel GetPropertyCacheLevel(PublishedPropertyType propertyType)
+                => _cacheLevel;
+
+            public object ConvertSourceToInter(IPublishedElement owner, PublishedPropertyType propertyType, object source, bool preview)
+            {
+                SourceConverts++;
+                return int.TryParse(source as string, out int i) ? i : 0;
+            }
+
+            public object ConvertInterToObject(IPublishedElement owner, PublishedPropertyType propertyType, PropertyCacheLevel referenceCacheLevel, object inter, bool preview)
+            {
+                InterConverts++;
+                return (int) inter;
+            }
+
+            public object ConvertInterToXPath(IPublishedElement owner, PublishedPropertyType propertyType, PropertyCacheLevel referenceCacheLevel, object inter, bool preview)
+                => ((int) inter).ToString();
+        }
+
+        // fixme kill
+        private class TestPublishedElementProperty : PublishedElementPropertyBase
+        {
+            public TestPublishedElementProperty(PublishedPropertyType propertyType, IPublishedElement element, bool previewing, PropertyCacheLevel referenceCacheLevel, object sourceValue,
+                Func<Dictionary<string, object>> getSnapshotCache, Func<Dictionary<string, object>> getFacadeCache)
+                : base(propertyType, element, previewing, referenceCacheLevel, sourceValue)
+            { }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Tests/PublishedContent/ModelsAndConvertersTests.cs b/src/Umbraco.Tests/PublishedContent/ModelsAndConvertersTests.cs
deleted file mode 100644
index ee1b61f9f4..0000000000
--- a/src/Umbraco.Tests/PublishedContent/ModelsAndConvertersTests.cs
+++ /dev/null
@@ -1,659 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using LightInject;
-using Moq;
-using NUnit.Framework;
-using Umbraco.Core;
-using Umbraco.Core.Composing;
-using Umbraco.Core.Models.PublishedContent;
-using Umbraco.Core.PropertyEditors;
-using Umbraco.Web;
-using Umbraco.Web.PublishedCache;
-
-namespace Umbraco.Tests.PublishedContent
-{
-    [TestFixture]
-    public class ModelsAndConvertersTests
-    {
-        #region ModelType
-
-        [Test]
-        public void ModelTypeEqualityTests()
-        {
-            Assert.AreNotEqual(ModelType.For("alias1"), ModelType.For("alias1"));
-
-            Assert.IsTrue(ModelType.Equals(ModelType.For("alias1"), ModelType.For("alias1")));
-            Assert.IsFalse(ModelType.Equals(ModelType.For("alias1"), ModelType.For("alias2")));
-
-            Assert.IsTrue(ModelType.Equals(typeof (IEnumerable<>).MakeGenericType(ModelType.For("alias1")), typeof (IEnumerable<>).MakeGenericType(ModelType.For("alias1"))));
-            Assert.IsFalse(ModelType.Equals(typeof (IEnumerable<>).MakeGenericType(ModelType.For("alias1")), typeof (IEnumerable<>).MakeGenericType(ModelType.For("alias2"))));
-
-            Assert.IsTrue(ModelType.Equals(ModelType.For("alias1").MakeArrayType(), ModelType.For("alias1").MakeArrayType()));
-            Assert.IsFalse(ModelType.Equals(ModelType.For("alias1").MakeArrayType(), ModelType.For("alias2").MakeArrayType()));
-        }
-
-        [Test]
-        public void ModelTypeToStringTests()
-        {
-            Assert.AreEqual("{alias1}", ModelType.For("alias1").ToString());
-
-            // there's an "*" there because the arrays are not true SZArray - but that changes when we map
-            Assert.AreEqual("{alias1}[*]", ModelType.For("alias1").MakeArrayType().ToString());
-            Assert.AreEqual("System.Collections.Generic.IEnumerable`1[{alias1}[*]]", typeof (IEnumerable<>).MakeGenericType(ModelType.For("alias1").MakeArrayType()).ToString());
-        }
-
-        [Test]
-        public void ModelTypeMapTests()
-        {
-            var map = new Dictionary<string, Type>
-            {
-                { "alias1", typeof (TestSetModel1) },
-                { "alias2", typeof (TestSetModel2) },
-            };
-
-            Assert.AreEqual("Umbraco.Tests.PublishedContent.ModelsAndConvertersTests+TestSetModel1",
-                ModelType.Map(ModelType.For("alias1"), map).ToString());
-            Assert.AreEqual("Umbraco.Tests.PublishedContent.ModelsAndConvertersTests+TestSetModel1[]",
-                ModelType.Map(ModelType.For("alias1").MakeArrayType(), map).ToString());
-            Assert.AreEqual("System.Collections.Generic.IEnumerable`1[Umbraco.Tests.PublishedContent.ModelsAndConvertersTests+TestSetModel1]",
-                ModelType.Map(typeof(IEnumerable<>).MakeGenericType(ModelType.For("alias1")), map).ToString());
-            Assert.AreEqual("System.Collections.Generic.IEnumerable`1[Umbraco.Tests.PublishedContent.ModelsAndConvertersTests+TestSetModel1[]]",
-                ModelType.Map(typeof(IEnumerable<>).MakeGenericType(ModelType.For("alias1").MakeArrayType()), map).ToString());
-        }
-
-        #endregion
-
-        #region SimpleConverter1
-
-        [Test]
-        public void SimpleConverter1Test()
-        {
-            var converters = new PropertyValueConverterCollection(new IPropertyValueConverter[]
-            {
-                new SimpleConverter1(),
-            });
-
-            var setType1 = new PublishedContentType(1000, "set1", new[]
-            {
-                new PublishedPropertyType("prop1", "editor1", converters),
-            });
-
-            var set1 = new PublishedElement(setType1, Guid.NewGuid(), new Dictionary<string, object> { { "prop1", "1234" } }, false);
-
-            Assert.AreEqual(1234, set1.Value("prop1"));
-        }
-
-        private class SimpleConverter1 : IPropertyValueConverter
-        {
-            public bool IsConverter(PublishedPropertyType propertyType)
-                => propertyType.PropertyEditorAlias.InvariantEquals("editor1");
-
-            public Type GetPropertyValueType(PublishedPropertyType propertyType)
-                => typeof (int);
-
-            public PropertyCacheLevel GetPropertyCacheLevel(PublishedPropertyType propertyType)
-                => PropertyCacheLevel.Content;
-
-            public object ConvertSourceToInter(IPublishedElement owner, PublishedPropertyType propertyType, object source, bool preview)
-                => int.TryParse(source as string, out int i) ? i : 0;
-
-            public object ConvertInterToObject(IPublishedElement owner, PublishedPropertyType propertyType, PropertyCacheLevel referenceCacheLevel, object inter, bool preview)
-                => (int) inter;
-
-            public object ConvertInterToXPath(IPublishedElement owner, PublishedPropertyType propertyType, PropertyCacheLevel referenceCacheLevel, object inter, bool preview)
-                => ((int) inter).ToString();
-        }
-
-        #endregion
-
-        #region SimpleConverter2
-
-        [Test]
-        public void SimpleConverter2Test()
-        {
-            var cacheMock = new Mock<IPublishedContentCache>();
-            var cacheContent = new Dictionary<int, IPublishedContent>();
-            cacheMock.Setup(x => x.GetById(It.IsAny<int>())).Returns<int>(id => cacheContent.TryGetValue(id, out IPublishedContent content) ? content : null);
-            var facadeMock = new Mock<IFacade>();
-            facadeMock.Setup(x => x.ContentCache).Returns(cacheMock.Object);
-            var facadeAccessorMock = new Mock<IFacadeAccessor>();
-            facadeAccessorMock.Setup(x => x.Facade).Returns(facadeMock.Object);
-            var facadeAccessor = facadeAccessorMock.Object;
-
-            var converters = new PropertyValueConverterCollection(new IPropertyValueConverter[]
-            {
-                new SimpleConverter2(facadeAccessor),
-            });
-
-            var setType1 = new PublishedContentType(1000, "set1", new[]
-            {
-                new PublishedPropertyType("prop1", "editor2", converters),
-            });
-
-            var set1 = new PublishedElement(setType1, Guid.NewGuid(), new Dictionary<string, object> { { "prop1", "1234" } }, false);
-
-            var cntType1 = new PublishedContentType(1001, "cnt1", Array.Empty<PublishedPropertyType>());
-            var cnt1 = new TestPublishedContent(cntType1, 1234, Guid.NewGuid(), new Dictionary<string, object>(), false);
-            cacheContent[cnt1.Id] = cnt1;
-
-            Assert.AreSame(cnt1, set1.Value("prop1"));
-        }
-
-        private class SimpleConverter2 : IPropertyValueConverter
-        {
-            private readonly IFacadeAccessor _facadeAccessor;
-            private readonly PropertyCacheLevel _cacheLevel;
-
-            public SimpleConverter2(IFacadeAccessor facadeAccessor, PropertyCacheLevel cacheLevel = PropertyCacheLevel.None)
-            {
-                _facadeAccessor = facadeAccessor;
-                _cacheLevel = cacheLevel;
-            }
-
-            public bool IsConverter(PublishedPropertyType propertyType)
-                => propertyType.PropertyEditorAlias.InvariantEquals("editor2");
-
-            public Type GetPropertyValueType(PublishedPropertyType propertyType)
-                // the first version would be the "generic" version, but say we want to be more precise
-                // and return: whatever Clr type is generated for content type with alias "cnt1" -- which
-                // we cannot really typeof() at the moment because it has not been generated, hence ModelType.
-                // => typeof (IPublishedContent);
-                => ModelType.For("cnt1");
-
-            public PropertyCacheLevel GetPropertyCacheLevel(PublishedPropertyType propertyType)
-                => _cacheLevel;
-
-            public object ConvertSourceToInter(IPublishedElement owner, PublishedPropertyType propertyType, object source, bool preview)
-                => int.TryParse(source as string, out int i) ? i : -1;
-
-            public object ConvertInterToObject(IPublishedElement owner, PublishedPropertyType propertyType, PropertyCacheLevel referenceCacheLevel, object inter, bool preview)
-                => _facadeAccessor.Facade.ContentCache.GetById((int) inter);
-
-            public object ConvertInterToXPath(IPublishedElement owner, PublishedPropertyType propertyType, PropertyCacheLevel referenceCacheLevel, object inter, bool preview)
-                => ((int) inter).ToString();
-        }
-
-        #endregion
-
-        #region SimpleConverter3
-
-        [Test]
-        public void SimpleConverter3Test()
-        {
-            Current.Reset();
-            var container = new ServiceContainer();
-            container.ConfigureUmbracoCore();
-
-            Current.Container.RegisterCollectionBuilder<PropertyValueConverterCollectionBuilder>()
-                .Append<SimpleConverter3A>()
-                .Append<SimpleConverter3B>();
-
-            IPublishedModelFactory factory = new PublishedModelFactory(new[]
-            {
-                typeof(TestSetModel1), typeof(TestSetModel2),
-                typeof(TestContentModel1), typeof(TestContentModel2),
-            });
-            Current.Container.Register(f => factory);
-
-            var cacheMock = new Mock<IPublishedContentCache>();
-            var cacheContent = new Dictionary<int, IPublishedContent>();
-            cacheMock.Setup(x => x.GetById(It.IsAny<int>())).Returns<int>(id => cacheContent.TryGetValue(id, out IPublishedContent content) ? content : null);
-            var facadeMock = new Mock<IFacade>();
-            facadeMock.Setup(x => x.ContentCache).Returns(cacheMock.Object);
-            var facadeAccessorMock = new Mock<IFacadeAccessor>();
-            facadeAccessorMock.Setup(x => x.Facade).Returns(facadeMock.Object);
-            Current.Container.Register(f => facadeAccessorMock.Object);
-
-            var setType1 = new PublishedContentType(1000, "set1", new[]
-            {
-                new PublishedPropertyType("prop1", "editor1"),
-            });
-
-            var setType2 = new PublishedContentType(1001, "set2", new[]
-            {
-                new PublishedPropertyType("prop2", "editor2"),
-            });
-
-            var contentType1 = new PublishedContentType(1002, "content1", new[]
-            {
-                new PublishedPropertyType("prop1", "editor1"),
-            });
-
-            var contentType2 = new PublishedContentType(1003, "content2", new[]
-            {
-                new PublishedPropertyType("prop2", "editor2"),
-            });
-
-            var set1 = new PublishedElement(setType1, Guid.NewGuid(), new Dictionary<string, object> { { "prop1", "val1" } }, false);
-            var set2 = new PublishedElement(setType2, Guid.NewGuid(), new Dictionary<string, object> { { "prop2", "1003" } }, false);
-            var cnt1 = new TestPublishedContent(contentType1, 1003, Guid.NewGuid(), new Dictionary<string, object> { { "prop1", "val1" } }, false);
-            var cnt2 = new TestPublishedContent(contentType2, 1004, Guid.NewGuid(), new Dictionary<string, object> { { "prop2", "1003" } }, false);
-
-            cacheContent[cnt1.Id] = cnt1.CreateModel();
-            cacheContent[cnt2.Id] = cnt2.CreateModel();
-
-            // can get the actual property Clr type
-            // ie ModelType gets properly mapped by IPublishedContentModelFactory
-            // must test ModelClrType with special equals 'cos they are not ref-equals
-            Assert.IsTrue(ModelType.Equals(typeof(IEnumerable<>).MakeGenericType(ModelType.For("content1")), contentType2.GetPropertyType("prop2").ModelClrType));
-            Assert.AreEqual(typeof(IEnumerable<TestContentModel1>), contentType2.GetPropertyType("prop2").ClrType);
-
-            // can create a model for a property set
-            var model1 = factory.CreateModel(set1);
-            Assert.IsInstanceOf<TestSetModel1>(model1);
-            Assert.AreEqual("val1", ((TestSetModel1)model1).Prop1);
-
-            // can create a model for a published content
-            var model2 = factory.CreateModel(set2);
-            Assert.IsInstanceOf<TestSetModel2>(model2);
-            var mmodel2 = (TestSetModel2)model2;
-
-            // and get direct property
-            Assert.IsInstanceOf<TestContentModel1[]>(model2.Value("prop2"));
-            Assert.AreEqual(1, ((TestContentModel1[])model2.Value("prop2")).Length);
-
-            // and get model property
-            Assert.IsInstanceOf<IEnumerable<TestContentModel1>>(mmodel2.Prop2);
-            Assert.IsInstanceOf<TestContentModel1[]>(mmodel2.Prop2);
-            var mmodel1 = mmodel2.Prop2.First();
-
-            // and we get what we want
-            Assert.AreSame(cacheContent[mmodel1.Id], mmodel1);
-        }
-
-        public class SimpleConverter3A : PropertyValueConverterBase
-        {
-            public override bool IsConverter(PublishedPropertyType propertyType)
-                => propertyType.PropertyEditorAlias == "editor1";
-
-            public override Type GetPropertyValueType(PublishedPropertyType propertyType)
-                => typeof (string);
-
-            public override PropertyCacheLevel GetPropertyCacheLevel(PublishedPropertyType propertyType)
-                => PropertyCacheLevel.Content;
-        }
-
-        public class SimpleConverter3B : PropertyValueConverterBase
-        {
-            private readonly IFacadeAccessor _facadeAccessor;
-
-            public SimpleConverter3B(IFacadeAccessor facadeAccessor)
-            {
-                _facadeAccessor = facadeAccessor;
-            }
-
-            public override bool IsConverter(PublishedPropertyType propertyType)
-                => propertyType.PropertyEditorAlias == "editor2";
-
-            public override Type GetPropertyValueType(PublishedPropertyType propertyType)
-                => typeof (IEnumerable<>).MakeGenericType(ModelType.For("content1"));
-
-            public override PropertyCacheLevel GetPropertyCacheLevel(PublishedPropertyType propertyType)
-                => PropertyCacheLevel.Snapshot;
-
-            public override object ConvertSourceToInter(IPublishedElement owner, PublishedPropertyType propertyType, object source, bool preview)
-            {
-                var s = source as string;
-                return s?.Split(',').Select(int.Parse).ToArray() ?? Array.Empty<int>();
-            }
-
-            public override object ConvertInterToObject(IPublishedElement owner, PublishedPropertyType propertyType, PropertyCacheLevel referenceCacheLevel, object inter, bool preview)
-            {
-                return ((int[]) inter).Select(x => (TestContentModel1) _facadeAccessor.Facade.ContentCache.GetById(x)).ToArray();
-            }
-        }
-
-        #endregion
-
-        #region ConversionCache
-
-        [TestCase(PropertyCacheLevel.None, 2)]
-        [TestCase(PropertyCacheLevel.Content, 1)]
-        [TestCase(PropertyCacheLevel.Snapshot, 1)]
-        [TestCase(PropertyCacheLevel.Facade, 1)]
-        public void CacheLevelTest(PropertyCacheLevel cacheLevel, int interConverts)
-        {
-            var converter = new CacheConverter1(cacheLevel);
-
-            var converters = new PropertyValueConverterCollection(new IPropertyValueConverter[]
-            {
-                converter,
-            });
-
-            var setType1 = new PublishedContentType(1000, "set1", new[]
-            {
-                new PublishedPropertyType("prop1", "editor1", converters),
-            });
-
-            // PropertySetPropertyBase.GetCacheLevels:
-            //
-            //   if property level is > reference level, or both are None
-            //     use None for property & new reference
-            //   else
-            //     use Content for property, & keep reference
-            //
-            // PropertySet creates properties with reference being None
-            // if converter specifies None, keep using None
-            // anything else is not > None, use Content
-            //
-            // for standalone property sets, it's only None or Content
-
-            var set1 = new PublishedElement(setType1, Guid.NewGuid(), new Dictionary<string, object> { { "prop1", "1234" } }, false);
-
-            Assert.AreEqual(1234, set1.Value("prop1"));
-            Assert.AreEqual(1, converter.SourceConverts);
-            Assert.AreEqual(1, converter.InterConverts);
-
-            // source is always converted once and cached per content
-            // inter conversion depends on the specified cache level
-
-            Assert.AreEqual(1234, set1.Value("prop1"));
-            Assert.AreEqual(1, converter.SourceConverts);
-            Assert.AreEqual(interConverts, converter.InterConverts);
-        }
-
-        // property is not cached, converted cached at Content, exept
-        //  /None = not cached at all
-        [TestCase(PropertyCacheLevel.None, PropertyCacheLevel.None, 2, 0, 0, 0, 0)]
-        [TestCase(PropertyCacheLevel.None, PropertyCacheLevel.Content, 1, 0, 0, 0, 0)]
-        [TestCase(PropertyCacheLevel.None, PropertyCacheLevel.Snapshot, 1, 0, 0, 0, 0)]
-        [TestCase(PropertyCacheLevel.None, PropertyCacheLevel.Facade, 1, 0, 0, 0, 0)]
-
-        // property is cached at content level, converted cached at
-        //  /None = not at all
-        //  /Content = in content
-        //  /Facade = in facade
-        //  /Snapshot = in snapshot
-        [TestCase(PropertyCacheLevel.Content, PropertyCacheLevel.None, 2, 0, 0, 0, 0)]
-        [TestCase(PropertyCacheLevel.Content, PropertyCacheLevel.Content, 1, 0, 0, 0, 0)]
-        [TestCase(PropertyCacheLevel.Content, PropertyCacheLevel.Snapshot, 1, 1, 0, 1, 0)]
-        [TestCase(PropertyCacheLevel.Content, PropertyCacheLevel.Facade, 1, 0, 1, 0, 1)]
-
-        // property is cached at snapshot level, converted cached at Content, exept
-        //  /None = not cached at all
-        //  /Facade = cached in facade
-        [TestCase(PropertyCacheLevel.Snapshot, PropertyCacheLevel.None, 2, 0, 0, 0, 0)]
-        [TestCase(PropertyCacheLevel.Snapshot, PropertyCacheLevel.Content, 1, 0, 0, 0, 0)]
-        [TestCase(PropertyCacheLevel.Snapshot, PropertyCacheLevel.Snapshot, 1, 0, 0, 0, 0)]
-        [TestCase(PropertyCacheLevel.Snapshot, PropertyCacheLevel.Facade, 1, 0, 1, 0, 1)]
-
-        // property is cached at facade level, converted cached at Content, exept
-        //  /None = not cached at all
-        [TestCase(PropertyCacheLevel.Facade, PropertyCacheLevel.None, 2, 0, 0, 0, 0)]
-        [TestCase(PropertyCacheLevel.Facade, PropertyCacheLevel.Content, 1, 0, 0, 0, 0)]
-        [TestCase(PropertyCacheLevel.Facade, PropertyCacheLevel.Snapshot, 1, 0, 0, 0, 0)]
-        [TestCase(PropertyCacheLevel.Facade, PropertyCacheLevel.Facade, 1, 0, 0, 0, 0)]
-
-        public void CacheFacadeTest(PropertyCacheLevel referenceCacheLevel, PropertyCacheLevel converterCacheLevel, int interConverts,
-            int snapshotCount1, int facadeCount1, int snapshotCount2, int facadeCount2)
-        {
-            var converter = new CacheConverter1(converterCacheLevel);
-
-            var converters = new PropertyValueConverterCollection(new IPropertyValueConverter[]
-            {
-                converter,
-            });
-
-            var setType1 = new PublishedContentType(1000, "set1", new[]
-            {
-                new PublishedPropertyType("prop1", "editor1", converters),
-            });
-
-            var snapshotCache = new Dictionary<string, object>();
-            var facadeCache = new Dictionary<string, object>();
-
-            var facadeServiceMock = new Mock<IFacadeService>();
-            facadeServiceMock
-                .Setup(x => x.CreateElementProperty(It.IsAny<PublishedPropertyType>(), It.IsAny<IPublishedElement>(), It.IsAny<bool>(), It.IsAny<PropertyCacheLevel>(), It.IsAny<object>()))
-                .Returns<PublishedPropertyType, IPublishedElement, bool, PropertyCacheLevel, object>((propertyType, set, previewing, refCacheLevel, value) =>
-                {
-                    // ReSharper disable AccessToModifiedClosure
-                    return new TestPublishedElementProperty(propertyType, set, previewing, refCacheLevel, value, () => snapshotCache, () => facadeCache);
-                    // ReSharper restore AccessToModifiedClosure
-                });
-            var facadeService = facadeServiceMock.Object;
-
-            // pretend we're creating this set as a value for a property
-            // referenceCacheLevel is the cache level for this fictious property
-            // converterCacheLevel is the cache level specified by the converter
-
-            var set1 = new PublishedElement(setType1, Guid.NewGuid(), new Dictionary<string, object> { { "prop1", "1234" } }, false, facadeService, referenceCacheLevel);
-
-            Assert.AreEqual(1234, set1.Value("prop1"));
-            Assert.AreEqual(1, converter.SourceConverts);
-            Assert.AreEqual(1, converter.InterConverts);
-
-            Assert.AreEqual(snapshotCount1, snapshotCache.Count);
-            Assert.AreEqual(facadeCount1, facadeCache.Count);
-
-            Assert.AreEqual(1234, set1.Value("prop1"));
-            Assert.AreEqual(1, converter.SourceConverts);
-            Assert.AreEqual(interConverts, converter.InterConverts);
-
-            Assert.AreEqual(snapshotCount2, snapshotCache.Count);
-            Assert.AreEqual(facadeCount2, facadeCache.Count);
-
-            var oldFacadeCache = facadeCache;
-            facadeCache = new Dictionary<string, object>();
-
-            Assert.AreEqual(1234, set1.Value("prop1"));
-            Assert.AreEqual(1, converter.SourceConverts);
-
-            Assert.AreEqual(snapshotCount2, snapshotCache.Count);
-            Assert.AreEqual(facadeCount2, facadeCache.Count);
-            Assert.AreEqual(facadeCount2, oldFacadeCache.Count);
-
-            Assert.AreEqual((interConverts == 1 ? 1 : 3) + facadeCache.Count, converter.InterConverts);
-
-            var oldSnapshotCache = snapshotCache;
-            snapshotCache = new Dictionary<string, object>();
-
-            Assert.AreEqual(1234, set1.Value("prop1"));
-            Assert.AreEqual(1, converter.SourceConverts);
-
-            Assert.AreEqual(snapshotCount2, snapshotCache.Count);
-            Assert.AreEqual(snapshotCount2, oldSnapshotCache.Count);
-            Assert.AreEqual(facadeCount2, facadeCache.Count);
-
-            Assert.AreEqual((interConverts == 1 ? 1 : 4) + facadeCache.Count + snapshotCache.Count, converter.InterConverts);
-        }
-
-        [Test]
-        public void CacheUnknownTest()
-        {
-            var converter = new CacheConverter1(PropertyCacheLevel.Unknown);
-
-            var converters = new PropertyValueConverterCollection(new IPropertyValueConverter[]
-            {
-                converter,
-            });
-
-            var setType1 = new PublishedContentType(1000, "set1", new[]
-            {
-                new PublishedPropertyType("prop1", "editor1", converters),
-            });
-
-            Assert.Throws<Exception>(() =>
-            {
-                var unused = new PublishedElement(setType1, Guid.NewGuid(), new Dictionary<string, object> { { "prop1", "1234" } }, false);
-            });
-        }
-
-        private class CacheConverter1 : IPropertyValueConverter
-        {
-            private readonly PropertyCacheLevel _cacheLevel;
-
-            public CacheConverter1(PropertyCacheLevel cacheLevel)
-            {
-                _cacheLevel = cacheLevel;
-            }
-
-            public int SourceConverts { get; private set; }
-            public int InterConverts { get; private set; }
-
-            public bool IsConverter(PublishedPropertyType propertyType)
-                => propertyType.PropertyEditorAlias.InvariantEquals("editor1");
-
-            public Type GetPropertyValueType(PublishedPropertyType propertyType)
-                => typeof(int);
-
-            public PropertyCacheLevel GetPropertyCacheLevel(PublishedPropertyType propertyType)
-                => _cacheLevel;
-
-            public object ConvertSourceToInter(IPublishedElement owner, PublishedPropertyType propertyType, object source, bool preview)
-            {
-                SourceConverts++;
-                return int.TryParse(source as string, out int i) ? i : 0;
-            }
-
-            public object ConvertInterToObject(IPublishedElement owner, PublishedPropertyType propertyType, PropertyCacheLevel referenceCacheLevel, object inter, bool preview)
-            {
-                InterConverts++;
-                return (int) inter;
-            }
-
-            public object ConvertInterToXPath(IPublishedElement owner, PublishedPropertyType propertyType, PropertyCacheLevel referenceCacheLevel, object inter, bool preview)
-                => ((int) inter).ToString();
-        }
-
-        private class TestPublishedElementProperty : PublishedElementPropertyBase
-        {
-            private readonly Func<Dictionary<string, object>> _getSnapshotCache;
-            private readonly Func<Dictionary<string, object>> _getFacadeCache;
-            private string _valuesCacheKey;
-
-            public TestPublishedElementProperty(PublishedPropertyType propertyType, IPublishedElement set, bool previewing, PropertyCacheLevel referenceCacheLevel, object sourceValue,
-                Func<Dictionary<string, object>> getSnapshotCache, Func<Dictionary<string, object>> getFacadeCache)
-                : base(propertyType, set, previewing, referenceCacheLevel, sourceValue)
-            {
-                _getSnapshotCache = getSnapshotCache;
-                _getFacadeCache = getFacadeCache;
-            }
-
-            private string ValuesCacheKey => _valuesCacheKey ?? (_valuesCacheKey = $"CacheValues[{(IsPreviewing ? "D" : "P")}{Set.Key}:{PropertyType.PropertyTypeAlias}");
-
-            protected override CacheValues GetSnapshotCacheValues()
-            {
-                var snapshotCache = _getSnapshotCache();
-                if (snapshotCache.TryGetValue(ValuesCacheKey, out object cacheValues))
-                    return (CacheValues) cacheValues;
-                snapshotCache[ValuesCacheKey] = cacheValues = new CacheValues();
-                return (CacheValues) cacheValues;
-            }
-
-            protected override CacheValues GetFacadeCacheValues()
-            {
-                var facadeCache = _getFacadeCache();
-                if (facadeCache.TryGetValue(ValuesCacheKey, out object cacheValues))
-                    return (CacheValues)cacheValues;
-                facadeCache[ValuesCacheKey] = cacheValues = new CacheValues();
-                return (CacheValues)cacheValues;
-            }
-        }
-
-        #endregion
-
-        #region Model classes
-
-        [PublishedContentModel("set1")]
-        public class TestSetModel1 : PublishedElementModel
-        {
-            public TestSetModel1(IPublishedElement content)
-                : base(content)
-            { }
-
-            public string Prop1 => this.Value<string>("prop1");
-        }
-
-        [PublishedContentModel("set2")]
-        public class TestSetModel2 : PublishedElementModel
-        {
-            public TestSetModel2(IPublishedElement content)
-                : base(content)
-            { }
-
-            public IEnumerable<TestContentModel1> Prop2 => this.Value<IEnumerable<TestContentModel1>>("prop2");
-        }
-
-        [PublishedContentModel("content1")]
-        public class TestContentModel1 : PublishedContentModel
-        {
-            public TestContentModel1(IPublishedContent content)
-                : base(content)
-            { }
-
-            public string Prop1 => this.Value<string>("prop1");
-        }
-
-        [PublishedContentModel("content2")]
-        public class TestContentModel2 : PublishedContentModel
-        {
-            public TestContentModel2(IPublishedContent content)
-                : base(content)
-            { }
-
-            public IEnumerable<TestContentModel1> Prop2 => this.Value<IEnumerable<TestContentModel1>>("prop2");
-        }
-
-        #endregion
-
-        #region Support classes
-
-        internal class TestPublishedContent : PublishedElement, IPublishedContent
-        {
-            public TestPublishedContent(PublishedContentType contentType, int id, Guid key, Dictionary<string, object> values, bool previewing)
-                : base(contentType, key, values, previewing)
-            {
-                Id = id;
-            }
-
-            public int Id { get; }
-            public int TemplateId { get; set; }
-            public int SortOrder { get; set; }
-            public string Name { get; set; }
-            public string UrlName { get; set; }
-            public string DocumentTypeAlias => ContentType.Alias;
-            public int DocumentTypeId { get; set; }
-            public string WriterName { get; set; }
-            public string CreatorName { get; set; }
-            public int WriterId { get; set; }
-            public int CreatorId { get; set; }
-            public string Path { get; set; }
-            public DateTime CreateDate { get; set; }
-            public DateTime UpdateDate { get; set; }
-            public Guid Version { get; set; }
-            public int Level { get; set; }
-            public string Url { get; set; }
-            public PublishedItemType ItemType => ContentType.ItemType;
-            public bool IsDraft { get; set; }
-            public IPublishedContent Parent { get; set; }
-            public IEnumerable<IPublishedContent> Children { get; set; }
-
-            // copied from PublishedContentBase
-            public IPublishedProperty GetProperty(string alias, bool recurse)
-            {
-                var property = GetProperty(alias);
-                if (recurse == false) return property;
-
-                IPublishedContent content = this;
-                var firstNonNullProperty = property;
-                while (content != null && (property == null || property.HasValue == false))
-                {
-                    content = content.Parent;
-                    property = content?.GetProperty(alias);
-                    if (firstNonNullProperty == null && property != null) firstNonNullProperty = property;
-                }
-
-                // if we find a content with the property with a value, return that property
-                // if we find no content with the property, return null
-                // if we find a content with the property without a value, return that property
-                //   have to save that first property while we look further up, hence firstNonNullProperty
-
-                return property != null && property.HasValue ? property : firstNonNullProperty;
-            }
-        }
-
-        #endregion
-    }
-}
diff --git a/src/Umbraco.Tests/PublishedContent/PublishedContentDataTableTests.cs b/src/Umbraco.Tests/PublishedContent/PublishedContentDataTableTests.cs
index 488a386529..521c1be2b9 100644
--- a/src/Umbraco.Tests/PublishedContent/PublishedContentDataTableTests.cs
+++ b/src/Umbraco.Tests/PublishedContent/PublishedContentDataTableTests.cs
@@ -139,15 +139,13 @@ namespace Umbraco.Tests.PublishedContent
                     WriterName = "Shannon",
                     Parent = null,
                     Level = 1,
-                    Properties = new Collection<IPublishedProperty>(
-                        new List<IPublishedProperty>()
-                            {
-                                // PropertyResult is gone, this should be done differently
-                                //new PropertyResult("property1", "value" + indexVals, PropertyResultType.UserProperty),
-                                //new PropertyResult("property2", "value" + (indexVals + 1), PropertyResultType.UserProperty)
-                            }),
                     Children = new List<IPublishedContent>()
                 };
+            d.Properties = new Collection<IPublishedProperty>(new List<IPublishedProperty>
+            {
+                new RawValueProperty(new PublishedPropertyType("property1", ""), d, "value" + indexVals),
+                new RawValueProperty(new PublishedPropertyType("property2", ""), d, "value" + (indexVals + 1))
+            });
             if (createChildren)
             {
                 d.Children = new List<IPublishedContent>()
@@ -158,16 +156,17 @@ namespace Umbraco.Tests.PublishedContent
                     };
             }
 
-            // PropertyResult is gone, this should be done differently
-            //if (!createChildren)
-            //{
-            //    //create additional columns, used to test the different columns for child nodes
-            //    ((Collection<IPublishedProperty>)d.Properties).Add(new PropertyResult("property4", "value" + (indexVals + 2), PropertyResultType.UserProperty));
-            //}
-            //else
-            //{
-            //    ((Collection<IPublishedProperty>)d.Properties).Add(new PropertyResult("property3", "value" + (indexVals + 2), PropertyResultType.UserProperty));
-            //}
+            if (!createChildren)
+            {
+                //create additional columns, used to test the different columns for child nodes
+                ((Collection<IPublishedProperty>) d.Properties).Add(
+                    new RawValueProperty(new PublishedPropertyType("property4", ""), d, "value" + (indexVals + 2)));
+            }
+            else
+            {
+                ((Collection<IPublishedProperty>) d.Properties).Add(
+                    new RawValueProperty(new PublishedPropertyType("property3", ""), d, "value" + (indexVals + 2)));
+            }
             return d;
         }
 
diff --git a/src/Umbraco.Tests/PublishedContent/PublishedContentTestElements.cs b/src/Umbraco.Tests/PublishedContent/PublishedContentTestElements.cs
index 6280cdabfa..035510c3f0 100644
--- a/src/Umbraco.Tests/PublishedContent/PublishedContentTestElements.cs
+++ b/src/Umbraco.Tests/PublishedContent/PublishedContentTestElements.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using Umbraco.Core;
+using Umbraco.Core.Cache;
 using Umbraco.Core.Models.PublishedContent;
 using Umbraco.Core.PropertyEditors;
 using Umbraco.Web;
@@ -29,6 +30,10 @@ namespace Umbraco.Tests.PublishedContent
 
         public void Resync()
         { }
+
+        public ICacheProvider FacadeCache => null;
+
+        public ICacheProvider SnapshotCache => null;
     }
 
     class SolidPublishedContentCache : PublishedCacheBase, IPublishedContentCache, IPublishedMediaCache
diff --git a/src/Umbraco.Tests/PublishedContent/PublishedContentTests.cs b/src/Umbraco.Tests/PublishedContent/PublishedContentTests.cs
index 7cdc8fd2c5..99db5e6ec3 100644
--- a/src/Umbraco.Tests/PublishedContent/PublishedContentTests.cs
+++ b/src/Umbraco.Tests/PublishedContent/PublishedContentTests.cs
@@ -556,7 +556,7 @@ namespace Umbraco.Tests.PublishedContent
         {
             var pt = new PublishedPropertyType("detached", Constants.PropertyEditors.IntegerAlias);
             var ct = new PublishedContentType(0, "alias", new[] { pt });
-            var prop = new PublishedElementProperty(pt, null, false, PropertyCacheLevel.None, 5548);
+            var prop = new PublishedElementPropertyBase(pt, null, false, PropertyCacheLevel.None, 5548);
             Assert.IsInstanceOf<int>(prop.Value);
             Assert.AreEqual(5548, prop.Value);
         }
diff --git a/src/Umbraco.Tests/Umbraco.Tests.csproj b/src/Umbraco.Tests/Umbraco.Tests.csproj
index 63a6f31443..a4653ac45d 100644
--- a/src/Umbraco.Tests/Umbraco.Tests.csproj
+++ b/src/Umbraco.Tests/Umbraco.Tests.csproj
@@ -40,6 +40,7 @@
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <Prefer32Bit>false</Prefer32Bit>
+    <LangVersion>latest</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
@@ -49,6 +50,7 @@
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <Prefer32Bit>false</Prefer32Bit>
+    <LangVersion>latest</LangVersion>
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="AutoMapper, Version=6.1.1.0, Culture=neutral, PublicKeyToken=be96cd2c38ef1005, processorArchitecture=MSIL">
@@ -222,7 +224,10 @@
     <Compile Include="CoreThings\CallContextTests.cs" />
     <Compile Include="Components\ComponentTests.cs" />
     <Compile Include="CoreXml\RenamedRootNavigatorTests.cs" />
+    <Compile Include="Facade\FacadeTestObjects.cs" />
+    <Compile Include="Facade\ModelTypeTests.cs" />
     <Compile Include="Facade\NestedContentTests.cs" />
+    <Compile Include="Facade\PropertyCacheLevelTests.cs" />
     <Compile Include="Misc\DateTimeExtensionsTests.cs" />
     <Compile Include="Misc\HashGeneratorTests.cs" />
     <Compile Include="IO\ShadowFileSystemTests.cs" />
@@ -237,7 +242,7 @@
     <Compile Include="Persistence\Repositories\EntityRepositoryTests.cs" />
     <Compile Include="Persistence\Repositories\SimilarNodeNameTests.cs" />
     <Compile Include="Persistence\Repositories\UserGroupRepositoryTest.cs" />
-    <Compile Include="PublishedContent\ModelsAndConvertersTests.cs" />
+    <Compile Include="Facade\ConvertersTests.cs" />
     <Compile Include="Routing\NiceUrlRoutesTests.cs" />
     <Compile Include="Scheduling\BackgroundTaskRunnerTests2.cs" />
     <Compile Include="Scoping\EventNameExtractorTests.cs" />
diff --git a/src/Umbraco.Web.UI/Umbraco.Web.UI.csproj b/src/Umbraco.Web.UI/Umbraco.Web.UI.csproj
index 6d6bacca98..1116d3a2cf 100644
--- a/src/Umbraco.Web.UI/Umbraco.Web.UI.csproj
+++ b/src/Umbraco.Web.UI/Umbraco.Web.UI.csproj
@@ -35,6 +35,7 @@
     <IntermediateOutputPath>..\bin\Debug\</IntermediateOutputPath>
     <PackageAsSingleFile>true</PackageAsSingleFile>
     <DesktopBuildPackageLocation>..\Package\Umbraco.Web.UI.zip</DesktopBuildPackageLocation>
+    <LangVersion>latest</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -47,6 +48,7 @@
     <DocumentationFile>bin\Umbraco.Web.UI.xml</DocumentationFile>
     <Prefer32Bit>false</Prefer32Bit>
     <IntermediateOutputPath>..\bin\Release\</IntermediateOutputPath>
+    <LangVersion>latest</LangVersion>
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="AutoMapper, Version=6.1.1.0, Culture=neutral, PublicKeyToken=be96cd2c38ef1005, processorArchitecture=MSIL">
diff --git a/src/Umbraco.Web/PropertyEditors/NestedContentHelper.cs b/src/Umbraco.Web/PropertyEditors/NestedContentHelper.cs
index b3c066ee27..6d487ec209 100644
--- a/src/Umbraco.Web/PropertyEditors/NestedContentHelper.cs
+++ b/src/Umbraco.Web/PropertyEditors/NestedContentHelper.cs
@@ -1,6 +1,4 @@
-using System;
-using System.Linq;
-using Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Linq;
 using Umbraco.Core.Composing;
 using Umbraco.Core.Models;
 
@@ -25,14 +23,9 @@ namespace Umbraco.Web.PropertyEditors
                 string.Concat(CacheKeyPrefix, id));
         }
 
-        public static string GetElementTypeAlias(JObject item)
-        {
-            return item[NestedContentPropertyEditor.ContentTypeAliasPropertyKey]?.ToObject<string>();
-        }
-
         public static IContentType GetElementType(JObject item)
         {
-            var contentTypeAlias = GetElementTypeAlias(item);
+            var contentTypeAlias = item[NestedContentPropertyEditor.ContentTypeAliasPropertyKey]?.ToObject<string>();
             return string.IsNullOrEmpty(contentTypeAlias)
                 ? null
                 : Current.Services.ContentTypeService.Get(contentTypeAlias);
diff --git a/src/Umbraco.Web/PropertyEditors/ValueConverters/NestedContentManyValueConverter.cs b/src/Umbraco.Web/PropertyEditors/ValueConverters/NestedContentManyValueConverter.cs
index 75230e6c59..8b68e42a58 100644
--- a/src/Umbraco.Web/PropertyEditors/ValueConverters/NestedContentManyValueConverter.cs
+++ b/src/Umbraco.Web/PropertyEditors/ValueConverters/NestedContentManyValueConverter.cs
@@ -19,14 +19,14 @@ namespace Umbraco.Web.PropertyEditors.ValueConverters
     /// </summary>
     public class NestedContentManyValueConverter : NestedContentValueConverterBase
     {
-        private readonly ConcurrentDictionary<Type, Func<object>> _listCtors = new ConcurrentDictionary<Type, Func<object>>();
+        private readonly ConcurrentDictionary<Type, Func<IList>> _listCtors = new ConcurrentDictionary<Type, Func<IList>>();
         private readonly ProfilingLogger _proflog;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="NestedContentManyValueConverter"/> class.
         /// </summary>
-        public NestedContentManyValueConverter(IFacadeAccessor facadeAccessor, Lazy<IFacadeService> facadeService, IPublishedModelFactory publishedModelFactory, ProfilingLogger proflog)
-            : base(facadeAccessor, facadeService, publishedModelFactory)
+        public NestedContentManyValueConverter(IFacadeAccessor facadeAccessor, IPublishedModelFactory publishedModelFactory, ProfilingLogger proflog)
+            : base(facadeAccessor, publishedModelFactory)
         {
             _proflog = proflog;
         }
@@ -67,7 +67,7 @@ namespace Umbraco.Web.PropertyEditors.ValueConverters
                 if (objects.Count == 0)
                     return Enumerable.Empty<IPublishedElement>();
 
-                // fixme do NOT do it here!
+                // fixme do NOT do it here! + use the facade cache
                 var preValueCollection = NestedContentHelper.GetPreValuesCollectionByDataTypeId(propertyType.DataTypeId);
                 var contentTypes = preValueCollection.PreValuesAsDictionary["contentTypes"].Value;
                 IList elements;
@@ -80,10 +80,10 @@ namespace Umbraco.Web.PropertyEditors.ValueConverters
                     var ctor = _listCtors.GetOrAdd(type, t =>
                     {
                         var listType = typeof(List<>).MakeGenericType(t);
-                        return ReflectionUtilities.GetCtor<Func<object>>(listType);
+                        return ReflectionUtilities.EmitCtor<Func<IList>>(declaring: listType);
                     });
 
-                    elements = (IList) ctor();
+                    elements = ctor();
                 }
                 else
                 {
diff --git a/src/Umbraco.Web/PropertyEditors/ValueConverters/NestedContentSingleValueConverter.cs b/src/Umbraco.Web/PropertyEditors/ValueConverters/NestedContentSingleValueConverter.cs
index 78f101e9cf..d90a6e52ad 100644
--- a/src/Umbraco.Web/PropertyEditors/ValueConverters/NestedContentSingleValueConverter.cs
+++ b/src/Umbraco.Web/PropertyEditors/ValueConverters/NestedContentSingleValueConverter.cs
@@ -20,8 +20,8 @@ namespace Umbraco.Web.PropertyEditors.ValueConverters
         /// <summary>
         /// Initializes a new instance of the <see cref="NestedContentSingleValueConverter"/> class.
         /// </summary>
-        public NestedContentSingleValueConverter(IFacadeAccessor facadeAccessor, Lazy<IFacadeService> facadeService, IPublishedModelFactory publishedModelFactory, ProfilingLogger proflog)
-            : base(facadeAccessor, facadeService, publishedModelFactory)
+        public NestedContentSingleValueConverter(IFacadeAccessor facadeAccessor, IPublishedModelFactory publishedModelFactory, ProfilingLogger proflog)
+            : base(facadeAccessor, publishedModelFactory)
         {
             _proflog = proflog;
         }
diff --git a/src/Umbraco.Web/PropertyEditors/ValueConverters/NestedContentValueConverterBase.cs b/src/Umbraco.Web/PropertyEditors/ValueConverters/NestedContentValueConverterBase.cs
index b449b13fef..09004be990 100644
--- a/src/Umbraco.Web/PropertyEditors/ValueConverters/NestedContentValueConverterBase.cs
+++ b/src/Umbraco.Web/PropertyEditors/ValueConverters/NestedContentValueConverterBase.cs
@@ -11,19 +11,15 @@ namespace Umbraco.Web.PropertyEditors.ValueConverters
     public abstract class NestedContentValueConverterBase : PropertyValueConverterBase
     {
         private readonly IFacadeAccessor _facadeAccessor;
-        private readonly Lazy<IFacadeService> _facadeService;
 
-        protected NestedContentValueConverterBase(IFacadeAccessor facadeAccessor, Lazy<IFacadeService> facadeService, IPublishedModelFactory publishedModelFactory)
+        protected NestedContentValueConverterBase(IFacadeAccessor facadeAccessor, IPublishedModelFactory publishedModelFactory)
         {
             _facadeAccessor = facadeAccessor;
-            _facadeService = facadeService;
             PublishedModelFactory = publishedModelFactory;
         }
 
-        protected IFacadeService FacadeService => _facadeService.Value;
-
         protected IPublishedModelFactory PublishedModelFactory { get; }
-    
+
         public static bool IsNested(PublishedPropertyType publishedProperty)
         {
             return publishedProperty.PropertyEditorAlias.InvariantEquals(Constants.PropertyEditors.NestedContentAlias);
@@ -34,6 +30,7 @@ namespace Umbraco.Web.PropertyEditors.ValueConverters
             if (!IsNested(publishedProperty))
                 return false;
 
+            // fixme - the facade should provide this
             var preValueCollection = NestedContentHelper.GetPreValuesCollectionByDataTypeId(publishedProperty.DataTypeId);
             var preValueDictionary = preValueCollection.PreValuesAsDictionary;
 
@@ -50,7 +47,7 @@ namespace Umbraco.Web.PropertyEditors.ValueConverters
 
         protected IPublishedElement ConvertToElement(JObject sourceObject, PropertyCacheLevel referenceCacheLevel, bool preview)
         {
-            var elementTypeAlias = NestedContentHelper.GetElementTypeAlias(sourceObject);
+            var elementTypeAlias = sourceObject[NestedContentPropertyEditor.ContentTypeAliasPropertyKey]?.ToObject<string>();
             if (string.IsNullOrEmpty(elementTypeAlias))
                 return null;
 
@@ -64,9 +61,7 @@ namespace Umbraco.Web.PropertyEditors.ValueConverters
                 || !Guid.TryParse(keyo.ToString(), out var key))
                 key = Guid.Empty;
 
-            // fixme - why does it need a facade service here?
-            IPublishedElement element = new PublishedElement(publishedContentType, key, propertyValues, preview, FacadeService, referenceCacheLevel);
-
+            IPublishedElement element = new PublishedElement(publishedContentType, key, propertyValues, preview, referenceCacheLevel, _facadeAccessor);
             element = PublishedModelFactory.CreateModel(element);
             return element;
         }
diff --git a/src/Umbraco.Web/PublishedCache/FacadeServiceBase.cs b/src/Umbraco.Web/PublishedCache/FacadeServiceBase.cs
index 40163dd2a8..e21e54aa5e 100644
--- a/src/Umbraco.Web/PublishedCache/FacadeServiceBase.cs
+++ b/src/Umbraco.Web/PublishedCache/FacadeServiceBase.cs
@@ -1,9 +1,5 @@
-using System;
-using System.Collections.Generic;
-using Umbraco.Core.Composing;
+using System.Collections.Generic;
 using Umbraco.Core.Models.Membership;
-using Umbraco.Core.Models.PublishedContent;
-using Umbraco.Core.PropertyEditors;
 using Umbraco.Web.Cache;
 
 namespace Umbraco.Web.PublishedCache
@@ -25,17 +21,6 @@ namespace Umbraco.Web.PublishedCache
 
         public abstract bool EnsureEnvironment(out IEnumerable<string> errors);
 
-        public virtual IPublishedElement CreateSet(PublishedContentType contentType, Guid key, Dictionary<string, object> values, bool previewing, PropertyCacheLevel referenceCacheLevel)
-        {
-            var set = new PublishedElement(contentType, key, values, previewing, this, referenceCacheLevel);
-            var model = Current.PublishedModelFactory.CreateModel(set);
-            if (model == null)
-                throw new Exception("Factory returned null.");
-            return model;
-        }
-
-        public abstract IPublishedProperty CreateElementProperty(PublishedPropertyType propertyType, IPublishedElement element, bool previewing, PropertyCacheLevel referenceCacheLevel, object sourceValue = null);
-
         public abstract string EnterPreview(IUser user, int contentId);
         public abstract void RefreshPreview(string previewToken, int contentId);
         public abstract void ExitPreview(string previewToken);
diff --git a/src/Umbraco.Web/PublishedCache/IFacade.cs b/src/Umbraco.Web/PublishedCache/IFacade.cs
index f425f3ebcf..804c01b5f0 100644
--- a/src/Umbraco.Web/PublishedCache/IFacade.cs
+++ b/src/Umbraco.Web/PublishedCache/IFacade.cs
@@ -1,4 +1,5 @@
 using System;
+using Umbraco.Core.Cache;
 
 namespace Umbraco.Web.PublishedCache
 {
@@ -27,6 +28,16 @@ namespace Umbraco.Web.PublishedCache
         /// </summary>
         IDomainCache DomainCache { get; }
 
+        /// <summary>
+        /// Gets the facade cache.
+        /// </summary>
+        ICacheProvider FacadeCache { get; }
+
+        /// <summary>
+        /// Gets the snapshot cache.
+        /// </summary>
+        ICacheProvider SnapshotCache { get; }
+
         /// <summary>
         /// Forces the facade preview mode.
         /// </summary>
diff --git a/src/Umbraco.Web/PublishedCache/IFacadeService.cs b/src/Umbraco.Web/PublishedCache/IFacadeService.cs
index 0059d8d0c1..75741769c2 100644
--- a/src/Umbraco.Web/PublishedCache/IFacadeService.cs
+++ b/src/Umbraco.Web/PublishedCache/IFacadeService.cs
@@ -151,31 +151,5 @@ namespace Umbraco.Web.PublishedCache
         void Notify(DomainCacheRefresher.JsonPayload[] payloads);
 
         #endregion
-
-        #region Published Element
-
-        /// <summary>
-        /// Creates a published element.
-        /// </summary>
-        /// <param name="contentType">The content type.</param>
-        /// <param name="key">The set key.</param>
-        /// <param name="values">Raw values for properties.</param>
-        /// <param name="previewing">A value indicating whether previewing.</param>
-        /// <param name="referenceCacheLevel">The reference cache level.</param>
-        /// <returns>A property set.</returns>
-        IPublishedElement CreateSet(PublishedContentType contentType, Guid key, Dictionary<string, object> values, bool previewing, PropertyCacheLevel referenceCacheLevel);
-
-        /// <summary>
-        /// Creates a published property for a published element.
-        /// </summary>
-        /// <param name="propertyType">The property type.</param>
-        /// <param name="element">The published element.</param>
-        /// <param name="previewing">A value indicating whether previewing.</param>
-        /// <param name="referenceCacheLevel">The reference cache level.</param>
-        /// <param name="sourceValue">The source value.</param>
-        /// <returns>A set property.</returns>
-        IPublishedProperty CreateElementProperty(PublishedPropertyType propertyType, IPublishedElement element, bool previewing, PropertyCacheLevel referenceCacheLevel, object sourceValue = null);
-
-        #endregion
     }
 }
diff --git a/src/Umbraco.Web/PublishedCache/NuCache/FacadeService.cs b/src/Umbraco.Web/PublishedCache/NuCache/FacadeService.cs
index 0f49bed0e4..ee27cd8f0b 100644
--- a/src/Umbraco.Web/PublishedCache/NuCache/FacadeService.cs
+++ b/src/Umbraco.Web/PublishedCache/NuCache/FacadeService.cs
@@ -18,12 +18,10 @@ using Umbraco.Core.Persistence;
 using Umbraco.Core.Persistence.DatabaseModelDefinitions;
 using Umbraco.Core.Persistence.Repositories;
 using Umbraco.Core.Persistence.UnitOfWork;
-using Umbraco.Core.PropertyEditors;
 using Umbraco.Core.Scoping;
 using Umbraco.Core.Services;
 using Umbraco.Core.Services.Changes;
 using Umbraco.Web.Cache;
-using Umbraco.Web.Composing;
 using Umbraco.Web.Install;
 using Umbraco.Web.PublishedCache.NuCache.DataSource;
 using Umbraco.Web.PublishedCache.XmlPublishedCache;
@@ -1533,14 +1531,5 @@ AND cmsContentNu.nodeId IS NULL
         }
 
         #endregion
-
-        #region Published Element
-
-        public override IPublishedProperty CreateElementProperty(PublishedPropertyType propertyType, IPublishedElement element, bool previewing, PropertyCacheLevel referenceCacheLevel, object sourceValue = null)
-        {
-            return new PublishedElementProperty(FacadeAccessor, propertyType, element, previewing, referenceCacheLevel, sourceValue);
-        }
-
-        #endregion
     }
 }
diff --git a/src/Umbraco.Web/PublishedCache/NuCache/PublishedElementProperty.cs b/src/Umbraco.Web/PublishedCache/NuCache/PublishedElementProperty.cs
deleted file mode 100644
index 59b689b9e0..0000000000
--- a/src/Umbraco.Web/PublishedCache/NuCache/PublishedElementProperty.cs
+++ /dev/null
@@ -1,55 +0,0 @@
-using System;
-using Umbraco.Core.Cache;
-using Umbraco.Core.Models.PublishedContent;
-using Umbraco.Core.PropertyEditors;
-
-namespace Umbraco.Web.PublishedCache.NuCache
-{
-    internal class PublishedElementProperty : PublishedElementPropertyBase
-    {
-        private readonly IFacadeAccessor _facadeAccessor;
-        private string _valuesCacheKey;
-
-        // initializes a published item property
-        public PublishedElementProperty(IFacadeAccessor facadeAccessor, PublishedPropertyType propertyType, IPublishedElement set, bool previewing, PropertyCacheLevel referenceCacheLevel, object sourceValue = null)
-            : base(propertyType, set, previewing, referenceCacheLevel, sourceValue)
-        {
-            _facadeAccessor = facadeAccessor;
-        }
-
-        // used to cache the CacheValues of this property
-        internal string ValuesCacheKey => _valuesCacheKey
-            ?? (_valuesCacheKey = CacheKeys.PropertyCacheValues(Set.Key, PropertyTypeAlias, IsPreviewing));
-
-        protected override CacheValues GetSnapshotCacheValues()
-        {
-            // cache within the snapshot cache, unless previewing, then use the facade or
-            // snapshot cache (if we don't want to pollute the snapshot cache with short-lived
-            // data) depending on settings
-            // for members, always cache in the facade cache - never pollute snapshot cache
-            var facade = (Facade) _facadeAccessor.Facade;
-            var cache = facade == null
-                ? null
-                : ((IsPreviewing == false || FacadeService.FullCacheWhenPreviewing) && (IsMember == false)
-                    ? facade.SnapshotCache
-                    : facade.FacadeCache);
-            return GetCacheValues(cache);
-        }
-
-        protected override CacheValues GetFacadeCacheValues()
-        {
-            // cache within the facade cache
-            var facade = (Facade) _facadeAccessor.Facade;
-            var cache = facade?.FacadeCache;
-            return GetCacheValues(cache);
-        }
-
-        private CacheValues GetCacheValues(ICacheProvider cache)
-        {
-            // no cache, don't cache
-            return cache == null
-                ? new CacheValues()
-                : (CacheValues) cache.GetCacheItem(ValuesCacheKey, () => new CacheValues());
-        }
-    }
-}
diff --git a/src/Umbraco.Web/PublishedCache/PublishedElement.cs b/src/Umbraco.Web/PublishedCache/PublishedElement.cs
index ee15db317b..3cbdb890be 100644
--- a/src/Umbraco.Web/PublishedCache/PublishedElement.cs
+++ b/src/Umbraco.Web/PublishedCache/PublishedElement.cs
@@ -19,9 +19,14 @@ namespace Umbraco.Web.PublishedCache
         // initializes a new instance of the PublishedElement class
         // within the context of a facade service (eg a published content property value)
         public PublishedElement(PublishedContentType contentType, Guid key, Dictionary<string, object> values, bool previewing,
-            IFacadeService facadeService, PropertyCacheLevel referenceCacheLevel)
+            PropertyCacheLevel referenceCacheLevel, IFacadeAccessor facadeAccessor)
         {
-            ContentType = contentType;
+            if (key == Guid.Empty) throw new ArgumentException("Empty guid.");
+            if (values == null) throw new ArgumentNullException(nameof(values));
+            if (referenceCacheLevel != PropertyCacheLevel.None && facadeAccessor == null)
+                throw new ArgumentNullException("A facade accessor is required when referenceCacheLevel != None.", nameof(facadeAccessor));
+
+            ContentType = contentType ?? throw new ArgumentNullException(nameof(contentType));
             Key = key;
 
             values = GetCaseInsensitiveValueDictionary(values);
@@ -30,35 +35,20 @@ namespace Umbraco.Web.PublishedCache
                 .PropertyTypes
                 .Select(propertyType =>
                 {
-                    values.TryGetValue(propertyType.PropertyTypeAlias, out object value);
-                    return facadeService.CreateElementProperty(propertyType, this, previewing, referenceCacheLevel, value);
+                    values.TryGetValue(propertyType.PropertyTypeAlias, out var value);
+                    return (IPublishedProperty) new PublishedElementPropertyBase(propertyType, this, previewing, referenceCacheLevel, value, facadeAccessor);
                 })
                 .ToArray();
         }
 
         // initializes a new instance of the PublishedElement class
         // without any context, so it's purely 'standalone' and should NOT interfere with the facade service
+        // + using an initial reference cache level of .None ensures that everything will be
+        // cached at .Content level - and that reference cache level will propagate to all
+        // properties
         public PublishedElement(PublishedContentType contentType, Guid key, Dictionary<string, object> values, bool previewing)
-        {
-            ContentType = contentType;
-            Key = key;
-
-            values = GetCaseInsensitiveValueDictionary(values);
-
-            // using an initial reference cache level of .None ensures that everything will be
-            // cached at .Content level - and that reference cache level will propagate to all
-            // properties
-            const PropertyCacheLevel cacheLevel = PropertyCacheLevel.None;
-
-            _propertiesArray = contentType
-                .PropertyTypes
-                .Select(propertyType =>
-                {
-                    values.TryGetValue(propertyType.PropertyTypeAlias, out object value);
-                    return (IPublishedProperty) new PublishedElementProperty(propertyType, this, previewing, cacheLevel, value);
-                })
-                .ToArray();
-        }
+            : this(contentType, key, values, previewing, PropertyCacheLevel.None, null)
+        { }
 
         private static Dictionary<string, object> GetCaseInsensitiveValueDictionary(Dictionary<string, object> values)
         {
diff --git a/src/Umbraco.Web/PublishedCache/PublishedElementProperty.cs b/src/Umbraco.Web/PublishedCache/PublishedElementProperty.cs
deleted file mode 100644
index adb7ababbc..0000000000
--- a/src/Umbraco.Web/PublishedCache/PublishedElementProperty.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-using System;
-using Umbraco.Core.Models.PublishedContent;
-using Umbraco.Core.PropertyEditors;
-
-namespace Umbraco.Web.PublishedCache
-{
-    internal class PublishedElementProperty : PublishedElementPropertyBase
-    {
-        public PublishedElementProperty(PublishedPropertyType propertyType, IPublishedElement set, bool previewing, PropertyCacheLevel cacheLevel, object sourceValue = null)
-            : base(propertyType, set, previewing, cacheLevel, sourceValue)
-        { }
-
-        protected override CacheValues GetSnapshotCacheValues()
-        {
-            throw new NotSupportedException();
-        }
-
-        protected override CacheValues GetFacadeCacheValues()
-        {
-            throw new NotSupportedException();
-        }
-    }
-}
diff --git a/src/Umbraco.Web/PublishedCache/PublishedElementPropertyBase.cs b/src/Umbraco.Web/PublishedCache/PublishedElementPropertyBase.cs
index b32939ab45..af9f6fe774 100644
--- a/src/Umbraco.Web/PublishedCache/PublishedElementPropertyBase.cs
+++ b/src/Umbraco.Web/PublishedCache/PublishedElementPropertyBase.cs
@@ -1,34 +1,49 @@
 using System;
+using Umbraco.Core.Cache;
 using Umbraco.Core.Models.PublishedContent;
 using Umbraco.Core.PropertyEditors;
 
 namespace Umbraco.Web.PublishedCache
 {
-    internal abstract class PublishedElementPropertyBase : PublishedPropertyBase
+    internal class PublishedElementPropertyBase : PublishedPropertyBase
     {
         private readonly object _locko = new object();
         private readonly object _sourceValue;
+        private readonly IFacadeAccessor _facadeAccessor;
 
-        protected readonly IPublishedElement Set; // fixme rename
+        protected readonly IPublishedElement Element;
         protected readonly bool IsPreviewing;
         protected readonly bool IsMember;
 
         private bool _interInitialized;
         private object _interValue;
         private CacheValues _cacheValues;
+        private string _valuesCacheKey;
 
-        // initializes a published item property
-        protected PublishedElementPropertyBase(PublishedPropertyType propertyType, IPublishedElement set, bool previewing, PropertyCacheLevel referenceCacheLevel, object sourceValue = null)
+        // define constant - determines whether to use cache when previewing
+        // to store eg routes, property converted values, anything - caching
+        // means faster execution, but uses memory - not sure if we want it
+        // so making it configureable.
+        private const bool FullCacheWhenPreviewing = true;
+
+        public PublishedElementPropertyBase(PublishedPropertyType propertyType, IPublishedElement element, bool previewing, PropertyCacheLevel referenceCacheLevel, object sourceValue = null, IFacadeAccessor facadeAccessor = null)
             : base(propertyType, referenceCacheLevel)
         {
             _sourceValue = sourceValue;
-            Set = set;
+            _facadeAccessor = facadeAccessor;
+            Element = element;
             IsPreviewing = previewing;
             IsMember = propertyType.ContentType.ItemType == PublishedItemType.Member;
         }
 
-        public override bool HasValue => _sourceValue != null
-            && (!(_sourceValue is string) || string.IsNullOrWhiteSpace((string) _sourceValue) == false);
+        public override bool HasValue
+            => _sourceValue != null && (!(_sourceValue is string s) || !string.IsNullOrWhiteSpace(s));
+
+        // used to cache the CacheValues of this property
+        // ReSharper disable InconsistentlySynchronizedField
+        internal string ValuesCacheKey => _valuesCacheKey
+            ?? (_valuesCacheKey = PropertyCacheValues(Element.Key, PropertyTypeAlias, IsPreviewing));
+        // ReSharper restore InconsistentlySynchronizedField
 
         protected class CacheValues
         {
@@ -38,6 +53,11 @@ namespace Umbraco.Web.PublishedCache
             public object XPathValue;
         }
 
+        public static string PropertyCacheValues(Guid contentUid, string typeAlias, bool previewing)
+        {
+            return "Facade.Property.CacheValues[" + (previewing ? "D:" : "P:") + contentUid + ":" + typeAlias + "]";
+        }
+
         private void GetCacheLevels(out PropertyCacheLevel cacheLevel, out PropertyCacheLevel referenceCacheLevel)
         {
             // based upon the current reference cache level (ReferenceCacheLevel) and this property
@@ -65,8 +85,18 @@ namespace Umbraco.Web.PublishedCache
             }
         }
 
-        protected abstract CacheValues GetSnapshotCacheValues();
-        protected abstract CacheValues GetFacadeCacheValues();
+        private ICacheProvider GetSnapshotCache()
+        {
+            // cache within the snapshot cache, unless previewing, then use the facade or
+            // snapshot cache (if we don't want to pollute the snapshot cache with short-lived
+            // data) depending on settings
+            // for members, always cache in the facade cache - never pollute snapshot cache
+            var facade = _facadeAccessor?.Facade;
+            if (facade == null) return null;
+            return (IsPreviewing == false || FullCacheWhenPreviewing) && IsMember == false
+                ? facade.SnapshotCache
+                : facade.FacadeCache;
+        }
 
         private CacheValues GetCacheValues(PropertyCacheLevel cacheLevel)
         {
@@ -83,11 +113,13 @@ namespace Umbraco.Web.PublishedCache
                     break;
                 case PropertyCacheLevel.Snapshot:
                     // cache within the snapshot cache, depending...
-                    cacheValues = GetSnapshotCacheValues();
+                    var snapshotCache = GetSnapshotCache();
+                    cacheValues = (CacheValues) snapshotCache?.GetCacheItem(ValuesCacheKey, () => new CacheValues()) ?? new CacheValues();
                     break;
                 case PropertyCacheLevel.Facade:
                     // cache within the facade cache
-                    cacheValues = GetFacadeCacheValues();
+                    var facadeCache = _facadeAccessor?.Facade?.FacadeCache;
+                    cacheValues = (CacheValues) facadeCache?.GetCacheItem(ValuesCacheKey, () => new CacheValues()) ?? new CacheValues();
                     break;
                 default:
                     throw new InvalidOperationException("Invalid cache level.");
@@ -99,7 +131,7 @@ namespace Umbraco.Web.PublishedCache
         {
             if (_interInitialized) return _interValue;
 
-            _interValue = PropertyType.ConvertSourceToInter(Set, _sourceValue, IsPreviewing);
+            _interValue = PropertyType.ConvertSourceToInter(Element, _sourceValue, IsPreviewing);
             _interInitialized = true;
             return _interValue;
         }
@@ -110,14 +142,13 @@ namespace Umbraco.Web.PublishedCache
         {
             get
             {
+                GetCacheLevels(out var cacheLevel, out var referenceCacheLevel);
+
                 lock (_locko)
                 {
-                    GetCacheLevels(out PropertyCacheLevel cacheLevel, out PropertyCacheLevel referenceCacheLevel);
-
                     var cacheValues = GetCacheValues(cacheLevel);
                     if (cacheValues.ObjectInitialized) return cacheValues.ObjectValue;
-
-                    cacheValues.ObjectValue = PropertyType.ConvertInterToObject(Set, referenceCacheLevel, GetInterValue(), IsPreviewing);
+                    cacheValues.ObjectValue = PropertyType.ConvertInterToObject(Element, referenceCacheLevel, GetInterValue(), IsPreviewing);
                     cacheValues.ObjectInitialized = true;
                     return cacheValues.ObjectValue;
                 }
@@ -128,14 +159,13 @@ namespace Umbraco.Web.PublishedCache
         {
             get
             {
+                GetCacheLevels(out var cacheLevel, out var referenceCacheLevel);
+
                 lock (_locko)
                 {
-                    GetCacheLevels(out PropertyCacheLevel cacheLevel, out PropertyCacheLevel referenceCacheLevel);
-
                     var cacheValues = GetCacheValues(cacheLevel);
                     if (cacheValues.XPathInitialized) return cacheValues.XPathValue;
-
-                    cacheValues.XPathValue = PropertyType.ConvertInterToXPath(Set, referenceCacheLevel, GetInterValue(), IsPreviewing);
+                    cacheValues.XPathValue = PropertyType.ConvertInterToXPath(Element, referenceCacheLevel, GetInterValue(), IsPreviewing);
                     cacheValues.XPathInitialized = true;
                     return cacheValues.XPathValue;
                 }
diff --git a/src/Umbraco.Web/PublishedCache/XmlPublishedCache/Facade.cs b/src/Umbraco.Web/PublishedCache/XmlPublishedCache/Facade.cs
index 59cb6e2d27..03a36d8094 100644
--- a/src/Umbraco.Web/PublishedCache/XmlPublishedCache/Facade.cs
+++ b/src/Umbraco.Web/PublishedCache/XmlPublishedCache/Facade.cs
@@ -1,5 +1,6 @@
 using System;
 using Umbraco.Core;
+using Umbraco.Core.Cache;
 using Umbraco.Core.Models.PublishedContent;
 using Umbraco.Core.PropertyEditors;
 
@@ -26,26 +27,25 @@ namespace Umbraco.Web.PublishedCache.XmlPublishedCache
             DomainCache = domainCache;
         }
 
-        /// <summary>
-        /// Gets the <see cref="IPublishedContentCache"/>.
-        /// </summary>
+        /// <inheritdoc />
         public IPublishedContentCache ContentCache { get; }
 
-        /// <summary>
-        /// Gets the <see cref="IPublishedMediaCache"/>.
-        /// </summary>
+        /// <inheritdoc />
         public IPublishedMediaCache MediaCache { get; }
 
-        /// <summary>
-        /// Gets the <see cref="IPublishedMemberCache"/>.
-        /// </summary>
+        /// <inheritdoc />
         public IPublishedMemberCache MemberCache { get; }
 
-        /// <summary>
-        /// Gets the <see cref="IDomainCache"/>.
-        /// </summary>
+        /// <inheritdoc />
         public IDomainCache DomainCache { get; }
 
+        /// <inheritdoc />
+        public ICacheProvider FacadeCache => null;
+
+        /// <inheritdoc />
+        public ICacheProvider SnapshotCache => null;
+
+        /// <inheritdoc />
         public IDisposable ForcedPreview(bool preview, Action<bool> callback = null)
         {
             // the XML cache does not support forcing preview, really, so, just pretend...
diff --git a/src/Umbraco.Web/PublishedCache/XmlPublishedCache/FacadeService.cs b/src/Umbraco.Web/PublishedCache/XmlPublishedCache/FacadeService.cs
index 82f3632317..4c398f156e 100644
--- a/src/Umbraco.Web/PublishedCache/XmlPublishedCache/FacadeService.cs
+++ b/src/Umbraco.Web/PublishedCache/XmlPublishedCache/FacadeService.cs
@@ -237,15 +237,5 @@ namespace Umbraco.Web.PublishedCache.XmlPublishedCache
         }
 
         #endregion
-
-        #region Property Set
-
-        public override IPublishedProperty CreateElementProperty(PublishedPropertyType propertyType, IPublishedElement element, bool previewing, PropertyCacheLevel referenceCacheLevel, object sourceValue = null)
-        {
-            // fixme - ouch?
-            throw new NotImplementedException();
-        }
-
-        #endregion
     }
 }
diff --git a/src/Umbraco.Web/Umbraco.Web.csproj b/src/Umbraco.Web/Umbraco.Web.csproj
index c492c2b79f..9ea8d78fb2 100644
--- a/src/Umbraco.Web/Umbraco.Web.csproj
+++ b/src/Umbraco.Web/Umbraco.Web.csproj
@@ -20,6 +20,7 @@
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <Prefer32Bit>false</Prefer32Bit>
+    <LangVersion>latest</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
@@ -30,6 +31,7 @@
     <WarningLevel>4</WarningLevel>
     <DocumentationFile>bin\Release\Umbraco.Web.xml</DocumentationFile>
     <Prefer32Bit>false</Prefer32Bit>
+    <LangVersion>latest</LangVersion>
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="Microsoft.CSharp" />
@@ -255,9 +257,7 @@
     <Compile Include="PropertyEditors\ValueConverters\MultiNodeTreePickerValueConverter.cs" />
     <Compile Include="PropertyEditors\ValueConverters\MediaPickerLegacyValueConverter.cs" />
     <Compile Include="PublishedCache\NuCache\NuCacheComponent.cs" />
-    <Compile Include="PublishedCache\NuCache\PublishedElementProperty.cs" />
     <Compile Include="PublishedCache\PublishedElement.cs" />
-    <Compile Include="PublishedCache\PublishedElementProperty.cs" />
     <Compile Include="PublishedCache\PublishedElementPropertyBase.cs" />
     <Compile Include="Models\Trees\DisableUser.cs" />
     <Compile Include="PropertyEditors\ValueConverters\ContentPickerValueConverter.cs" />
diff --git a/src/umbraco.sln.DotSettings b/src/umbraco.sln.DotSettings
index c624496084..3c08188b8a 100644
--- a/src/umbraco.sln.DotSettings
+++ b/src/umbraco.sln.DotSettings
@@ -4,5 +4,5 @@
 	<s:String x:Key="/Default/PatternsAndTemplates/StructuralSearch/Pattern/=2DA32DA040A7D74599ABE288C7224CF0/Comment/@EntryValue">Disposable construction</s:String>
 	<s:String x:Key="/Default/PatternsAndTemplates/StructuralSearch/Pattern/=2DA32DA040A7D74599ABE288C7224CF0/Severity/@EntryValue">HINT</s:String>
 	<s:Boolean x:Key="/Default/PatternsAndTemplates/StructuralSearch/Pattern/=37A0B37A0ABAA34AA5CB32A93653C4FE/@KeyIndexDefined">False</s:Boolean>
-	<s:String x:Key="/Default/CodeInspection/CSharpLanguageProject/LanguageLevel/@EntryValue">CSharp70</s:String></wpf:ResourceDictionary>
+	<s:String x:Key="/Default/CodeInspection/CSharpLanguageProject/LanguageLevel/@EntryValue">CSharp71</s:String></wpf:ResourceDictionary>
 </wpf:ResourceDictionary>
\ No newline at end of file