Updates referencesource to .NET 4.7

[mono.git] / mcs / class / referencesource / System.Data.Entity / System / Data / Objects / DataClasses / RelatedEnd.cs

//---------------------------------------------------------------------
// <copyright file="RelatedEnd.cs" company="Microsoft">
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//
// @owner       Microsoft
// @backupOwner Microsoft
//---------------------------------------------------------------------

namespace System.Data.Objects.DataClasses
{
    using System.Collections;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data.Common.Utils;
    using System.Data.Metadata.Edm;
    using System.Data.Objects.Internal;
    using System.Diagnostics;
    using System.Linq;
    using System.Runtime.Serialization;
    using System.Text;

    /// <summary>
    /// Base class for EntityCollection and EntityReference
    /// </summary>

    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1710:IdentifiersShouldHaveCorrectSuffix")]
    [DataContract]
    [Serializable]
    public abstract class RelatedEnd : IRelatedEnd
    {

        //-----------------
        // Internal Constructors
        //-----------------

        /// <summary>
        /// The default constructor is required for some serialization scenarios with EntityReference.
        /// </summary>
        internal RelatedEnd()
        {
            _wrappedOwner = EntityWrapperFactory.NullWrapper;
        }

        internal RelatedEnd(IEntityWrapper wrappedOwner, RelationshipNavigation navigation, IRelationshipFixer relationshipFixer)
        {
            EntityUtil.CheckArgumentNull(wrappedOwner, "wrappedOwner");
            EntityUtil.CheckArgumentNull(wrappedOwner.Entity, "wrappedOwner.Entity");
            EntityUtil.CheckArgumentNull(navigation, "navigation");
            EntityUtil.CheckArgumentNull(relationshipFixer, "fixer");

            InitializeRelatedEnd(wrappedOwner, navigation, relationshipFixer);
        }

        // ------
        // Fields
        // ------
        private const string _entityKeyParamName = "EntityKeyValue";

        // The following 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.
        // These fields should not be changed once they have been initialized with non-null values, but they can't be read-only because there
        // are serialization scenarios where they have to be set after construction

        /// <summary>
        /// Note that this field should no longer be used directly.  Instead, use the _wrappedOwner
        /// field.  This field is retained only for compatibility with the serialization format introduced in v1.
        /// </summary>
        [Obsolete()]
        private IEntityWithRelationships _owner;

        private RelationshipNavigation _navigation;
        private IRelationshipFixer _relationshipFixer;

        internal bool _isLoaded;

        // The fields in this group are set only when attached to a context, so we don't need to serialize.
        [NonSerialized]
        private RelationshipSet _relationshipSet;
        [NonSerialized]
        private ObjectContext _context;
        [NonSerialized]
        private bool _usingNoTracking;
        [NonSerialized]
        private RelationshipType _relationMetadata;
        [NonSerialized]
        private RelationshipEndMember _fromEndProperty; //owner end property
        [NonSerialized]
        private RelationshipEndMember _toEndProperty;
        [NonSerialized]
        private string _sourceQuery;
        [NonSerialized]
        private IEnumerable<EdmMember> _sourceQueryParamProperties; // indicates which properties populate query parameters

        [NonSerialized]
        internal bool _suppressEvents;
        [NonSerialized]
        internal CollectionChangeEventHandler _onAssociationChanged;

        [NonSerialized]
        private IEntityWrapper _wrappedOwner;

        // ------
        // Events
        // ------

        /// <summary>
        /// Event to notify changes in the Associations.
        /// </summary>
        public event CollectionChangeEventHandler AssociationChanged
        {
            add
            {
                CheckOwnerNull();
                _onAssociationChanged += value;
            }
            remove
            {
                CheckOwnerNull();
                _onAssociationChanged -= value;
            }
        }

        /// <summary>internal event to notify change in collection</summary>
        internal virtual event CollectionChangeEventHandler AssociationChangedForObjectView
        {
            // we fire this event only from EntityCollection, definitely not from EntityReference
            add { Debug.Assert(false, "should never happen"); }
            remove { Debug.Assert(false, "should never happen"); }
        }


        // ----------
        // Properties
        // ----------


        internal bool IsForeignKey
        {
            get
            {
                Debug.Assert(this.ObjectContext != null, "the IsForeignKey property shouldn't be used in detached scenarios");
                Debug.Assert(this._relationMetadata != null, "this._relationMetadata == null");

                return ((AssociationType)_relationMetadata).IsForeignKey;
            }
        }

        /// <summary>
        /// This class describes a relationship navigation from the
        /// navigation property on one entity to another entity. 
        /// RelationshipNavigation uniquely identify a relationship type.
        /// The RelationshipNavigation class is internal only, so this property is also internal.
        /// See RelationshipName, SourceRoleName, and TargetRoleName for the public exposure
        /// of the information contained in this RelationshipNavigation.
        /// </summary>
        internal RelationshipNavigation RelationshipNavigation
        {
            get
            {
                return _navigation;
            }
        }

        /// <summary>
        /// Name of the relationship in which this RelatedEnd is participating        
        /// </summary>
        [System.Xml.Serialization.SoapIgnore]
        [System.Xml.Serialization.XmlIgnore]
        public string RelationshipName
        {
            get
            {
                CheckOwnerNull();
                return _navigation.RelationshipName;
            }
        }

        /// <summary>
        /// Name of the relationship source role used to generate this RelatedEnd
        /// </summary>
        [System.Xml.Serialization.SoapIgnore]
        [System.Xml.Serialization.XmlIgnore]
        public string SourceRoleName
        {
            get
            {
                CheckOwnerNull();
                return _navigation.From;
            }
        }

        /// <summary>
        /// Name of the relationship target role used to generate this RelatedEnd
        /// </summary>
        [System.Xml.Serialization.SoapIgnore]
        [System.Xml.Serialization.XmlIgnore]
        public string TargetRoleName
        {
            get
            {
                CheckOwnerNull();
                return _navigation.To;
            }
        }

        IEnumerable IRelatedEnd.CreateSourceQuery()
        {
            CheckOwnerNull();
            return this.CreateSourceQueryInternal();
        }

        internal IEntityWrapper WrappedOwner
        {
            get
            {
                return this._wrappedOwner;
            }
        }

        internal ObjectContext ObjectContext
        {
            get
            {
                return this._context;
            }
        }

        internal virtual void BulkDeleteAll(System.Collections.Generic.List<object> list)
        {
            throw EntityUtil.NotSupported();
        }

        /// <summary>
        /// Returns the relationship metadata associated with this RelatedEnd.
        /// This value is available once the RelatedEnd is attached to an ObjectContext
        /// or is retrieved with MergeOption.NoTracking
        /// </summary>
        [System.Xml.Serialization.SoapIgnore]
        [System.Xml.Serialization.XmlIgnore]
        public RelationshipSet RelationshipSet
        {
            get
            {
                CheckOwnerNull();
                return this._relationshipSet;
            }
        }

        internal RelationshipType RelationMetadata
        {
            get
            {
                return this._relationMetadata;
            }
        }

        internal RelationshipEndMember ToEndMember
        {
            get
            {
                return this._toEndProperty;
            }
        }

        internal bool UsingNoTracking
        {
            get
            {
                return this._usingNoTracking;
            }
        }

        internal MergeOption DefaultMergeOption
        {
            get
            {
                return UsingNoTracking ? MergeOption.NoTracking : MergeOption.AppendOnly;
            }
        }

        internal RelationshipEndMember FromEndProperty
        {
            get
            {
                return this._fromEndProperty;
            }
        }

        /// <summary>
        /// IsLoaded returns true if and only if Load was called.
        /// </summary>
        [System.Xml.Serialization.SoapIgnore]
        [System.Xml.Serialization.XmlIgnore]
        public bool IsLoaded
        {
            get
            {
                CheckOwnerNull();
                return this._isLoaded;
            }
        }

        internal void SetIsLoaded(bool value)
        {
            this._isLoaded = value;
        }

