項目使用Entity Framework用到的公共操作方法基類(Repository)及其使用

在項目中會有很多常用的操作方法如添加、刪除、修改等，而在使用EF時雖然已是ORM，但仍然會習慣性的在業務層寫大量類似方法，為此，分享一個我在項目使用的公共基類，經過多次修改，已在mssql和oracle數據庫項目上使用沒問題。希望對使用EF開發項目的朋友有幫助，不是說寫的有多好，只是為了分享，因為我在使用EF之初也一直在找這樣一個類但資源很少。 歡迎拍磚，不要傷人就行。。。

以下是 Repository.cs源碼 :

using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Data.Objects;
using System.Data.Common;
using System.Transactions;

namespace System.Data.Entity
{
    public class Repository<TEntity> : IDisposable where TEntity : class
    {
        #region 私有屬性
        private ObjectContext objectContext;
        private string entitySetName;
        private string keyProperty = "ID";
        private string keyPropertyType = "Int32";
        #endregion

        #region 公共屬性
        /// <summary>
        /// 獲得提供用於查詢和使用對象形式的實體數據功能
        /// </summary>
        protected ObjectContext ObjContext
        {
            get
            {
                if (this.objectContext == null)
                {
                    throw new Exception("數據庫對象為空");
                }
                if (this.objectContext.Connection.State == System.Data.ConnectionState.Closed)
                {
                    this.objectContext.Connection.Open(); //如果關閉則打開
                }
                return this.objectContext;
            }
            set
            {
                this.objectContext = value;
                objectContext.MetadataWorkspace.LoadFromAssembly(typeof(TEntity).Assembly);
            }
        }
        /// <summary>
        /// 實體名字
        /// </summary>
        public string EntitySetName
        {
            get { return this.entitySetName; }
        }
        /// <summary>
        /// 主鍵字段名
        /// </summary>
        public string KeyProperty
        {
            get { return this.keyProperty; }
        }
        /// <summary>
        /// 主鍵字段類型
        /// </summary>
        public string KeyPropertyType
        {
            get { return this.keyPropertyType; }
        }
        #endregion

        #region objectContext
        /// <summary>
        /// 
        /// </summary>
        public Repository()
            : this(null)
        {
        }
        /// <summary>
        /// 用指定上下文構造新的實例
        /// </summary>
        /// <param name="objectContext">特定的上下文實例</param>
        public Repository(ObjectContext objectContext)
        {
            if (objectContext != null) //也可以構造后再指定數據庫
            {
                this.objectContext = objectContext; //指定數據庫
            }

            Type entityType = typeof(TEntity);
            //表名
            this.entitySetName = entityType.Name;
            //主鍵
            foreach (var prop in entityType.GetProperties())
            {
                var attr = prop.GetCustomAttributes(typeof(System.Data.Objects.DataClasses.EdmScalarPropertyAttribute), false).FirstOrDefault() as System.Data.Objects.DataClasses.EdmScalarPropertyAttribute;
                if (attr != null && attr.EntityKeyProperty)
                {
                    this.keyProperty = prop.Name;
                    this.keyPropertyType = prop.PropertyType.Name;
                    break;
                }
            }

            if (objectContext != null)
            {
                objectContext.MetadataWorkspace.LoadFromAssembly(typeof(TEntity).Assembly);
            }
        }
        /// <summary>
        /// 釋放對象上下文使用的資源
        /// </summary>
        public void Dispose()
        {
            CloseObjectContext();
        }
        /// <summary>
        /// 釋放ObjectContext連接
        /// </summary>
        public void CloseObjectContext()
        {
            if (objectContext != null )
            {
                if (objectContext.Connection.State == ConnectionState.Open)
                {
                    objectContext.Connection.Close();
                }
                objectContext.Dispose();
            }
        }
        #endregion

        #region Find 條件表達式查詢
        /// <summary>
        /// 所有數據的查詢列表
        /// </summary>
        /// <returns></returns>
        public IQueryable<TEntity> FindAll()
        {
            return objectContext.CreateObjectSet<TEntity>().AsQueryable();
        }

        /// <summary>
        /// 根據指定條件表達式得到數據查詢列表
        /// </summary>
        /// <param name="exp">條件表達式</param>
        /// <returns></returns>
        public IQueryable<TEntity> FindAll(Expression<Func<TEntity, bool>> exp)
        {
            return objectContext.CreateObjectSet<TEntity>().Where(exp);
        }

