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