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(); } }
protected override bool ResolveConflicts(IEnumerable <DbEntityEntry> conflicts) { ObjectContext objectContext = ((IObjectContextAdapter)this.DbContext).ObjectContext; ObjectStateManager objectStateManager = objectContext.ObjectStateManager; foreach (DbEntityEntry entityEntry in conflicts) { ObjectStateEntry stateEntry = objectStateManager.GetObjectStateEntry(entityEntry.Entity); if (entityEntry.State == EntityState.Detached || stateEntry.IsRelationship) { continue; } Type entityType = stateEntry.Entity.GetType(); if (entityType == typeof(Product)) { if (!this.ResolveProductConflict(entityEntry)) { return(false); } } } return(true); }
public void CommitAndRefreshChanges() { try { Commit(); } catch (OptimisticConcurrencyException ex) { //if client wins refresh data ( queries database and adapt original values //and re-save changes in client Refresh(RefreshMode.ClientWins, ex.StateEntries.Select(se => se.Entity)); SaveChanges(); //accept all changes in STE entities attached in context var steEntities = (from entry in ObjectStateManager.GetObjectStateEntries(~EntityState.Detached) where entry.Entity != null && (entry.Entity as IObjectWithChangeTracker != null) select entry.Entity as IObjectWithChangeTracker); steEntities.ToList().ForEach(ste => ste.MarkAsUnchanged()); } }
public override void ChangeState(EntityState state) { EntityUtil.CheckValidStateForChangeRelationshipState(state, "state"); if (State == EntityState.Detached && state == EntityState.Detached) { return; } ValidateState(); if (RelationshipWrapper.Key0 == Key0) { ObjectStateManager.ChangeRelationshipState( Key0, Key1, RelationshipWrapper.AssociationSet.ElementType.FullName, RelationshipWrapper.AssociationEndMembers[1].Name, state); } else { Debug.Assert(RelationshipWrapper.Key0 == Key1, "invalid relationship"); ObjectStateManager.ChangeRelationshipState( Key0, Key1, RelationshipWrapper.AssociationSet.ElementType.FullName, RelationshipWrapper.AssociationEndMembers[0].Name, state); } }
public IEnumerable <T> ManagedEntities <T>() { var oses = ObjectStateManager.GetObjectStateEntries(); return(oses.Where(entry => entry.Entity is T) .Select(entry => (T)entry.Entity)); }
/// <summary> /// откатывам все изменения в контексте, /// </summary> public void Rollback() { ServerAction = true; //detaching all added entities var addedEntities = ObjectStateManager.GetObjectStateEntries(EntityState.Added); foreach (var objectStateEntry in addedEntities) { Detach(objectStateEntry.Entity); } var deletedEntities = ObjectStateManager.GetObjectStateEntries(EntityState.Deleted); //apply origin value for all modified entities foreach (var objectStateEntry in deletedEntities) { if (objectStateEntry.Entity != null) { ObjectStateManager.ChangeObjectState(objectStateEntry.Entity, EntityState.Modified); } } //apply origin value for all modified entities var modifiedEntities = ObjectStateManager.GetObjectStateEntries(EntityState.Modified); foreach (var objectStateEntry in modifiedEntities) { RevertEntityScalars((EntityObject)objectStateEntry.Entity); } //set state for every changed entities in unchanged AcceptAllChanges(); ServerAction = false; }
/// <summary> /// универсальный *перегруженный метод /// </summary> public new bool SaveChanges() { try { IEnumerable <ObjectStateEntry> addedEntities = ObjectStateManager.GetObjectStateEntries(EntityState.Added); IEnumerable <ObjectStateEntry> deletedEntities = ObjectStateManager.GetObjectStateEntries(EntityState.Deleted); ServerAction = true; ((ObjectContext)this).SaveChanges(); addedEntities.ToList(); deletedEntities.ToList(); addedEntities = null; deletedEntities = null; ServerAction = false; if (SavedChanges != null) { SavedChanges(this, null); } return(true); } catch (UpdateException e) { Exception showException = e.InnerException ?? e; LoggerContext.Instance.AddError(showException); if (ShowError) { MessageBox.Show(showException.Message); } LastError = showException; Rollback(); return(false); } }
private IEnumerable <TCommandTree> GenerateAssociation <TCommandTree>( string associationIdentity, EntityState state) where TCommandTree : DbCommandTree { AssociationType associationType = this._metadataWorkspace.GetItem <AssociationType>(associationIdentity, DataSpace.CSpace); using (DbContext context = this.CreateContext()) { EntityType sourceEntityType = associationType.SourceEnd.GetEntityType(); object sourceEntity = this.InstantiateAndAttachEntity(sourceEntityType, context); EntityType targetEntityType = associationType.TargetEnd.GetEntityType(); object targetEntity = sourceEntityType.GetRootType() == targetEntityType.GetRootType() ? sourceEntity : this.InstantiateAndAttachEntity(targetEntityType, context); ObjectStateManager objectStateManager = ((IObjectContextAdapter)context).ObjectContext.ObjectStateManager; objectStateManager.ChangeRelationshipState(sourceEntity, targetEntity, associationType.FullName, associationType.TargetEnd.Name, state == EntityState.Deleted ? state : EntityState.Added); using (CommandTracer commandTracer = new CommandTracer(context)) { context.SaveChanges(); foreach (DbCommandTree commandTree in commandTracer.CommandTrees) { yield return((TCommandTree)commandTree); } } } }
private void SavingChangesHandler(object sender, EventArgs e) { var errorBuilder = new StringBuilder(); foreach (var entry in ObjectStateManager.GetObjectStateEntries( EntityState.Added | EntityState.Modified)) { var entity = entry.Entity as IDataErrorInfo; if (entity != null) { string error = entity.Validate(); if (!string.IsNullOrEmpty(error)) { //errorBuilder.AppendInNewLine(string.Format(CultureInfo.CurrentCulture, Resources.EntityInvalid, // EntityToString(entity), error)); Debug.Assert(false); } } } string errorMessage = errorBuilder.ToString(); if (!string.IsNullOrEmpty(errorMessage)) { throw new ValidationException(errorMessage); } }
public override int SaveChanges(SaveOptions options) { try { var now = DateTime.UtcNow; var entities = ObjectStateManager.GetObjectStateEntries(EntityState.Added | EntityState.Modified) .Select(e => e.Entity) .OfType <IHasEntryTimeStamp>(); foreach (var entry in entities) { // IHasEntryTimeStamp lastModified = entry as IHasEntryTimeStamp; //if (lastModified != null) entry.EntryTimeStamp = now; } return(base.SaveChanges(options)); } catch (UpdateException u) { throw; } catch (Exception ex) { throw; } }
public void RefreshAllModifiedObjects(bool ignoreExceptions = true) { IEnumerable <ObjectStateEntry> objectStates = ObjectStateManager.GetObjectStateEntries(EntityState.Modified); Refresh(RefreshMode.StoreWins, objectStates.Where(item => !item.IsRelationship).Select(item => item.Entity)); }
public void Handle(SaveExpression notification) { StudentExpression studentExpression = _dbContext.StudentExpressions .Where(e => e.StudentId.Equals(notification.StudentId)) .SingleOrDefault(e => e.Type == notification.Type) ?? new StudentExpression { Type = notification.Type }; studentExpression.StudentId = notification.StudentId; studentExpression.Text = notification.Text; if (studentExpression.Id == default(int)) { _dbContext.StudentExpressions.Add(studentExpression); } else { ObjectStateManager objectStateManager = ((IObjectContextAdapter)_dbContext).ObjectContext.ObjectStateManager; _dbContext.StudentExpressions.Attach(studentExpression); objectStateManager.ChangeObjectState(studentExpression, EntityState.Modified); } _dbContext.SaveChanges(); }
public override int SaveChanges(System.Data.Objects.SaveOptions options) { foreach (ObjectStateEntry entry in ObjectStateManager.GetObjectStateEntries(EntityState.Added | EntityState.Modified)) { dynamic e = entry.Entity; if (entry.State == EntityState.Added) { try { e.CreatedDate = DateTime.Now; e.CreatedBy = OAMSSetting.Username; } catch (Exception) { } } try { e.LastUpdatedDate = DateTime.Now; e.LastUpdatedBy = OAMSSetting.Username; } catch (Exception) { } // Validate the objects in the Added and Modified state // if the validation fails throw an exeption. } return(base.SaveChanges(options)); }
private ObjectStateEntry GetEntityEntryFromRelation(ObjectStateEntry relationEntry, int index) { var firstKey = (EntityKey)relationEntry.OriginalValues[index]; ObjectStateEntry entry = ObjectStateManager.GetObjectStateEntry(firstKey); return(entry); }
public override void OnBeforeInsert(DbContext dbContext, ObjectStateManager manager, IVersion item) { base.OnBeforeInsert(dbContext, manager, item); item.VersionNo = 1; item.Key = Guid.NewGuid(); item.IsObsolete = false; }
private void IncludeEntityKey(bool doAttach) { ObjectStateManager objectStateManager = this.ObjectContext.ObjectStateManager; bool flag1 = false; bool flag2 = false; EntityEntry entityEntry = objectStateManager.FindEntityEntry(this.DetachedEntityKey); if (entityEntry == null) { flag2 = true; flag1 = true; } else if (entityEntry.IsKeyEntry) { if (this.FromEndMember.RelationshipMultiplicity != RelationshipMultiplicity.Many) { foreach (RelationshipEntry relationshipEntry in this.ObjectContext.ObjectStateManager.FindRelationshipsByKey(this.DetachedEntityKey)) { if (relationshipEntry.IsSameAssociationSetAndRole((AssociationSet)this.RelationshipSet, (AssociationEndMember)this.ToEndMember, this.DetachedEntityKey) && relationshipEntry.State != EntityState.Deleted) { throw new InvalidOperationException(Strings.ObjectStateManager_EntityConflictsWithKeyEntry); } } } flag1 = true; } else { IEntityWrapper wrappedEntity = entityEntry.WrappedEntity; if (entityEntry.State == EntityState.Deleted) { throw new InvalidOperationException(Strings.RelatedEnd_UnableToAddRelationshipWithDeletedEntity); } RelatedEnd relatedEndInternal = wrappedEntity.RelationshipManager.GetRelatedEndInternal(this.RelationshipName, this.RelationshipNavigation.From); if (this.FromEndMember.RelationshipMultiplicity != RelationshipMultiplicity.Many && !relatedEndInternal.IsEmpty()) { throw new InvalidOperationException(Strings.ObjectStateManager_EntityConflictsWithKeyEntry); } this.Add(wrappedEntity, true, doAttach, false, true, true); objectStateManager.TransactionManager.PopulatedEntityReferences.Add((EntityReference)this); } if (!flag1 || this.IsForeignKey) { return; } if (flag2) { EntitySet entitySet = this.DetachedEntityKey.GetEntitySet(this.ObjectContext.MetadataWorkspace); objectStateManager.AddKeyEntry(this.DetachedEntityKey, entitySet); } EntityKey entityKey = this.WrappedOwner.EntityKey; if ((object)entityKey == null) { throw Error.EntityKey_UnexpectedNull(); } RelationshipWrapper wrapper = new RelationshipWrapper((AssociationSet)this.RelationshipSet, this.RelationshipNavigation.From, entityKey, this.RelationshipNavigation.To, this.DetachedEntityKey); objectStateManager.AddNewRelation(wrapper, doAttach ? EntityState.Unchanged : EntityState.Added); }
public new int SaveChanges() { foreach (ObjectStateEntry entry in ObjectStateManager.GetObjectStateEntries(EntityState.Added)) { Type targetType = entry.Entity.GetType(); PropertyInfo[] pInfoList; if (Dict.ContainsKey(targetType)) { pInfoList = Dict[targetType]; } else { pInfoList = targetType.GetProperties(BindingFlags.Public | BindingFlags.Instance); } foreach (PropertyInfo pInfo in pInfoList) { if (pInfo.Name.Equals("InsertDate") || pInfo.Name.Equals("UpdateDate") || pInfo.Name.Equals("AccessDate") || pInfo.Name.Equals("RegistDate") || pInfo.Name.Equals("RegisterDateTime")) { pInfo.SetValue(entry.Entity, CurrentInfoHolder.GetBoundDateTime(), null); } else if (pInfo.Name.Equals("InsertUser") || pInfo.Name.Equals("UpdateUser") || pInfo.Name.Equals("RegisterSystem")) { pInfo.SetValue(entry.Entity, CurrentInfoHolder.GetBoundUser(), null); } else if (pInfo.Name.Equals("VersionNo") || pInfo.Name.Equals("Version")) { pInfo.SetValue(entry.Entity, 1, null); } } } return(base.SaveChanges()); }
public override int SaveChanges(SaveOptions options) { foreach (ObjectStateEntry relationEntry in ObjectStateManager .GetObjectStateEntries(EntityState.Deleted) .Where(e => e.IsRelationship)) { var entry = GetEntityEntryFromRelation(relationEntry, 0); // Find representation of the relation IRelatedEnd relatedEnd = entry.RelationshipManager .GetAllRelatedEnds() .First(r => r.RelationshipSet == relationEntry.EntitySet); RelationshipType relationshipType = relatedEnd.RelationshipSet.ElementType; if (!SkipDeletion(relationshipType)) { // Now we know that model is inconsistent and entity on many side must be deleted if (!(relatedEnd is EntityReference)) // related end is many side { entry = GetEntityEntryFromRelation(relationEntry, 1); } if (entry.State != EntityState.Deleted) { context.DeleteObject(entry.Entity); } } } return(base.SaveChanges()); }
/// <summary> /// 获取数据上下文的变更日志信息 /// </summary> public static IEnumerable <DataLog> GetEntityDataLogs(this DbContext dbContext, IServiceProvider provider) { if (provider == null) { return(Enumerable.Empty <DataLog>()); } IEntityInfoHandler entityInfoHandler = provider.GetService <IEntityInfoHandler>(); if (entityInfoHandler == null) { return(Enumerable.Empty <DataLog>()); } ObjectContext objectContext = ((IObjectContextAdapter)dbContext).ObjectContext; ObjectStateManager manager = objectContext.ObjectStateManager; IEnumerable <DataLog> logs = from entry in manager.GetObjectStateEntries(EntityState.Added).Where(entry => entry.Entity != null) let entityInfo = entityInfoHandler.GetEntityInfo(entry.Entity.GetType()) where entityInfo != null && entityInfo.DataLogEnabled select GetAddedLog(entry, entityInfo); logs = logs.Concat(from entry in manager.GetObjectStateEntries(EntityState.Modified).Where(entry => entry.Entity != null) let entityInfo = entityInfoHandler.GetEntityInfo(entry.Entity.GetType()) where entityInfo != null && entityInfo.DataLogEnabled select GetModifiedLog(entry, entityInfo)); logs = logs.Concat(from entry in manager.GetObjectStateEntries(EntityState.Deleted).Where(entry => entry.Entity != null) let entityInfo = entityInfoHandler.GetEntityInfo(entry.Entity.GetType()) where entityInfo != null && entityInfo.DataLogEnabled select GetDeletedLog(entry, entityInfo)); return(logs); }
public void Handle(SavePicture notification) { if (!notification.HasImage()) { throw new InvalidOperationException("No Image was uploaded."); } StudentPicture studentPicture = _dbContext.StudentPictures .Where(e => e.StudentId.Equals(_currentUser.User.Id)) .SingleOrDefault(e => e.ImageType == notification.Type) ?? new StudentPicture { ImageType = notification.Type }; studentPicture.StudentId = _currentUser.User.Id; studentPicture.DateSubmitted = DateTime.Now; studentPicture.ImageName = notification.FileName; studentPicture.ImageData = notification.ImageData; studentPicture.MimeType = notification.MimeType; if (studentPicture.Id == default(int)) { _dbContext.StudentPictures.Add(studentPicture); } else { ObjectStateManager objectStateManager = ((IObjectContextAdapter)_dbContext).ObjectContext.ObjectStateManager; _dbContext.StudentPictures.Attach(studentPicture); objectStateManager.ChangeObjectState(studentPicture, EntityState.Modified); } _dbContext.SaveChanges(); }
public void RollbackChanges() { IEnumerable <object> itemsToRefresh = ObjectStateManager.GetObjectStateEntries(EntityState.Modified) .Where(ose => !ose.IsRelationship && ose.Entity != null) .Select(ose => ose.Entity); Refresh(RefreshMode.StoreWins, itemsToRefresh); }
public void GetChanges(ObjectStateManager Entities) { var entries = Entities.GetObjectStateEntries(EntityState.Added | EntityState.Modified | EntityState.Deleted); foreach (var Item in entries) { } }
public void OnSavingChanges(object sender, System.EventArgs e) { var stateManager = ((AdventureWorksLTEntities)sender).ObjectStateManager; var changedEntities = ObjectStateManager.GetObjectStateEntries(EntityState.Modified | EntityState.Added); // validation check logic throw new ValidationException("Something went wrong."); }
// ObjectStateEntry will not be detached and creation will be handled from ObjectStateManager internal ObjectStateEntry(ObjectStateManager cache, EntitySet entitySet, EntityState state) { //Contract.Requires(cache != null); _cache = cache; _entitySet = entitySet; _state = state; }
// ObjectStateEntry will not be detached and creation will be handled from ObjectStateManager internal ObjectStateEntry(ObjectStateManager cache, EntitySet entitySet, EntityState state) { DebugCheck.NotNull(cache); _cache = cache; _entitySet = entitySet; _state = state; }
internal IEntityWrapper WrapEntityUsingStateManager( object entity, ObjectStateManager stateManager) { EntityEntry existingEntry; return(this.WrapEntityUsingStateManagerGettingEntry(entity, stateManager, out existingEntry)); }
public WidgetDataContext(string contextString) : base(contextString) { _widgetManager = new ObjectStateManager<Widget>(); _widgetGateway = new DirectoryGateway<Widget>(base.ContextString, new WidgetMapper()); LoadData(); }
// ObjectStateEntry will not be detached and creation will be handled from ObjectStateManager internal ObjectStateEntry(ObjectStateManager cache, EntitySet entitySet, EntityState state) { Debug.Assert(cache != null, "cache cannot be null."); _cache = cache; _entitySet = entitySet; _state = state; }
/// <summary> /// Private extension method for ObjectStateManager class /// Dump all tracking info to a string /// </summary> /// <param name="manager">ObjectStateManager</param> /// <param name="objectStateEntries">Collection of ObjectStateEntries. If null, then all entities will be displayed</param> /// <param name="entityKey">EntityKey of given entity. If null, then all entities will be displayed</param> /// <param name="asHtml">Output string as HTML</param> /// <returns>String with tracking info about entries</returns> private static string Dump( ObjectStateManager manager, IEnumerable<ObjectStateEntry> objectStateEntries, EntityKey entityKey, bool asHtml) { StringBuilder dump = new StringBuilder(); if (entityKey != null) { objectStateEntries = new List<ObjectStateEntry>(); (objectStateEntries as List<ObjectStateEntry>).Add(manager.GetObjectStateEntry(entityKey)); } else if (objectStateEntries == null) { objectStateEntries = manager.GetObjectStateEntries(~EntityState.Detached); } dump.AppendFormat("ObjectStateManager entries : # {0}\n", objectStateEntries.Count()); foreach (var entry in objectStateEntries) { dump.Append(ObjectStateEntryToString(entry)); if (entry.State == EntityState.Added) { for (int i = 0; i < entry.CurrentValues.FieldCount; i++) { dump.AppendFormat("\n\t- {0} = {1}", entry.CurrentValues.GetName(i), ObjectToString(entry.CurrentValues[i])); } } else if (entry.State == EntityState.Modified) { foreach (string prop in entry.GetModifiedProperties()) { dump.AppendFormat("\n\t- {0} : {1} -> {2}", prop, ObjectToString(entry.OriginalValues[prop]), ObjectToString(entry.CurrentValues[prop])); } } } if (asHtml) { dump.Replace("\n", "<br />"); dump.Replace("\t", " "); } else { dump.Replace("<b>", ""); dump.Replace("</b>", ""); } return dump.ToString(); }
/// <summary> /// Private extension method for ObjectStateManager class /// Dump all tracking info to a string /// </summary> /// <param name="manager">ObjectStateManager</param> /// <param name="objectStateEntries">Collection of ObjectStateEntries. If null, then all entities will be displayed</param> /// <param name="entityKey">EntityKey of given entity. If null, then all entities will be displayed</param> /// <param name="asHtml">Output string as HTML</param> /// <returns>String with tracking info about entries</returns> private static string Dump( ObjectStateManager manager, IEnumerable <ObjectStateEntry> objectStateEntries, EntityKey entityKey, bool asHtml) { StringBuilder dump = new StringBuilder(); if (entityKey != null) { objectStateEntries = new List <ObjectStateEntry>(); (objectStateEntries as List <ObjectStateEntry>).Add(manager.GetObjectStateEntry(entityKey)); } else if (objectStateEntries == null) { objectStateEntries = manager.GetObjectStateEntries(~EntityState.Detached); } dump.AppendFormat("ObjectStateManager entries : # {0}\n", objectStateEntries.Count()); foreach (var entry in objectStateEntries) { dump.Append(ObjectStateEntryToString(entry)); if (entry.State == EntityState.Added) { for (int i = 0; i < entry.CurrentValues.FieldCount; i++) { dump.AppendFormat("\n\t- {0} = {1}", entry.CurrentValues.GetName(i), ObjectToString(entry.CurrentValues[i])); } } else if (entry.State == EntityState.Modified) { foreach (string prop in entry.GetModifiedProperties()) { dump.AppendFormat("\n\t- {0} : {1} -> {2}", prop, ObjectToString(entry.OriginalValues[prop]), ObjectToString(entry.CurrentValues[prop])); } } } if (asHtml) { dump.Replace("\n", "<br />"); dump.Replace("\t", " "); } else { dump.Replace("<b>", ""); dump.Replace("</b>", ""); } return(dump.ToString()); }
GetObjectStateEntries <TEntity>(this ObjectStateManager osm, EntityState state) { var typeEntries = from entry in osm.GetObjectStateEntries(state) where entry.Entity is TEntity select entry; return(typeEntries); }
public static IEnumerable <ObjectStateEntry> GetObjectStateEntries(this ObjectStateManager osm) { var typeEntries = from entry in osm.GetObjectStateEntries (EntityState.Added | EntityState.Deleted | EntityState.Modified | EntityState.Unchanged) select entry; return(typeEntries); }
internal RelationshipEntry( ObjectStateManager cache, EntityState state, RelationshipWrapper relationshipWrapper) : base(cache, (EntitySet)null, state) { this._entitySet = (EntitySetBase)relationshipWrapper.AssociationSet; this._relationshipWrapper = relationshipWrapper; }
/// <summary> /// Attaches to the ObjectContext's events. /// </summary> /// <param name="objectContext">The ObjectContext.</param> public void AttachToEvents(IAuditableObjectContext objectContext) { var entityContext = objectContext as ObjectContext; if (entityContext != null) { entityContext.SavingChanges += new EventHandler(EntityContext_SavingChanges); entityContext.ObjectMaterialized += new ObjectMaterializedEventHandler(EntityContext_ObjectMaterialized); _objectStateManager = entityContext.ObjectStateManager; } }
internal RelationshipEntry(ObjectStateManager cache, EntityState state, RelationshipWrapper relationshipWrapper) : base(cache, null, state) { Debug.Assert(null != relationshipWrapper, "null RelationshipWrapper"); Debug.Assert(EntityState.Added == state || EntityState.Unchanged == state || EntityState.Deleted == state, "invalid EntityState"); base._entitySet = relationshipWrapper.AssociationSet; _relationshipWrapper = relationshipWrapper; }
/// <summary> /// 动态设置实体字段的值 /// </summary> /// <param name="entry">ObjectStateEntry 实体封装对象</param> /// <param name="osm">对象缓冲</param> /// <param name="FieldName">字段名</param> /// <param name="EDMType">字段类型</param> /// <param name="Value">字段值</param> internal static void FixupModifiedDates(this ObjectStateEntry entry, ObjectStateManager osm, string FieldName, PrimitiveTypeKind EDMType, object Value) { var fieldMetaData = entry.CurrentValues.DataRecordInfo.FieldMetadata; FieldMetadata modifiedField = fieldMetaData .Where(f => f.FieldType.Name == FieldName) .FirstOrDefault(); if (modifiedField.FieldType != null) { string fieldTypeName = modifiedField.FieldType.TypeUsage.EdmType.Name; if (fieldTypeName == EDMType.ToString()) { entry.CurrentValues.SetValue(modifiedField.Ordinal, Value); } } }
virtual internal void Reset() { _cache = null; _entitySet = null; _state = EntityState.Detached; }
/// <summary> /// Keep the member list synchronized with the one that is saved to database. /// </summary> /// <param name="objectStateManager"></param> private static void RefreshMembersListTask(ObjectStateManager objectStateManager) { using(new DebugTimer("Refresh members list")) { IEnumerable<ObjectStateEntry> addedEntries = objectStateManager.GetObjectStateEntries(System.Data.EntityState.Added); IEnumerable<ObjectStateEntry> deletedEntries = objectStateManager.GetObjectStateEntries(System.Data.EntityState.Deleted); IEnumerable<ObjectStateEntry> modifiedEntries = objectStateManager.GetObjectStateEntries(System.Data.EntityState.Modified); HandleAddedMembers(addedEntries); HandleDeletedMembers(deletedEntries); HandleModifiedMembers(modifiedEntries); Debug.Print("Got {0} added, {1} deleted and {2} modified members", addedEntries.Count(), deletedEntries.Count(), modifiedEntries.Count()); } if (RefreshFinished != null) RefreshFinished(null, null); }
private static void ChangeStateOfEntity(ObjectStateManager objectStateManager, EntityWithId entity) { // TODO: Check for changs or deleted before moving this to Added/Modified objectStateManager.ChangeObjectState(entity, entity.Id == 0 ? EntityState.Added : EntityState.Modified); }