        /// <summary>
        /// 根據指定條件表達式得到數據實體
        /// </summary>
        /// <param name="exp">條件表達式</param>
        /// <returns></returns>
        public TEntity Find(Expression<Func<TEntity, bool>> exp)
        {
            return objectContext.CreateObjectSet<TEntity>().FirstOrDefault(exp);
        }
        #endregion

        #region GetQuery ESQL查詢
        /// <summary>
        /// ESQL查詢
        /// </summary>
        /// <param name="query">ESQL語句</param>
        /// <param name="parameter">參數(可選)</param>
        /// <returns></returns>
        ///  <remarks>可用.Execute(MergeOption.AppendOnly)執行查詢</remarks>
        public ObjectQuery<TEntity> GetQuery(string query, params ObjectParameter[] parameter)
        {
            return objectContext.CreateQuery<TEntity>(query, parameter);
        }

        /// <summary>
        /// ESQL查詢列表
        /// </summary>
        /// <param name="query">ESQL語句</param>
        /// <param name="parameter">參數(可選)</param>
        /// <returns></returns>
        ///  <remarks>可用.Execute(MergeOption.AppendOnly)執行查詢</remarks>
        public List<TEntity> GetListByQuery(string query, params ObjectParameter[] parameter)
        {
            return objectContext.CreateQuery<TEntity>(query, parameter).ToList();
        }
        /// <summary>
        /// ESQL查詢
        /// </summary>
        /// <param name="query">ESQL語句</param>
        /// <param name="parameter">參數(可選)</param>
        /// <returns></returns>
        /// <remarks>可用.Execute(MergeOption.AppendOnly)執行查詢</remarks>
        public ObjectQuery<Object> GetObjectQuery(string query, params ObjectParameter[] parameter)
        {
            return objectContext.CreateQuery<Object>(query, parameter);
        }
        /// <summary>
        /// ESQL查詢，返回單值Object
        /// </summary>
        /// <param name="query">ESQL語句</param>
        /// <param name="parameter">參數(可選)</param>
        /// <returns></returns>
        /// <remarks>用.Execute(MergeOption.AppendOnly)查詢</remarks>
        public Object GetObjectByQuery(string query, params ObjectParameter[] parameter)
        {
            return GetObjectQuery(query, parameter).Execute(MergeOption.AppendOnly).FirstOrDefault();
        }
        #endregion

        #region GetList 返回List列表
        /// <summary>
        /// 所有數據列表
        /// </summary>
        /// <returns></returns>
        public List<TEntity> GetList()
        {
            return objectContext.CreateObjectSet<TEntity>().AsQueryable().ToList();
        }

        /// <summary>
        /// 根據指定表達式得到數據列表
        /// </summary>
        /// <returns></returns>
        public List<TEntity> GetList(Expression<Func<TEntity, bool>> exp)
        {
            return objectContext.CreateObjectSet<TEntity>().Where(exp).ToList();
        }

        #endregion

        #region Add 添加實體數據
        /// <summary>
        /// 添加實體數據
        /// </summary>
        /// <param name="entity">實體</param>
        public int Add(TEntity entity)
        {
            objectContext.CreateObjectSet<TEntity>().AddObject(entity);
            return objectContext.SaveChanges();
        }
        /// <summary>
        /// 添加實體數據
        /// </summary>
        /// <param name="entity">實體</param>
        /// <param name="options">SaveOptions：
        /// AcceptAllChangesAfterSave：把數據保存到數據庫以后重置實體的狀態。
        /// DetectChangesBeforeSave：把數據保存到數據庫之前同步實體的狀態。
        /// None：把數據保存到數據庫之前，不同步實體的狀態；把數據保存到數據庫以后，也不重置實體的狀態。
        /// </param>
        public int Add(TEntity entity, SaveOptions options)
        {
            objectContext.CreateObjectSet<TEntity>().AddObject(entity);
            return objectContext.SaveChanges(options);
        }

