/// <summary> /// Use this to query the database with LINQ. /// NOTE: Some operations may not be supported directly on the database. If you continue to /// get errors on a query, try doing .ToList() first and performing the query in memory. /// </summary> /// <typeparam name="T">The class of the object that you want to query.</typeparam> /// <returns>A LINQ query compatible object.</returns> public T Save <T>(ref T item) where T : class, IRepoData, new() { T retval = null; object oldItem = null; var setName = db.CreateObjectSet <T>().EntitySet.Name; EntityKey itemID = item.CastTo <EntityObject>().EntityKey ?? db.CreateEntityKey(setName, item); if (db.TryGetObjectByKey(itemID, out oldItem)) { var existingItem = oldItem.CastTo <T>(); if (oldItem.IsNotNull() && existingItem.Timestamp.DropMillisecods() > item.Timestamp.DropMillisecods()) { retval = existingItem; } else { item.Timestamp = DateTime.Now; db.ApplyCurrentValues(setName, item); } } else { item.Timestamp = DateTime.Now; db.AddObject(setName, item); } return(retval); }
private DbSyncEntry CreateAddedDbSyncEntry(ObjectStateEntry sourceEntry) { Contract.Assert(sourceEntry.IsRelationship == false); Contract.Assert(sourceEntry.State == EntityState.Added); var sourceEntity = sourceEntry.Entity; var sourceEntityKey = sourceEntry.EntityKey; if (_target.ObjectStateManager.TryGetObjectStateEntry(sourceEntityKey, out var targetEntry)) { return new DbSyncEntry(targetEntry.Entity, targetEntry.EntityKey) { SourceState = EntityState.Added, TargetState = targetEntry.State } } ; // clone, or activate new instance // TODO test cases var targetEntityKey = _target.CreateEntityKey(sourceEntry.EntitySet.Name, sourceEntity); var targetEntity = sourceEntity is ICloneable cloneable?cloneable.Clone() : Activator.CreateInstance(ObjectContext.GetObjectType(sourceEntity.GetType())); return(new DbSyncEntry(targetEntity, targetEntityKey) { SourceState = EntityState.Added, TargetState = EntityState.Detached }); }
private void AttachEntity(Object dataContext, Object entity, EntityState entityState) { ObjectContext objectContext = ((IObjectContextAdapter)dataContext).ObjectContext; EntityKey entityKey = objectContext.CreateEntityKey(EntitySetName, entity); ObjectStateEntry objectStateEntry; if (objectContext.ObjectStateManager.TryGetObjectStateEntry(entityKey, out objectStateEntry)) { if (entityState == EntityState.Modified) { objectStateEntry.ApplyCurrentValues(entity); } else { objectStateEntry.ChangeState(entityState); } } else { var context = (T)dataContext; IDbSet <TEntity> dbSet = _getEntitySet(context); dbSet.Attach((TEntity)entity); context.Entry(entity).State = entityState; } }
/// <summary> /// Gets the entity key updated. /// </summary> /// <param name="context">The context.</param> /// <param name="entry">The entry.</param> /// <param name="state">The state.</param> /// <param name="entitySetName">Name of the entity set.</param> /// <returns>returns key</returns> private string GetEntityKeyUpdated(ObjectContext context, DbEntityEntry entry, EntityState state, out string entitySetName) { var keyBuilder = new StringBuilder(); ObjectStateEntry newEntry = null; if (!context.ObjectStateManager.TryGetObjectStateEntry(entry.Entity, out newEntry)) { entitySetName = String.Empty; Trace.TraceInformation("Can't find state entry for \"{0}\"", entry.ToString()); return(null); } entitySetName = newEntry.EntitySet.Name; var keys = state == EntityState.Added ? context.CreateEntityKey(newEntry.EntitySet.Name, entry.Entity) : newEntry.EntityKey; foreach (var key in keys.EntityKeyValues) { if (keyBuilder.Length > 0) { keyBuilder.Append(","); } keyBuilder.Append(Convert.ToString(key.Value)); } return(keyBuilder.ToString()); }
public override void RemoveEntity(Object dataContext, ODataResourceBase entry) { var context = (T)dataContext; InitKey(context); ObjectContext objectContext = ((IObjectContextAdapter)context).ObjectContext; var entity = (TEntity)OeEdmClrHelper.CreateEntity(EntityType, entry); EntityKey entityKey = objectContext.CreateEntityKey(EntitySetName, entity); if (objectContext.ObjectStateManager.TryGetObjectStateEntry(entityKey, out ObjectStateEntry objectStateEntry)) { objectStateEntry.ChangeState(EntityState.Deleted); } else { if (_isCascade && !_isSelfReference) { context.Entry(entity).State = EntityState.Deleted; } else { var keyValues = new Object[entityKey.EntityKeyValues.Length]; for (int i = 0; i < keyValues.Length; i++) { keyValues[i] = entityKey.EntityKeyValues[i].Value; } IDbSet <TEntity> dbSet = _getEntitySet(context); context.Entry(dbSet.Find(keyValues)).State = EntityState.Deleted; } } }
public override void AttachEntity(Object dataContext, ODataResourceBase entry) { var entity = (TEntity)OeEdmClrHelper.CreateEntity(EntityType, entry); ObjectContext objectContext = ((IObjectContextAdapter)dataContext).ObjectContext; EntityKey entityKey = objectContext.CreateEntityKey(EntitySetName, entity); if (objectContext.ObjectStateManager.TryGetObjectStateEntry(entityKey, out ObjectStateEntry objectStateEntry)) { foreach (ODataProperty odataProperty in entry.Properties) { if (Array.Find(objectStateEntry.EntityKey.EntityKeyValues, k => k.Key == odataProperty.Name) == null) { int i = objectStateEntry.CurrentValues.GetOrdinal(odataProperty.Name); objectStateEntry.CurrentValues.SetValue(i, odataProperty.Value); } } } else { var context = (T)dataContext; _getEntitySet(context).Attach(entity); objectContext.ObjectStateManager.TryGetObjectStateEntry(entityKey, out objectStateEntry); foreach (ODataProperty odataProperty in entry.Properties) { if (Array.Find(objectStateEntry.EntityKey.EntityKeyValues, k => k.Key == odataProperty.Name) == null) { objectStateEntry.SetModifiedProperty(odataProperty.Name); } } } }
/// <summary> /// 修改token /// </summary> /// <param name="userName"></param> /// <param name="token"></param> /// <returns></returns> public bool ModifyToken(string userName, string token) { //以EF不跟踪状态获取对象 var user = Db.User.AsNoTracking().Where(u => u.Name == userName).FirstOrDefault(); user.Token = token; //判断该实体是否EF里的未跟踪状态 if (Db.Entry <User>(user).State == System.Data.Entity.EntityState.Detached) { //获取DbContext的对象上下文 ObjectContext objectContext = ((IObjectContextAdapter)Db).ObjectContext; //获取一个DbSet对象,用于操作该表 ObjectSet <User> entitySet = objectContext.CreateObjectSet <User>(); //获取当前要到数据库修改的对象的标识 EntityKey entityKey = objectContext.CreateEntityKey(entitySet.EntitySet.Name, user); //检查EF是否有跟这个主键相同的对象 object foundSet; bool exists = objectContext.TryGetObjectByKey(entityKey, out foundSet); //如果有,移除这个对象 if (exists) { objectContext.Detach(foundSet); //从上下文中移除 } } //将新的对象添加进行 Db.User.Attach(user); Db.Entry <User>(user).State = System.Data.Entity.EntityState.Modified; return(Db.SaveChanges() > 0); }
private ObjectStateEntry GetObjectStateEntry(TEntity entity) { ObjectStateEntry entry = null; context.ObjectStateManager.TryGetObjectStateEntry( context.CreateEntityKey(EntitySetName, entity), out entry); return(entry); }
// // original values // // Extension method for the ObjectContext which will create an object instance that is essentially equivalent // to the original object that was added or attached to the context before any changes were performed. // NOTE: This object will have no relationships--just the original value properties. public static object CreateOriginalValuesObject(this ObjectContext context, object source) { // Get the state entry of the source object // NOTE: For now we require the object to implement IEntityWithKey. // This is something we should be able to relax later. Debug.Assert(source is IEntityWithKey); EntityKey sourceKey = ((IEntityWithKey)source).EntityKey; // This method will throw if the key is null or an entry isn't found to match it. We // could throw nicer exceptions, but this will catch the important invalid cases. ObjectStateEntry sourceStateEntry = context.ObjectStateManager.GetObjectStateEntry(sourceKey); // Return null for added entities & throw an exception for detached ones. In other cases we can // always make a new object with the original values. switch (sourceStateEntry.State) { case EntityState.Added: return(null); case EntityState.Detached: throw new InvalidOperationException("Can't get original values when detached."); } // Create target object and add it to the context so that we can easily set properties using // the StateEntry. Since objects in the added state use temp keys, we know this won't // conflict with anything already in the context. object target = Activator.CreateInstance(source.GetType()); string fullEntitySetName = sourceKey.EntityContainerName + "." + sourceKey.EntitySetName; context.AddObject(fullEntitySetName, target); EntityKey targetKey = context.CreateEntityKey(fullEntitySetName, target); ObjectStateEntry targetStateEntry = context.ObjectStateManager.GetObjectStateEntry(targetKey); // Copy original values from the sourceStateEntry to the targetStateEntry. This will // cause the corresponding properties on the object to be set. for (int i = 0; i < sourceStateEntry.OriginalValues.FieldCount; i++) { // TODO: For best perf we should have a switch on the type here so that we could call // the type-specific methods and avoid boxing. targetStateEntry.CurrentValues.SetValue(i, sourceStateEntry.OriginalValues[i]); } // Detach the object we just created since we only attached it temporarily in order to use // the stateEntry. context.Detach(target); // Set the EntityKey property on the object (if it implements IEntityWithKey). IEntityWithKey targetWithKey = target as IEntityWithKey; if (targetWithKey != null) { targetWithKey.EntityKey = sourceKey; } return(target); }
public void DeleteEntity <EntityType>(ObjectContext objCtx, string entitySetName, EntityType newEntity) where EntityType : class { object oldObject = null; objCtx.TryGetObjectByKey(objCtx.CreateEntityKey(entitySetName, newEntity), out oldObject); if (oldObject != null) { objCtx.DeleteObject(oldObject); objCtx.SaveChanges(); } }
public void Update <TEntity>(TEntity entity) where TEntity : class { var fqen = GetEntityName <TEntity>(); object originalItem; EntityKey key = ObjectContext.CreateEntityKey(fqen, entity); if (ObjectContext.TryGetObjectByKey(key, out originalItem)) { ObjectContext.ApplyCurrentValues(key.EntitySetName, entity); } }
private static void Manter(ObjectContext context, string nomeTipo, Entidade item) { if (item.Id == 0) { context.AddObject(nomeTipo, item); } else { context.ApplyOriginalValues(nomeTipo, context.GetObjectByKey(context.CreateEntityKey(nomeTipo, item))); context.ApplyCurrentValues(nomeTipo, item); } }
/// <summary> /// Get entity /// </summary> /// <param name="element"></param> /// <returns></returns> public virtual TEntity Get(TEntity element) { ObjectContext context = null; Object foundEntity = null; context = ((IObjectContextAdapter)this._dbContext).ObjectContext; //var context = this.Context; var objSet = context.CreateObjectSet <TEntity>(); var entityKey = context.CreateEntityKey(objSet.EntitySet.Name, element); var exists = context.TryGetObjectByKey(entityKey, out foundEntity); return((TEntity)foundEntity); }
public void Update(T entity) { // use our method to get the entity set name var entityES = GetEntitySet(entity); // create the entity key var key = _context.CreateEntityKey(entityES.Name, entity); // retrieve and update the item _context.GetObjectByKey(key); _context.ApplyCurrentValues(entityES.Name, entity); _context.SaveChanges(); }
private bool Detached(T entity) { ObjectContext objectContext = ((IObjectContextAdapter)_dbContext).ObjectContext; ObjectSet <T> entitySet = objectContext.CreateObjectSet <T>(); EntityKey entityKey = objectContext.CreateEntityKey(entitySet.EntitySet.Name, entity); bool exists = objectContext.TryGetObjectByKey(entityKey, out object foundSet); if (exists) { objectContext.Detach(foundSet); } return(exists); }
/// <summary> /// 监测Context中的Entity是否存在,如果存在,将其Detach,防止出现问题 /// </summary> /// <param name="entity"></param> /// <returns></returns> private bool RemoveHoldingEntityInContext(T entity) { ObjectContext objContext = ((IObjectContextAdapter)_Context).ObjectContext; var objSet = objContext.CreateObjectSet <T>(); var entityKey = objContext.CreateEntityKey(objSet.EntitySet.Name, entity); object foundEntity; var exists = objContext.TryGetObjectByKey(entityKey, out foundEntity); if (exists) { objContext.Detach(foundEntity); } return(exists); }
public object[] GetKeyValues(object entity) { string esName; try { esName = GetEntitySetName(entity.GetType()); } catch (Exception ex) { throw new ArgumentException("EntitySet not found for type " + entity.GetType(), ex); } var key = ObjectContext.CreateEntityKey(esName, entity); var keyValues = key.EntityKeyValues.Select(km => km.Value).ToArray(); return(keyValues); }
/// <summary> /// 如果上下文中存在对象则移除 /// </summary> /// <param name="entity"></param> /// <returns></returns> public bool Exists(TEntity entity) { ObjectContext _ObjContext = ((IObjectContextAdapter)context).ObjectContext; ObjectSet <TEntity> _ObjSet = _ObjContext.CreateObjectSet <TEntity>(); var entityKey = _ObjContext.CreateEntityKey(_ObjSet.EntitySet.Name, entity); Object foundEntity; var exists = _ObjContext.TryGetObjectByKey(entityKey, out foundEntity); if (exists) { _ObjContext.Detach(foundEntity); } return(exists); }
public void Detach(T entity) { ObjectStateEntry entry = null; ObjectContext objCtx = ((IObjectContextAdapter)DbContext).ObjectContext; EntityContainer container = objCtx.MetadataWorkspace.GetEntityContainer(objCtx.DefaultContainerName, DataSpace.CSpace); EntitySetBase entitySet = container.BaseEntitySets.Where(item => item.ElementType.Name.Equals(typeof(T).Name)).FirstOrDefault(); EntityKey key = objCtx.CreateEntityKey(entitySet.Name, entity); if (objCtx.ObjectStateManager.TryGetObjectStateEntry(key, out entry)) { objCtx.Detach(entry.Entity); } }
public void Attach(ref T entityWithKey) { entityWithKey.EntityKey = objectContext.CreateEntityKey(typeof(T).Name, entityWithKey); object entityRef = entityWithKey; if (objectContext.TryGetObjectByKey(entityWithKey.EntityKey, out entityRef)) { entityWithKey = (T)entityRef; } else { objectContext.Attach(entityWithKey); } }
public void RegisterDirty <TEntidade>(TEntidade obj) where TEntidade : class { // Faz o select do item pela sua chave primária. var objNoContexto = ObjectContext.GetObjectByKey(ObjectContext.CreateEntityKey(ObjectContext.CreateObjectSet <TEntidade>().EntitySet.Name, obj)); if (ReferenceEquals(obj, objNoContexto)) { } // ... Não faz nada, pois o objeto no contexto já está alterado. else { // ...atualiza os valores escalares da instância no item informado. Entry((TEntidade)objNoContexto).CurrentValues.SetValues(obj); } }
/// <summary> /// 如果上下文中存在对象则移除 /// </summary> /// <param name="entity"></param> /// <returns></returns> private bool Exists(DbContext dbContext, T entity) { ObjectContext _ObjContext = ((IObjectContextAdapter)dbContext).ObjectContext; ObjectSet <T> _ObjSet = _ObjContext.CreateObjectSet <T>(); var entityKey = _ObjContext.CreateEntityKey(_ObjSet.EntitySet.Name, entity); Object foundEntity; var exists = _ObjContext.TryGetObjectByKey(entityKey, out foundEntity); // TryGetObjectByKey attaches a found entity // Detach it here to prevent side-effects if (exists) { _ObjContext.Detach(foundEntity); } return(exists); }
public static void Detach <T>(this DbContext context, T entity) where T : EntityBase { try { ObjectContext objContext = ((IObjectContextAdapter)context).ObjectContext; ObjectSet <T> objSet = objContext.CreateObjectSet <T>(); EntityKey entityKey = objContext.CreateEntityKey(objSet.EntitySet.Name, entity); object foundEntity = default(object); if (objContext.TryGetObjectByKey(entityKey, out foundEntity)) { objContext.Detach(foundEntity); } } catch (Exception) { } }
public static void Update(this ObjectContext context, string entitySetName, EntityObject entity) { if (entity.EntityKey == null) { entity.EntityKey = context.CreateEntityKey(entitySetName, entity); } if (entity.EntityState == System.Data.EntityState.Detached) { context.Attach(entity); } var stateEntry = context.ObjectStateManager.GetObjectStateEntry(entity.EntityKey); var propertyNameList = stateEntry.CurrentValues.DataRecordInfo.FieldMetadata.Select(pn => pn.FieldType.Name); foreach (var propName in propertyNameList) { stateEntry.SetModifiedProperty(propName); } }
/// <summary> /// Attach or update storage entity /// </summary> protected void AttachOrUpdate(object entity, System.Data.Entity.EntityState state) { if (entity == null) { throw new ArgumentNullException($"{nameof(entity)}", "Provided storage entity is null."); } ObjectContext context = ((IObjectContextAdapter)_context).ObjectContext; EntityKey key = context.CreateEntityKey(PluralEntity(entity), entity); if (context.ObjectStateManager.TryGetObjectStateEntry(key, out ObjectStateEntry entry)) { entry.ApplyCurrentValues(entity); } else { _context.Entry(entity).State = state; } }
public bool PersistEntity <EntityType>(ObjectContext objCtx, string entitySetName, EntityType newEntity) where EntityType : class { bool isNew = false; object oldObject = null; objCtx.TryGetObjectByKey(objCtx.CreateEntityKey(entitySetName, newEntity), out oldObject); if (oldObject == null) { objCtx.AddObject(entitySetName, newEntity); isNew = true; } else { objCtx.ApplyCurrentValues(entitySetName, newEntity); } objCtx.DetectChanges(); objCtx.SaveChanges(); return(isNew); }
/// <summary> /// Insert if new otherwise attach data into context /// </summary> /// <param name="entity"></param> public void AddOrAttach(TEntity entity) { // Define an ObjectStateEntry and EntityKey for the current object. EntityKey key; // Get the detached object's entity key. if (entity.EntityKey == null) { // Get the entity key of the updated object. //key = _ctx.CreateEntityKey(entity.GetType().Name, entity); key = _ctx.CreateEntityKey(GetEntitySetName(_ctx), entity); } else { key = entity.EntityKey; } try { // Get the original item based on the entity key from the context // or from the database. object originalItem; if (_ctx.TryGetObjectByKey(key, out originalItem)) {//accept the changed property if (originalItem is EntityObject && ((EntityObject)originalItem).EntityState != EntityState.Added) { // Call the ApplyPropertyChanges method to apply changes // from the updated item to the original version. //_ctx.ApplyPropertyChanges( // key.EntitySetName, entity); } } else {//add the new entity Add(entity); }//end else } catch (Exception ex) { throw ex; } }
private bool ExisteNoContexto(object objeto) { ObjectContext contexto = (this as IObjectContextAdapter).ObjectContext; Type entityType = ObjectContext.GetObjectType(objeto.GetType()); EntityContainer container = contexto.MetadataWorkspace. GetEntityContainer(contexto.DefaultContainerName, DataSpace.CSpace); EntitySetBase entitySet = container.BaseEntitySets. Where(s => s.ElementType.Name == entityType.Name).SingleOrDefault(); EntityKey key = contexto.CreateEntityKey(entitySet.Name, objeto); ObjectStateEntry entry; if (contexto.ObjectStateManager.TryGetObjectStateEntry(key, out entry)) { return(entry.State != EntityState.Detached); } return(false); }
/// <summary> /// Remove entity by keyValues /// </summary> /// <param name="keyValues">Key values</param> public void Remove(params object[] keyValues) { var item = Set.Create(); var itemType = typeof(T); var entityContainer = ObjectContext.MetadataWorkspace.GetEntityContainer(ObjectContext.DefaultContainerName, DataSpace.CSpace); var entitySetName = entityContainer.BaseEntitySets.First(b => b.ElementType.Name == itemType.Name).Name; var entityKey = ObjectContext.CreateEntityKey(entitySetName, item); var i = 0; foreach (var key in entityKey.EntityKeyValues) { itemType.GetProperty(key.Key).SetValue(item, keyValues[i], null); i++; } Set.Attach(item); ObjectContext.ObjectStateManager.ChangeObjectState(item, EntityState.Deleted); }
public static void ApplyDetachedPropertyChanges <T>(this ObjectContext db, T entity, Func <T, int> getIdDelegate) where T : EntityObject { var entitySetName = db.DefaultContainerName + "." + entity.GetType().Name; T newEntity = Activator.CreateInstance <T>(); newEntity.EntityKey = db.CreateEntityKey(entitySetName, entity); Type t = typeof(T); foreach (EntityKeyMember keyMember in newEntity.EntityKey.EntityKeyValues) { PropertyInfo p = t.GetProperty(keyMember.Key); p.SetValue(newEntity, keyMember.Value, null); } db.Attach(newEntity); //db.AcceptAllChanges(); db.ApplyPropertyChanges(entitySetName, entity); }
/// <summary> /// Gets the entity key updated. /// </summary> /// <param name="context">The context.</param> /// <param name="entry">The entry.</param> /// <param name="state">The state.</param> /// <param name="entitySetName">Name of the entity set.</param> /// <returns>returns key</returns> private string GetEntityKeyUpdated(ObjectContext context, DbEntityEntry entry, EntityState state, out string entitySetName) { var keyBuilder = new StringBuilder(); ObjectStateEntry newEntry = null; if (!context.ObjectStateManager.TryGetObjectStateEntry(entry.Entity, out newEntry)) { entitySetName = String.Empty; Trace.TraceInformation("Can't find state entry for \"{0}\"", entry.ToString()); return null; } entitySetName = newEntry.EntitySet.Name; var keys = state == EntityState.Added ? context.CreateEntityKey(newEntry.EntitySet.Name, entry.Entity) : newEntry.EntityKey; foreach (var key in keys.EntityKeyValues) { if (keyBuilder.Length > 0) { keyBuilder.Append(","); } keyBuilder.Append(Convert.ToString(key.Value)); } return keyBuilder.ToString(); }