private EntityKey ExtractPrincipalKey(IEntityWrapper wrappedRelatedEntity)
{
EntitySet fromRelationshipSet = this.GetTargetEntitySetFromRelationshipSet();
EntityKey entityKey = wrappedRelatedEntity.EntityKey;
if ((object)entityKey != null && !entityKey.IsTemporary)
{
EntityUtil.ValidateEntitySetInKey(entityKey, fromRelationshipSet);
entityKey.ValidateEntityKey(this.ObjectContext.MetadataWorkspace, fromRelationshipSet);
}
else
{
entityKey = this.ObjectContext.ObjectStateManager.CreateEntityKey(fromRelationshipSet, wrappedRelatedEntity.Entity);
}
return(entityKey);
}
internal override void ValidateDetachedEntityKey()
{
if (!this.IsEmpty() || !(this.DetachedEntityKey != (EntityKey)null))
{
return;
}
EntityKey detachedEntityKey = this.DetachedEntityKey;
if (!RelatedEnd.IsValidEntityKeyType(detachedEntityKey))
{
throw Error.EntityReference_CannotSetSpecialKeys();
}
EntitySet entitySet = detachedEntityKey.GetEntitySet(this.ObjectContext.MetadataWorkspace);
this.CheckRelationEntitySet(entitySet);
detachedEntityKey.ValidateEntityKey(this.ObjectContext.MetadataWorkspace, entitySet);
}
internal void SetEntityKey(EntityKey value, bool forceFixup)
{
if (value != null && value == EntityKey
&& (ReferenceValue.Entity != null || (ReferenceValue.Entity == null && !forceFixup)))
{
// "no-op" -- this is not really no-op in the attached case, because at a minimum we have to do a key lookup,
// worst case we have to review all relationships for the owner entity
// However, if we don't do this, we can get into a scenario where we are setting the key to the same thing it's already set to
// and this could have side effects, especially with RI constraints and cascade delete. We don't want to delete something
// and then add it back, if that deleting could have additional unexpected effects. Don't bother doing this check if value is
// null, because EntityKey could be null even if there are Added/Unchanged relationships, if the target entity has a temporary key.
// In that case, we still need to delete that existing relationship, so it's not a no-op
return;
}
if (ObjectContext != null
&& !UsingNoTracking)
{
Debug.Assert(WrappedOwner.Entity != null, "Unexpected null Owner on EntityReference attached to a context");
// null is a valid value for the EntityKey, but temporary and special keys are not
// devnote: Can't check this on detached references because this property could be set to a temp key during deserialization,
// if the key hasn't finished deserializing yet.
if (value != null
&& !IsValidEntityKeyType(value))
{
throw new ArgumentException(Strings.EntityReference_CannotSetSpecialKeys, "value");
}
if (value == null)
{
if (AttemptToNullFKsOnRefOrKeySetToNull())
{
DetachedEntityKey = null;
}
else
{
ReferenceValue = NullEntityWrapper.NullWrapper;
}
}
else
{
// Verify that the key has the right EntitySet for this RelationshipSet
var targetEntitySet = value.GetEntitySet(ObjectContext.MetadataWorkspace);
CheckRelationEntitySet(targetEntitySet);
value.ValidateEntityKey(ObjectContext.MetadataWorkspace, targetEntitySet, true /*isArgumentException */, "value");
var manager = ObjectContext.ObjectStateManager;
// If we already have an entry with this key, we just need to create a relationship with it
var addNewRelationship = false;
// If we don't already have any matching entries for this key, we'll have to create a new entry
var addKeyEntry = false;
var targetEntry = manager.FindEntityEntry(value);
if (targetEntry != null)
{
// If it's not a key entry, just use the entity to set this reference's Value
if (!targetEntry.IsKeyEntry)
{
// Delegate to the Value property to clear any existing relationship
// and to add the new one. This will fire the appropriate events and
// ensure that the related ends are connected.
// It has to be a TEntity since we already verified that the EntitySet is correct above
ReferenceValue = targetEntry.WrappedEntity;
}
else
{
// if the existing entry is a key entry, we just need to
// add a new relationship between the source entity and that key
addNewRelationship = true;
}
}
else
{
// no entry exists, so we'll need to add a key along with the relationship
addKeyEntry = !IsForeignKey;
addNewRelationship = true;
}
if (addNewRelationship)
{
var ownerKey = ValidateOwnerWithRIConstraints(
targetEntry == null ? null : targetEntry.WrappedEntity, value, checkBothEnds: true);
// Verify that the owner is in a valid state for adding a relationship
ValidateStateForAdd(WrappedOwner);
if (addKeyEntry)
{
manager.AddKeyEntry(value, targetEntitySet);
}
// First, clear any existing relationships
manager.TransactionManager.EntityBeingReparented = WrappedOwner.Entity;
try
{
ClearCollectionOrRef(null, null, /*doCascadeDelete*/ false);
}
finally
{
manager.TransactionManager.EntityBeingReparented = null;
}
// Then add the new one
if (IsForeignKey)
{
DetachedEntityKey = value;
// Update the FK values in this entity
if (IsDependentEndOfReferentialConstraint(false))
{
UpdateForeignKeyValues(WrappedOwner, value);
}
}
else
{
var wrapper = new RelationshipWrapper(
(AssociationSet)RelationshipSet, RelationshipNavigation.From, ownerKey, RelationshipNavigation.To, value);
// Add the relationship in the unchanged state if
var relationshipState = EntityState.Added;
// If this is an unchanged/modified dependent end of a relationship and we are allowing the EntityKey to be set
// create the relationship in the Unchanged state because the state must "match" the dependent end state
if (!ownerKey.IsTemporary
&& IsDependentEndOfReferentialConstraint(false))
{
relationshipState = EntityState.Unchanged;
}
manager.AddNewRelation(wrapper, relationshipState);
}
}
}
}
else
{
// Just set the field for detached object -- during Attach/Add we will make sure this value
// is not in conflict if the EntityReference contains a real entity. We cannot always determine the
// EntityKey for any real entity in the detached state, so we don't bother to do it here.
DetachedEntityKey = value;
}
}
internal void SetEntityKey(EntityKey value, bool forceFixup)
{
if (value != null && value == EntityKey && (ReferenceValue.Entity != null || (ReferenceValue.Entity == null && !forceFixup)))
{
// "no-op" -- this is not really no-op in the attached case, because at a minimum we have to do a key lookup,
// worst case we have to review all relationships for the owner entity
// However, if we don't do this, we can get into a scenario where we are setting the key to the same thing it's already set to
// and this could have side effects, especially with RI constraints and cascade delete. We don't want to delete something
// and then add it back, if that deleting could have additional unexpected effects. Don't bother doing this check if value is
// null, because EntityKey could be null even if there are Added/Unchanged relationships, if the target entity has a temporary key.
// In that case, we still need to delete that existing relationship, so it's not a no-op
return;
}
if (this.ObjectContext != null && !UsingNoTracking)
{
Debug.Assert(this.WrappedOwner.Entity != null, "Unexpected null Owner on EntityReference attached to a context");
// null is a valid value for the EntityKey, but temporary and special keys are not
// devnote: Can't check this on detached references because this property could be set to a temp key during deserialization,
// if the key hasn't finished deserializing yet.
if (value != null && !IsValidEntityKeyType(value))
{
throw EntityUtil.CannotSetSpecialKeys();
}
if (value == null)
{
if (AttemptToNullFKsOnRefOrKeySetToNull())
{
DetachedEntityKey = null;
}
else
{
ReferenceValue = EntityWrapperFactory.NullWrapper;
}
}
else
{
// Verify that the key has the right EntitySet for this RelationshipSet
EntitySet targetEntitySet = value.GetEntitySet(ObjectContext.MetadataWorkspace);
CheckRelationEntitySet(targetEntitySet);
value.ValidateEntityKey(ObjectContext.MetadataWorkspace, targetEntitySet, true /*isArgumentException */, "value");
ObjectStateManager manager = this.ObjectContext.ObjectStateManager;
// If we already have an entry with this key, we just need to create a relationship with it
bool addNewRelationship = false;
// If we don't already have any matching entries for this key, we'll have to create a new entry
bool addKeyEntry = false;
EntityEntry targetEntry = manager.FindEntityEntry(value);
if (targetEntry != null)
{
// If it's not a key entry, just use the entity to set this reference's Value
if (!targetEntry.IsKeyEntry)
{
// Delegate to the Value property to clear any existing relationship
// and to add the new one. This will fire the appropriate events and
// ensure that the related ends are connected.
// It has to be a TEntity since we already verified that the EntitySet is correct above
this.ReferenceValue = targetEntry.WrappedEntity;
}
else
{
// if the existing entry is a key entry, we just need to
// add a new relationship between the source entity and that key
addNewRelationship = true;
}
}
else
{
// no entry exists, so we'll need to add a key along with the relationship
addKeyEntry = !IsForeignKey;
addNewRelationship = true;
}
if (addNewRelationship)
{
EntityKey ownerKey = ValidateOwnerWithRIConstraints(targetEntry == null ? null : targetEntry.WrappedEntity, value, checkBothEnds: true);
// Verify that the owner is in a valid state for adding a relationship
ValidateStateForAdd(this.WrappedOwner);
if (addKeyEntry)
{
manager.AddKeyEntry(value, targetEntitySet);
}
// First, clear any existing relationships
manager.TransactionManager.EntityBeingReparented = WrappedOwner.Entity;
try
{
ClearCollectionOrRef(null, null, /*doCascadeDelete*/ false);
}
finally
{
manager.TransactionManager.EntityBeingReparented = null;
}
// Then add the new one
if (IsForeignKey)
{
DetachedEntityKey = value;
// Update the FK values in this entity
if (IsDependentEndOfReferentialConstraint(false))
{
UpdateForeignKeyValues(WrappedOwner, value);
}
}
else
{
RelationshipWrapper wrapper = new RelationshipWrapper((AssociationSet)RelationshipSet, RelationshipNavigation.From, ownerKey, RelationshipNavigation.To, value);
// Add the relationship in the unchanged state if
EntityState relationshipState = EntityState.Added;
// If this is an unchanged/modified dependent end of a relationship and we are allowing the EntityKey to be set
// create the relationship in the Unchanged state because the state must "match" the dependent end state
if (!ownerKey.IsTemporary && IsDependentEndOfReferentialConstraint(false))
{
relationshipState = EntityState.Unchanged;
}
manager.AddNewRelation(wrapper, relationshipState);
}
}
}
}
else
{
// Just set the field for detached object -- during Attach/Add we will make sure this value
// is not in conflict if the EntityReference contains a real entity. We cannot always determine the
// EntityKey for any real entity in the detached state, so we don't bother to do it here.
DetachedEntityKey = value;
}
}
internal void SetEntityKey(EntityKey value, bool forceFixup)
{
if (value != (EntityKey)null && value == this.EntityKey && (this.ReferenceValue.Entity != null || this.ReferenceValue.Entity == null && !forceFixup))
{
return;
}
if (this.ObjectContext != null && !this.UsingNoTracking)
{
if (value != (EntityKey)null && !RelatedEnd.IsValidEntityKeyType(value))
{
throw new ArgumentException(Strings.EntityReference_CannotSetSpecialKeys, nameof(value));
}
if (value == (EntityKey)null)
{
if (this.AttemptToNullFKsOnRefOrKeySetToNull())
{
this.DetachedEntityKey = (EntityKey)null;
}
else
{
this.ReferenceValue = NullEntityWrapper.NullWrapper;
}
}
else
{
EntitySet entitySet = value.GetEntitySet(this.ObjectContext.MetadataWorkspace);
this.CheckRelationEntitySet(entitySet);
value.ValidateEntityKey(this.ObjectContext.MetadataWorkspace, entitySet, true, nameof(value));
ObjectStateManager objectStateManager = this.ObjectContext.ObjectStateManager;
bool flag1 = false;
bool flag2 = false;
EntityEntry entityEntry = objectStateManager.FindEntityEntry(value);
if (entityEntry != null)
{
if (!entityEntry.IsKeyEntry)
{
this.ReferenceValue = entityEntry.WrappedEntity;
}
else
{
flag1 = true;
}
}
else
{
flag2 = !this.IsForeignKey;
flag1 = true;
}
if (!flag1)
{
return;
}
EntityKey key0 = this.ValidateOwnerWithRIConstraints(entityEntry == null ? (IEntityWrapper)null : entityEntry.WrappedEntity, value, true);
this.ValidateStateForAdd(this.WrappedOwner);
if (flag2)
{
objectStateManager.AddKeyEntry(value, entitySet);
}
objectStateManager.TransactionManager.EntityBeingReparented = this.WrappedOwner.Entity;
try
{
this.ClearCollectionOrRef((IEntityWrapper)null, (RelationshipNavigation)null, false);
}
finally
{
objectStateManager.TransactionManager.EntityBeingReparented = (object)null;
}
if (this.IsForeignKey)
{
this.DetachedEntityKey = value;
if (!this.IsDependentEndOfReferentialConstraint(false))
{
return;
}
this.UpdateForeignKeyValues(this.WrappedOwner, value);
}
else
{
RelationshipWrapper wrapper = new RelationshipWrapper((AssociationSet)this.RelationshipSet, this.RelationshipNavigation.From, key0, this.RelationshipNavigation.To, value);
EntityState desiredState = EntityState.Added;
if (!key0.IsTemporary && this.IsDependentEndOfReferentialConstraint(false))
{
desiredState = EntityState.Unchanged;
}
objectStateManager.AddNewRelation(wrapper, desiredState);
}
}
}
else
{
this.DetachedEntityKey = value;
}
}