        /// <summary>
        /// 批量添加實體數據
        /// </summary>
        /// <param name="entitys">實體列表</param>
        public int AddAll(IEnumerable<TEntity> entitys)
        {
            foreach (var entity in entitys)
            {
                objectContext.CreateObjectSet<TEntity>().AddObject(entity);
            }
            return objectContext.SaveChanges();
        }
        /// <summary>
        /// 批量添加實體數據
        /// </summary>
        /// <param name="entitys">實體列表</param>
        /// <param name="options">SaveOptions：
        /// AcceptAllChangesAfterSave：把數據保存到數據庫以后重置實體的狀態。
        /// DetectChangesBeforeSave：把數據保存到數據庫之前同步實體的狀態。
        /// None：把數據保存到數據庫之前，不同步實體的狀態；把數據保存到數據庫以后，也不重置實體的狀態。
        /// </param>
        public int AddAll(IEnumerable<TEntity> entitys, SaveOptions options)
        {
            var objSet = objectContext.CreateObjectSet<TEntity>();
            foreach (var entity in entitys)
            {
                objSet.AddObject(entity);
            }
            return objectContext.SaveChanges(options);
        }
        #endregion

        #region Delete 刪除實體數據
        /// <summary>
        /// 刪除實體數據
        /// </summary>
        /// <param name="entity">實體</param>
        public int Delete(TEntity entity)
        {
            objectContext.CreateObjectSet<TEntity>().DeleteObject(entity);
            return objectContext.SaveChanges();
        }

        /// <summary>
        /// 批量刪除實體數據
        /// </summary>
        /// <param name="entitys">實體列表</param>
        public int DeleteAll(IEnumerable<TEntity> entitys)
        {
            if (entitys != null && entitys.Count() > 0)
            {
                foreach (var entity in entitys)
                {
                    objectContext.CreateObjectSet<TEntity>().DeleteObject(entity);
                }
                return objectContext.SaveChanges();
            }
            return 0;
        }
        #endregion

        #region Save 保存實體
        /// <summary>
        /// 保存實體和變動
        /// </summary>        
        /// <returns></returns>
        public int Save()
        {
            return objectContext.SaveChanges();
        }
        /// <summary>
        /// 保存實體和變動
        /// </summary>    
        /// <param name="options">SaveOptions：
        /// AcceptAllChangesAfterSave：把數據保存到數據庫以后重置實體的狀態。
        /// DetectChangesBeforeSave：把數據保存到數據庫之前同步實體的狀態。
        /// None：把數據保存到數據庫之前，不同步實體的狀態；把數據保存到數據庫以后，也不重置實體的狀態。
        /// </param>
        public int Save(SaveOptions options)
        {
            return objectContext.SaveChanges(options);
        }
        /// <summary>
        /// 保存指定的實體變動
        /// </summary>        
        /// <param name="entity">實體列表</param>
        /// <returns></returns>
        public int Save(TEntity entity)
        {
            objectContext.AttachTo(this.entitySetName, entity);
            objectContext.SetAllModified(entity);
            return objectContext.SaveChanges();
        }
        /// <summary>
        /// 保存指定的實體變動
        /// </summary>        
        /// <param name="entity">實體列表</param>
        /// <param name="options">SaveOptions：
        /// AcceptAllChangesAfterSave：把數據保存到數據庫以后重置實體的狀態。
        /// DetectChangesBeforeSave：把數據保存到數據庫之前同步實體的狀態。
        /// None：把數據保存到數據庫之前，不同步實體的狀態；把數據保存到數據庫以后，也不重置實體的狀態。
        /// </param>
        public int Save(TEntity entity, SaveOptions options)
        {
            objectContext.AttachTo(this.entitySetName, entity);
            objectContext.SetAllModified(entity);
            return objectContext.SaveChanges(options);
        }
        #endregion