        /// <summary>
        /// This is the query which represents the source of the
        /// related end.  It is constructed on demand using the
        /// _connection and _cache fields and a query string based on
        /// the type of related end and the metadata passed into its
        /// constructor indicating the particular EDM construct the
        /// related end models. This method is called by both subclasses of this type
        /// and those subclasses pass in their generic type parameter in order
        /// to produce an ObjectQuery of the right type. This allows this common 
        /// functionality to be implemented here in the base class while still
        /// allowing the base class to be non-generic.
        /// </summary>
        /// <param name="mergeOption">MergeOption to use when creating the query</param>
        /// <param name="hasResults">Indicates whether the query can produce results.
        /// For instance, a lookup with null key values cannot produce results.</param>
        /// <returns>The query loading related entities.</returns>
        internal ObjectQuery<TEntity> CreateSourceQuery<TEntity>(MergeOption mergeOption, out bool hasResults)
        {
            // must have a context
            if (_context == null)
            {
                hasResults = false;
                return null;
            }

            EntityEntry stateEntry = _context.ObjectStateManager.FindEntityEntry(_wrappedOwner.Entity);
            EntityState entityState;
            if (stateEntry == null)
            {
                if (UsingNoTracking)
                {
                    entityState = EntityState.Detached;
                }
                else
                {
                    throw EntityUtil.InvalidEntityStateSource();
                }
            }
            else
            {
                Debug.Assert(stateEntry != null, "Entity should exist in the current context");
                entityState = stateEntry.State;
            }

            //Throw incase entity is in added state, unless this is the dependent end of an FK relationship
            if (entityState == EntityState.Added &&
                (!IsForeignKey ||
                 !IsDependentEndOfReferentialConstraint(checkIdentifying: false)))
            {
                throw EntityUtil.InvalidEntityStateSource();
            }

            Debug.Assert(!(entityState != EntityState.Detached && UsingNoTracking), "Entity with NoTracking option cannot exist in the ObjectStateManager");

            // the CreateSourceQuery method can only return non-NULL when we're
            // either detached & mergeOption is NoTracking or
            // Added/Modified/Unchanged/Deleted and mergeOption is NOT NoTracking
            // (if entity is attached to the context, mergeOption should never be NoTracking)
            // If the entity state is added, at this point it is an FK dependent end
            if (!((entityState == EntityState.Detached && UsingNoTracking) ||
                   entityState == EntityState.Modified ||
                   entityState == EntityState.Unchanged ||
                   entityState == EntityState.Deleted ||
                   entityState == EntityState.Added))
            {
                hasResults = false;
                return null;
            }

            // Construct a new source query and return it.
            Debug.Assert(_relationshipSet != null, "If we are attached to a context, we should have a relationship set.");

            // Retrieve the entity key of the owner.
            EntityKey key = _wrappedOwner.EntityKey;
            EntityUtil.CheckEntityKeyNull(key); // Might be null because of faulty IPOCO implementation

            // If the source query text has not been initialized, then do so now.
            if (null == _sourceQuery)
            {
                Debug.Assert(_relationshipSet.BuiltInTypeKind == BuiltInTypeKind.AssociationSet, "Non-AssociationSet Relationship Set?");
                AssociationType associationMetadata = (AssociationType)_relationMetadata;

                EntitySet ownerEntitySet = ((AssociationSet)_relationshipSet).AssociationSetEnds[_fromEndProperty.Name].EntitySet;
                EntitySet targetEntitySet = ((AssociationSet)_relationshipSet).AssociationSetEnds[_toEndProperty.Name].EntitySet;

                EntityType targetEntityType = MetadataHelper.GetEntityTypeForEnd((AssociationEndMember)_toEndProperty);
                bool ofTypeRequired = false;
                if (!targetEntitySet.ElementType.EdmEquals(targetEntityType) &&
                    !TypeSemantics.IsSubTypeOf(targetEntitySet.ElementType, targetEntityType))
                {
                    // If the type contained in the target entity set is not equal to
                    // or a subtype of the referenced type, then an OfType must be
                    // applied to the target entityset to yield only those elements that
                    // are of the referenced type or a subtype of the referenced type.
                    ofTypeRequired = true;

                    // The type name used in the OfType clause must be the name of the
                    // corresponding O-Space Entity type, since the source query will be
                    // parsed using the CLR perspective (by ObjectQuery).
                    TypeUsage targetOSpaceTypeUsage = ObjectContext.MetadataWorkspace.GetOSpaceTypeUsage(TypeUsage.Create(targetEntityType));
                    targetEntityType = (EntityType)targetOSpaceTypeUsage.EdmType;
                }

                StringBuilder sourceBuilder;
                if (associationMetadata.IsForeignKey)
                {
                    var fkConstraint = associationMetadata.ReferentialConstraints[0];
                    var principalProps = fkConstraint.FromProperties;
                    var dependentProps = fkConstraint.ToProperties;
                    Debug.Assert(principalProps.Count == dependentProps.Count, "Mismatched foreign key properties?");

                    if (fkConstraint.ToRole.EdmEquals(_toEndProperty))
                    {
                        // This related end goes from 'principal' to 'dependent', and has the key of the principal.
                        // In this case it is sufficient to filter the target (dependent) set where the foreign key
                        // properties have the same values as the corresponding entity key properties from the principal.
                        //
                        // SELECT VALUE D 
                        //   FROM OfType(##DependentEntityset, ##DependentEntityType) 
                        // AS D
                        // WHERE 
                        //   D.DependentProperty1 = @PrincipalProperty1 [AND
                        //   ...
                        //   D.DependentPropertyN = @PrincipalPropertyN]
                        //
                        // Note that the OfType operator can be omitted if the element type of ##DependentEntitySet
                        // is equal to the Entity type produced by the target end of the relationship.
                        sourceBuilder = new StringBuilder("SELECT VALUE D FROM ");
                        AppendEntitySet(sourceBuilder, targetEntitySet, targetEntityType, ofTypeRequired);
                        sourceBuilder.Append(" AS D WHERE ");

                        // For each principal key property there is a corresponding query parameter that supplies the value
                        // from this owner's entity key, so KeyParam1 corresponds to the first key member, etc.
                        // We remember the order of the corresponding principal key values in the _sourceQueryParamProperties
                        // field.
                        AliasGenerator keyParamNameGen = new AliasGenerator(_entityKeyParamName); // Aliases are cached in AliasGenerator
                        _sourceQueryParamProperties = principalProps;

                        for (int idx = 0; idx < dependentProps.Count; idx++)
                        {
                            if (idx > 0)
                            {
                                sourceBuilder.Append(" AND ");
                            }

                            sourceBuilder.Append("D.[");
                            sourceBuilder.Append(dependentProps[idx].Name);
                            sourceBuilder.Append("] = @");
                            sourceBuilder.Append(keyParamNameGen.Next());
                        }
                    }
                    else
                    {
                        // This related end goes from 'dependent' to 'principal', and has the key of the dependent
                        // In this case it is necessary to filter the target (principal) entity set on the foreign 
                        // key relationship properties to retrieve the corresponding principal entity.
                        //
                        // SELECT VALUE P FROM
                        //   OfType(##PrincipalEntityset, ##PrincipalEntityType) AS P
                        // WHERE 
                        //   P.PrincipalProperty1 = @DependentProperty1 AND ...
                        //
                        Debug.Assert(fkConstraint.FromRole.EdmEquals(_toEndProperty), "Source query for foreign key association related end is not based on principal or dependent?");

                        sourceBuilder = new StringBuilder("SELECT VALUE P FROM ");
                        AppendEntitySet(sourceBuilder, targetEntitySet, targetEntityType, ofTypeRequired);
                        sourceBuilder.Append(" AS P WHERE ");

                        AliasGenerator keyParamNameGen = new AliasGenerator(_entityKeyParamName); // Aliases are cached in AliasGenerator
                        _sourceQueryParamProperties = dependentProps;
                        for (int idx = 0; idx < principalProps.Count; idx++)
                        {
                            if (idx > 0)
                            {
                                sourceBuilder.Append(" AND ");
                            }
                            sourceBuilder.Append("P.[");
                            sourceBuilder.Append(principalProps[idx].Name);
                            sourceBuilder.Append("] = @");
                            sourceBuilder.Append(keyParamNameGen.Next());
                        }
                        _sourceQuery = sourceBuilder.ToString();
                    }
                }
                else
                {
                    // Translate to:
                    // SELECT VALUE [TargetEntity]
                    //  FROM 
                    //      (SELECT VALUE x FROM ##RelationshipSet AS x
                    //       WHERE Key(x.[##SourceRoleName]) = ROW(@key1 AS key1[..., @keyN AS keyN])
                    //       ) AS [AssociationEntry]
                    //  INNER JOIN 
                    //       OfType(##TargetEntityset, ##TargetRole.EntityType) AS [TargetEntity] 
                    //  ON
                    //       Key([AssociationEntry].##TargetRoleName) = Key(Ref([TargetEntity]))
                    //
                    // Note that the OfType operator can be omitted if the element type of ##TargetEntitySet
                    // is equal to the Entity type produced by the target end of the relationship.

                    sourceBuilder = new StringBuilder("SELECT VALUE [TargetEntity] FROM (SELECT VALUE x FROM ");
                    sourceBuilder.Append("[");
                    sourceBuilder.Append(_relationshipSet.EntityContainer.Name);
                    sourceBuilder.Append("].[");
                    sourceBuilder.Append(_relationshipSet.Name);
                    sourceBuilder.Append("] AS x WHERE Key(x.[");
                    sourceBuilder.Append(_fromEndProperty.Name);
                    sourceBuilder.Append("]) = ");

                    AppendKeyParameterRow(sourceBuilder, key.GetEntitySet(ObjectContext.MetadataWorkspace).ElementType.KeyMembers);

                    sourceBuilder.Append(") AS [AssociationEntry] INNER JOIN ");

                    AppendEntitySet(sourceBuilder, targetEntitySet, targetEntityType, ofTypeRequired);

                    sourceBuilder.Append(" AS [TargetEntity] ON Key([AssociationEntry].[");
                    sourceBuilder.Append(_toEndProperty.Name);
                    sourceBuilder.Append("]) = Key(Ref([TargetEntity]))");
                }

                _sourceQuery = sourceBuilder.ToString();
            }

            // Create a new ObjectQuery based on the source query text, the object context, and the specified merge option.
            ObjectQuery<TEntity> query = new ObjectQuery<TEntity>(_sourceQuery, _context, mergeOption);

            // Add a parameter for each entity key value found on the key.
            AliasGenerator paramNameGen = new AliasGenerator(_entityKeyParamName); // Aliases are cached in AliasGenerator
            IEnumerable<EdmMember> parameterMembers = _sourceQueryParamProperties
                ?? key.GetEntitySet(ObjectContext.MetadataWorkspace).ElementType.KeyMembers;

            hasResults = true;
            foreach (EdmMember parameterMember in parameterMembers)
            {
                // Create a new ObjectParameter with the next parameter name and the next entity value.
                // When _sourceQueryParamProperties are defined, it means we are handling a foreign key association. For an FK association,
                // the current entity values are considered truth. Otherwise, we use EntityKey values for backwards
                // compatibility with independent association behaviors in .NET 3.5.
                object value;
                if (null == _sourceQueryParamProperties)
                {
                    // retrieve the value from the entity key (independent association lookup)
                    value = _wrappedOwner.EntityKey.EntityKeyValues.Single(ekv => ekv.Key == parameterMember.Name).Value;
                }
                else
                {
                    // retrieve the value from the entity itself (FK lookup)
                    EntityReference reference = this as EntityReference;
                    if (reference != null && ForeignKeyFactory.IsConceptualNullKey(reference.CachedForeignKey))
                    {
                        value = null;
                    }
                    else
                    {
                        value = GetCurrentValueFromEntity(parameterMember);
                    }
                }
                ObjectParameter queryParam;
                if (null == value)
                {
                    var parameterEdmType = parameterMember.TypeUsage.EdmType;
                    Debug.Assert(Helper.IsScalarType(parameterEdmType), "Only primitive or enum type expected for parameters");

                    Type parameterClrType = Helper.IsPrimitiveType(parameterEdmType) ? 
                        ((PrimitiveType)parameterEdmType).ClrEquivalentType :
                        ((ClrEnumType)ObjectContext.MetadataWorkspace.GetObjectSpaceType((EnumType)parameterEdmType)).ClrType;

                    queryParam = new ObjectParameter(paramNameGen.Next(), parameterClrType);
                    // If any lookup value is null, the query cannot match any rows.
                    hasResults = false;
                }
                else
                {
                    queryParam = new ObjectParameter(paramNameGen.Next(), value);
                }

                // Map the type of the key member to C-Space and explicitly specify this mapped type
                // as the effective type of the new ObjectParameter - this is required so that the
                // type of the key value parameter matches the declared type of the key member when
                // the query text is parsed.
                queryParam.TypeUsage = Helper.GetModelTypeUsage(parameterMember);

                // Add the new parameter to the Parameters collection of the query.
                query.Parameters.Add(queryParam);
            }

            // It should not be possible to add or remove parameters from the new query, since the query text
            // is fixed. Adding or removing parameters will likely make the query fail to execute.
            query.Parameters.SetReadOnly(true);

            // Return the new ObjectQuery. Note that this is intentionally a tear-off so that any changes made
            // to its Parameters collection (or the ObjectParameters themselves) have no effect on anyone else
            // that may retrieve this query - each access will always return a new ObjectQuery instance.
            return query;
        }

        private object GetCurrentValueFromEntity(EdmMember member)
        {
            // retrieve member accessor from the object context (which already keeps track of the relevant
            // metadata)
            StateManagerTypeMetadata metaType = _context.ObjectStateManager.GetOrAddStateManagerTypeMetadata(member.DeclaringType);
            StateManagerMemberMetadata metaMember = metaType.Member(metaType.GetOrdinalforCLayerMemberName(member.Name));
            return metaMember.GetValue(_wrappedOwner.Entity);
        }

        private static void AppendKeyParameterRow(StringBuilder sourceBuilder, IList<EdmMember> keyMembers)
        {
            sourceBuilder.Append("ROW(");
            AliasGenerator keyParamNameGen = new AliasGenerator(_entityKeyParamName); // Aliases are cached in AliasGenerator
            int keyMemberCount = keyMembers.Count;
            for (int idx = 0; idx < keyMemberCount; idx++)
            {
                string keyParamName = keyParamNameGen.Next();
                sourceBuilder.Append("@");
                sourceBuilder.Append(keyParamName);
                sourceBuilder.Append(" AS ");
                sourceBuilder.Append(keyParamName);

                if (idx < keyMemberCount - 1)
                {
                    sourceBuilder.Append(",");
                }
            }
            sourceBuilder.Append(")");
        }

        private static void AppendEntitySet(StringBuilder sourceBuilder, EntitySet targetEntitySet, EntityType targetEntityType, bool ofTypeRequired)
        {
            if (ofTypeRequired)
            {
                sourceBuilder.Append("OfType(");
            }
            sourceBuilder.Append("[");
            sourceBuilder.Append(targetEntitySet.EntityContainer.Name);
            sourceBuilder.Append("].[");
            sourceBuilder.Append(targetEntitySet.Name);
            sourceBuilder.Append("]");
            if (ofTypeRequired)
            {
                sourceBuilder.Append(", [");
                if (targetEntityType.NamespaceName != string.Empty)
                {
                    sourceBuilder.Append(targetEntityType.NamespaceName);
                    sourceBuilder.Append("].[");
                }
                sourceBuilder.Append(targetEntityType.Name);
                sourceBuilder.Append("])");
            }
        }

        /// <summary>
        /// Validates that a call to Load has the correct conditions
        /// This helps to reduce the complexity of the Load call (SQLBU 524128)
        /// </summary>
        /// <returns>See RelatedEnd.CreateSourceQuery method. This is returned here so we can create it and validate the state before returning it to the caller</returns>
        internal ObjectQuery<TEntity> ValidateLoad<TEntity>(MergeOption mergeOption, string relatedEndName, out bool hasResults)
        {
            ObjectQuery<TEntity> sourceQuery = CreateSourceQuery<TEntity>(mergeOption, out hasResults);
            if (null == sourceQuery)
            {
                throw EntityUtil.RelatedEndNotAttachedToContext(relatedEndName);
            }

            EntityEntry entry = ObjectContext.ObjectStateManager.FindEntityEntry(_wrappedOwner.Entity);
            //Throw in case entity is in deleted state
            if (entry != null && entry.State == EntityState.Deleted)
            {
                throw EntityUtil.InvalidEntityStateLoad(relatedEndName);
            }

            // MergeOption for Load must be NoTracking if and only if the source entity was NoTracking. If the source entity was 
            // retrieved with any other MergeOption, the Load MergeOption can be anything but NoTracking. I.e. The entity could
            // have been loaded with OverwriteChanges and the Load option can be AppendOnly.
            if (UsingNoTracking != (mergeOption == MergeOption.NoTracking))
            {
                throw EntityUtil.MismatchedMergeOptionOnLoad(mergeOption);
            }

            if (UsingNoTracking)
            {
                if (this.IsLoaded)
                {
                    throw EntityUtil.LoadCalledOnAlreadyLoadedNoTrackedRelatedEnd();
                }

                if (!IsEmpty())
                {
                    throw EntityUtil.LoadCalledOnNonEmptyNoTrackedRelatedEnd();
                }
            }

            return sourceQuery;
        }

        // -------
        // Methods
        // -------

        /// <summary>
        /// Loads the related entity or entities into the local related end using the default merge option.        
        /// </summary>
        public void Load()
        {
            CheckOwnerNull();
            Load(DefaultMergeOption);
        }

        /// <summary>
        /// Loads the related entity or entities into the local related end using the supplied MergeOption.        
        /// </summary>
        public abstract void Load(MergeOption mergeOption);

        /// <summary>
        /// 
        /// </summary>
        internal void DeferredLoad()
        {
            if (_wrappedOwner != null && _wrappedOwner != EntityWrapperFactory.NullWrapper &&
                !IsLoaded &&
                _context != null &&
                _context.ContextOptions.LazyLoadingEnabled &&
                !_context.InMaterialization &&
                CanDeferredLoad)
            {
                // Ensure the parent EntityState is NoTracking, Unchanged, or Modified
                // Detached, Added, and Deleted parents cannot call Load
                Debug.Assert(_wrappedOwner != null, "Wrapper owner should never be null");
                if (UsingNoTracking ||
                    (_wrappedOwner.ObjectStateEntry != null &&
                     (_wrappedOwner.ObjectStateEntry.State == EntityState.Unchanged ||
                      _wrappedOwner.ObjectStateEntry.State == EntityState.Modified ||
                      (_wrappedOwner.ObjectStateEntry.State == EntityState.Added && IsForeignKey && IsDependentEndOfReferentialConstraint(false)))))
                {
                    // Avoid infinite recursive calls
                    _context.ContextOptions.LazyLoadingEnabled = false;
                    try
                    {
                        Load();
                    }
                    finally
                    {
                        _context.ContextOptions.LazyLoadingEnabled = true;
                    }
                }
            }
        }

        internal virtual bool CanDeferredLoad
        {
            get { return true; }
        }

