internal void UpdateForeignKeyValues(IEntityWrapper dependentEntity, EntityKey principalKey)
{
ReferentialConstraint referentialConstraint = ((AssociationType)this.RelationMetadata).ReferentialConstraints[0];
ObjectStateManager objectStateManager = this.ObjectContext.ObjectStateManager;
objectStateManager.TransactionManager.BeginForeignKeyUpdate(this);
try
{
EntitySet entitySet = ((AssociationSet)this.RelationshipSet).AssociationSetEnds[this.FromEndMember.Name].EntitySet;
StateManagerTypeMetadata managerTypeMetadata = objectStateManager.GetOrAddStateManagerTypeMetadata(dependentEntity.IdentityType, entitySet);
for (int index = 0; index < referentialConstraint.FromProperties.Count; ++index)
{
object valueByName = principalKey.FindValueByName(referentialConstraint.FromProperties[index].Name);
int olayerMemberName = managerTypeMetadata.GetOrdinalforOLayerMemberName(referentialConstraint.ToProperties[index].Name);
object x = managerTypeMetadata.Member(olayerMemberName).GetValue(dependentEntity.Entity);
if (!ByValueEqualityComparer.Default.Equals(x, valueByName))
{
dependentEntity.SetCurrentValue(dependentEntity.ObjectStateEntry, managerTypeMetadata.Member(olayerMemberName), -1, dependentEntity.Entity, valueByName);
}
}
this.SetCachedForeignKey(principalKey, dependentEntity.ObjectStateEntry);
if (this.WrappedOwner.ObjectStateEntry == null)
{
return;
}
objectStateManager.ForgetEntryWithConceptualNull(this.WrappedOwner.ObjectStateEntry, false);
}
finally
{
objectStateManager.TransactionManager.EndForeignKeyUpdate();
}
}
// Note that this is called only for association ends. Entities have key values inline.
private PropagatorResult CreateEntityKeyResult(IEntityStateEntry stateEntry, EntityKey entityKey)
{
// get metadata for key
var entityType = entityKey.GetEntitySet(m_translator.MetadataWorkspace).ElementType;
var keyRowType = entityType.GetKeyRowType();
var keyMetadata = m_translator.GetExtractorMetadata(stateEntry.EntitySet, keyRowType);
var keyMemberCount = keyRowType.Properties.Count;
var keyValues = new PropagatorResult[keyMemberCount];
for (var ordinal = 0; ordinal < keyRowType.Properties.Count; ordinal++)
{
EdmMember keyMember = keyRowType.Properties[ordinal];
// retrieve information about this key value
var keyMemberInformation = keyMetadata.m_memberMap[ordinal];
var keyIdentifier = m_translator.KeyManager.GetKeyIdentifierForMemberOffset(entityKey, ordinal, keyRowType.Properties.Count);
object keyValue = null;
if (entityKey.IsTemporary)
{
// If the EntityKey is temporary, we need to retrieve the appropriate
// key value from the entity itself (or in this case, the IEntityStateEntry).
var entityEntry = stateEntry.StateManager.GetEntityStateEntry(entityKey);
Debug.Assert(
entityEntry.State == EntityState.Added,
"The corresponding entry for a temp EntityKey should be in the Added State.");
keyValue = entityEntry.CurrentValues[keyMember.Name];
}
else
{
// Otherwise, we extract the value from within the EntityKey.
keyValue = entityKey.FindValueByName(keyMember.Name);
}
Debug.Assert(keyValue != null, "keyValue should've been retrieved.");
// construct propagator result
keyValues[ordinal] = PropagatorResult.CreateKeyValue(
keyMemberInformation.Flags,
keyValue,
stateEntry,
keyIdentifier);
// see UpdateTranslator.Identifiers for information on key identifiers and ordinals
}
return(PropagatorResult.CreateStructuralValue(keyValues, keyMetadata.m_type, false));
}
/// <summary>
/// Takes key values from the given principal key and transfers them to the foreign key properties
/// of the dependant entry. This method requires a context, but does not require that either
/// entity or key is in the context. This allows it to work in NoTracking cases where we have the context
/// but we're not tracked by that context.
/// </summary>
/// <param name="dependentEntity">The entity into which foreign key values will be written</param>
/// <param name="principalEntity">The key from which key values will be obtained</param>
internal void UpdateForeignKeyValues(IEntityWrapper dependentEntity, EntityKey principalKey)
{
Debug.Assert(dependentEntity.Entity != null, "dependentEntity.Entity == null");
Debug.Assert(principalKey != null, "principalKey == null");
Debug.Assert(!principalKey.IsTemporary, "Cannot update from a temp key");
Debug.Assert(this.IsForeignKey, "cannot update foreign key values if the relationship is not a FK");
ReferentialConstraint constraint = ((AssociationType)this.RelationMetadata).ReferentialConstraints[0];
Debug.Assert(constraint != null, "null constraint");
ObjectStateManager stateManager = ObjectContext.ObjectStateManager;
stateManager.TransactionManager.BeginForeignKeyUpdate(this);
try
{
EntitySet dependentEntitySet = ((AssociationSet)RelationshipSet).AssociationSetEnds[FromEndProperty.Name].EntitySet;
StateManagerTypeMetadata dependentTypeMetadata = stateManager.GetOrAddStateManagerTypeMetadata(dependentEntity.IdentityType, dependentEntitySet);
for (int i = 0; i < constraint.FromProperties.Count; i++)
{
object value = principalKey.FindValueByName(constraint.FromProperties[i].Name);
int dependentOrdinal = dependentTypeMetadata.GetOrdinalforOLayerMemberName(constraint.ToProperties[i].Name);
object currentValue = dependentTypeMetadata.Member(dependentOrdinal).GetValue(dependentEntity.Entity);
if (!ByValueEqualityComparer.Default.Equals(currentValue, value))
{
dependentEntity.SetCurrentValue(
dependentEntity.ObjectStateEntry,
dependentTypeMetadata.Member(dependentOrdinal),
-1,
dependentEntity.Entity,
value);
}
}
SetCachedForeignKey(principalKey, dependentEntity.ObjectStateEntry);
if (WrappedOwner.ObjectStateEntry != null)
{
stateManager.ForgetEntryWithConceptualNull(WrappedOwner.ObjectStateEntry, resetAllKeys: false);
}
}
finally
{
stateManager.TransactionManager.EndForeignKeyUpdate();
}
}
private PropagatorResult CreateEntityKeyResult(
IEntityStateEntry stateEntry,
EntityKey entityKey)
{
RowType keyRowType = entityKey.GetEntitySet(this.m_translator.MetadataWorkspace).ElementType.GetKeyRowType();
ExtractorMetadata extractorMetadata = this.m_translator.GetExtractorMetadata(stateEntry.EntitySet, (StructuralType)keyRowType);
PropagatorResult[] values = new PropagatorResult[keyRowType.Properties.Count];
for (int memberOffset = 0; memberOffset < keyRowType.Properties.Count; ++memberOffset)
{
EdmMember property = (EdmMember)keyRowType.Properties[memberOffset];
ExtractorMetadata.MemberInformation member = extractorMetadata.m_memberMap[memberOffset];
int identifierForMemberOffset = this.m_translator.KeyManager.GetKeyIdentifierForMemberOffset(entityKey, memberOffset, keyRowType.Properties.Count);
object obj = !entityKey.IsTemporary ? entityKey.FindValueByName(property.Name) : stateEntry.StateManager.GetEntityStateEntry(entityKey).CurrentValues[property.Name];
values[memberOffset] = PropagatorResult.CreateKeyValue(member.Flags, obj, stateEntry, identifierForMemberOffset);
}
return(PropagatorResult.CreateStructuralValue(values, extractorMetadata.m_type, false));
}
/// <summary>
/// Takes key values from the given principal key and transfers them to the foreign key properties
/// of the dependant entry. This method requires a context, but does not require that either
/// entity or key is in the context. This allows it to work in NoTracking cases where we have the context
/// but we're not tracked by that context.
/// </summary>
/// <param name="dependentEntity">The entity into which foreign key values will be written</param>
/// <param name="principalEntity">The key from which key values will be obtained</param>
internal void UpdateForeignKeyValues(IEntityWrapper dependentEntity, EntityKey principalKey)
{
Debug.Assert(dependentEntity.Entity != null, "dependentEntity.Entity == null");
Debug.Assert(principalKey != null, "principalKey == null");
Debug.Assert(!principalKey.IsTemporary, "Cannot update from a temp key");
Debug.Assert(IsForeignKey, "cannot update foreign key values if the relationship is not a FK");
var constraint = ((AssociationType)RelationMetadata).ReferentialConstraints[0];
Debug.Assert(constraint != null, "null constraint");
var stateManager = ObjectContext.ObjectStateManager;
stateManager.TransactionManager.BeginForeignKeyUpdate(this);
try
{
var dependentEntitySet = ((AssociationSet)RelationshipSet).AssociationSetEnds[FromEndMember.Name].EntitySet;
var dependentTypeMetadata = stateManager.GetOrAddStateManagerTypeMetadata(dependentEntity.IdentityType, dependentEntitySet);
for (var i = 0; i < constraint.FromProperties.Count; i++)
{
var value = principalKey.FindValueByName(constraint.FromProperties[i].Name);
var dependentOrdinal = dependentTypeMetadata.GetOrdinalforOLayerMemberName(constraint.ToProperties[i].Name);
var currentValue = dependentTypeMetadata.Member(dependentOrdinal).GetValue(dependentEntity.Entity);
if (!ByValueEqualityComparer.Default.Equals(currentValue, value))
{
dependentEntity.SetCurrentValue(
dependentEntity.ObjectStateEntry,
dependentTypeMetadata.Member(dependentOrdinal),
-1,
dependentEntity.Entity,
value);
}
}
SetCachedForeignKey(principalKey, dependentEntity.ObjectStateEntry);
if (WrappedOwner.ObjectStateEntry != null)
{
stateManager.ForgetEntryWithConceptualNull(WrappedOwner.ObjectStateEntry, resetAllKeys: false);
}
}
finally
{
stateManager.TransactionManager.EndForeignKeyUpdate();
}
}
// Note that this is called only for association ends. Entities have key values inline.
private PropagatorResult CreateEntityKeyResult(IEntityStateEntry stateEntry, EntityKey entityKey)
{
// get metadata for key
var entityType = entityKey.GetEntitySet(m_translator.MetadataWorkspace).ElementType;
var keyRowType = entityType.GetKeyRowType();
var keyMetadata = m_translator.GetExtractorMetadata(stateEntry.EntitySet, keyRowType);
var keyMemberCount = keyRowType.Properties.Count;
var keyValues = new PropagatorResult[keyMemberCount];
for (var ordinal = 0; ordinal < keyRowType.Properties.Count; ordinal++)
{
EdmMember keyMember = keyRowType.Properties[ordinal];
// retrieve information about this key value
var keyMemberInformation = keyMetadata.m_memberMap[ordinal];
var keyIdentifier = m_translator.KeyManager.GetKeyIdentifierForMemberOffset(entityKey, ordinal, keyRowType.Properties.Count);
object keyValue = null;
if (entityKey.IsTemporary)
{
// If the EntityKey is temporary, we need to retrieve the appropriate
// key value from the entity itself (or in this case, the IEntityStateEntry).
var entityEntry = stateEntry.StateManager.GetEntityStateEntry(entityKey);
Debug.Assert(
entityEntry.State == EntityState.Added,
"The corresponding entry for a temp EntityKey should be in the Added State.");
keyValue = entityEntry.CurrentValues[keyMember.Name];
}
else
{
// Otherwise, we extract the value from within the EntityKey.
keyValue = entityKey.FindValueByName(keyMember.Name);
}
Debug.Assert(keyValue != null, "keyValue should've been retrieved.");
// construct propagator result
keyValues[ordinal] = PropagatorResult.CreateKeyValue(
keyMemberInformation.Flags,
keyValue,
stateEntry,
keyIdentifier);
// see UpdateTranslator.Identifiers for information on key identifiers and ordinals
}
return PropagatorResult.CreateStructuralValue(keyValues, keyMetadata.m_type, false);
}