        /// <summary>
        /// 將對象或對象圖附加到本實體集中的對象上下文。
        /// </summary>
        /// <param name="entity"> 要附加的 System.Object。</param>
        public void AttachTo(TEntity entity)
        {
            objectContext.AttachTo(this.entitySetName, entity);
        }
        /// <summary>
        /// 將對象或對象圖附加到特定實體集中的對象上下文。
        /// </summary>
        /// <param name="entitySetName"> 表示實體集名稱，可以選擇通過實體容器名稱對它進行限定。</param>
        /// <param name="entity"> 要附加的 System.Object。</param>
        public void AttachTo(string entitySetName, TEntity entity)
        {
            objectContext.AttachTo(entitySetName, entity);
        }
        /// <summary>
        /// 在對象具有實體鍵時將對象或對象圖附加到對象上下文。
        /// </summary>
        /// <param name="entity">要附加的對象。</param>
        public void Attach(System.Data.Objects.DataClasses.IEntityWithKey entity)
        {
            objectContext.Attach(entity);
        }
        /// <summary>
        /// 從對象上下文移除對象。
        /// </summary>
        /// <param name="entity">要分離的對象。僅移除 entity；如果有任何相關對象受同一 System.Data.Objects.ObjectStateManager 跟蹤，則不會自動分離這些對象。</param>
        public void Detach(object entity)
        {
            objectContext.Detach(entity);
        }

        #region ExecuteforStore 直接執行數據源語句，如MSSQL、Oracle
        /// <summary>
        /// 執行數據源語句(如MSSQL)，返回影響的行數
        /// </summary>
        /// <param name="commandText">查詢語句</param>
        /// <param name="parameter">參數(可選)</param>
        /// <returns></returns>
        public int ExecuteStoreCommand(string commandText, params ObjectParameter[] parameter)
        {
            if (string.IsNullOrEmpty(commandText))
            {
                return 0;
            }
            return objectContext.ExecuteStoreCommand(commandText, parameter);
        }

        /// <summary>
        /// 執行數據源查詢語句(如MSSQL)，獲得數據查詢列表
        /// </summary>
        /// <param name="commandText">查詢語句</param>
        /// <param name="parameter">參數(可選)</param>
        /// <returns></returns>
        public ObjectResult<TEntity> ExecuteStoreQuery(string commandText, params ObjectParameter[] parameter)
        {
            return objectContext.ExecuteStoreQuery<TEntity>(commandText, parameter);
        }

        /// <summary>
        /// 執行數據源的函數或存儲過程，返回影響的行數
        /// </summary>
        /// <param name="functionName">函數或存儲過程</param>
        /// <param name="parameter">參數(可選)</param>
        /// <returns></returns>
        public int ExecuteFunction(string functionName, params ObjectParameter[] parameter)
        {
            if (string.IsNullOrEmpty(functionName))
            {
                return 0;
            }
            return objectContext.ExecuteFunction(functionName, parameter);
        }

        /// <summary>
        /// 執行數據源的查詢函數或存儲過程，獲得數據查詢列表
        /// </summary>
        /// <param name="functionName">函數或存儲過程</param>
        /// <param name="parameter">參數(可選)</param>
        /// <returns></returns>
        public ObjectResult<TEntity> ExecuteFunctionQuery(string functionName, params ObjectParameter[] parameter)
        {
            return objectContext.ExecuteFunction<TEntity>(functionName, parameter);
        }

        /// <summary>
        /// 執行數據源語句(如MSSQL)，獲得得數據列表
        /// </summary>
        /// <param name="commandText">查詢語句</param>
        /// <param name="parameter">參數(可選)</param>
        /// <returns></returns>
        public List<TEntity> GetListByStoreQuery(string commandText, params ObjectParameter[] parameter)
        {
            return objectContext.ExecuteStoreQuery<TEntity>(commandText, parameter).ToList();
        }
        /// <summary>
        /// 執行數據源的查詢函數或存儲過程，獲得數據列表
        /// </summary>
        /// <param name="functionName">函數或存儲過程</param>
        /// <param name="parameter">參數(可選)</param>
        /// <returns></returns>
        public List<TEntity> GetListByFunction(string functionName, params ObjectParameter[] parameter)
        {
            return objectContext.ExecuteFunction<TEntity>(functionName, parameter).ToList();
        }
        #endregion

        #region ByID 對主鍵相關操作
        /// <summary>
        /// 獲得指定主鍵的實體
        /// </summary>
        /// <param name="id">主鍵值</param>
        /// <returns></returns>
        public virtual TEntity GetByID(object id)
        {
            EntityKey ek = new EntityKey(objectContext.DefaultContainerName + "." + this.entitySetName, this.keyProperty, id);
            object entity = null;
            objectContext.TryGetObjectByKey(ek, out entity);
            return (entity as TEntity);
        }