        /// <summary>
        /// Takes a list of related entities and merges them into the current collection.
        /// </summary>        
        /// <param name="collection">Entities to relate to the owner of this EntityCollection</param>
        /// <param name="mergeOption">MergeOption to use when updating existing relationships</param>
        /// <param name="setIsLoaded">Indicates whether IsLoaded should be set to true after the Load is complete.
        /// Should be false in cases where we cannot guarantee that the set of entities is complete
        /// and matches the server, such as Attach.</param>
        internal void Merge<TEntity>(IEnumerable<TEntity> collection, MergeOption mergeOption, bool setIsLoaded)
        {
            List<IEntityWrapper> refreshedCollection = collection as List<IEntityWrapper>;
            if (refreshedCollection == null)
            {
                refreshedCollection = new List<IEntityWrapper>();
                EntitySet targetEntitySet = ((AssociationSet)RelationshipSet).AssociationSetEnds[TargetRoleName].EntitySet;
                foreach (TEntity entity in collection)
                {
                    IEntityWrapper wrapper = EntityWrapperFactory.WrapEntityUsingContext(entity, ObjectContext);
                    // When the MergeOption is NoTraking, we need to make sure the wrapper reflects the current context and
                    // has an EntityKey
                    if (mergeOption == MergeOption.NoTracking)
                    {
                        EntityWrapperFactory.UpdateNoTrackingWrapper(wrapper, ObjectContext, targetEntitySet);
                    }
                    refreshedCollection.Add(wrapper);
                }
            }
            Merge<TEntity>(refreshedCollection, mergeOption, setIsLoaded);
        }

        // Internal version of Merge that works on wrapped entities.
        internal void Merge<TEntity>(List<IEntityWrapper> collection, MergeOption mergeOption, bool setIsLoaded)
        {
            //Dev note: do not add event firing in Merge API, if it need to be added, add it to the caller
            EntityKey sourceKey = _wrappedOwner.EntityKey;
            EntityUtil.CheckEntityKeyNull(sourceKey);

            ObjectStateManager.UpdateRelationships(this.ObjectContext, mergeOption, (AssociationSet)RelationshipSet, (AssociationEndMember)FromEndProperty, sourceKey, _wrappedOwner, (AssociationEndMember)ToEndMember, collection, setIsLoaded);

            if (setIsLoaded)
            {
                // If the input collection contains all related entities, mark the collection as "loaded"
                _isLoaded = true;
            }
        }

        /// <summary>
        /// Attaches an entity to the related end.  This method works in exactly the same way as Attach(object).
        /// It is maintained for backward compatibility with previous versions of IRelatedEnd.
        /// </summary>
        /// <param name="entity">The entity to attach to the related end</param>
        /// <exception cref="ArgumentNullException">Thrown when <paramref name="entity"/> is null.</exception>
        /// <exception cref="InvalidOperationException">Thrown when the entity cannot be related via the current relationship end.</exception>
        void IRelatedEnd.Attach(IEntityWithRelationships entity)
        {
            ((IRelatedEnd)this).Attach((object)entity);
        }

        /// <summary>
        /// Attaches an entity to the related end. If the related end is already filled
        /// or partially filled, this merges the existing entities with the given entity. The given
        /// entity is not assumed to be the complete set of related entities.
        /// 
        /// Owner and all entities passed in must be in Unchanged or Modified state. 
        /// Deleted elements are allowed only when the state manager is already tracking the relationship
        /// instance.
        /// </summary>
        /// <param name="entity">The entity to attach to the related end</param>
        /// <exception cref="ArgumentNullException">Thrown when <paramref name="entity"/> is null.</exception>
        /// <exception cref="InvalidOperationException">Thrown when the entity cannot be related via the current relationship end.</exception>
        void IRelatedEnd.Attach(object entity)
        {
            CheckOwnerNull();
            EntityUtil.CheckArgumentNull(entity, "entity");
            Attach(new IEntityWrapper[] { EntityWrapperFactory.WrapEntityUsingContext(entity, ObjectContext) }, false);
        }

        internal void Attach(IEnumerable<IEntityWrapper> wrappedEntities, bool allowCollection)
        {
            CheckOwnerNull();
            ValidateOwnerForAttach();

            // validate children and collect them in the "refreshedCollection" for this instance
            int index = 0;
            List<IEntityWrapper> collection = new List<IEntityWrapper>();

            foreach (IEntityWrapper entity in wrappedEntities)
            {
                ValidateEntityForAttach(entity, index++, allowCollection);
                collection.Add(entity);
            }

            _suppressEvents = true;
            try
            {
                // After Attach, the two entities should be related in the Unchanged state, so use OverwriteChanges
                // Since no query is done in this case, the MergeOption only controls the relationships
                Merge(collection, MergeOption.OverwriteChanges, false /*setIsLoaded*/);
                ReferentialConstraint constraint = ((AssociationType)RelationMetadata).ReferentialConstraints.FirstOrDefault();
                if (constraint != null)
                {
                    ObjectStateManager stateManager = ObjectContext.ObjectStateManager;
                    EntityEntry ownerEntry = stateManager.FindEntityEntry(_wrappedOwner.Entity);
                    Debug.Assert(ownerEntry != null, "Both entities should be attached.");
                    if (IsDependentEndOfReferentialConstraint(checkIdentifying: false))
                    {
                        Debug.Assert(collection.Count == 1, "Dependant should attach to single principal");
                        if (!VerifyRIConstraintsWithRelatedEntry(constraint, ownerEntry.GetCurrentEntityValue, collection[0].ObjectStateEntry.EntityKey))
                        {
                            throw EntityUtil.InconsistentReferentialConstraintProperties();
                        }
                    }
                    else
                    {
                        foreach (IEntityWrapper wrappedTarget in collection)
                        {
                            RelatedEnd targetRelatedEnd = GetOtherEndOfRelationship(wrappedTarget);
                            if (targetRelatedEnd.IsDependentEndOfReferentialConstraint(checkIdentifying: false))
                            {
                                EntityEntry targetEntry = stateManager.FindEntityEntry(((EntityReference)targetRelatedEnd).WrappedOwner.Entity);
                                Debug.Assert(targetEntry != null, "Both entities should be attached.");
                                if (!VerifyRIConstraintsWithRelatedEntry(constraint, targetEntry.GetCurrentEntityValue, ownerEntry.EntityKey))
                                {
                                    throw EntityUtil.InconsistentReferentialConstraintProperties();
                                }
                            }
                        }
                    }
                }
            }
            finally
            {
                _suppressEvents = false;
            }
            OnAssociationChanged(CollectionChangeAction.Refresh, null);
        }

        // verifies requirements for Owner in Attach()
        internal void ValidateOwnerForAttach()
        {
            if (null == this.ObjectContext || UsingNoTracking)
            {
                throw EntityUtil.InvalidOwnerStateForAttach();
            }

            // find state entry
            EntityEntry stateEntry = this.ObjectContext.ObjectStateManager.GetEntityEntry(_wrappedOwner.Entity);
            if (stateEntry.State != EntityState.Modified &&
                stateEntry.State != EntityState.Unchanged)
            {
                throw EntityUtil.InvalidOwnerStateForAttach();
            }
        }

        // verifies requirements for child entity passed to Attach()
        internal void ValidateEntityForAttach(IEntityWrapper wrappedEntity, int index, bool allowCollection)
        {
            if (null == wrappedEntity || null == wrappedEntity.Entity)
            {
                if (allowCollection)
                {
                    throw EntityUtil.InvalidNthElementNullForAttach(index);
                }
                else
                {
                    throw EntityUtil.ArgumentNull("wrappedEntity");
                }
            }

            // Having this verification here results in having the same exception no matter how the further code path is changed.
            this.VerifyType(wrappedEntity);

            // verify the entity exists in the current context
            Debug.Assert(null != this.ObjectContext,
                "ObjectContext must not be null after call to ValidateOwnerForAttach");
            Debug.Assert(!UsingNoTracking, "We should not be here for NoTracking case.");
            EntityEntry stateEntry = ObjectContext.ObjectStateManager.FindEntityEntry(wrappedEntity.Entity);
            if (null == stateEntry || !Object.ReferenceEquals(stateEntry.Entity, wrappedEntity.Entity))
            {
                if (allowCollection)
                {
                    throw EntityUtil.InvalidNthElementContextForAttach(index);
                }
                else
                {
                    throw EntityUtil.InvalidEntityContextForAttach();
                }
            }
            Debug.Assert(stateEntry.State != EntityState.Detached,
                "State cannot be detached if the entry was retrieved from the context");

            // verify the state of the entity (may not be in added state, since we only support attaching relationships
            // to existing entities)
            if (stateEntry.State != EntityState.Unchanged &&
                stateEntry.State != EntityState.Modified)
            {
                if (allowCollection)
                {
                    throw EntityUtil.InvalidNthElementStateForAttach(index);
                }
                else
                {
                    throw EntityUtil.InvalidEntityStateForAttach();
                }
            }
        }

        internal abstract IEnumerable CreateSourceQueryInternal();

        /// <summary>
        /// Adds an entity to the related end.  This method works in exactly the same way as Add(object).
        /// It is maintained for backward compatibility with previous versions of IRelatedEnd.
        /// </summary>
        /// <param name="entity">
        ///   Entity instance to add to the related end
        /// </param>
        void IRelatedEnd.Add(IEntityWithRelationships entity)
        {
            ((IRelatedEnd)this).Add((object)entity);
        }

        /// <summary>
        ///   Adds an entity to the related end.  If the owner is
        ///   attached to a cache then the all the connected ends are
        ///   added to the object cache and their corresponding relationships 
        ///   are also added to the ObjectStateManager. The RelatedEnd of the
        ///   relationship is also fixed.
        /// </summary>
        /// <param name="entity">
        ///   Entity instance to add to the related end
        /// </param>
        void IRelatedEnd.Add(object entity)
        {
            EntityUtil.CheckArgumentNull(entity, "entity");
            this.Add(EntityWrapperFactory.WrapEntityUsingContext(entity, ObjectContext));
        }

        internal void Add(IEntityWrapper wrappedEntity)
        {
            Debug.Assert(wrappedEntity != null, "IEntityWrapper instance is null.");

            if (_wrappedOwner.Entity != null)
            {
                Add(wrappedEntity, /*applyConstraints*/true);
            }
            else
            {
                // The related end is in a disconnected state, so the related end is just a container
                // A common scenario for this is during WCF deserialization
                DisconnectedAdd(wrappedEntity);
            }
        }

        /// <summary>
        /// Removes an entity from the related end.  This method works in exactly the same way as Remove(object).
        /// It is maintained for backward compatibility with previous versions of IRelatedEnd.
        /// </summary>
        /// <param name="entity">
        ///   Entity instance to remove from the related end
        /// </param>
        /// <returns>Returns true if the entity was successfully removed, false if the entity was not part of the RelatedEnd.</returns>
        bool IRelatedEnd.Remove(IEntityWithRelationships entity)
        {
            return ((IRelatedEnd)this).Remove((object)entity);
        }

        /// <summary>
        ///   Removes an entity from the related end.  If owner is
        ///   attached to a cache, marks relationship for deletion and if
        ///   the relationship is composition also marks the entity for deletion.
        /// </summary>
        /// <param name="entity">
        ///   Entity instance to remove from the related end
        /// </param>
        /// <returns>Returns true if the entity was successfully removed, false if the entity was not part of the RelatedEnd.</returns>
        bool IRelatedEnd.Remove(object entity)
        {
            EntityUtil.CheckArgumentNull(entity, "entity");
            DeferredLoad();
            return Remove(EntityWrapperFactory.WrapEntityUsingContext(entity, ObjectContext), false);
        }

        // Internal version that works on a wrapped entity and can be called from multiple
        // places where the public version is no longer appropriate.
        internal bool Remove(IEntityWrapper wrappedEntity, bool preserveForeignKey)
        {
            Debug.Assert(wrappedEntity != null, "IEntityWrapper instance is null.");

            if (_wrappedOwner.Entity != null)
            {
                if (ContainsEntity(wrappedEntity))
                {

                    Remove(wrappedEntity, /*fixup*/true, /*deleteEntity*/false, /*deleteOwner*/false, /*applyReferentialConstraints*/true, preserveForeignKey);
                    return true;
                }
                // The entity is not related so return false
                return false;

            }
            else
            {
                // The related end is in a disconnected state, so the related end is just a container
                // A common scenario for this is during WCF deserialization
                return DisconnectedRemove(wrappedEntity);
            }
        }


        internal abstract void DisconnectedAdd(IEntityWrapper wrappedEntity);
        internal abstract bool DisconnectedRemove(IEntityWrapper wrappedEntity);

        internal void Add(IEntityWrapper wrappedEntity, bool applyConstraints)
        {
            // SQLBU: 508819 508813 508752
            // Detect as soon as possible if we are trying to re-add entities which are in Deleted state.
            // When one of the entity is in Deleted state, attempt would be made to re-add this entity
            // to the OSM which is not allowed.
            // NOTE: Current cleaning code (which uses cleanupOwnerEntity and cleanupPassedInEntity) 
            // works only if one of the entity is not attached to the context.
            // PERFORMANCE: following can be performed faster if ObjectStateManager provide method to
            // lookup only in dictionary with Deleted entities (because here we are interested only in Deleted entities)
            if (_context != null && !UsingNoTracking)
            {
                ValidateStateForAdd(_wrappedOwner);
                ValidateStateForAdd(wrappedEntity);
            }

            this.Add(wrappedEntity,
                applyConstraints: applyConstraints,
                addRelationshipAsUnchanged: false,
                relationshipAlreadyExists: false,
                allowModifyingOtherEndOfRelationship: true,
                forceForeignKeyChanges: true);

        }

