Fixes: U4-4926 Pre-values need to be cloned in/out of the cache

src/Umbraco.Core/Models/PreValue.cs

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

src/Umbraco.Core/Models/PreValueCollection.cs

@@ -14,7 +14,7 @@ namespace Umbraco.Core.Models
     /// Most legacy property editors won't support the dictionary format but new property editors should always use the dictionary format.
     /// In order to get overrideable pre-values working we need a dictionary since we'll have to reference a pre-value by a key.
     /// </remarks>
-    public class PreValueCollection
+    public class PreValueCollection : IDeepCloneable
     {
         private IDictionary<string, PreValue> _preValuesAsDictionary;
         private IEnumerable<PreValue> _preValuesAsArray;
@@ -82,5 +82,21 @@ namespace Umbraco.Core.Models
             }
             return result;
         }
+
+        public object DeepClone()
+        {
+            var clone = (PreValueCollection) MemberwiseClone();
+            if (_preValuesAsArray != null)
+            {
+                clone._preValuesAsArray = _preValuesAsArray.Select(x => (PreValue)x.DeepClone()).ToArray();    
+            }
+            if (_preValuesAsDictionary != null)
+            {
+                clone._preValuesAsDictionary = _preValuesAsDictionary.ToDictionary(x => x.Key, x => (PreValue)x.Value.DeepClone());    
+            }
+            
+
+            return clone;
+        }
     }
 }

src/Umbraco.Core/Persistence/Repositories/DataTypeDefinitionRepository.cs

@@ -295,8 +295,8 @@ AND umbracoNode.id <> @id",
                 var cached = _cacheHelper.RuntimeCache.GetCacheItemsByKeySearch<PreValueCollection>(GetPrefixedCacheKey(dataTypeId));
                 if (cached != null && cached.Any())
                 {
-                    //return from the cache
-                    return cached.First();
+                    //return from the cache, ensure it's a cloned result
+                    return (PreValueCollection)cached.First().DeepClone();
                 }
 
                 l.UpgradeToWriteLock();

src/Umbraco.Tests/Models/PreValueCollectionTests.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using Umbraco.Core.Models;
+
+namespace Umbraco.Tests.Models
+{
+    [TestFixture]
+    public class PreValueCollectionTests
+    {
+        [Test]
+        public void Can_Deep_Clone()
+        {
+            var d = new PreValueCollection(new Dictionary<string, PreValue>
+            {
+                {"blah1", new PreValue(1, "test1", 1)},
+                {"blah2", new PreValue(2, "test1", 3)},
+                {"blah3", new PreValue(3, "test1", 2)}
+            });
+
+            var a = new PreValueCollection(new[]
+            {
+                new PreValue(1, "test1", 1),
+                new PreValue(2, "test1", 3),
+                new PreValue(3, "test1", 2)
+            });
+
+            var clone1 = (PreValueCollection)d.DeepClone();
+            var clone2 = (PreValueCollection)a.DeepClone();
+
+            Action<PreValueCollection, PreValueCollection> assert = (orig, clone) =>
+            {
+                Assert.AreNotSame(orig, clone);
+                var oDic = orig.FormatAsDictionary();
+                var cDic = clone.FormatAsDictionary();
+                Assert.AreEqual(oDic.Keys.Count(), cDic.Keys.Count());
+                foreach (var k in oDic.Keys)
+                {
+                    Assert.AreNotSame(oDic[k], cDic[k]);
+                    Assert.AreEqual(oDic[k].Id, cDic[k].Id);
+                    Assert.AreEqual(oDic[k].SortOrder, cDic[k].SortOrder);
+                    Assert.AreEqual(oDic[k].Value, cDic[k].Value);
+                }
+            };
+
+            assert(d, clone1);
+            assert(a, clone2);
+        }
+    }
+}

src/Umbraco.Tests/Umbraco.Tests.csproj

@@ -191,6 +191,7 @@
     <Compile Include="Models\LanguageTests.cs" />
     <Compile Include="Models\MemberGroupTests.cs" />
     <Compile Include="Models\MemberTests.cs" />
+    <Compile Include="Models\PreValueCollectionTests.cs" />
     <Compile Include="Models\PropertyGroupTests.cs" />
     <Compile Include="Models\PropertyTypeTests.cs" />
     <Compile Include="Models\RelationTests.cs" />