        /// <summary>
        /// 獲得指定主鍵的實體列表
        /// </summary>
        /// <param name="ids">用逗號(,)分隔的主鍵ID</param>
        /// <returns></returns>
        public virtual List<TEntity> GetListByIDs(string ids)
        {
            ids = SqlFilter(ids);
            if ("string".Equals(this.keyPropertyType, StringComparison.OrdinalIgnoreCase))
            {
                ids = "'" + ids.Replace(",", "','") + "'";
            }
            string query = "select value it from " + this.entitySetName + " as it where it." + this.keyProperty + " in {" + ids + "}";
            return objectContext.CreateQuery<TEntity>(query).ToList();
        }
        /// <summary>
        /// 獲得指定主鍵的實體列表
        /// </summary>
        /// <param name="ids">主鍵ID列表</param>
        /// <returns></returns>
        public virtual List<TEntity> GetListByIDs(IEnumerable<object> ids)
        {
            string strIDs = string.Empty;
            foreach (int id in ids)
            {
                strIDs += "," + id.ToString();
            }
            if (strIDs.Length > 1)
            {
                strIDs = strIDs.Substring(1);
            }
            return GetListByIDs(strIDs);
        }

        /// <summary>
        /// 刪除指定ID的實體。
        /// 注意：此處直接執行數據源語句
        /// </summary>
        /// <param name="ids">用逗號(,)分隔的主鍵ID</param>
        /// <returns></returns>
        public virtual int DeleteByIDs(string ids)
        {
            if (string.IsNullOrEmpty(ids))
            {
                return 0;
            }
            ids = SqlFilter(ids);
            if ("string".Equals(this.keyPropertyType, StringComparison.OrdinalIgnoreCase))
            {
                ids = "'" + ids.Replace(",", "','") + "'";
            }
            string sql = string.Format("delete {0}  where {1} in({2})", this.entitySetName, this.keyProperty, ids);
            return ExecuteStoreCommand(sql);
        }

        /// <summary>
        /// 刪除指定ID組的實體
        /// </summary>
        /// <param name="ids">主鍵ID列表</param>
        /// <returns></returns>
        public virtual int DeleteByIDs(IEnumerable<object> ids)
        {
            string strIDs = string.Empty;
            foreach (int id in ids)
            {
                strIDs += "," + id.ToString();
            }
            if (strIDs.Length > 1)
            {
                strIDs = strIDs.Substring(1);
            }
            return DeleteByIDs(strIDs);
        }
        #endregion

        #region 事務
        /// <summary>
        /// TransactionScope事務處理。
        /// TransactionScopeOption 默認值為 Required。
        /// 用 .Complete() 提交事務
        /// </summary>
        /// <returns>返回 TransactionScope</returns>        
        public TransactionScope GetTransactionScope()
        {
            return (new TransactionScope(TransactionScopeOption.Required));
        }
        /// <summary>
        /// TransactionScope事務處理。
        /// 用 .Complete() 提交事務
        /// </summary>
        /// <param name="scopeOption">提供用於創建事務范圍的附加選項：
        /// Required：該范圍需要一個事務。如果已經存在環境事務，則使用該環境事務。否則，在進入范圍之前創建新的事務。這是默認值。 
        /// RequiresNew：總是為該范圍創建新事務。 
        /// Suppress：環境事務上下文在創建范圍時被取消。范圍中的所有操作都在無環境事務上下文的情況下完成。 
        /// </param>
        /// <returns>返回 TransactionScope</returns>
        public TransactionScope GetTransactionScope(TransactionScopeOption scopeOption)
        {
            return (new TransactionScope(scopeOption));
        }
        /// <summary>
        /// TransactionScope事務處理。
        /// 用 .Complete() 提交事務
        /// </summary>
        /// <param name="scopeOption">提供用於創建事務范圍的附加選項：
        /// Required：該范圍需要一個事務。如果已經存在環境事務，則使用該環境事務。否則，在進入范圍之前創建新的事務。這是默認值。 
        /// RequiresNew：總是為該范圍創建新事務。 
        /// Suppress：環境事務上下文在創建范圍時被取消。范圍中的所有操作都在無環境事務上下文的情況下完成。 
        /// </param>
        /// <param name="scopeTimeout">在它之后，事務范圍將超時並中止此事務。</param>
        /// <returns>返回 TransactionScope</returns> 
        public TransactionScope GetTransactionScope(TransactionScopeOption scopeOption, TimeSpan scopeTimeout)
        {
            return (new TransactionScope(scopeOption, scopeTimeout));
        }