        internal void CheckRelationEntitySet(EntitySet set)
        {
            Debug.Assert(set != null, "null EntitySet");
            Debug.Assert(_relationshipSet != null,
                "Should only be checking the RelationshipSet on an attached entity and it should always be non-null in that case");

            if ((((AssociationSet)_relationshipSet).AssociationSetEnds[_navigation.To] != null) &&
                (((AssociationSet)_relationshipSet).AssociationSetEnds[_navigation.To].EntitySet != set))
            {
                throw EntityUtil.EntitySetIsNotValidForRelationship(set.EntityContainer.Name, set.Name, _navigation.To, _relationshipSet.EntityContainer.Name, _relationshipSet.Name);
            }
        }

        internal void ValidateStateForAdd(IEntityWrapper wrappedEntity)
        {
            Debug.Assert(wrappedEntity != null, "IEntityWrapper instance is null.");
            EntityEntry entry = this.ObjectContext.ObjectStateManager.FindEntityEntry(wrappedEntity.Entity);
            if (entry != null && entry.State == EntityState.Deleted)
            {
                throw EntityUtil.UnableToAddRelationshipWithDeletedEntity();
            }
        }

        internal void Add(IEntityWrapper wrappedTarget,
            bool applyConstraints,
            bool addRelationshipAsUnchanged,
            bool relationshipAlreadyExists,
            bool allowModifyingOtherEndOfRelationship,   // needed by ChangeRelationshipState - check multiplicity constraints instead of silently updating other end of relationship
            bool forceForeignKeyChanges)
        {
            Debug.Assert(wrappedTarget != null, "IEntityWrapper instance is null.");
            // Do verification
            if (!this.VerifyEntityForAdd(wrappedTarget, relationshipAlreadyExists))
            {
                // Allow the same item to be "added" to a collection as a no-op operation
                return;
            }

            EntityKey key = wrappedTarget.EntityKey;
            if ((object)key != null && ObjectContext != null)
            {
                CheckRelationEntitySet(key.GetEntitySet(ObjectContext.MetadataWorkspace));
            }

            RelatedEnd targetRelatedEnd = GetOtherEndOfRelationship(wrappedTarget);

            if (Object.ReferenceEquals(this.ObjectContext, targetRelatedEnd.ObjectContext) && this.ObjectContext != null)
            {
                // Both entities are associated with the same non-null context

                // Make sure that they are either both tracked or both not tracked, or both don't have contexts
                if (UsingNoTracking != targetRelatedEnd.UsingNoTracking)
                {
                    throw EntityUtil.CannotCreateRelationshipBetweenTrackedAndNoTrackedEntities(UsingNoTracking ?
                        this._navigation.From : this._navigation.To);
                }
            }
            else if (this.ObjectContext != null && targetRelatedEnd.ObjectContext != null)
            {
                // Both entities have a context
                if (UsingNoTracking && targetRelatedEnd.UsingNoTracking)
                {
                    // Both entities are NoTracking, but have different contexts
                    // Attach the owner's context to the target's RelationshipManager
                    // O-C mappings are 1:1, so this operation is allowed
                    wrappedTarget.ResetContext(this.ObjectContext, GetTargetEntitySetFromRelationshipSet(), MergeOption.NoTracking);
                }
                else
                {
                    // Both entities are already tracked by different non-null contexts
                    throw EntityUtil.CannotCreateRelationshipEntitiesInDifferentContexts();
                }
            }
            else if ((_context == null || UsingNoTracking) && (targetRelatedEnd.ObjectContext != null && !targetRelatedEnd.UsingNoTracking))
            {
                // Only the target has a context, so validate it is in a suitable state
                targetRelatedEnd.ValidateStateForAdd(targetRelatedEnd.WrappedOwner);
            }

            targetRelatedEnd.VerifyEntityForAdd(_wrappedOwner, relationshipAlreadyExists);


            // Do actual add

            // Perform multiplicity constraints verification for the target related end before current related end is modified.
            // The "allowModifyingOtherEndOfRelationship" is used by ObjectStateManager.ChangeRelationshipState.
            targetRelatedEnd.VerifyMultiplicityConstraintsForAdd(!allowModifyingOtherEndOfRelationship);

            // Add the target entity to the source entity's collection or reference
            if (this.CheckIfNavigationPropertyContainsEntity(wrappedTarget))
            {
                this.AddToLocalCache(wrappedTarget, applyConstraints);
            }
            else
            {
                this.AddToCache(wrappedTarget, applyConstraints);
            }

            // Fix up the target end of the relationship by adding the source entity to the target entity's collection or reference
            // devnote: applyConstraints should be always false to enable scenarios like this:
            //             orderLine.Order = order1;
            //             order2.OrderLines.Add(orderLine); // orderLine.Order is changed to order2
            if (targetRelatedEnd.CheckIfNavigationPropertyContainsEntity(WrappedOwner))
            {
                // Example: IPOCO order, POCO customer with a bidirectional relationship
                //  customer.Orders.Add(order);
                //  order.Customer = customer <-- the Orders collection already contains "order" on fixup and this would add a duplicate
                targetRelatedEnd.AddToLocalCache(_wrappedOwner, /*applyConstraints*/ false);
            }
            else
            {
                targetRelatedEnd.AddToCache(_wrappedOwner, /*applyConstraints*/ false);
            }
            // delay event firing for targetRelatedEnd. once we fire the event, we should be at operation completed state

            // Ensure that both entities end up in the same context:
            // (1) If neither entity is attached to a context, we don't need to do anything else.
            // (2) If they are both in the same one, we need to make sure neither one was created with MergeOption.NoTracking,
            //     and if not, add a relationship entry if it doesn't already exist.
            // (3) If both entities are already in different contexts, fail.            
            // (4) Otherwise, only one entity is attached, and that is the context we will use.
            //     For the entity that is not attached, attach it to that context.    

            RelatedEnd attachedRelatedEnd = null; // the end of the relationship that is already attached to a context, if there is one.
            IEntityWrapper entityToAdd = null; // the entity to be added to attachedRelatedEnd

            if (Object.ReferenceEquals(this.ObjectContext, targetRelatedEnd.ObjectContext) && this.ObjectContext != null)
            {
                // Both entities are associated with the same non-null context

                // Make sure that a relationship entry exists between these two entities. It is possible that the entities could
                // have been added to the context independently of each other, so the relationship may not exist yet.
                if (!this.IsForeignKey && !relationshipAlreadyExists && !UsingNoTracking)
                {
                    // If this Add is triggered by setting the principle end of an unchanged/modified dependent end, then the relationship should be Unchanged
                    if (!this.ObjectContext.ObjectStateManager.TransactionManager.IsLocalPublicAPI &&
                        this.WrappedOwner.EntityKey != null &&
                        !this.WrappedOwner.EntityKey.IsTemporary && IsDependentEndOfReferentialConstraint(false))
                    {
                        addRelationshipAsUnchanged = true;
                    }

                    AddRelationshipToObjectStateManager(wrappedTarget, addRelationshipAsUnchanged, /*doAttach*/false);
                }

                // The condition (IsAddTracking || IsAttachTracking || IsDetectChanges) excludes the case
                // when the method is called from materialization when we don't want to verify the navigation property.
                if (wrappedTarget.RequiresRelationshipChangeTracking &&
                    (this.ObjectContext.ObjectStateManager.TransactionManager.IsAddTracking ||
                     this.ObjectContext.ObjectStateManager.TransactionManager.IsAttachTracking ||
                     this.ObjectContext.ObjectStateManager.TransactionManager.IsDetectChanges))
                {
                    this.AddToNavigationProperty(wrappedTarget);
                    targetRelatedEnd.AddToNavigationProperty(this._wrappedOwner);
                }
            }
            else if (this.ObjectContext != null || targetRelatedEnd.ObjectContext != null)
            {
                // Only one entity has a context, so figure out which one it is, and determine which entity we will be adding to it
                if (this.ObjectContext == null)
                {
                    attachedRelatedEnd = targetRelatedEnd;
                    entityToAdd = _wrappedOwner;
                }
                else
                {
                    attachedRelatedEnd = this;
                    entityToAdd = wrappedTarget;
                }

                if (!attachedRelatedEnd.UsingNoTracking)
                {
                    TransactionManager transManager = attachedRelatedEnd.WrappedOwner.Context.ObjectStateManager.TransactionManager;
                    transManager.BeginAddTracking();

                    try
                    {
                        bool doCleanup = true;

                        try
                        {
                            if (attachedRelatedEnd.WrappedOwner.Context.ObjectStateManager.TransactionManager.TrackProcessedEntities)
                            {
                                // The Entity could have been already wrapped by DetectChanges
                                if (!attachedRelatedEnd.WrappedOwner.Context.ObjectStateManager.TransactionManager.WrappedEntities.ContainsKey(entityToAdd.Entity))
                                {
                                    attachedRelatedEnd.WrappedOwner.Context.ObjectStateManager.TransactionManager.WrappedEntities.Add(entityToAdd.Entity, entityToAdd);
                                }
                                attachedRelatedEnd.WrappedOwner.Context.ObjectStateManager.TransactionManager.ProcessedEntities.Add(attachedRelatedEnd.WrappedOwner);
                            }

                            attachedRelatedEnd.AddGraphToObjectStateManager(entityToAdd, relationshipAlreadyExists,
                                addRelationshipAsUnchanged, /*doAttach*/ false);

                            // The code below is almost duplicated as the code few lines above 
                            // because this one can't be moved outside of try{}catch{}.
                            if (entityToAdd.RequiresRelationshipChangeTracking && TargetAccessor.HasProperty)
                            {
                                Debug.Assert(this.CheckIfNavigationPropertyContainsEntity(wrappedTarget), "owner's navigation property doesn't contain the target entity as expected");
                                targetRelatedEnd.AddToNavigationProperty(this._wrappedOwner);
                            }

                            doCleanup = false;
                        }
                        finally
                        {
                            if (doCleanup)
                            {
                                Debug.Assert(entityToAdd != null, "entityToAdd should be set if attachedRelatedEnd is set");

                                attachedRelatedEnd.WrappedOwner.Context.ObjectStateManager.DegradePromotedRelationships();

                                // Remove the source entity from the target related end
                                attachedRelatedEnd.FixupOtherEndOfRelationshipForRemove(entityToAdd, /*preserveForeignKey*/ false);

                                // Remove the target entity from the source related end
                                attachedRelatedEnd.RemoveFromCache(entityToAdd, /*resetIsLoaded*/ false, /*preserveForeignKey*/ false);

                                // Remove the graph that we just tried to add to the context
                                entityToAdd.RelationshipManager.NodeVisited = true;
                                RelationshipManager.RemoveRelatedEntitiesFromObjectStateManager(entityToAdd);
                                RemoveEntityFromObjectStateManager(entityToAdd);
                            }
                        }
                    }
                    finally
                    {
                        attachedRelatedEnd.WrappedOwner.Context.ObjectStateManager.TransactionManager.EndAddTracking();
                    }
                }
            }

            // FK: update foreign key values on the dependent end.
            if (this.ObjectContext != null &&
                this.IsForeignKey &&
                !this.ObjectContext.ObjectStateManager.TransactionManager.IsGraphUpdate)
            {
                // Note that we use "forceChange" below so that the FK properties will be set as modified
                // even if they don't actually change.
                if (this.IsDependentEndOfReferentialConstraint(false))
                {
                    Debug.Assert(this is EntityReference, "Dependent end cannot be a collection.");
                    ((EntityReference)this).UpdateForeignKeyValues(_wrappedOwner, wrappedTarget, changedFKs: null, forceChange: forceForeignKeyChanges);
                }
                else if (targetRelatedEnd.IsDependentEndOfReferentialConstraint(false))
                {
                    Debug.Assert(targetRelatedEnd is EntityReference, "Dependent end cannot be a collection.");
                    ((EntityReference)targetRelatedEnd).UpdateForeignKeyValues(wrappedTarget, _wrappedOwner, changedFKs: null, forceChange: forceForeignKeyChanges);
                }
            }

            // else neither entity is associated with a context, so there is no state manager to update
            // fire the Association changed event, first on targetRelatedEnd then on this EC
            targetRelatedEnd.OnAssociationChanged(CollectionChangeAction.Add, _wrappedOwner.Entity);
            OnAssociationChanged(CollectionChangeAction.Add, wrappedTarget.Entity);
        }

        private void AddGraphToObjectStateManager(IEntityWrapper wrappedEntity, bool relationshipAlreadyExists,
                                                  bool addRelationshipAsUnchanged, bool doAttach)
        {
            Debug.Assert(wrappedEntity != null, "IEntityWrapper instance is null.");
            Debug.Assert(!UsingNoTracking, "Should not be attempting to add graphs to the state manager with NoTracking related ends");

            AddEntityToObjectStateManager(wrappedEntity, doAttach);
            if (!relationshipAlreadyExists &&
                this.ObjectContext != null && wrappedEntity.Context != null)
            {
                if (!this.IsForeignKey)
                {
                    AddRelationshipToObjectStateManager(wrappedEntity, addRelationshipAsUnchanged, doAttach);
                }

                if (wrappedEntity.RequiresRelationshipChangeTracking || WrappedOwner.RequiresRelationshipChangeTracking)
                {
                    this.UpdateSnapshotOfRelationships(wrappedEntity);
                    if (doAttach)
                    {
                        EntityEntry entry = _context.ObjectStateManager.GetEntityEntry(wrappedEntity.Entity);
                        wrappedEntity.RelationshipManager.CheckReferentialConstraintProperties(entry);
                    }
                }
            }
            WalkObjectGraphToIncludeAllRelatedEntities(wrappedEntity, addRelationshipAsUnchanged, doAttach);
        }

