Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Data.Entity/System/Data/Objects/DataClasses/EntityObject.cs

@@ -0,0 +1,275 @@
+//---------------------------------------------------------------------
+// <copyright file="EntityObject.cs" company="Microsoft">
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//
+// @owner       [....]
+// @backupOwner [....]
+//---------------------------------------------------------------------
+using System.Data;
+using System.Diagnostics;
+using System.Reflection;
+using System.ComponentModel;
+using System.Runtime.Serialization;
+
+namespace System.Data.Objects.DataClasses
+{
+    /// <summary>
+    /// This is the class is the basis for all perscribed EntityObject classes.
+    /// </summary>
+    [DataContract(IsReference=true)]
+    [Serializable]
+    public abstract class EntityObject : StructuralObject, IEntityWithKey, IEntityWithChangeTracker, IEntityWithRelationships
+    {
+        #region Privates
+
+        // The following 2 fields are serialized.  Adding or removing a serialized field is considered
+        // a breaking change.  This includes changing the field type or field name of existing
+        // serialized fields. If you need to make this kind of change, it may be possible, but it
+        // will require some custom serialization/deserialization code.
+        private RelationshipManager _relationships;
+        private EntityKey _entityKey;
+
+        [NonSerialized]
+        private IEntityChangeTracker _entityChangeTracker = s_detachedEntityChangeTracker;
+        [NonSerialized]
+        private static readonly DetachedEntityChangeTracker s_detachedEntityChangeTracker = new DetachedEntityChangeTracker();
+
+        /// <summary>
+        /// Helper class used when we are not currently attached to a change tracker.
+        /// Simplifies the code so we don't always have to check for null before using the change tracker
+        /// </summary>
+        private class DetachedEntityChangeTracker : IEntityChangeTracker
+        {
+            void IEntityChangeTracker.EntityMemberChanging(string entityMemberName) { }
+            void IEntityChangeTracker.EntityMemberChanged(string entityMemberName) { }
+            void IEntityChangeTracker.EntityComplexMemberChanging(string entityMemberName, object complexObject, string complexMemberName) { }
+            void IEntityChangeTracker.EntityComplexMemberChanged(string entityMemberName, object complexObject, string complexMemberName) { }
+            EntityState IEntityChangeTracker.EntityState
+            {
+                get
+                {
+                    return EntityState.Detached;
+                }
+            }
+        }
+
+        private IEntityChangeTracker EntityChangeTracker
+        {
+            get
+            {
+                if (_entityChangeTracker == null)
+                {
+                    _entityChangeTracker = s_detachedEntityChangeTracker;
+                }
+                return _entityChangeTracker;
+            }
+            set
+            {
+                _entityChangeTracker = value;
+            }
+        }
+
+        #endregion
+        #region Publics
+        /// <summary>
+        /// The storage state of this EntityObject 
+        /// </summary>
+        /// <value>
+        /// This property returns a value from the EntityState enum.
+        /// </value>
+        [System.ComponentModel.Browsable(false)]
+        [System.Xml.Serialization.XmlIgnore]
+        public EntityState EntityState
+        {
+            get
+            {
+                Debug.Assert(EntityChangeTracker != null,
+                    "EntityChangeTracker should never return null -- if detached should be set to s_detachedEntityChangeTracker");
+                Debug.Assert(EntityChangeTracker != s_detachedEntityChangeTracker ? EntityChangeTracker.EntityState != EntityState.Detached : true,
+                    "Should never get a detached state from an attached change tracker.");
+
+                return EntityChangeTracker.EntityState;
+            }
+        }
+
+        #region IEntityWithKey
+
+        /// <summary>
+        /// Returns the EntityKey for this EntityObject.
+        /// </summary>
+        [Browsable(false)]
+        [DataMember]
+        public EntityKey EntityKey
+        {
+            get
+            {
+                return _entityKey;
+            }
+            set
+            {
+                // Report the change to the change tracker
+                // If we are not attached to a change tracker, we can do anything we want to the key
+                // If we are attached, the change tracker should make sure the new value is valid for the current state
+                Debug.Assert(EntityChangeTracker != null, "_entityChangeTracker should never be null -- if detached it should return s_detachedEntityChangeTracker");
+                EntityChangeTracker.EntityMemberChanging(StructuralObject.EntityKeyPropertyName);
+                _entityKey = value;
+                EntityChangeTracker.EntityMemberChanged(StructuralObject.EntityKeyPropertyName);                
+            }
+        } 
+
+        #endregion       
+        #region IEntityWithChangeTracker
+
+
+        /// <summary>
+        /// Used by the ObjectStateManager to attach or detach this EntityObject to the cache.
+        /// </summary>
+        /// <param name="changeTracker">
+        /// Reference to the ObjectStateEntry that contains this entity
+        /// </param>
+        void IEntityWithChangeTracker.SetChangeTracker(IEntityChangeTracker changeTracker)
+        {
+            // Fail if the change tracker is already set for this EntityObject and it's being set to something different
+            // If the original change tracker is associated with a disposed ObjectStateManager, then allow
+            // the entity to be attached
+            if (changeTracker != null && EntityChangeTracker != s_detachedEntityChangeTracker && !Object.ReferenceEquals(changeTracker, EntityChangeTracker))
+            {
+                EntityEntry entry = EntityChangeTracker as EntityEntry;
+                if (entry == null || !entry.ObjectStateManager.IsDisposed)
+                {
+                    throw EntityUtil.EntityCantHaveMultipleChangeTrackers();
+                }
+            }
+            
+            EntityChangeTracker = changeTracker;
+        }
+
+        #endregion IEntityWithChangeTracker
+        #region IEntityWithRelationships
+
+        /// <summary>
+        /// Returns the container for the lazily created relationship 
+        /// navigation property objects, collections and refs.
+        /// </summary>
+        RelationshipManager IEntityWithRelationships.RelationshipManager
+        {
+            get
+            {
+                if (_relationships == null)
+                {
+                    _relationships = RelationshipManager.Create(this);
+                }
+
+                return _relationships;
+            }
+        }
+
+        #endregion
+        #endregion        
+        #region Protected Change Tracking Methods
+
+        /// <summary>
+        /// This method is called whenever a change is going to be made to an EntityObject 
+        /// property.
+        /// </summary>
+        /// <param name="property">
+        /// The name of the changing property.
+        /// </param>        
+        /// <exception cref="System.ArgumentNullException">
+        /// When parameter member is null (Nothing in Visual Basic).
+        /// </exception>
+        protected sealed override void ReportPropertyChanging(
+            string property)
+        {
+            EntityUtil.CheckStringArgument(property, "property");
+
+            Debug.Assert(EntityChangeTracker != null, "_entityChangeTracker should never be null -- if detached it should return s_detachedEntityChangeTracker");
+
+            base.ReportPropertyChanging(property);
+
+            EntityChangeTracker.EntityMemberChanging(property);
+        }
+
+        /// <summary>
+        /// This method is called whenever a change is made to an EntityObject 
+        /// property.
+        /// </summary>
+        /// <param name="property">
+        /// The name of the changed property.
+        /// </param>        
+        /// <exception cref="System.ArgumentNullException">
+        /// When parameter member is null (Nothing in Visual Basic).
+        /// </exception>
+        protected sealed override void ReportPropertyChanged(
+            string property)
+        {
+            EntityUtil.CheckStringArgument(property, "property");
+
+            Debug.Assert(EntityChangeTracker != null, "EntityChangeTracker should never return null -- if detached it should be return s_detachedEntityChangeTracker");
+            EntityChangeTracker.EntityMemberChanged(property);           
+            
+            base.ReportPropertyChanged(property);
+        }
+
+        #endregion
+        #region Internal ComplexObject Change Tracking Methods and Properties
+
+        internal sealed override bool IsChangeTracked
+        {
+            get
+            {
+                return EntityState != EntityState.Detached;
+            }
+        }
+
+        /// <summary>
+        /// This method is called by a ComplexObject contained in this Entity 
+        /// whenever a change is about to be made to a property of the  
+        /// ComplexObject so that the change can be forwarded to the change tracker.
+        /// </summary>
+        /// <param name="entityMemberName">
+        /// The name of the top-level entity property that contains the ComplexObject that is calling this method.
+        /// </param>
+        /// <param name="complexObject">
+        /// The instance of the ComplexObject on which the property is changing.
+        /// </param>
+        /// <param name="complexMemberName">
+        /// The name of the changing property on complexObject.
+        /// </param>        
+        internal sealed override void ReportComplexPropertyChanging(
+            string entityMemberName, ComplexObject complexObject, string complexMemberName)
+        {
+            Debug.Assert(complexObject != null, "invalid complexObject");
+            Debug.Assert(!String.IsNullOrEmpty(complexMemberName), "invalid complexMemberName");
+
+            EntityChangeTracker.EntityComplexMemberChanging(entityMemberName, complexObject, complexMemberName);            
+        }
+
+        /// <summary>
+        /// This method is called by a ComplexObject contained in this Entity 
+        /// whenever a change has been made to a property of the  
+        /// ComplexObject so that the change can be forwarded to the change tracker.
+        /// </summary>
+        /// <param name="entityMemberName">
+        /// The name of the top-level entity property that contains the ComplexObject that is calling this method.
+        /// </param>
+        /// <param name="complexObject">
+        /// The instance of the ComplexObject on which the property is changing.
+        /// </param>
+        /// <param name="complexMemberName">
+        /// The name of the changing property on complexObject.
+        /// </param>        
+        internal sealed override void ReportComplexPropertyChanged(
+            string entityMemberName, ComplexObject complexObject, string complexMemberName)
+        {
+            Debug.Assert(complexObject != null, "invalid complexObject");
+            Debug.Assert(!String.IsNullOrEmpty(complexMemberName), "invalid complexMemberName");
+
+            EntityChangeTracker.EntityComplexMemberChanged(entityMemberName, complexObject, complexMemberName);
+        }
+
+        #endregion      
+    }
+}
+