private void check(IValuePair actual, EntityState state, object oldValue, object newValue, string propertyName) { Assert.AreEqual(state, actual.State); Assert.AreEqual(oldValue, actual.OriginalValue()); Assert.AreEqual(newValue, actual.NewValue()); Assert.AreEqual(propertyName, actual.PropertyName); }
/// <summary> /// Saves the current entity. /// </summary> /// <param name="db">The db context</param> /// <param name="state">The current entity state</param> public override void OnSave(DataContext db, System.Data.EntityState state) { var user = HttpContext.Current.User; // We never connect comments to drafts. ParentIsDraft = false; if (state == EntityState.Added) { if (Id == Guid.Empty) { Id = Guid.NewGuid(); } Created = Updated = DateTime.Now; if (user.Identity.IsAuthenticated || db.Identity != Guid.Empty) { CreatedById = UpdatedById = db.Identity != Guid.Empty ? db.Identity : new Guid(user.Identity.Name); } } else if (state == EntityState.Modified) { Updated = DateTime.Now; if (user.Identity.IsAuthenticated || db.Identity != Guid.Empty) { UpdatedById = db.Identity != Guid.Empty ? db.Identity : new Guid(user.Identity.Name); } } base.OnSave(db, state); }
/// <summary> /// Saves the current user. /// </summary> /// <param name="db">The db context</param> /// <param name="state">The entity state</param> public override void OnSave(DataContext db, System.Data.EntityState state) { var user = HttpContext.Current != null ? HttpContext.Current.User : null; if (db.Identity != Guid.Empty || user.Identity.IsAuthenticated) { if (state == EntityState.Added) { if (Id == Guid.Empty) { Id = Guid.NewGuid(); } Created = Updated = DateTime.Now; CreatedById = UpdatedById = db.Identity != Guid.Empty ? db.Identity : new Guid(user.Identity.Name); } else if (state == EntityState.Modified) { Updated = DateTime.Now; UpdatedById = db.Identity != Guid.Empty ? db.Identity : new Guid(user.Identity.Name); } } else { throw new UnauthorizedAccessException("User must be logged in to save entity"); } }
/// <summary> /// Returns all <see cref="DbEntityEntry"/> from <paramref name="context"/> with specified <see cref="EntityState"/> /// (all changed by default).</summary> /// <remarks> We can use <see cref="ObjectStateEntry"/>, if needed (with <see cref="IObjectContextAdapter"/>. /// But we should touch <see cref="DbChangeTracker.Entries()"/> anyway (due to EF implementation).</remarks> public static DbEntityEntry[] GetDbStateEntries(this DbContext context, EntityState state = EntityState.Added | EntityState.Modified | EntityState.Deleted) { if (context == null) return new DbEntityEntry[0]; // returns array to avoid parallel calls problems return context.ChangeTracker.Entries().Where(x => (x.State & state) != 0).ToArray(); }
public RelationshipChange(EntityKey sourceKey, EntityKey targetKey, object source, object target, EntitySetBase entitySet, EntityState state) { _sourceKey = sourceKey; _targetKey = targetKey; _source = source; _target = target; _entitySet = entitySet; _state = state; }
public void AttachUpdatedObject(System.Data.Objects.DataClasses.IEntityWithKey obj, EntityState objState = EntityState.Modified) { ObjectStateEntry state; bool exist = this.ObjectStateManager.TryGetObjectStateEntry(obj, out state); if (!exist || state == null || state.State == EntityState.Detached) { this.Attach(obj); this.ObjectStateManager.ChangeObjectState(obj, objState); } }
private void AddModifiedEntities(IEnumerable<DbEntityEntry> changes, EntityState? entityState = null) { foreach (var entry in changes) { ChangeEntity changesEntity = GetChangeEntity(entry, entityState ?? entry.State); if (changesEntity != null) { _changeSet.ChangeEntities.Add(changesEntity); } } }
/// <summary> /// Executes after the changes. /// </summary> /// <param name="context">The context.</param> /// <param name="item">The item.</param> /// <param name="state">The state.</param> private void After(ObjectContext context, DbEntityEntry item, EntityState state) { var now = DateTime.UtcNow; string entitySetName; var keys = state == EntityState.Deleted ? this.GetEntityKeyDeleted(item, out entitySetName) : this.GetEntityKeyUpdated(context, item, state, out entitySetName); if (keys != null) { var activityLog = this.StateEntry2OperationLog(entitySetName, item.GetType().Name, now, keys, state); this._logContext.Add(activityLog); } }
private ChangeEntity GetChangeEntity(DbEntityEntry entry, EntityState entityState) { if (!((BaseEntity)entry.Entity).IsTrackChanges) return null; List<ChangeField> changeFields = new List<ChangeField>(); List<string> modifiedProperties; if (entityState == EntityState.Added || entityState == EntityState.Modified) modifiedProperties = entry.CurrentValues.PropertyNames.ToList(); else if (entityState == EntityState.Deleted) modifiedProperties = entry.OriginalValues.PropertyNames.ToList(); else throw new NotSupportedException(entityState.ToString()); foreach (var modifiedPropertyName in modifiedProperties) { string newValue = null; string oldValue = null; if (entityState != EntityState.Deleted) newValue = String.Format("{0}", entry.CurrentValues[modifiedPropertyName]); if (entityState != EntityState.Added) oldValue = String.Format("{0}", entry.OriginalValues[modifiedPropertyName]); if (newValue != oldValue) { ChangeField changeField = new ChangeField(); changeField.NewValue = newValue; changeField.OldValue = oldValue; changeField.FieldName = modifiedPropertyName; changeFields.Add(changeField); } } if (changeFields.Count != 0) { var changeEntity = new ChangeEntity() { EntityName = GetEntityName(entry.Entity), ChangeActionId = CreateChangeEntity(entityState), KeyValue = ((BaseEntity)entry.Entity).Id, ChangeFields = new List<ChangeField>() }; foreach (var changeField in changeFields) changeEntity.ChangeFields.Add(changeField); return changeEntity; } else { return null; } }
private EntityEventArgs CreateArgs(DbEntityEntry item, EntityState state) { PropertyValues originalValues = null; PropertyValues currentValues = null; if (state == EntityState.Modified && !(item.State == EntityState.Detached)) { originalValues = new PropertyValues(item.OriginalValues); currentValues = new PropertyValues(item.CurrentValues); } var args = new EntityEventArgs(state, originalValues, currentValues); return args; }
/// <summary> /// Attaches an untracked entity to an entity set and marks it as modified. /// Note: child elements need to be manually added. /// </summary> /// <param name="entity"></param> /// <param name="entitySet"></param> /// <param name="markAsModified"></param> /// <param name="addNew"></param> /// <returns></returns> public object Attach(object entity, bool addNew = false, System.Data.EntityState entityState = System.Data.EntityState.Modified) { var dbSet = Context.Set(entity.GetType()); if (addNew) { dbSet.Add(entity); } else { dbSet.Attach(entity); GetEntityEntry(entity).State = entityState; } return(entity); }
private static IEnumerable<Tuple<object, object>> GetRelationships( this DbContext context, EntityState relationshipState, Func<ObjectStateEntry, int, object> getValue) { context.ChangeTracker.DetectChanges(); var objectContext = ((IObjectContextAdapter)context).ObjectContext; return objectContext.ObjectStateManager .GetObjectStateEntries(relationshipState) .Where(e => e.IsRelationship) .Select( e => Tuple.Create( objectContext.GetObjectByKey((EntityKey)getValue(e, 0)), objectContext.GetObjectByKey((EntityKey)getValue(e, 1)))); }
private DbObjectState ToDbObjectState(EntityState state) { switch (state) { case EntityState.Unchanged: return DbObjectState.Unchanged; case EntityState.Added: return DbObjectState.Added; case EntityState.Modified: return DbObjectState.Modified; case EntityState.Deleted: return DbObjectState.Deleted; default: return DbObjectState.Unchanged; } }
internal void AddChangedField(string fieldName,object fieldValue) { if (this._EntityState == EntityState.Deleted) { throw new NotSupportedException("删除状态的对象不能做操作!"); } if (_OriginalEntityState == EntityState.UnChange) //说明是从datareader里面读取出来后修改的 { if (_OriginalData.ContainsKey(fieldName)) { //如果相同则将该字段移除 ,不相同添加进ChangedFields if (_OriginalData[fieldName]!=null&&_OriginalData[fieldName].Equals(fieldValue)) { _ChangedFields.Remove(fieldName); if (_ChangedFields.Count == 0) { _EntityState = EntityState.UnChange; } } else { _EntityState = EntityState.Modified; if (!_ChangedFields.Contains(fieldName)) { _ChangedFields.Add(fieldName); } } } } else if (_OriginalEntityState == EntityState.New)//只有New的时候才会去修改_OriginalData { if (_OriginalData.ContainsKey(fieldName)) { _OriginalData[fieldName] = fieldValue; } else { _OriginalData.Add(fieldName, fieldValue); } } else { throw new NotSupportedException(_OriginalEntityState + " 是未知的EntityState"); } }
private static IEnumerable<Tuple<string, string, object, string, object, object>> GetSavedValues(ObjectContext context, EntityState state , Func<ObjectStateEntry, IEnumerable<Tuple<string, object, object>>> getValues) { return context .ObjectStateManager .GetObjectStateEntries(state) .SelectMany( e => { string entityname = e.EntitySet.Name; object id = null; if (e.EntityKey != null && e.EntityKey.EntityKeyValues != null) id = e.EntityKey.EntityKeyValues.Select(k => k.Value).FirstOrDefault(); return getValues(e).Select(t => Tuple.Create(state.ToString(), entityname, id, t.Item1, t.Item2, t.Item3)); } ); }
private static void DoTest( EntityState state, bool isPostSave, Expression<Action<IInterceptor<IAuditedEntity>>> expression = null) { // Arrange var entityEntry = new Mock<IEntityEntry>(); entityEntry.SetupGet(x => x.Entity).Returns(new Book { Id = 123 }); entityEntry.SetupGet(x => x.State).Returns(state); var interceptor = new Mock<IInterceptor<IAuditedEntity>>(MockBehavior.Strict); if (expression != null) interceptor.Setup(expression); // Act new MockInterceptor<IAuditedEntity>(interceptor.Object).Intercept(entityEntry.Object, isPostSave); // Assert interceptor.VerifyAll(); }
// Recursively get entity states public static IEnumerable<EntityState> GetEntityStates(this DbContext context, ITrackable item, EntityState? entityState = null, ObjectVisitationHelper visitationHelper = null) { // Prevent endless recursion ObjectVisitationHelper.EnsureCreated(ref visitationHelper); if (!visitationHelper.TryVisit(item)) yield break; foreach (var colProp in item.GetNavigationProperties().OfCollectionType()) { foreach (ITrackable child in colProp.EntityCollection) { foreach (var state in context.GetEntityStates(child, visitationHelper: visitationHelper)) { if (entityState == null || state == entityState) yield return state; } } } yield return context.Entry(item).State; }
public static ObjectState ConvertState(EntityState state) { switch (state) { case EntityState.Detached: return ObjectState.Unchanged; case EntityState.Unchanged: return ObjectState.Unchanged; case EntityState.Added: return ObjectState.Added; case EntityState.Deleted: return ObjectState.Deleted; case EntityState.Modified: return ObjectState.Modified; default: throw new ArgumentOutOfRangeException("state"); } }
/// <summary> /// Saves the current entity. /// </summary> /// <param name="db">The db context</param> /// <param name="state">The current entity state</param> public override void OnSave(DataContext db, System.Data.EntityState state) { if (db.Identity != Guid.Empty || Application.Current.UserProvider.IsAuthenticated || AllowAnonymous) { if (state == EntityState.Added) { if (Id == Guid.Empty) { Id = Guid.NewGuid(); } Created = Updated = DateTime.Now; CreatedById = UpdatedById = db.Identity != Guid.Empty ? db.Identity : Application.Current.UserProvider.UserId; } else if (state == EntityState.Modified) { Updated = DateTime.Now; UpdatedById = db.Identity != Guid.Empty ? db.Identity : Application.Current.UserProvider.UserId; } } else { throw new UnauthorizedAccessException("User must be logged in to save entity"); } }
private void After(DbEntityEntry item, EntityState state) { if (this.IsTargetEntity(item)) this.OnAfter(item, state); }
/// <summary> /// 1、恢复实体为默认状态。 /// 2、标记实体为不做任何数据库操作(仅对.Save()有效果) /// </summary> public void DeAttach() { this.isAttached = false; this.entityState = EntityState.Unchanged; }
/// <summary> /// 将实体置为指定状态 /// </summary> public void Attach(EntityState entityState) { this.entityState = entityState; }
public HookEntityMetadata(EntityState state) { _state = state; }
private void Current_collection_value_can_be_read_and_set(EntityState state) { using (var context = new F1Context()) { var engineEntry = context.Entry(GetTeamEntry(context).Entity.Engine); engineEntry.State = state; var collectionEntry = engineEntry.Collection(t => t.Gearboxes); var value = collectionEntry.CurrentValue; Assert.Same(engineEntry.Entity.Gearboxes, value); value = new List<Gearbox>(); collectionEntry.CurrentValue = value; Assert.Same(engineEntry.Entity.Gearboxes, value); context.ChangeTracker.DetectChanges(); value = collectionEntry.CurrentValue; Assert.Same(engineEntry.Entity.Gearboxes, value); collectionEntry.CurrentValue = null; Assert.Null(collectionEntry.CurrentValue); context.ChangeTracker.DetectChanges(); } }
private void TestPropertyValuePositiveForState(Func<DbPropertyEntry<Building, string>, string> getValue, Action<DbPropertyEntry<Building, string>, string> setValue, EntityState state) { using (var context = new AdvancedPatternsMasterContext()) { var building = context.Buildings.Single(b => b.Name == "Building One"); var entry = context.Entry(building); var propEntry = entry.Property(b => b.Name); entry.State = state; Assert.Equal("Building One", getValue(propEntry)); setValue(propEntry, "New Building"); Assert.Equal("New Building", getValue(propEntry)); } }
private void Current_reference_value_for_one_to_many_principal_can_be_read_and_set(EntityState state) { using (var context = new F1Context()) { var teamEntry = GetTeamEntry(context); teamEntry.State = state; var refEntry = teamEntry.Reference(t => t.Gearbox); var value = refEntry.CurrentValue; Assert.Same(teamEntry.Entity.Gearbox, value); value = new Gearbox { Id = -7 }; refEntry.CurrentValue = value; Assert.Same(teamEntry.Entity.Gearbox, value); if (state != EntityState.Detached && state != EntityState.Deleted) { // FK is fixed up without a call to DetectChanges Assert.Equal(teamEntry.Entity.GearboxId, value.Id); } if (state == EntityState.Deleted) { Assert.Throws<InvalidOperationException>(() => context.ChangeTracker.DetectChanges()). ValidateMessage("RelatedEnd_UnableToAddRelationshipWithDeletedEntity"); } else { context.ChangeTracker.DetectChanges(); } value = refEntry.CurrentValue; Assert.Same(teamEntry.Entity.Gearbox, value); refEntry.CurrentValue = null; Assert.Null(refEntry.CurrentValue); Assert.Null(teamEntry.Entity.Gearbox); if (state != EntityState.Detached) { // FK is fixed up without a call to DetectChanges // For Deleted state the FK should already have been null Assert.Null(teamEntry.Entity.GearboxId); } context.ChangeTracker.DetectChanges(); } }
private void Current_reference_value_for_independent_one_to_many_principal_can_be_read_and_set(EntityState state) { using (var context = new F1Context()) { var teamEntry = GetTeamEntry(context); teamEntry.State = state; var refEntry = teamEntry.Reference(t => t.Engine); var value = refEntry.CurrentValue; Assert.Same(teamEntry.Entity.Engine, value); value = new Engine(); refEntry.CurrentValue = value; Assert.Same(teamEntry.Entity.Engine, value); if (state == EntityState.Deleted) { Assert.Throws<InvalidOperationException>(() => context.ChangeTracker.DetectChanges()). ValidateMessage("RelatedEnd_UnableToAddRelationshipWithDeletedEntity"); } else { context.ChangeTracker.DetectChanges(); } value = refEntry.CurrentValue; Assert.Same(teamEntry.Entity.Engine, value); refEntry.CurrentValue = null; Assert.Null(refEntry.CurrentValue); Assert.Null(teamEntry.Entity.Engine); context.ChangeTracker.DetectChanges(); } }
private void Current_reference_value_for_one_to_one_principal_can_be_read_and_set(EntityState state) { using (var context = new F1Context()) { var chassisEntry = context.Entry(GetTeamEntry(context).Entity.Chassis); chassisEntry.State = state; var refEntry = chassisEntry.Reference(c => c.Team); var value = refEntry.CurrentValue; Assert.Same(chassisEntry.Entity.Team, value); if (state == EntityState.Unchanged || state == EntityState.Modified) { // Changing the reference to the principal will cause EF to throw a referential integrity exception // because it would need a change in the PK of the dependent. Assert.Throws<InvalidOperationException>(() => refEntry.CurrentValue = new Team()).ValidateMessage( "EntityReference_CannotChangeReferentialConstraintProperty"); } else { value = new Team(); refEntry.CurrentValue = value; Assert.Same(chassisEntry.Entity.Team, value); if (state == EntityState.Deleted) { Assert.Throws<InvalidOperationException>(() => context.ChangeTracker.DetectChanges()). ValidateMessage("RelatedEnd_UnableToAddRelationshipWithDeletedEntity"); } else { context.ChangeTracker.DetectChanges(); } value = refEntry.CurrentValue; Assert.Same(chassisEntry.Entity.Team, value); } refEntry.CurrentValue = null; Assert.Null(refEntry.CurrentValue); Assert.Null(chassisEntry.Entity.Team); context.ChangeTracker.DetectChanges(); } }
private void DbPropertyEntryTest(EntityState state, Action<DbEntityEntry<Building>> test) { using (var context = new AdvancedPatternsMasterContext()) { var entry = context.Entry(new Building { Name = "Building 18", Address = new Address { Street = "1 Microsoft Way", City = "Redmond", State = "WA", ZipCode = "98052", County = "KING", SiteInfo = new SiteInfo { Zone = 2, Environment = "Clean" } }, NotInModel = "NotInModel", }); entry.State = state; test(entry); } }
private void CheckPropertyIsModified(DbEntityEntry entityEntry, DbPropertyEntry propertyEntry, EntityState initialState) { if (initialState == EntityState.Modified || initialState == EntityState.Unchanged) { Assert.True(propertyEntry.IsModified); Assert.Equal(EntityState.Modified, entityEntry.State); } else { Assert.False(propertyEntry.IsModified); Assert.Equal(initialState, entityEntry.State); } }
public static void ChangeEntityState(EntityObject item, EntityState entityState) { EntityModelContainer context = GetContext(); context.ObjectStateManager.ChangeObjectState(item, entityState); }
protected abstract void OnAfter(DbEntityEntry item, EntityState state);
private static InternalEntityEntry CreateEntry( EntityState entityState, bool generateKeyValues = false, bool computeNonKeyValue = false) { var model = BuildModel(generateKeyValues, computeNonKeyValue); return RelationalTestHelpers.Instance.CreateInternalEntry(model, entityState, new T1 { Id = 1, Name = computeNonKeyValue ? null : "Test" }); }
public static void State(this ValidationContext context, EntityState state) { context.Items["state"] = state; }