        private void UpdateSnapshotOfRelationships(IEntityWrapper wrappedEntity)
        {
            RelatedEnd otherRelatedEnd = this.GetOtherEndOfRelationship(wrappedEntity);
            if (!otherRelatedEnd.ContainsEntity(this.WrappedOwner))
            {
                // Since we now align changes, we can allow the Add to remove the old value
                // Reference/FK violations are detected elsewhere
                otherRelatedEnd.AddToLocalCache(this.WrappedOwner, applyConstraints: false);
            }
        }

        internal void Remove(IEntityWrapper wrappedEntity, bool doFixup, bool deleteEntity, bool deleteOwner, bool applyReferentialConstraints, bool preserveForeignKey)
        {
            if (wrappedEntity.RequiresRelationshipChangeTracking &&      // Is it POCO?
                doFixup &&                                               // Remove() is called for both ends of relationship, once with doFixup==true, once with doFixup==false. Verify only one time.
                this.TargetAccessor.HasProperty)                     // Is there anything to verify?
            {
                bool contains = this.CheckIfNavigationPropertyContainsEntity(wrappedEntity);

                if (!contains)
                {
                    RelatedEnd relatedEnd = GetOtherEndOfRelationship(wrappedEntity);
                    relatedEnd.RemoveFromNavigationProperty(this.WrappedOwner);
                }
            }

            if (!this.ContainsEntity(wrappedEntity))
            {
                return;
            }

            // There can be a case when symmetrical Remove() shall be performed because of Referential Constraints
            // Example:
            //   Relationship Client -> Order with Referential Constraint on in.
            //   When user calls (pseudo code) Order.Remove(Client), we perform Client.Remove(Order), 
            //   because removing relationship between Client and Order should cause cascade delete on the Order side.
            if (null != _context && doFixup &&
                applyReferentialConstraints &&
                IsDependentEndOfReferentialConstraint(false))  // don't check the nullability of the "from" properties
            {
                // Remove _wrappedOwner from the related end with applying Referential Constraints
                RelatedEnd relatedEnd = GetOtherEndOfRelationship(wrappedEntity);
                relatedEnd.Remove(_wrappedOwner, doFixup, deleteEntity, deleteOwner, applyReferentialConstraints, preserveForeignKey);

                return;
            }


            //The following call will verify that the given entity is part of the collection or ref.
            bool fireEvent = RemoveFromCache(wrappedEntity, false, preserveForeignKey);

            if (!UsingNoTracking &&
                this.ObjectContext != null &&
                !this.IsForeignKey)
            {
                MarkRelationshipAsDeletedInObjectStateManager(wrappedEntity, _wrappedOwner, _relationshipSet, _navigation);
            }

            if (doFixup)
            {
                FixupOtherEndOfRelationshipForRemove(wrappedEntity, preserveForeignKey);

                // For the "LocalPublicAPI" just remove the entity from the related end, don't trigger cascade delete
                if (_context == null || !_context.ObjectStateManager.TransactionManager.IsLocalPublicAPI)
                {
                    //The related end "entity" cannot live without this side "owner". It should be deleted. Cascade this 
                    // effect to related entities of the "related" entity
                    // We skip this delete/detach if the entity is being reparented (TransactionManager.EntityBeingReparented)
                    // or if the reference is being nulled as part of fixup in a POCO proxy while setting the FK (InFKSetter).
                    if (null != _context && (deleteEntity ||
                       (deleteOwner && CheckCascadeDeleteFlag(_fromEndProperty)) ||
                       (applyReferentialConstraints && IsPrincipalEndOfReferentialConstraint())) &&
                        !ReferenceEquals(wrappedEntity.Entity, _context.ObjectStateManager.TransactionManager.EntityBeingReparented) &&
                        !ReferenceEquals(_context.ObjectStateManager.EntityInvokingFKSetter, wrappedEntity.Entity))
                    {
                        //Once related entity is deleted, all relationships involving related entity would be updated

                        // RemoveEntityFromRelatedEnds check for graph circularities to make sure
                        // it does not get into infinite loop
                        EnsureRelationshipNavigationAccessorsInitialized();
                        RemoveEntityFromRelatedEnds(wrappedEntity, _wrappedOwner, _navigation.Reverse);
                        MarkEntityAsDeletedInObjectStateManager(wrappedEntity);
                    }
                }
            }

            if (fireEvent)
            {
                OnAssociationChanged(CollectionChangeAction.Remove, wrappedEntity.Entity);
            }
        }


        /// <summary>
        /// Returns true if this Related end represents the dependent of a Referential Constraint
        /// </summary>
        /// <param name="checkIdentifying">If true then the method will only return true if the Referential Constraint is identifying</param>
        internal bool IsDependentEndOfReferentialConstraint(bool checkIdentifying)
        {
            if (null != _relationMetadata)
            {
                // NOTE Referential constraints collection will usually contains 0 or 1 element,
                // so performance shouldn't be an issue here
                foreach (ReferentialConstraint constraint in ((AssociationType)this.RelationMetadata).ReferentialConstraints)
                {
                    if (constraint.ToRole == this.FromEndProperty)
                    {
                        if (checkIdentifying)
                        {
                            EntityType entityType = constraint.ToRole.GetEntityType();
                            bool allPropertiesAreKeyProperties = RelatedEnd.CheckIfAllPropertiesAreKeyProperties(entityType.KeyMemberNames, constraint.ToProperties);

                            return allPropertiesAreKeyProperties;
                        }
                        else
                        {
                            // Example: 
                            //    Client<C_ID> --- Order<O_ID, Client_ID>
                            //    RI Constraint: Principal/From <Client.C_ID>,  Dependent/To <Order.Client_ID>
                            // When current RelatedEnd is a CollectionOrReference in Order's relationships,
                            // constarint.ToRole == this._fromEndProperty == Order
                            return true;
                        }
                    }
                }
            }
            return false;
        }

        /// <summary>
        /// Check if current RelatedEnd is a Principal end of some Referential Constraint and if some of the "from" properties is not-nullable
        /// </summary>
        internal bool IsPrincipalEndOfReferentialConstraint()
        {
            if (null != _relationMetadata)
            {
                // NOTE Referential constraints collection will usually contains 0 or 1 element,
                // so performance shouldn't be an issue here
                foreach (ReferentialConstraint constraint in ((AssociationType)_relationMetadata).ReferentialConstraints)
                {
                    if (constraint.FromRole == this._fromEndProperty)
                    {
                        EntityType entityType = constraint.ToRole.GetEntityType();
                        bool allPropertiesAreKeyProperties = RelatedEnd.CheckIfAllPropertiesAreKeyProperties(entityType.KeyMemberNames, constraint.ToProperties);

                        // Example: 
                        //    Client<C_ID> --- Order<O_ID, Client_ID>
                        //    RI Constraint: Principal/From <Client.C_ID>,  Dependent/To <Order.Client_ID>
                        // When current RelatedEnd is a CollectionOrReference in Client's relationships,
                        // constarint.FromRole == this._fromEndProperty == Client
                        return allPropertiesAreKeyProperties;
                    }
                }
            }
            return false;
        }

        static internal bool CheckIfAllPropertiesAreKeyProperties(string[] keyMemberNames, ReadOnlyMetadataCollection<EdmProperty> toProperties)
        {
            // Check if some of the "to" properties is not a key property
            foreach (EdmProperty property in toProperties)
            {
                bool found = false;
                foreach (string keyPropertyName in keyMemberNames)
                {
                    if (keyPropertyName == property.Name)
                    {
                        found = true;
                        break;
                    }
                }
                if (!found)
                {
                    return false;
                }
            }
            return true;
        }

        //Add given entity and its relationship to ObjectStateManager. Walk graph to recursively
        // add all entities in the graph.
        // If doAttach==TRUE, the entities are attached directly as Unchanged without calling AcceptChanges()
        internal void IncludeEntity(IEntityWrapper wrappedEntity, bool addRelationshipAsUnchanged, bool doAttach)
        {
            Debug.Assert(wrappedEntity != null, "IEntityWrapper instance is null.");
            Debug.Assert(!UsingNoTracking, "Should not be trying to include entities in the state manager for NoTracking related ends");

            //check to see if entity is already added to the cache
            //search by object reference so that we will not find any entries with the same key but a different object instance
            // NOTE: if (cacheEntry.Entity == entity) then this part of the graph is skipped
            EntityEntry cacheEntry = _context.ObjectStateManager.FindEntityEntry(wrappedEntity.Entity);
            Debug.Assert(cacheEntry == null || cacheEntry.Entity == wrappedEntity.Entity,
                    "Expected to have looked up this state entry by reference, how did we get a different entity?");

            if (null != cacheEntry && cacheEntry.State == EntityState.Deleted)
            {
                throw EntityUtil.UnableToAddRelationshipWithDeletedEntity();
            }

            if (wrappedEntity.RequiresRelationshipChangeTracking || WrappedOwner.RequiresRelationshipChangeTracking)
            {
                // Verify relationship fixup before including rest of the graph.
                RelatedEnd otherRelatedEnd = GetOtherEndOfRelationship(wrappedEntity);

                // Validate the type is compatible before trying to get/set properties on it.
                // The following will throw if the type is not mapped.
                _context.GetTypeUsage(otherRelatedEnd.WrappedOwner.IdentityType);

                // If the other end is a reference that is non-null, then don't overwrite it.
                // If the reference is non-null and doesn't match what we think it should be, then throw.
                EntityReference otherEndAsRef = otherRelatedEnd as EntityReference;
                if (otherEndAsRef != null)
                {
                    if (otherEndAsRef.NavigationPropertyIsNullOrMissing())
                    {
                        otherRelatedEnd.AddToNavigationProperty(this._wrappedOwner);
                        // If the other end is a dependent that is already tracked, then we need to make sure
                        // its FK props are marked as modified even though we are not fixing them up.
                        Debug.Assert(ObjectContext != null, "Expected attached context at this point.");
                        if (cacheEntry != null && 
                            ObjectContext.ObjectStateManager.TransactionManager.IsAddTracking &&
                            IsForeignKey &&
                            otherRelatedEnd.IsDependentEndOfReferentialConstraint(checkIdentifying: false))
                        {
                            otherRelatedEnd.MarkForeignKeyPropertiesModified();
                        }
                    }
                    else if (!otherEndAsRef.CheckIfNavigationPropertyContainsEntity(this._wrappedOwner))
                    {
                        throw new InvalidOperationException(System.Data.Entity.Strings.ObjectStateManager_ConflictingChangesOfRelationshipDetected(
                            otherEndAsRef.RelationshipNavigation.To,
                            otherEndAsRef.RelationshipNavigation.RelationshipName));
                    }
                }
                else
                {
                    // For collections, always add
                    otherRelatedEnd.AddToNavigationProperty(this._wrappedOwner);
                }
            }

            if (null == cacheEntry)
            {
                // NOTE (Attach): if (null == entity.Key) then check must be performed whether entity really
                // doesn't exist in the context (by creating fake Key and calling FindObjectStateEntry(Key) )
                // This is done in the ObjectContext::AttachSingleObject().

                AddGraphToObjectStateManager(wrappedEntity, /*relationshipAlreadyExists*/ false,
                                             addRelationshipAsUnchanged, doAttach);
            }

            // There is a possibility that related entity is added to cache but relationship is not added.
            // Example: Suppose A and B are related. When walking the graph it is possible that 
            // node B was visited through some relationship other than A-B. 
            else if (null == FindRelationshipEntryInObjectStateManager(wrappedEntity))
            {
                // If we have a reference with a detached key, make sure the key matches the relationship we are about to add
                EntityReference entityRef = this as EntityReference;
                if (entityRef != null && entityRef.DetachedEntityKey != null)
                {
                    EntityKey targetKey = wrappedEntity.EntityKey;
                    if (entityRef.DetachedEntityKey != targetKey)
                    {
                        // Check for the case where a NoTracking (with detached entity key) is being Added and throw the same
                        // exception we do elsewhere for this case.
                        // We might consider changing this behavior in the future to just put the entity in the Added state,
                        // but for consistency for now we throw the same exception as elsewhere.
                        if (targetKey.IsTemporary)
                        {
                            throw EntityUtil.CannotCreateRelationshipBetweenTrackedAndNoTrackedEntities(_navigation.To);
                        }

                        throw EntityUtil.EntityKeyValueMismatch();
                    }
                    // else -- null just means the key isn't set, so the target entity key doesn't also have to be null
                }

                if (this.ObjectContext != null && wrappedEntity.Context != null)
                {
                    if (!this.IsForeignKey)
                    {
                        if (cacheEntry.State == EntityState.Added)
                        {
                            // In POCO, when the graph is partially attached and user is calling Attach on the detached entity
                            // and the entity in the context is in the Added state, the relationship has to created also in Added state.
                            AddRelationshipToObjectStateManager(wrappedEntity, addRelationshipAsUnchanged, false);
                        }
                        else
                        {
                            AddRelationshipToObjectStateManager(wrappedEntity, addRelationshipAsUnchanged, doAttach);
                        }
                    }

                    if (wrappedEntity.RequiresRelationshipChangeTracking || WrappedOwner.RequiresRelationshipChangeTracking)
                    {
                        this.UpdateSnapshotOfRelationships(wrappedEntity);
                        if (doAttach && cacheEntry.State != EntityState.Added)
                        {
                            EntityEntry entry = this.ObjectContext.ObjectStateManager.GetEntityEntry(wrappedEntity.Entity);
                            wrappedEntity.RelationshipManager.CheckReferentialConstraintProperties(entry);
                        }
                    }
                }
            }
            // else relationship is already there, nothing more to do
        }

