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));
}
// 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;
}
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;
}
// 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);
}