        /// <summary>
        /// TransactionScope事務處理。
        /// 用 .Complete() 提交事務
        /// </summary>
        /// <param name="transactionToUse">要設置為環境事務（以便該范圍中進行的事務性工作使用此事務）的事務。</param>
        /// <returns>返回 TransactionScope</returns> 
        public TransactionScope GetTransactionScope(Transaction transactionToUse)
        {
            return (new TransactionScope(transactionToUse));
        }
        /// <summary>
        /// TransactionScope事務處理。
        /// 用 .Complete() 提交事務
        /// </summary>
        /// <param name="transactionToUse">要設置為環境事務（以便該范圍中進行的事務性工作使用此事務）的事務。</param>
        /// <param name="scopeTimeout">在它之后，事務范圍將超時並中止此事務。</param>
        /// <returns>返回 TransactionScope</returns> 
        public TransactionScope GetTransactionScope(Transaction transactionToUse, TimeSpan scopeTimeout)
        {
            return (new TransactionScope(transactionToUse, scopeTimeout));
        }

        /// <summary>
        /// TransactionScope事務處理。
        /// 用 .Complete() 提交事務
        /// </summary>
        /// <param name="scopeOption">提供用於創建事務范圍的附加選項：
        /// Required：該范圍需要一個事務。如果已經存在環境事務，則使用該環境事務。否則，在進入范圍之前創建新的事務。這是默認值。 
        /// RequiresNew：總是為該范圍創建新事務。 
        /// Suppress：環境事務上下文在創建范圍時被取消。范圍中的所有操作都在無環境事務上下文的情況下完成。 
        /// </param>
        /// <param name="transactionOptions">包含指定事務行為的附加信息。</param>
        /// <returns>返回 TransactionScope</returns> 
        public TransactionScope GetTransactionScope(TransactionScopeOption scopeOption, TransactionOptions transactionOptions)
        {
            return (new TransactionScope(scopeOption, transactionOptions));
        }        

        #endregion

        #region 輔助方法
        /// <summary>
        /// sql注入過濾
        /// </summary>
        /// <param name="sqlString"></param>
        /// <returns></returns>
        public string SqlFilter(string sqlString)
        {
            return sqlString
                .Replace("'", "''");
        }
        #endregion
    }

}

ObjectContext擴展類ObjectContextExtension.cs

using System.Linq;
using System.Data.Objects;
using System.Collections;

namespace System.Data.Objects
{
    /// <summary>
    /// ObjectContext擴展
    /// </summary>
    public static class ObjectContextExtension
    {
        /// <summary>
        /// 把所有屬性都標為已修改
        /// </summary>
        /// <param name="objectContext"></param>
        /// <param name="item"></param>
        public static void SetAllModified(this ObjectContext objectContext, object item)
        {
            ObjectStateEntry stateEntry = objectContext.ObjectStateManager.GetObjectStateEntry(item) as ObjectStateEntry;
            IEnumerable propertyNameList = stateEntry.CurrentValues.DataRecordInfo.FieldMetadata.Select(pn => pn.FieldType.Name);
            foreach (string propName in propertyNameList)
            {
                stateEntry.SetModifiedProperty(propName);
            }
            stateEntry.SetModified();
        }
    }
}

 

使用上可以用以下結構：
1. 建一個base業務類，代碼如下：

public class BaseService<TEntity> : Repository<TEntity> where TEntity : System.Data.Objects.DataClasses.EntityObject //或用class       
    {
        public BaseService()
            : base(new OA.Data.OAEntities())//默認數據庫
        {
        }
        public BaseService(System.Data.Objects.ObjectContext objContext)
            : base(objContext)
        {
        }
        /// <summary>
        /// 為其它Service指定與本Service相同的ObjContext數據對象
        /// </summary>
        /// <param name="newService">目標Service</param>
        protected dynamic SameObjContext(dynamic service)
        {
            service.ObjContext = this.ObjContext;
            return service;
        }
    }

2.業務層的每個業務類都繼承BaseService，如針對Department的業務層DepartmentService.cs代碼：

public class DepartmentService : BaseService<Department>
{
}

（完）