        internal void MarkForeignKeyPropertiesModified()
        {
            Debug.Assert(IsForeignKey, "cannot update foreign key values if the relationship is not a FK");
            ReferentialConstraint constraint = ((AssociationType)RelationMetadata).ReferentialConstraints[0];
            Debug.Assert(constraint != null, "null constraint");

            EntityEntry dependentEntry = WrappedOwner.ObjectStateEntry;
            Debug.Assert(dependentEntry != null, "Expected tracked entity.");

            // No need to try to mark properties as modified for added/deleted/detached entities.
            // Even if the entity is modified, the FK props may not be modified.
            if (dependentEntry.State == EntityState.Unchanged || dependentEntry.State == EntityState.Modified)
            {
                foreach (var dependentProp in constraint.ToProperties)
                {
                    dependentEntry.SetModifiedProperty(dependentProp.Name);
                }
            }
        }

        internal abstract bool CheckIfNavigationPropertyContainsEntity(IEntityWrapper wrapper);

        internal abstract void VerifyNavigationPropertyForAdd(IEntityWrapper wrapper);

        internal void AddToNavigationProperty(IEntityWrapper wrapper)
        {
            Debug.Assert(this.RelationshipNavigation != null, "null RelationshipNavigation");

            if (this.TargetAccessor.HasProperty && !this.CheckIfNavigationPropertyContainsEntity(wrapper))
            {
                Debug.Assert(wrapper.Context != null, "Expected context to be available.");
                // We keep track of the nav properties we have set during Add/Attach so that they
                // can be undone during rollback.
                TransactionManager tm = wrapper.Context.ObjectStateManager.TransactionManager;
                if (tm.IsAddTracking || tm.IsAttachTracking)
                {
                    wrapper.Context.ObjectStateManager.TrackPromotedRelationship(this, wrapper);
                }
                this.AddToObjectCache(wrapper);
            }
        }

        internal void RemoveFromNavigationProperty(IEntityWrapper wrapper)
        {
            Debug.Assert(this.RelationshipNavigation != null, "null RelationshipNavigation");

            if (this.TargetAccessor.HasProperty && this.CheckIfNavigationPropertyContainsEntity(wrapper))
            {
                this.RemoveFromObjectCache(wrapper);
            }
        }

        // Remove given entity and its relationship from ObjectStateManager.
        // Traversegraph to recursively remove all entities in the graph.
        internal void ExcludeEntity(IEntityWrapper wrappedEntity)
        {
            Debug.Assert(wrappedEntity != null, "IEntityWrapper instance is null.");
            Debug.Assert(!UsingNoTracking, "Should not try to exclude entities from the state manager for NoTracking related ends.");

            if (!_context.ObjectStateManager.TransactionManager.TrackProcessedEntities ||
                !(_context.ObjectStateManager.TransactionManager.IsAttachTracking || _context.ObjectStateManager.TransactionManager.IsAddTracking) ||
                _context.ObjectStateManager.TransactionManager.ProcessedEntities.Contains(wrappedEntity))
            {
                //check to see if entity is already removed from the cache
                EntityEntry cacheEntry = _context.ObjectStateManager.FindEntityEntry(wrappedEntity.Entity);

                if (null != cacheEntry && cacheEntry.State != EntityState.Deleted && !wrappedEntity.RelationshipManager.NodeVisited)
                {
                    wrappedEntity.RelationshipManager.NodeVisited = true;

                    RelationshipManager.RemoveRelatedEntitiesFromObjectStateManager(wrappedEntity);
                    if (!this.IsForeignKey)
                    {
                        RemoveRelationshipFromObjectStateManager(wrappedEntity, _wrappedOwner, _relationshipSet, _navigation);
                    }
                    RemoveEntityFromObjectStateManager(wrappedEntity);
                }
                // There is a possibility that related entity is removed from cache but relationship is not removed.
                // Example: Suppose A and B are related. When walking the graph it is possible that 
                // node B was visited through some relationship other than A-B. 
                else if (!this.IsForeignKey && null != FindRelationshipEntryInObjectStateManager(wrappedEntity))
                {
                    RemoveRelationshipFromObjectStateManager(wrappedEntity, _wrappedOwner, _relationshipSet, _navigation);
                }
            }
        }

        internal RelationshipEntry FindRelationshipEntryInObjectStateManager(IEntityWrapper wrappedEntity)
        {
            Debug.Assert(wrappedEntity != null, "IEntityWrapper instance is null.");
            Debug.Assert(!UsingNoTracking, "Should not look for RelationshipEntry in ObjectStateManager for NoTracking cases.");
            EntityKey entityKey = wrappedEntity.EntityKey;
            EntityKey ownerKey = _wrappedOwner.EntityKey;
            return this._context.ObjectStateManager.FindRelationship(_relationshipSet,
                new KeyValuePair<string, EntityKey>(_navigation.From, ownerKey),
                new KeyValuePair<string, EntityKey>(_navigation.To, entityKey));
        }

        internal void Clear(IEntityWrapper wrappedEntity, RelationshipNavigation navigation, bool doCascadeDelete)
        {
            ClearCollectionOrRef(wrappedEntity, navigation, doCascadeDelete);
        }

        // Check if related entities contain proper property values 
        // (entities with temporary keys are skipped)
        internal bool CheckReferentialConstraintProperties(EntityEntry ownerEntry)
        {
            // if the related end contains a real entity or is a reference with a detached entitykey, we need to check for RI constraints
            if (!this.IsEmpty() ||
                ((ToEndMember.RelationshipMultiplicity == RelationshipMultiplicity.ZeroOrOne ||
                ToEndMember.RelationshipMultiplicity == RelationshipMultiplicity.One) &&
                ((EntityReference)this).DetachedEntityKey != null))
            {
                foreach (ReferentialConstraint constraint in ((AssociationType)this.RelationMetadata).ReferentialConstraints)
                {
                    // Check properties in principals
                    if (constraint.ToRole == FromEndProperty)
                    {
                        Debug.Assert(this is EntityReference, "Expected reference to principal");
                        EntityKey principalKey;
                        if (IsEmpty())
                        {
                            // Generally for foreign keys we want to use the EntityKey to do RI constraint validation
                            // However, if we are doing an Add/Attach, we should use the DetachedEntityKey because this is the value
                            // set by the user while the entity was detached, and should be used until the entity is fully added/attached
                            if (this.IsForeignKey &&
                                !(this.ObjectContext.ObjectStateManager.TransactionManager.IsAddTracking ||
                                  this.ObjectContext.ObjectStateManager.TransactionManager.IsAttachTracking))
                            {
                                principalKey = ((EntityReference)this).EntityKey;
                            }
                            else
                            {
                                principalKey = ((EntityReference)this).DetachedEntityKey;
                            }
                        }
                        else
                        {
                            IEntityWrapper wrappedRelatedEntity = ((EntityReference)this).ReferenceValue;
                            // For Added entities, it doesn't matter what the key value is since it can't be trusted anyway.
                            if (wrappedRelatedEntity.ObjectStateEntry != null && wrappedRelatedEntity.ObjectStateEntry.State == EntityState.Added)
                            {
                                return true;
                            }
                            principalKey = ExtractPrincipalKey(wrappedRelatedEntity);
                        }
                        if (!VerifyRIConstraintsWithRelatedEntry(constraint, ownerEntry.GetCurrentEntityValue, principalKey))
                        {
                            return false;
                        }
                    }
                    else if (constraint.FromRole == FromEndProperty)
                    {
                        if (IsEmpty())
                        {
                            // related end is empty, so we must have a reference with a detached key
                            EntityKey detachedKey = ((EntityReference)this).DetachedEntityKey;
#if DEBUG
                            // If the constraint is not PK<->PK then we can't validate it here.
                            // This debug code checks that we don't try to validate it.
                            List<string> keyNames = new List<string>(from v in detachedKey.EntityKeyValues select v.Key);
                            foreach (EdmProperty prop in constraint.ToProperties)
                            {
                                Debug.Assert(keyNames.Contains(prop.Name), "Attempt to validate constraint where some FK values are not in the dependent PK");
                            }
#endif
                            // don't need to validate the principal/detached key here because that has already been done during AttachContext
                            if (!VerifyRIConstraintsWithRelatedEntry(constraint, detachedKey.FindValueByName, ownerEntry.EntityKey))
                            {
                                return false;
                            }
                        }
                        else
                        {
                            foreach (IEntityWrapper wrappedRelatedEntity in GetWrappedEntities())
                            {
                                EntityEntry dependent = wrappedRelatedEntity.ObjectStateEntry;
                                if (dependent != null &&
                                    dependent.State != EntityState.Added &&
                                    dependent.State != EntityState.Deleted &&
                                    dependent.State != EntityState.Detached)
                                {
                                    if (!VerifyRIConstraintsWithRelatedEntry(constraint, dependent.GetCurrentEntityValue, ownerEntry.EntityKey))
                                    {
                                        return false;
                                    }
                                }
                            }
                        }
                    }
                    // else keep processing the other constraints
                }
            }
            return true;
        }

        private EntityKey ExtractPrincipalKey(IEntityWrapper wrappedRelatedEntity)
        {
            EntitySet principalEntitySet = GetTargetEntitySetFromRelationshipSet();
            // get or create a key to use to compare the values -- the target entity might not have been attached
            // yet so it may not have a key, but we can create one here to use for checking the values
            EntityKey principalKey = wrappedRelatedEntity.EntityKey;
            if (null != (object)principalKey && !principalKey.IsTemporary)
            {
                // Validate the key here because we need to get values from it for verification
                // and that will fail if the key is malformed.
                // Verify only if the key already exists.
                EntityUtil.ValidateEntitySetInKey(principalKey, principalEntitySet);
                principalKey.ValidateEntityKey(ObjectContext.MetadataWorkspace, principalEntitySet);
            }
            else
            {
                principalKey = _context.ObjectStateManager.CreateEntityKey(principalEntitySet, wrappedRelatedEntity.Entity);
            }
            return principalKey;
        }

        internal static bool VerifyRIConstraintsWithRelatedEntry(ReferentialConstraint constraint, Func<string, object> getDependentPropertyValue, EntityKey principalKey)
        {
            Debug.Assert(constraint.FromProperties.Count == constraint.ToProperties.Count, "RIC: Referential constraints From/To properties list have different size");

            // NOTE order of properties in collections (From/ToProperties) is important.
            for (int i = 0; i < constraint.FromProperties.Count; ++i)
            {
                string fromPropertyName = constraint.FromProperties[i].Name;
                string toPropertyName = constraint.ToProperties[i].Name;

                object currentValue = principalKey.FindValueByName(fromPropertyName);
                object expectedValue = getDependentPropertyValue(toPropertyName);

                Debug.Assert(currentValue != null, "currentValue is part of Key on an attached entity, it must not be null");

                if (!ByValueEqualityComparer.Default.Equals(currentValue, expectedValue))
                {
                    // RI Constraint violated
                    return false;
                }
            }

            return true;
        }

        public IEnumerator GetEnumerator()
        {
            // Due to the way the CLR handles IEnumerator return types, the check for a null owner for EntityReferences
            // must be made here because GetInternalEnumerator is delay-executed and so will not throw until the 
            // enumerator is advanced
            if (this is EntityReference)
            {
                CheckOwnerNull();
            }
            DeferredLoad();
            return GetInternalEnumerable().GetEnumerator();
        }

        internal void RemoveAll()
        {
            //copy into list because changing collection member is not allowed during enumeration.
            // If possible avoid copying into list.
            List<IEntityWrapper> deletedEntities = null;

            bool fireEvent = false;
            try
            {
                _suppressEvents = true;
                foreach (IEntityWrapper wrappedEntity in GetWrappedEntities())
                {
                    if (null == deletedEntities)
                    {
                        deletedEntities = new List<IEntityWrapper>();
                    }
                    deletedEntities.Add(wrappedEntity);
                }


                if (fireEvent = (null != deletedEntities) && (deletedEntities.Count > 0))
                {
                    foreach (IEntityWrapper wrappedEntity in deletedEntities)
                    {
                        Remove(wrappedEntity, /*fixup*/true, /*deleteEntity*/false, /*deleteOwner*/true, /*applyReferentialConstraints*/true, /*preserveForeignKey*/false);
                    }
                }
            }
            finally
            {
                _suppressEvents = false;
            }
            if (fireEvent)
            {
                OnAssociationChanged(CollectionChangeAction.Refresh, null);
            }
        }

        internal void DetachAll(EntityState ownerEntityState)
        {
            //copy into list because changing collection member is not allowed during enumeration.
            // If possible avoid copying into list.
            List<IEntityWrapper> deletedEntities = new List<IEntityWrapper>();

            foreach (IEntityWrapper wrappedEntity in GetWrappedEntities())
            {
                deletedEntities.Add(wrappedEntity);
            }

            bool detachRelationship =
                    ownerEntityState == EntityState.Added ||
                    _fromEndProperty.RelationshipMultiplicity == RelationshipMultiplicity.Many;

            // every-fix up will fire with Remove action
            // every forward operation (removing from this relatedEnd) will fire with Refresh
            // do not merge the loops, handle the related ends separately (when the event is being fired, 
            // we should be in good state: for every entity deleted, related event should have been fired)
            foreach (IEntityWrapper wrappedEntity in deletedEntities)
            {
                // future enhancement: it does not make sense to return in the half way, either remove this code or
                // move it to the right place
                if (!this.ContainsEntity(wrappedEntity))
                {
                    return;
                }

                // if this is a reference, set the EntityKey property before removing the relationship and entity
                EntityReference entityReference = this as EntityReference;
                if (entityReference != null)
                {
                    entityReference.DetachedEntityKey = entityReference.AttachedEntityKey;
                }

                if (detachRelationship)
                {
                    DetachRelationshipFromObjectStateManager(wrappedEntity, _wrappedOwner, _relationshipSet, _navigation);
                }
                RelatedEnd relatedEnd = GetOtherEndOfRelationship(wrappedEntity);
                relatedEnd.RemoveFromCache(_wrappedOwner, /* resetIsLoaded */ true, /*preserveForeignKey*/ false);
                relatedEnd.OnAssociationChanged(CollectionChangeAction.Remove, _wrappedOwner.Entity);
            }

            // Clear the DetachedEntityKey if this is a foreign key
            if (IsForeignKey)
            {
                EntityReference entityReference = this as EntityReference;
                if (entityReference != null)
                {
                    entityReference.DetachedEntityKey = null;
                }
            }

            foreach (IEntityWrapper wrappedEntity in deletedEntities)
            {
                RelatedEnd relatedEnd = GetOtherEndOfRelationship(wrappedEntity);
                this.RemoveFromCache(wrappedEntity, /* resetIsLoaded */ false, /*preserveForeignKey*/ false);
            }
            this.OnAssociationChanged(CollectionChangeAction.Refresh, null);

            Debug.Assert(this.IsEmpty(), "Collection or reference should be empty");
        }

