public static ObjectContext GetObjectContext(this IEntityWithRelationships entity) { if (entity == null) { throw new ArgumentNullException("entity"); } var relationshipManager = entity.RelationshipManager; var relatedEnd = relationshipManager.GetAllRelatedEnds() .FirstOrDefault(); if (relatedEnd == null) { throw new Exception("No relationships found"); } var query = relatedEnd.CreateSourceQuery() as ObjectQuery; if (query == null) { throw new Exception("The Entity is Detached"); } return(query.Context); }
public static object CreateOriginalValuesObjectWithReferences(this ObjectContext context, object source) { object target = context.CreateOriginalValuesObject(source); EntityKey srcKey = ((IEntityWithKey)source).EntityKey; IEntityWithRelationships sourceWithRelationships = source as IEntityWithRelationships; if (sourceWithRelationships == null) { return(target); } foreach (var relationshipGroup in context.GetRelationshipsByRelatedEnd((IEntityWithKey)target, EntityState.Unchanged | EntityState.Deleted)) { IRelatedEnd tgtRelatedEnd = (IRelatedEnd)relationshipGroup.Key; foreach (ObjectStateEntry srcEntry in relationshipGroup) { if (tgtRelatedEnd.IsEntityReference()) { tgtRelatedEnd.SetEntityKey(srcEntry.OtherEndKey(srcKey)); } } } return(target); }
/// <summary> /// Atualiza os relacionamentos. /// </summary> /// <param name="context"></param> /// <param name="newEntity"></param> /// <param name="oldEntity"></param> public static void ApplyReferencePropertyChanges(this ObjectContext context, IEntityWithRelationships newEntity, IEntityWithRelationships oldEntity) { foreach (var relatedEnd in oldEntity.RelationshipManager.GetAllRelatedEnds()) { var oldRef = relatedEnd as EntityReference; if (oldRef == null) continue; var newRef = newEntity.RelationshipManager.GetRelatedEnd(oldRef.RelationshipName, oldRef.TargetRoleName) as EntityReference; if (newRef != null) oldRef.EntityKey = newRef.EntityKey; } }
internal virtual IEntityWrapper WrapEntityUsingStateManagerGettingEntry( object entity, ObjectStateManager stateManager, out EntityEntry existingEntry) { IEntityWrapper wrapper = (IEntityWrapper)null; existingEntry = (EntityEntry)null; if (entity == null) { return(NullEntityWrapper.NullWrapper); } if (stateManager != null) { existingEntry = stateManager.FindEntityEntry(entity); if (existingEntry != null) { return(existingEntry.WrappedEntity); } if (stateManager.TransactionManager.TrackProcessedEntities && stateManager.TransactionManager.WrappedEntities.TryGetValue(entity, out wrapper)) { return(wrapper); } } IEntityWithRelationships withRelationships = entity as IEntityWithRelationships; if (withRelationships != null) { RelationshipManager relationshipManager = withRelationships.RelationshipManager; if (relationshipManager == null) { throw new InvalidOperationException(Strings.RelationshipManager_UnexpectedNull); } IEntityWrapper wrappedOwner = relationshipManager.WrappedOwner; if (!object.ReferenceEquals(wrappedOwner.Entity, entity)) { throw new InvalidOperationException(Strings.RelationshipManager_InvalidRelationshipManagerOwner); } return(wrappedOwner); } EntityProxyFactory.TryGetProxyWrapper(entity, out wrapper); if (wrapper == null) { IEntityWithKey entityWithKey = entity as IEntityWithKey; wrapper = EntityWrapperFactory.CreateNewWrapper(entity, entityWithKey == null ? (EntityKey)null : entityWithKey.EntityKey); } if (stateManager != null && stateManager.TransactionManager.TrackProcessedEntities) { stateManager.TransactionManager.WrappedEntities.Add(entity, wrapper); } return(wrapper); }
/// <summary> /// Gets the name of the entity container /// </summary> /// <param name="entity">entity</param> /// <returns>name of the entity container</returns> public static string GetEntityContainerName(this IEntityWithRelationships entity) { var result = string.Empty; if (entity != null) { var entitySet = GetEntitySet(entity.GetType()); if (entitySet != null) { result = entitySet.EntityContainer.Name; } } return(result); }
public void ApplyReferencePropertyChanges( IEntityWithRelationships newEntity, IEntityWithRelationships oldEntity) { foreach (var relatedEnd in oldEntity.RelationshipManager.GetAllRelatedEnds()) { var oldRef = relatedEnd as EntityReference; if (oldRef != null) { // this related end is a reference not a collection var newRef = newEntity.RelationshipManager.GetRelatedEnd(oldRef.RelationshipName, oldRef.TargetRoleName) as EntityReference; oldRef.EntityKey = newRef.EntityKey; } } }
public static bool IsUnloadedEntityAssociation(object item, MemberInfo fieldOrProp) { Type propertyType = null; bool flag2; if (fieldOrProp is PropertyInfo) { propertyType = ((PropertyInfo)fieldOrProp).PropertyType; } else { if (!(fieldOrProp is FieldInfo)) { return(false); } propertyType = ((FieldInfo)fieldOrProp).FieldType; } EdmRelationshipNavigationPropertyAttribute attribute = (EdmRelationshipNavigationPropertyAttribute)fieldOrProp.GetCustomAttributes(typeof(EdmRelationshipNavigationPropertyAttribute), true).FirstOrDefault <object>(); if (attribute == null) { return(false); } IEntityWithRelationships relationships = item as IEntityWithRelationships; if (relationships == null) { return(true); } Type type2 = (flag2 = propertyType.IsGenericType && propertyType.Name.StartsWith("EntityCollection")) ? propertyType.GetGenericArguments()[0] : propertyType; string str = attribute.RelationshipNamespaceName + "." + attribute.RelationshipName; MethodInfo method = typeof(RelationshipManager).GetMethod(flag2 ? "GetRelatedCollection" : "GetRelatedReference", new Type[] { typeof(string), typeof(string) }); if (method == null) { return(true); } object obj2 = method.MakeGenericMethod(new Type[] { type2 }).Invoke(relationships.RelationshipManager, new object[] { str, attribute.TargetRoleName }); if (obj2 == null) { return(true); } Type type3 = flag2 ? typeof(EntityCollection <>) : typeof(EntityReference <>); PropertyInfo property = type3.MakeGenericType(new Type[] { type2 }).GetProperty("IsLoaded"); return((property == null) || !((bool)property.GetValue(obj2, null))); }
/// <summary> /// /// </summary> /// <param name="context"></param> /// <param name="newEntity"></param> /// <param name="oldEntity"></param> public static void ApplyReferencePropertyChanges(this ObjectContext context, IEntityWithRelationships newEntity, IEntityWithRelationships oldEntity) { foreach (var relatedEnd in oldEntity.RelationshipManager.GetAllRelatedEnds()) { var oldRef = relatedEnd as EntityReference; if (oldRef != null) { // this related end is a reference not a collection var newRef = newEntity.RelationshipManager.GetRelatedEnd(oldRef.RelationshipName, oldRef.TargetRoleName) as EntityReference; EntityObject refEntity = newRef.GetType().GetProperty("Value").GetValue(newRef, null) as EntityObject; if (newRef.EntityKey == null && refEntity != null) { newRef.EntityKey = context.GetEntityKey(refEntity); } oldRef.EntityKey = newRef.EntityKey; } } }
/// <summary> /// Wraps an entity and returns a new wrapper, or returns an existing wrapper if one /// already exists in the ObjectStateManager or in a RelationshipManager associated with /// the entity. /// </summary> /// <param name="entity">The entity to wrap</param> /// <param name="context">The state manager in which the entity may exist, or null</param> /// <param name="existingEntry">The existing state entry for the given entity if one exists, otherwise null</param> /// <returns>A new or existing wrapper</returns> internal static IEntityWrapper WrapEntityUsingStateManagerGettingEntry(object entity, ObjectStateManager stateManager, out EntityEntry existingEntry) { Debug.Assert(!(entity is IEntityWrapper), "Object is an IEntityWrapper instance instead of the raw entity."); IEntityWrapper wrapper = null; existingEntry = null; if (entity == null) { return(NullEntityWrapper.NullWrapper); } // First attempt to find an existing wrapper in the ObjectStateMager. if (stateManager != null) { existingEntry = stateManager.FindEntityEntry(entity); if (existingEntry != null) { return(existingEntry.WrappedEntity); } if (stateManager.TransactionManager.TrackProcessedEntities) { if (stateManager.TransactionManager.WrappedEntities.TryGetValue(entity, out wrapper)) { return(wrapper); } } } // If no entity was found in the OSM, then check if one exists on an associated // RelationshipManager. This only works where the entity implements IEntityWithRelationshops. IEntityWithRelationships entityWithRelationships = entity as IEntityWithRelationships; if (entityWithRelationships != null) { RelationshipManager relManager = entityWithRelationships.RelationshipManager; if (relManager == null) { throw EntityUtil.UnexpectedNullRelationshipManager(); } IEntityWrapper wrappedEntity = relManager.WrappedOwner; if (!Object.ReferenceEquals(wrappedEntity.Entity, entity)) { // This means that the owner of the RelationshipManager must have been set // incorrectly in the call to RelationshipManager.Create(). throw EntityUtil.InvalidRelationshipManagerOwner(); } return(wrappedEntity); } else { // Finally look to see if the instance is a proxy and get the wrapper from the proxy EntityProxyFactory.TryGetProxyWrapper(entity, out wrapper); } // If we could not find an existing wrapper, then go create a new one if (wrapper == null) { IEntityWithKey withKey = entity as IEntityWithKey; wrapper = CreateNewWrapper(entity, withKey == null ? null : withKey.EntityKey); } if (stateManager != null && stateManager.TransactionManager.TrackProcessedEntities) { stateManager.TransactionManager.WrappedEntities.Add(entity, wrapper); } return(wrapper); }
private static void ApplyReferencePropertyChanges(this ObjectContext context, IEntityWithRelationships newEntity, IEntityWithRelationships oldEntity) { foreach (var relatedEnd in oldEntity.RelationshipManager.GetAllRelatedEnds()) { var oldReference = relatedEnd as EntityReference; if (oldReference != null) { var newReference = newEntity.RelationshipManager.GetRelatedEnd(oldReference.RelationshipName, oldReference.TargetRoleName) as EntityReference; if (newReference != null) { oldReference.EntityKey = newReference.EntityKey; } } } }
public void Attach(IEntityWithRelationships entity) { Contract.Requires(entity != null); throw new NotImplementedException(); }
public bool Remove(IEntityWithRelationships entity) { Contract.Requires(entity != null); throw new NotImplementedException(); }
public static TContext GetEntities <TContext>(this IEntityWithRelationships entity) where TContext : class { return(GetContext(entity) as TContext); }