Creates IRememberBeingDirty interface to track the properties that we're changed before the last commit for a given entity.

Adds internal property and tracks it's dirty changes to the ContentTypeBase - HasPropertyBeenRemoved.
Fixes: #U4-1942 - ensures content xml cache is refreshed even across servers when a property is removed or when the alias is changed.

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

@@ -14,7 +14,7 @@ namespace Umbraco.Core.Models.EntityBase
     [Serializable]
     [DataContract(IsReference = true)]
     [DebuggerDisplay("Id: {Id}")]
-    public abstract class Entity : IEntity, ICanBeDirty
+    public abstract class Entity : IEntity, IRememberBeingDirty, ICanBeDirty
     {
         private bool _hasIdentity;
         private int? _hash;
@@ -115,6 +115,11 @@ namespace Umbraco.Core.Models.EntityBase
         /// </summary>
         private readonly IDictionary<string, bool> _propertyChangedInfo = new Dictionary<string, bool>();
 
+        /// <summary>
+        /// Tracks the properties that we're changed before the last commit (or last call to ResetDirtyProperties)
+        /// </summary>
+        private IDictionary<string, bool> _lastPropertyChangedInfo = null;
+
         /// <summary>
         /// Indicates whether a specific property on the current entity is dirty.
         /// </summary>
@@ -134,6 +139,33 @@ namespace Umbraco.Core.Models.EntityBase
             return _propertyChangedInfo.Any();
         }
 
+        /// <summary>
+        /// Indicates that the entity had been changed and the changes were committed
+        /// </summary>
+        /// <returns></returns>
+        public bool WasDirty()
+        {
+            return _lastPropertyChangedInfo != null && _lastPropertyChangedInfo.Any();
+        }
+
+        /// <summary>
+        /// Indicates whether a specific property on the current entity was changed and the changes were committed
+        /// </summary>
+        /// <param name="propertyName">Name of the property to check</param>
+        /// <returns>True if Property was changed, otherwise False. Returns false if the entity had not been previously changed.</returns>
+        public virtual bool WasPropertyDirty(string propertyName)
+        {
+            return WasDirty() && _lastPropertyChangedInfo.Any(x => x.Key == propertyName);
+        }
+
+        /// <summary>
+        /// Resets the remembered dirty properties from before the last commit
+        /// </summary>
+        public void ForgetPreviouslyDirtyProperties()
+        {
+            _lastPropertyChangedInfo.Clear();
+        }
+
         /// <summary>
         /// Resets dirty properties by clearing the dictionary used to track changes.
         /// </summary>
@@ -143,9 +175,37 @@ namespace Umbraco.Core.Models.EntityBase
         /// </remarks>
         public virtual void ResetDirtyProperties()
         {
+            //copy the changed properties to the last changed properties
+            _lastPropertyChangedInfo = _propertyChangedInfo.ToDictionary(v => v.Key, v => v.Value);
+            
             _propertyChangedInfo.Clear();
         }
 
+        /// <summary>
+        /// Used by inheritors to set the value of properties, this will detect if the property value actually changed and if it did
+        /// it will ensure that the property has a dirty flag set.
+        /// </summary>
+        /// <param name="setValue"></param>
+        /// <param name="value"></param>
+        /// <param name="propertySelector"></param>
+        /// <returns>returns true if the value changed</returns>
+        /// <remarks>
+        /// This is required because we don't want a property to show up as "dirty" if the value is the same. For example, when we 
+        /// save a document type, nearly all properties are flagged as dirty just because we've 'reset' them, but they are all set 
+        /// to the same value, so it's really not dirty.
+        /// </remarks>
+        internal bool SetPropertyValueAndDetectChanges<T>(Func<T, T> setValue, T value, PropertyInfo propertySelector)
+        {
+            var initVal = value;
+            var newVal = setValue(value);            
+            if (!Equals(initVal, newVal))
+            {
+                OnPropertyChanged(propertySelector);
+                return true;
+            }
+            return false;
+        }
+
         /// <summary>
         /// Indicates whether the current entity has an identity, eg. Id.
         /// </summary>

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

@@ -0,0 +1,13 @@
+namespace Umbraco.Core.Models.EntityBase
+{
+    /// <summary>
+    /// An interface that defines if the object is tracking property changes and that is is also
+    /// remembering what property changes had been made after the changes were committed.
+    /// </summary>
+    public interface IRememberBeingDirty : ICanBeDirty
+    {
+        bool WasDirty();
+        bool WasPropertyDirty(string propertyName);
+        void ForgetPreviouslyDirtyProperties();
+    }
+}