        #region Add

        internal void AddToCache(IEntityWrapper wrappedEntity, bool applyConstraints)
        {
            AddToLocalCache(wrappedEntity, applyConstraints);
            AddToObjectCache(wrappedEntity);
        }
        internal abstract void AddToLocalCache(IEntityWrapper wrappedEntity, bool applyConstraints);
        internal abstract void AddToObjectCache(IEntityWrapper wrappedEntity);

        #endregion

        #region Remove

        internal bool RemoveFromCache(IEntityWrapper wrappedEntity, bool resetIsLoaded, bool preserveForeignKey)
        {
            bool result = RemoveFromLocalCache(wrappedEntity, resetIsLoaded, preserveForeignKey);
            RemoveFromObjectCache(wrappedEntity);
            return result;
        }
        // Remove from the RelatedEnd
        internal abstract bool RemoveFromLocalCache(IEntityWrapper wrappedEntity, bool resetIsLoaded, bool preserveForeignKey);
        // Remove from the underlying POCO navigation property
        internal abstract bool RemoveFromObjectCache(IEntityWrapper wrappedEntity);

        #endregion

        internal abstract bool VerifyEntityForAdd(IEntityWrapper wrappedEntity, bool relationshipAlreadyExists);
        internal abstract void VerifyType(IEntityWrapper wrappedEntity);
        internal abstract bool CanSetEntityType(IEntityWrapper wrappedEntity);
        internal abstract void Include(bool addRelationshipAsUnchanged, bool doAttach);
        internal abstract void Exclude();
        internal abstract void ClearCollectionOrRef(IEntityWrapper wrappedEntity, RelationshipNavigation navigation, bool doCascadeDelete);
        internal abstract bool ContainsEntity(IEntityWrapper wrappedEntity);
        internal abstract IEnumerable GetInternalEnumerable();
        internal abstract IEnumerable<IEntityWrapper> GetWrappedEntities();
        internal abstract void RetrieveReferentialConstraintProperties(Dictionary<string, KeyValuePair<object, IntBox>> keyValues, HashSet<object> visited);
        internal abstract bool IsEmpty();
        internal abstract void OnRelatedEndClear();
        internal abstract void ClearWrappedValues();
        internal abstract void VerifyMultiplicityConstraintsForAdd(bool applyConstraints);

        internal virtual void OnAssociationChanged(CollectionChangeAction collectionChangeAction, object entity)
        {
            Debug.Assert(!(entity is IEntityWrapper), "Object is an IEntityWrapper instance instead of the raw entity.");
            if (!_suppressEvents)
            {
                if (_onAssociationChanged != null)
                {
                    _onAssociationChanged(this, (new CollectionChangeEventArgs(collectionChangeAction, entity)));
                }
            }
        }

        private void AddEntityToObjectStateManager(IEntityWrapper wrappedEntity, bool doAttach)
        {
            Debug.Assert(wrappedEntity != null, "IEntityWrapper instance is null.");
            Debug.Assert(_context != null, "Can't add to state manager if _context is null");
            Debug.Assert(!UsingNoTracking, "Should not add an Entity to ObjectStateManager for NoTracking cases.");

            EntitySet es = GetTargetEntitySetFromRelationshipSet();
            if (!doAttach)
            {
                _context.AddSingleObject(es, wrappedEntity, "entity");
            }
            else
            {
                _context.AttachSingleObject(wrappedEntity, es, "entity");
            }

            // Now that we know we have a valid EntityKey for the target entity, verify that it matches the detached EntityKey, if there is one
            EntityReference entityRef = this as EntityReference;
            if (entityRef != null && entityRef.DetachedEntityKey != null)
            {
                EntityKey targetKey = wrappedEntity.EntityKey;
                if (entityRef.DetachedEntityKey != targetKey)
                {
                    throw EntityUtil.EntityKeyValueMismatch();
                }
                // else -- null just means the key isn't set, so the target entity key doesn't also have to be null
            }
        }

        internal EntitySet GetTargetEntitySetFromRelationshipSet()
        {
            EntitySet entitySet = null;
            AssociationSet associationSet = (AssociationSet)_relationshipSet;
            Debug.Assert(associationSet != null, "(AssociationSet) cast failed");

            AssociationEndMember associationEndMember = (AssociationEndMember)ToEndMember;
            Debug.Assert(associationEndMember != null, "(AssociationEndMember) cast failed");

            entitySet = associationSet.AssociationSetEnds[associationEndMember.Name].EntitySet;
            Debug.Assert(entitySet != null, "cannot find entitySet");
            return entitySet;
        }

        private RelationshipEntry AddRelationshipToObjectStateManager(IEntityWrapper wrappedEntity, bool addRelationshipAsUnchanged, bool doAttach)
        {
            Debug.Assert(wrappedEntity != null, "IEntityWrapper instance is null.");
            Debug.Assert(!UsingNoTracking, "Should not add Relationship to ObjectStateManager for NoTracking cases.");
            Debug.Assert(!this.IsForeignKey, "for IsForeignKey relationship ObjectStateEntries don't exist");
            Debug.Assert(this._context != null && wrappedEntity.Context != null, "should be called only if both entities are attached");
            Debug.Assert(this._context == wrappedEntity.Context, "both entities should be attached to the same context");

            EntityKey ownerKey = _wrappedOwner.EntityKey;
            EntityKey entityKey = wrappedEntity.EntityKey;
            EntityUtil.CheckEntityKeyNull(ownerKey);
            EntityUtil.CheckEntityKeyNull(entityKey);

            return this.ObjectContext.ObjectStateManager.AddRelation(
                new RelationshipWrapper((AssociationSet)_relationshipSet,
                       new KeyValuePair<string, EntityKey>(_navigation.From, ownerKey),
                       new KeyValuePair<string, EntityKey>(_navigation.To, entityKey)),
                // When Add method is called through Load API the relationship cache entries
                // needs to be added to ObjectStateManager in Unchanged state rather then Added state
                (addRelationshipAsUnchanged || doAttach) ? EntityState.Unchanged : EntityState.Added);
        }

        private static void WalkObjectGraphToIncludeAllRelatedEntities(IEntityWrapper wrappedEntity,
                                                                       bool addRelationshipAsUnchanged, bool doAttach)
        {
            Debug.Assert(wrappedEntity != null, "IEntityWrapper instance is null.");
            foreach (RelatedEnd relatedEnd in wrappedEntity.RelationshipManager.Relationships)
            {
                relatedEnd.Include(addRelationshipAsUnchanged, doAttach);
            }
        }

        internal static void RemoveEntityFromObjectStateManager(IEntityWrapper wrappedEntity)
        {
            Debug.Assert(wrappedEntity != null, "IEntityWrapper instance is null.");
            EntityEntry entry;

            if (wrappedEntity.Context != null &&
                wrappedEntity.Context.ObjectStateManager.TransactionManager.IsAttachTracking &&
                wrappedEntity.Context.ObjectStateManager.TransactionManager.PromotedKeyEntries.TryGetValue(wrappedEntity.Entity, out entry))
            {
                // This is executed only in the cleanup code from ObjectContext.AttachTo()
                // If the entry was promoted in AttachTo(), it has to be degraded now instead of being deleted.
                entry.DegradeEntry();
            }
            else
            {
                entry = MarkEntityAsDeletedInObjectStateManager(wrappedEntity);
                if (entry != null && entry.State != EntityState.Detached)
                {
                    entry.AcceptChanges();
                }
            }
        }

        private static void RemoveRelationshipFromObjectStateManager(IEntityWrapper wrappedEntity, IEntityWrapper wrappedOwner, RelationshipSet relationshipSet, RelationshipNavigation navigation)
        {
            Debug.Assert(wrappedEntity != null, "IEntityWrapper instance is null.");
            Debug.Assert(relationshipSet == null || !(relationshipSet.ElementType as AssociationType).IsForeignKey, "for IsForeignKey relationships ObjectStateEntries don't exist");

            RelationshipEntry deletedEntry = MarkRelationshipAsDeletedInObjectStateManager(wrappedEntity, wrappedOwner, relationshipSet, navigation);
            if (deletedEntry != null && deletedEntry.State != EntityState.Detached)
            {
                deletedEntry.AcceptChanges();
            }
        }

        private void FixupOtherEndOfRelationshipForRemove(IEntityWrapper wrappedEntity, bool preserveForeignKey)
        {
            Debug.Assert(wrappedEntity != null, "IEntityWrapper instance is null.");
            RelatedEnd relatedEnd = GetOtherEndOfRelationship(wrappedEntity);
            relatedEnd.Remove(_wrappedOwner, /*fixup*/false, /*deleteEntity*/false, /*deleteOwner*/false, /*applyReferentialConstraints*/false, preserveForeignKey);
            relatedEnd.RemoveFromNavigationProperty(_wrappedOwner);
        }

        private static EntityEntry MarkEntityAsDeletedInObjectStateManager(IEntityWrapper wrappedEntity)
        {
            Debug.Assert(wrappedEntity != null, "IEntityWrapper instance is null.");
            EntityEntry entry = null;
            if (wrappedEntity.Context != null)
            {
                entry = wrappedEntity.Context.ObjectStateManager.FindEntityEntry(wrappedEntity.Entity);

                if (entry != null)
                {
                    entry.Delete(/*doFixup*/false);
                }
            }
            return entry;
        }

        private static RelationshipEntry MarkRelationshipAsDeletedInObjectStateManager(IEntityWrapper wrappedEntity, IEntityWrapper wrappedOwner, RelationshipSet relationshipSet, RelationshipNavigation navigation)
        {
            Debug.Assert(wrappedEntity != null, "IEntityWrapper instance is null.");
            Debug.Assert(relationshipSet == null || !(relationshipSet.ElementType as AssociationType).IsForeignKey, "for IsForeignKey relationships ObjectStateEntries don't exist");
            RelationshipEntry entry = null;
            if (wrappedOwner.Context != null && wrappedEntity.Context != null && relationshipSet != null)
            {
                EntityKey ownerKey = wrappedOwner.EntityKey;
                EntityKey entityKey = wrappedEntity.EntityKey;

                entry = wrappedEntity.Context.ObjectStateManager.DeleteRelationship(relationshipSet,
                                      new KeyValuePair<string, EntityKey>(navigation.From, ownerKey),
                                      new KeyValuePair<string, EntityKey>(navigation.To, entityKey));
            }
            return entry;
        }

        private static void DetachRelationshipFromObjectStateManager(IEntityWrapper wrappedEntity, IEntityWrapper wrappedOwner, RelationshipSet relationshipSet, RelationshipNavigation navigation)
        {
            Debug.Assert(wrappedEntity != null, "IEntityWrapper instance is null.");
            if (wrappedOwner.Context != null && wrappedEntity.Context != null && relationshipSet != null)
            {
                EntityKey ownerKey = wrappedOwner.EntityKey;
                EntityKey entityKey = wrappedEntity.EntityKey;
                RelationshipEntry entry = wrappedEntity.Context.ObjectStateManager.FindRelationship(relationshipSet,
                                                                          new KeyValuePair<string, EntityKey>(navigation.From, ownerKey),
                                                                          new KeyValuePair<string, EntityKey>(navigation.To, entityKey));
                if (entry != null)
                {
                    entry.DetachRelationshipEntry();
                }
            }
        }

        private static void RemoveEntityFromRelatedEnds(IEntityWrapper wrappedEntity1, IEntityWrapper wrappedEntity2, RelationshipNavigation navigation)
        {
            Debug.Assert(wrappedEntity1 != null, "IEntityWrapper instance is null.");
            Debug.Assert(wrappedEntity2 != null, "IEntityWrapper instance is null.");
            foreach (RelatedEnd relatedEnd in wrappedEntity1.RelationshipManager.Relationships)
            {
                bool doCascadeDelete = false;
                //check for cascade delete flag
                doCascadeDelete = CheckCascadeDeleteFlag(relatedEnd.FromEndProperty) || relatedEnd.IsPrincipalEndOfReferentialConstraint();
                //Remove the owner from the related end
                relatedEnd.Clear(wrappedEntity2, navigation, doCascadeDelete);
            }
        }

        private static bool CheckCascadeDeleteFlag(RelationshipEndMember relationEndProperty)
        {
            if (null != relationEndProperty)
            {
                return (relationEndProperty.DeleteBehavior == OperationAction.Cascade);
            }
            return false;
        }


        internal void AttachContext(ObjectContext context, MergeOption mergeOption)
        {
            if (!_wrappedOwner.InitializingProxyRelatedEnds)
            {
                EntityKey ownerKey = _wrappedOwner.EntityKey;
                EntityUtil.CheckEntityKeyNull(ownerKey);
                EntitySet entitySet = ownerKey.GetEntitySet(context.MetadataWorkspace);

                AttachContext(context, entitySet, mergeOption);
            }
        }


        /// <summary>
        /// Set the context and load options so that Query can be constructed on demand.
        /// </summary>
        internal void AttachContext(ObjectContext context, EntitySet entitySet, MergeOption mergeOption)
        {
            EntityUtil.CheckArgumentNull(context, "context");
            EntityUtil.CheckArgumentMergeOption(mergeOption);
            EntityUtil.CheckArgumentNull(entitySet, "entitySet");

            _wrappedOwner.RelationshipManager.NodeVisited = false;
            // If the context is the same as what we already have, and the mergeOption is consistent with our UsingNoTracking setting, nothing more to do
            if (_context == context && (_usingNoTracking == (mergeOption == MergeOption.NoTracking)))
            {
                return;
            }

            bool doCleanup = true;

            try
            {
                // if the source isn't null, clear it
                _sourceQuery = null;
                this._context = context;
                this._usingNoTracking = (mergeOption == MergeOption.NoTracking);

                EdmType relationshipType;
                RelationshipSet relationshipSet;
                FindRelationshipSet(_context, entitySet, out relationshipType, out relationshipSet);

                if (relationshipSet != null)
                {
                    this._relationshipSet = relationshipSet;
                    this._relationMetadata = (RelationshipType)relationshipType;
                }
                else
                {
                    foreach (EntitySetBase set in entitySet.EntityContainer.BaseEntitySets)
                    {
                        AssociationSet associationset = set as AssociationSet;
                        if (associationset != null)
                        {
                            if (associationset.ElementType == relationshipType &&
                                associationset.AssociationSetEnds[_navigation.From].EntitySet != entitySet &&
                                associationset.AssociationSetEnds[_navigation.From].EntitySet.ElementType == entitySet.ElementType)
                                throw EntityUtil.EntitySetIsNotValidForRelationship(entitySet.EntityContainer.Name, entitySet.Name, _navigation.From, ((AssociationSet)set).EntityContainer.Name, ((AssociationSet)set).Name);
                        }
                    }
                    throw EntityUtil.NoRelationshipSetMatched(_navigation.RelationshipName);
                }

                //find relation end property
                bool foundFromRelationEnd = false;
                bool foundToRelationEnd = false;
                foreach (AssociationEndMember relationEnd in ((AssociationType)_relationMetadata).AssociationEndMembers) //Only Association relationship is supported
                {
                    if (relationEnd.Name == this._navigation.From)
                    {
                        Debug.Assert(!foundFromRelationEnd, "More than one related end was found with the same role name.");

                        foundFromRelationEnd = true;
                        this._fromEndProperty = relationEnd;
                    }
                    if (relationEnd.Name == this._navigation.To)
                    {
                        Debug.Assert(!foundToRelationEnd, "More than one related end was found with the same role name.");

                        foundToRelationEnd = true;
                        this._toEndProperty = relationEnd;
                    }
                }
                if (!(foundFromRelationEnd && foundToRelationEnd))
                {
                    throw EntityUtil.RelatedEndNotFound();
                }

                // If this is a stub EntityReference and the DetachedEntityKey is set, make sure it is valid
                if (this.IsEmpty())
                {
                    // if there are no contained entities but this is a reference with a detached entity key, validate the key
                    EntityReference entityRef = this as EntityReference;
                    if (entityRef != null && entityRef.DetachedEntityKey != null)
                    {
                        EntityKey detachedKey = entityRef.DetachedEntityKey;
                        if (!IsValidEntityKeyType(detachedKey))
                        {
                            // devnote: We have to check this here instead of in the EntityKey property setter,
                            //          because the key could be set to an invalid type temporarily during deserialization
                            throw EntityUtil.CannotSetSpecialKeys();
                        }
                        EntitySet targetEntitySet = detachedKey.GetEntitySet(context.MetadataWorkspace);
                        CheckRelationEntitySet(targetEntitySet);
                        detachedKey.ValidateEntityKey(ObjectContext.MetadataWorkspace, targetEntitySet);
                    }
                }
                // else even for a reference we don't need to validate the key
                // because it will be checked later once we have the key for the contained entity

                doCleanup = false;
            }
            finally
            {
                if (doCleanup)
                {
                    // Uninitialize fields, so the cleanup code (for example in RelationshipWrapper.RemoveRelatedEntitiesFromObjectStateManager) 
                    // knows that this RelatedEnd was not properly Attached.
                    this.DetachContext();
                }
            }
        }

        internal void FindRelationshipSet(ObjectContext context, EntitySet entitySet, out EdmType relationshipType, out RelationshipSet relationshipSet)
        {
            // find the relationship set
            Debug.Assert(context.MetadataWorkspace != null, "The context should not have a null metadata workspace.");

            // find the TypeMetadata for the given relationship
            relationshipType = context.MetadataWorkspace.GetItem<EdmType>(_navigation.RelationshipName, DataSpace.CSpace);
            if (relationshipType == null)
            {
                throw EntityUtil.NoRelationshipSetMatched(_navigation.RelationshipName);
            }

            // find the RelationshipSet
            foreach (EntitySetBase entitySetBase in entitySet.EntityContainer.BaseEntitySets)
            {
                if ((EdmType)entitySetBase.ElementType == relationshipType)
                {
                    if (((AssociationSet)entitySetBase).AssociationSetEnds[_navigation.From].EntitySet == entitySet)
                    {
                        relationshipSet = (RelationshipSet)entitySetBase;
                        return;
                    }
                }
            }
            relationshipSet = null;
        }

        /// <summary>
        /// Clear the source and context.
        /// </summary>        
        internal void DetachContext()
        {
            if (this._context != null &&
                this.ObjectContext.ObjectStateManager.TransactionManager.IsAttachTracking &&
                this.ObjectContext.ObjectStateManager.TransactionManager.OriginalMergeOption == MergeOption.NoTracking)
            {
                this._usingNoTracking = true;
                return;
            }

            this._sourceQuery = null;
            this._context = null;
            this._relationshipSet = null;
            this._fromEndProperty = null;
            this._toEndProperty = null;
            this._relationMetadata = null;

            // Detached entity should have IsLoaded property set to false
            this._isLoaded = false;
        }

        /// <summary>
        ///  This method is very similar to the private method in Query of U class
        ///  Only difference is that it calls meterializer with a overload which does
        ///  not skip the deleted items.
        /// </summary>
        /// <param name="query">query of U</param>
        /// <returns></returns>
        internal static IEnumerable<U> GetResults<U>(ObjectQuery<U> query)
        {
            return query.Execute(query.MergeOption);
        }

        internal RelatedEnd GetOtherEndOfRelationship(IEntityWrapper wrappedEntity)
        {
            Debug.Assert(wrappedEntity != null, "IEntityWrapper instance is null.");
            EnsureRelationshipNavigationAccessorsInitialized();
            return (RelatedEnd)wrappedEntity.RelationshipManager.GetRelatedEnd(_navigation.Reverse, _relationshipFixer);
        }

        // We have to allow a default constructor for serialization, so we need to make sure that the only
        // thing you can do with a null owner is get/set the EntityReference.EntityKey property. All other
        // operations are invalid. This needs to be used on all public methods in this class and EntityReference
        // but not in EntityCollection because EntityCollection does not have a default constructor.
        // It is not possible to get an EntityReference with a null Owner into the RelationshipManager, and there 
        // is no way to access EntityReference without creating one using the default constructor or going through
        // the RelationshipManager, so we don't need to check this in internal or private methods.
        internal void CheckOwnerNull()
        {
            if (_wrappedOwner.Entity == null)
            {
                throw EntityUtil.OwnerIsNull();
            }
        }

        // This method is intended to be used to support the public API InitializeRelatedReference, where we have to take an existing EntityReference
        // and set up the appropriate fields as shown below, instead of creating a new EntityReference and setting these fields in the constructor.   
        // This is also used by the constructor -- if we add something that needs to be set at construction time, it probably needs to be set for InitializeRelatedReference as well.
        internal void InitializeRelatedEnd(IEntityWrapper wrappedOwner, RelationshipNavigation navigation, IRelationshipFixer relationshipFixer)
        {
            SetWrappedOwner(wrappedOwner);
            _navigation = navigation;
            _relationshipFixer = relationshipFixer;
        }

        internal void SetWrappedOwner(IEntityWrapper wrappedOwner)
        {
            _wrappedOwner = wrappedOwner != null ? wrappedOwner : EntityWrapperFactory.NullWrapper;
#pragma warning disable 612 // Disable "obsolete" warning for the _owner field. Used for backwards compatibility.
            _owner = wrappedOwner.Entity as IEntityWithRelationships;
#pragma warning restore 612
        }

        internal static bool IsValidEntityKeyType(EntityKey entityKey)
        {
            return !(entityKey.IsTemporary ||
                     Object.ReferenceEquals(EntityKey.EntityNotValidKey, entityKey) ||
                     Object.ReferenceEquals(EntityKey.NoEntitySetKey, entityKey));
        }

        // This method is required to maintain compatibility with the v1 binary serialization format. 
        // In particular, it recreates a entity wrapper from the serialized owner.
        // Note that this is only expected to work for non-POCO entities, since serialization of POCO
        // entities will not result in serialization of the RelationshipManager or its related objects.
        [OnDeserialized()]
        [Browsable(false)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        public void OnDeserialized(StreamingContext context)
        {
#pragma warning disable 612 // Disable "obsolete" warning for the _owner field. Used for backwards compatibility.
            _wrappedOwner = EntityWrapperFactory.WrapEntityUsingContext(_owner, ObjectContext);
#pragma warning restore 612
        }

        [NonSerialized]
        private NavigationProperty navigationPropertyCache = null;

        internal NavigationProperty NavigationProperty
        {
            get
            {
                if (this.navigationPropertyCache == null && _wrappedOwner.Context != null && this.TargetAccessor.HasProperty)
                {
                    string navigationPropertyName = this.TargetAccessor.PropertyName;

                    EntityType entityType = _wrappedOwner.Context.MetadataWorkspace.GetItem<EntityType>(_wrappedOwner.IdentityType.FullName, DataSpace.OSpace);
                    NavigationProperty member;
                    if (!entityType.NavigationProperties.TryGetValue(navigationPropertyName, false, out member))
                    {
                        throw new InvalidOperationException(System.Data.Entity.Strings.RelationshipManager_NavigationPropertyNotFound(navigationPropertyName));
                    }
                    // Avoid metadata lookups by caching the navigation property locally
                    this.navigationPropertyCache = member;
                }
                return this.navigationPropertyCache;
            }
        }

        #region POCO Navigation Property Accessors

        internal NavigationPropertyAccessor TargetAccessor
        {
            get
            {
                if (_wrappedOwner.Entity != null)
                {
                    EnsureRelationshipNavigationAccessorsInitialized();
                    return RelationshipNavigation.ToPropertyAccessor;
                }
                else
                {
                    // Disconnected RelatedEnds have no POCO navigation properties
                    return NavigationPropertyAccessor.NoNavigationProperty;
                }
            }
        }

        // If the RelationshipNavigation has not been fully initialized, it means this RelatedEnd was created without metadata
        // This can occur in serialization scenarios
        // Try to look up the metadata in all metadata repositories that are available and populate it
        // This must be called before accessing any of the Accessor properties on the RelationshipNavigation
        private void EnsureRelationshipNavigationAccessorsInitialized()
        {
            Debug.Assert(_navigation != null, "Null RelationshipNavigation");
            Debug.Assert(_wrappedOwner.Entity != null, "Must be connected to lookup metadata");
            if (!RelationshipNavigation.IsInitialized)
            {
                NavigationPropertyAccessor sourceAccessor = null;
                NavigationPropertyAccessor targetAccessor = null;

                AssociationType associationType = this.RelationMetadata as AssociationType;
                string relationshipName = _navigation.RelationshipName;
                string sourceRoleName = _navigation.From;
                string targetRoleName = _navigation.To;
                if (associationType != null ||
                    RelationshipManager.TryGetRelationshipType(WrappedOwner, WrappedOwner.IdentityType, relationshipName, out associationType) ||
                    EntityProxyFactory.TryGetAssociationTypeFromProxyInfo(WrappedOwner, relationshipName, targetRoleName, out associationType))
                {
                    AssociationEndMember sourceEnd;
                    if (associationType.AssociationEndMembers.TryGetValue(sourceRoleName, false, out sourceEnd))
                    {
                        EntityType sourceEntityType = MetadataHelper.GetEntityTypeForEnd(sourceEnd);
                        targetAccessor = MetadataHelper.GetNavigationPropertyAccessor(sourceEntityType, relationshipName, sourceRoleName, targetRoleName);
                    }

                    AssociationEndMember targetEnd;
                    if (associationType.AssociationEndMembers.TryGetValue(targetRoleName, false, out targetEnd))
                    {
                        EntityType targetEntityType = MetadataHelper.GetEntityTypeForEnd(targetEnd);
                        sourceAccessor = MetadataHelper.GetNavigationPropertyAccessor(targetEntityType, relationshipName, targetRoleName, sourceRoleName);
                    }
                }

                if (sourceAccessor == null || targetAccessor == null)
                {
                    throw RelationshipManager.UnableToGetMetadata(WrappedOwner, relationshipName);
                }

                RelationshipNavigation.InitializeAccessors(sourceAccessor, targetAccessor);
            }
        }

        #endregion
    }
}