【無私分享：從入門到精通ASP.NET MVC】從0開始，一起搭框架、做項目（3）公共基礎數據操作類 RepositoryBase

索引

【無私分享：從入門到精通ASP.NET MVC】從0開始，一起搭框架、做項目 目錄索引

簡述

今天我們寫一個基礎數據的操作類，如果里面有大家不理解的地方，可采取兩種方式，第一：提出來，第二：會用就行。這個類呢我一般不去修改它，因為基礎操作類，大家也可以直接拷貝到自己的項目中。

項目准備

我們用的工具是：VS 2013 + SqlServer 2012 + IIS7.5

希望大家對ASP.NET MVC有一個初步的理解，理論性的東西我們不做過多解釋，有些地方不理解也沒關系，會用就行了，用的多了，用的久了，自然就理解了。

項目開始

一、創建接口 IRepository

我們在應用服務的Service類庫下面新建一個接口 IRepository

右擊Service類庫→添加→新建項→接口  名稱 IRepository

 

二、基礎操作的接口方法

不了解接口的朋友需要注意下，接口是個規范，是不需要方法體的，說的通俗點，有了接口如果被繼承肯定會有實現，這里你只需要寫方法就行了，具體的方法是如何實現的我們不管，愛怎么實現怎么實現，我只是告訴你，你要是繼承我這個接口，那么我這些方法你必須實現，而且要符合我規范。這就跟領導一條批示：你給我做個上傳圖片的方法，返回上傳成功或失敗。領導就是接口，你是實現類，你在這個領導下面干活，就相當於你繼承了領導，那么你必須要完成這個圖片上傳方法並且返回上傳結果，至於你是用網上的上傳方法呀還是自己寫個webservice啊還是用jquery插件啊隨你，領導不關心你用什么，他只關心你按照他的要求去實現這個方法。這樣不知道大家理解接口了不？

 

我們這個接口是公共基礎數據操作類，所以要有數據模型啊，模型說白了就是類，因為是通用的，所以我們這里寫 T 並且標識 T 是個 Class

我們的Service類庫呢，如果按照三層架構來講，應該是數據管理層，既然是數據管理層，那么我們就是操作數據模型的，我們添加Domain 數據模型的引用，並且我們可能用到一些公共的方法，所以我們也添加對Common公共幫助類庫的引用

 

上面我們講了，這是數據管理層，我們是要對數據進行操作的，公用類庫呢，我們提供多種數據管理的方式，我們再添加兩個庫引用 EntityFramework和EntityFramework.SqlServer

 

我們先來聲明幾個數據對象操作

 

下面，我們寫幾個接口方法

主要有 單模型操作  多模型操作 存儲過程操作 查詢多條數據 分頁查詢 ADO.NET增刪改查

 

有朋友看到這會罵街了，我擦，能不能直接貼代碼，截圖干嘛~~ 不要急，不要急，一定要有耐心~~

我是先貼圖，給大家有個大致的了解，代碼肯定會貼出來的~~

 

單模型操作

 

 #region 單模型操作
        /// <summary>
        /// 獲取實體
        /// </summary>
        /// <param name="id">主鍵</param>
        /// <returns>實體</returns>
        T Get(Expression<Func<T, bool>> predicate);
        /// <summary>
        /// 插入實體
        /// </summary>
        /// <param name="entity">實體</param>
        /// <returns>ID</returns>
        bool Save(T entity);

        /// <summary>
        /// 修改實體
        /// </summary>
        /// <param name="entity">實體</param>
        bool Update(T entity);
        /// <summary>
        /// 修改或保存實體
        /// </summary>
        /// <param name="entity">實體</param>
        bool SaveOrUpdate(T entity, bool isEdit);

        /// <summary>
        /// 刪除實體
        /// </summary>
        int Delete(Expression<Func<T, bool>> predicate = null);

        /// <summary>
        /// 執行SQL刪除
        /// </summary>
        int DeleteBySql(string sql, params DbParameter[] para);

        /// <summary>
        /// 根據屬性驗證實體對象是否存在
        /// </summary>
        bool IsExist(Expression<Func<T, bool>> predicate);

        /// <summary>
        /// 根據SQL驗證實體對象是否存在
        /// </summary>
        bool IsExist(string sql, params DbParameter[] para);
        #endregion

 

 

多模型操作

 

 #region 多模型操作
        /// <summary>
        /// 增加多模型數據，指定獨立模型集合
        /// </summary>
        int SaveList<T1>(List<T1> t) where T1 : class;
        /// <summary>
        /// 增加多模型數據，與當前模型一致
        /// </summary>
        int SaveList(List<T> t);
        /// <summary>
        /// 更新多模型，指定獨立模型集合
        /// </summary>
        int UpdateList<T1>(List<T1> t) where T1 : class;
        /// <summary>
        /// 更新多模型，與當前模型一致
        /// </summary>
        int UpdateList(List<T> t);
        /// <summary>
        /// 批量刪除數據，當前模型
        /// </summary>
        int DeleteList(List<T> t);
        /// <summary>
        /// 批量刪除數據，獨立模型
        /// </summary>
        int DeleteList<T1>(List<T1> t) where T1 : class;
        #endregion

 

 

存儲過程操作

 

 #region 存儲過程操作
        /// <summary>
        /// 執行增刪改存儲過程
        /// </summary>
        object ExecuteProc(string procname, params DbParameter[] parameter);
        /// <summary>
        /// 執行查詢的存儲過程
        /// </summary>
        object ExecuteQueryProc(string procname, params DbParameter[] parameter);
        #endregion

 

 

查詢多條數據

 

 #region 查詢多條數據
        /// <summary>
        /// 獲取集合 IQueryable
        /// </summary>
        IQueryable<T> LoadAll(Expression<Func<T, bool>> predicate);
        /// <summary>
        /// 獲取集合 IList
        /// </summary>
        List<T> LoadListAll(Expression<Func<T, bool>> predicate);
        /// <summary>
        /// 獲取DbQuery的列表
        /// </summary>
        DbQuery<T> LoadQueryAll(Expression<Func<T, bool>> predicate);
        /// <summary>
        /// 獲取IEnumerable列表
        /// </summary>
        IEnumerable<T> LoadEnumerableAll(string sql, params DbParameter[] para);
        /// <summary>
        /// 獲取數據動態集合
        /// </summary>
        System.Collections.IEnumerable LoadEnumerable(string sql, params DbParameter[] para);
        /// <summary>
        /// 采用SQL進行數據的查詢，並轉換
        /// </summary>
        List<T> SelectBySql(string sql, params DbParameter[] para);
        List<T1> SelectBySql<T1>(string sql, params DbParameter[] para);
        /// <summary>
        /// 可指定返回結果、排序、查詢條件的通用查詢方法，返回實體對象
        /// </summary>
        /// <typeparam name="TEntity">實體對象</typeparam>
        /// <typeparam name="TOrderBy">排序字段類型</typeparam>
        /// <typeparam name="TResult">數據結果，一般為object</typeparam>
        /// <param name="where">過濾條件，需要用到類型轉換的需要提前處理與數據表一致的</param>
        /// <param name="orderby">排序字段</param>
        /// <param name="selector">返回結果（必須是模型中存在的字段）</param>
        /// <param name="IsAsc">排序方向，true為正序false為倒序</param>
        /// <returns>實體集合</returns>
        List<TResult> QueryEntity<TEntity, TOrderBy, TResult>(Expression<Func<TEntity, bool>> where, Expression<Func<TEntity, TOrderBy>> orderby, Expression<Func<TEntity, TResult>> selector, bool IsAsc)
            where TEntity : class
            where TResult : class;
        /// <summary>
        /// 可指定返回結果、排序、查詢條件的通用查詢方法，返回Object對象
        /// </summary>
        /// <typeparam name="TEntity">實體對象</typeparam>
        /// <typeparam name="TOrderBy">排序字段類型</typeparam>
        /// <param name="where">過濾條件，需要用到類型轉換的需要提前處理與數據表一致的</param>
        /// <param name="orderby">排序字段</param>
        /// <param name="selector">返回結果（必須是模型中存在的字段）</param>
        /// <param name="IsAsc">排序方向，true為正序false為倒序</param>
        /// <returns>自定義實體集合</returns>
        List<object> QueryObject<TEntity, TOrderBy>(Expression<Func<TEntity, bool>> where, Expression<Func<TEntity, TOrderBy>> orderby, Func<IQueryable<TEntity>, List<object>> selector, bool IsAsc)
            where TEntity : class;
        /// <summary>
        /// 可指定返回結果、排序、查詢條件的通用查詢方法，返回動態類對象
        /// </summary>
        /// <typeparam name="TEntity">實體對象</typeparam>
        /// <typeparam name="TOrderBy">排序字段類型</typeparam>
        /// <param name="where">過濾條件，需要用到類型轉換的需要提前處理與數據表一致的</param>
        /// <param name="orderby">排序字段</param>
        /// <param name="selector">返回結果（必須是模型中存在的字段）</param>
        /// <param name="IsAsc">排序方向，true為正序false為倒序</param>
        /// <returns>動態類對象</returns>
        dynamic QueryDynamic<TEntity, TOrderBy>(Expression<Func<TEntity, bool>> where, Expression<Func<TEntity, TOrderBy>> orderby, Func<IQueryable<TEntity>, List<object>> selector, bool IsAsc)
            where TEntity : class;
        #endregion

 

 

分頁查詢

 

  #region 分頁查詢

        /// <summary>
        /// 通過SQL分頁
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="parameters"></param>
        /// <param name="page"></param>
        /// <returns></returns>
        IList<T1> PageByListSql<T1>(string sql, IList<DbParameter> parameters, PageCollection page);
        IList<T> PageByListSql(string sql, IList<DbParameter> parameters, PageCollection page);
        /// <summary>
        /// 通用EF分頁，默認顯示20條記錄
        /// </summary>
        /// <typeparam name="TEntity">實體模型</typeparam>
        /// <typeparam name="TOrderBy">排序類型</typeparam>
        /// <param name="index">當前頁</param>
        /// <param name="pageSize">顯示條數</param>
        /// <param name="where">過濾條件</param>
        /// <param name="orderby">排序字段</param>
        /// <param name="selector">結果集合</param>
        /// <param name="isAsc">排序方向true正序 false倒序</param>
        /// <returns>自定義實體集合</returns>
        PageInfo<object> Query<TEntity, TOrderBy>
            (int index, int pageSize,
            Expression<Func<TEntity, bool>> where,
            Expression<Func<TEntity, TOrderBy>> orderby,
            Func<IQueryable<TEntity>, List<object>> selector,
            bool IsAsc)
            where TEntity : class;
        /// <summary>
        /// 對IQueryable對象進行分頁邏輯處理，過濾、查詢項、排序對IQueryable操作
        /// </summary>
        /// <param name="t">Iqueryable</param>
        /// <param name="index">當前頁</param>
        /// <param name="PageSize">每頁顯示多少條</param>
        /// <returns>當前IQueryable to List的對象</returns>
        Common.PageInfo<T> Query(IQueryable<T> query, int index, int PageSize);
        /// <summary>
        /// 普通SQL查詢分頁方法
        /// </summary>
        /// <param name="index">當前頁</param>
        /// <param name="pageSize">顯示行數</param>
        /// <param name="tableName">表名/視圖</param>
        /// <param name="field">獲取項</param>
        /// <param name="filter">過濾條件</param>
        /// <param name="orderby">排序字段+排序方向</param>
        /// <param name="group">分組字段</param>
        /// <returns>結果集</returns>
        Common.PageInfo Query(int index, int pageSize, string tableName, string field, string filter, string orderby, string group, params DbParameter[] para);
        /// <summary>
        /// 簡單的Sql查詢分頁
        /// </summary>
        /// <param name="index"></param>
        /// <param name="pageSize"></param>
        /// <param name="sql"></param>
        /// <returns></returns>
        Common.PageInfo Query(int index, int pageSize, string sql, string orderby, params DbParameter[] para);
        /// <summary>
        /// 多表聯合分頁算法
        /// </summary>
        PageInfo Query(IQueryable query, int index, int pagesize);
        #endregion

 

 

ADO.NET增刪改查

 

  #region ADO.NET增刪改查方法
        /// <summary>
        /// 執行增刪改方法,含事務處理
        /// </summary>
        object ExecuteSqlCommand(string sql, params DbParameter[] para);
        /// <summary>
        /// 執行多條SQL，增刪改方法,含事務處理
        /// </summary>
        object ExecuteSqlCommand(Dictionary<string, object> sqllist);
        /// <summary>
        /// 執行查詢方法,返回動態類，接收使用var，遍歷時使用dynamic類型
        /// </summary>
        object ExecuteSqlQuery(string sql, params DbParameter[] para);
        #endregion

 

 

我們引用的類庫和解決方案

 

using Common;
using System;
using System.Collections.Generic;
using System.Data.Common;
using System.Linq;
using System.Text;
using System.Data.Entity.Infrastructure;
using System.Data.Entity;
using System.Linq.Expressions;

 

 

這里是完整的IRepository.cs

 

using Common;
using System;
using System.Collections.Generic;
using System.Data.Common;
using System.Linq;
using System.Text;
using System.Data.Entity.Infrastructure;
using System.Data.Entity;
using System.Linq.Expressions;

namespace Service
{
    /// <summary>
    /// 所有的數據操作基類接口
    /// add yuangang by 2016-05-09
    /// </summary>
    public interface IRepository<T> where T:class
    {
        #region 數據對象操作
        /// <summary>
        /// 數據上下文
        /// </summary>
        DbContext Context { get; }
        /// <summary>
        /// 數據上下文
        /// </summary>
        Domain.MyConfig Config { get; }
        /// <summary>
        /// 數據模型操作
        /// </summary>
        DbSet<T> dbSet { get; }
        /// <summary>
        /// EF事務
        /// </summary>
        DbContextTransaction Transaction { get; set; }
        /// <summary>
        /// 事務提交結果
        /// </summary>
        bool Committed { get; set; }
        /// <summary>
        /// 提交事務
        /// </summary>
        void Commit();
        /// <summary>
        /// 回滾事務
        /// </summary>
        void Rollback();
        #endregion

        #region 單模型操作
        /// <summary>
        /// 獲取實體
        /// </summary>
        /// <param name="id">主鍵</param>
        /// <returns>實體</returns>
        T Get(Expression<Func<T, bool>> predicate);
        /// <summary>
        /// 插入實體
        /// </summary>
        /// <param name="entity">實體</param>
        /// <returns>ID</returns>
        bool Save(T entity);

        /// <summary>
        /// 修改實體
        /// </summary>
        /// <param name="entity">實體</param>
        bool Update(T entity);
        /// <summary>
        /// 修改或保存實體
        /// </summary>
        /// <param name="entity">實體</param>
        bool SaveOrUpdate(T entity, bool isEdit);

        /// <summary>
        /// 刪除實體
        /// </summary>
        int Delete(Expression<Func<T, bool>> predicate = null);

        /// <summary>
        /// 執行SQL刪除
        /// </summary>
        int DeleteBySql(string sql, params DbParameter[] para);

        /// <summary>
        /// 根據屬性驗證實體對象是否存在
        /// </summary>
        bool IsExist(Expression<Func<T, bool>> predicate);

        /// <summary>
        /// 根據SQL驗證實體對象是否存在
        /// </summary>
        bool IsExist(string sql, params DbParameter[] para);
        #endregion

        #region 多模型操作
        /// <summary>
        /// 增加多模型數據，指定獨立模型集合
        /// </summary>
        int SaveList<T1>(List<T1> t) where T1 : class;
        /// <summary>
        /// 增加多模型數據，與當前模型一致
        /// </summary>
        int SaveList(List<T> t);
        /// <summary>
        /// 更新多模型，指定獨立模型集合
        /// </summary>
        int UpdateList<T1>(List<T1> t) where T1 : class;
        /// <summary>
        /// 更新多模型，與當前模型一致
        /// </summary>
        int UpdateList(List<T> t);
        /// <summary>
        /// 批量刪除數據，當前模型
        /// </summary>
        int DeleteList(List<T> t);
        /// <summary>
        /// 批量刪除數據，獨立模型
        /// </summary>
        int DeleteList<T1>(List<T1> t) where T1 : class;
        #endregion

        #region 存儲過程操作
        /// <summary>
        /// 執行增刪改存儲過程
        /// </summary>
        object ExecuteProc(string procname, params DbParameter[] parameter);
        /// <summary>
        /// 執行查詢的存儲過程
        /// </summary>
        object ExecuteQueryProc(string procname, params DbParameter[] parameter);
        #endregion

        #region 查詢多條數據
        /// <summary>
        /// 獲取集合 IQueryable
        /// </summary>
        IQueryable<T> LoadAll(Expression<Func<T, bool>> predicate);
        /// <summary>
        /// 獲取集合 IList
        /// </summary>
        List<T> LoadListAll(Expression<Func<T, bool>> predicate);
        /// <summary>
        /// 獲取DbQuery的列表
        /// </summary>
        DbQuery<T> LoadQueryAll(Expression<Func<T, bool>> predicate);
        /// <summary>
        /// 獲取IEnumerable列表
        /// </summary>
        IEnumerable<T> LoadEnumerableAll(string sql, params DbParameter[] para);
        /// <summary>
        /// 獲取數據動態集合
        /// </summary>
        System.Collections.IEnumerable LoadEnumerable(string sql, params DbParameter[] para);
        /// <summary>
        /// 采用SQL進行數據的查詢，並轉換
        /// </summary>
        List<T> SelectBySql(string sql, params DbParameter[] para);
        List<T1> SelectBySql<T1>(string sql, params DbParameter[] para);
        /// <summary>
        /// 可指定返回結果、排序、查詢條件的通用查詢方法，返回實體對象
        /// </summary>
        /// <typeparam name="TEntity">實體對象</typeparam>
        /// <typeparam name="TOrderBy">排序字段類型</typeparam>
        /// <typeparam name="TResult">數據結果，一般為object</typeparam>
        /// <param name="where">過濾條件，需要用到類型轉換的需要提前處理與數據表一致的</param>
        /// <param name="orderby">排序字段</param>
        /// <param name="selector">返回結果（必須是模型中存在的字段）</param>
        /// <param name="IsAsc">排序方向，true為正序false為倒序</param>
        /// <returns>實體集合</returns>
        List<TResult> QueryEntity<TEntity, TOrderBy, TResult>(Expression<Func<TEntity, bool>> where, Expression<Func<TEntity, TOrderBy>> orderby, Expression<Func<TEntity, TResult>> selector, bool IsAsc)
            where TEntity : class
            where TResult : class;
        /// <summary>
        /// 可指定返回結果、排序、查詢條件的通用查詢方法，返回Object對象
        /// </summary>
        /// <typeparam name="TEntity">實體對象</typeparam>
        /// <typeparam name="TOrderBy">排序字段類型</typeparam>
        /// <param name="where">過濾條件，需要用到類型轉換的需要提前處理與數據表一致的</param>
        /// <param name="orderby">排序字段</param>
        /// <param name="selector">返回結果（必須是模型中存在的字段）</param>
        /// <param name="IsAsc">排序方向，true為正序false為倒序</param>
        /// <returns>自定義實體集合</returns>
        List<object> QueryObject<TEntity, TOrderBy>(Expression<Func<TEntity, bool>> where, Expression<Func<TEntity, TOrderBy>> orderby, Func<IQueryable<TEntity>, List<object>> selector, bool IsAsc)
            where TEntity : class;
        /// <summary>
        /// 可指定返回結果、排序、查詢條件的通用查詢方法，返回動態類對象
        /// </summary>
        /// <typeparam name="TEntity">實體對象</typeparam>
        /// <typeparam name="TOrderBy">排序字段類型</typeparam>
        /// <param name="where">過濾條件，需要用到類型轉換的需要提前處理與數據表一致的</param>
        /// <param name="orderby">排序字段</param>
        /// <param name="selector">返回結果（必須是模型中存在的字段）</param>
        /// <param name="IsAsc">排序方向，true為正序false為倒序</param>
        /// <returns>動態類對象</returns>
        dynamic QueryDynamic<TEntity, TOrderBy>(Expression<Func<TEntity, bool>> where, Expression<Func<TEntity, TOrderBy>> orderby, Func<IQueryable<TEntity>, List<object>> selector, bool IsAsc)
            where TEntity : class;
        #endregion

        #region 分頁查詢

        /// <summary>
        /// 通過SQL分頁
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="parameters"></param>
        /// <param name="page"></param>
        /// <returns></returns>
        IList<T1> PageByListSql<T1>(string sql, IList<DbParameter> parameters, PageCollection page);
        IList<T> PageByListSql(string sql, IList<DbParameter> parameters, PageCollection page);
        /// <summary>
        /// 通用EF分頁，默認顯示20條記錄
        /// </summary>
        /// <typeparam name="TEntity">實體模型</typeparam>
        /// <typeparam name="TOrderBy">排序類型</typeparam>
        /// <param name="index">當前頁</param>
        /// <param name="pageSize">顯示條數</param>
        /// <param name="where">過濾條件</param>
        /// <param name="orderby">排序字段</param>
        /// <param name="selector">結果集合</param>
        /// <param name="isAsc">排序方向true正序 false倒序</param>
        /// <returns>自定義實體集合</returns>
        PageInfo<object> Query<TEntity, TOrderBy>
            (int index, int pageSize,
            Expression<Func<TEntity, bool>> where,
            Expression<Func<TEntity, TOrderBy>> orderby,
            Func<IQueryable<TEntity>, List<object>> selector,
            bool IsAsc)
            where TEntity : class;
        /// <summary>
        /// 對IQueryable對象進行分頁邏輯處理，過濾、查詢項、排序對IQueryable操作
        /// </summary>
        /// <param name="t">Iqueryable</param>
        /// <param name="index">當前頁</param>
        /// <param name="PageSize">每頁顯示多少條</param>
        /// <returns>當前IQueryable to List的對象</returns>
        Common.PageInfo<T> Query(IQueryable<T> query, int index, int PageSize);
        /// <summary>
        /// 普通SQL查詢分頁方法
        /// </summary>
        /// <param name="index">當前頁</param>
        /// <param name="pageSize">顯示行數</param>
        /// <param name="tableName">表名/視圖</param>
        /// <param name="field">獲取項</param>
        /// <param name="filter">過濾條件</param>
        /// <param name="orderby">排序字段+排序方向</param>
        /// <param name="group">分組字段</param>
        /// <returns>結果集</returns>
        Common.PageInfo Query(int index, int pageSize, string tableName, string field, string filter, string orderby, string group, params DbParameter[] para);
        /// <summary>
        /// 簡單的Sql查詢分頁
        /// </summary>
        /// <param name="index"></param>
        /// <param name="pageSize"></param>
        /// <param name="sql"></param>
        /// <returns></returns>
        Common.PageInfo Query(int index, int pageSize, string sql, string orderby, params DbParameter[] para);
        /// <summary>
        /// 多表聯合分頁算法
        /// </summary>
        PageInfo Query(IQueryable query, int index, int pagesize);
        #endregion

        #region ADO.NET增刪改查方法
        /// <summary>
        /// 執行增刪改方法,含事務處理
        /// </summary>
        object ExecuteSqlCommand(string sql, params DbParameter[] para);
        /// <summary>
        /// 執行多條SQL，增刪改方法,含事務處理
        /// </summary>
        object ExecuteSqlCommand(Dictionary<string, object> sqllist);
        /// <summary>
        /// 執行查詢方法,返回動態類，接收使用var，遍歷時使用dynamic類型
        /// </summary>
        object ExecuteSqlQuery(string sql, params DbParameter[] para);
        #endregion
    }
}

 

 

注意：在分頁查詢中，我們引用了Common公共類庫的一個公共類 PageCollection.cs

 

這個類庫在C#公共幫助類里面  連接：【C#公共幫助類】 分頁邏輯處理類

 

三、基礎操作的實現類

我們在Service類庫下新建一個公共基礎數據操作類 RepositoryBase.cs 繼承接口 IRepository

 

因為這個實現類呢，東西比較多，如果沒有什么問題，大家可以直接拿來用，鑒於時間的關系（還在上班，大家理解~~），我就直接把代碼貼出來了，這篇文章寫完不是結束，我會抽空再回來簡單介紹一下這個實現類的一些方法和原理，同時，如果網友提出了問題或是整改，我也會回來整理修改。

 

固定公用幫助，含事務

 

#region 固定公用幫助，含事務

        private DbContext context = new MyConfig().db;
        /// <summary>
        /// 數據上下文--->根據Domain實體模型名稱進行更改
        /// </summary>
        public DbContext Context
        {
            get
            {
                context.Configuration.ValidateOnSaveEnabled = false;
                return context;
            }
        }
        /// <summary>
        /// 數據上下文--->拓展屬性
        /// </summary>
        public MyConfig Config
        {
            get
            {
                return new MyConfig();
            }
        }
        /// <summary>
        /// 公用泛型處理屬性
        /// 注:所有泛型操作的基礎
        /// </summary>
        public DbSet<T> dbSet
        {
            get { return this.Context.Set<T>(); }
        }
        /// <summary>
        /// 事務
        /// </summary>
        private DbContextTransaction _transaction = null;
        /// <summary>
        /// 開始事務
        /// </summary>
        public DbContextTransaction Transaction
        {
            get
            {
                if (this._transaction == null)
                {
                    this._transaction = this.Context.Database.BeginTransaction();
                }
                return this._transaction;
            }
            set { this._transaction = value; }
        }
        /// <summary>
        /// 事務狀態
        /// </summary>
        public bool Committed { get; set; }
        /// <summary>
        /// 異步鎖定
        /// </summary>
        private readonly object sync = new object();
        /// <summary>
        /// 提交事務
        /// </summary>
        public void Commit()
        {
            if (!Committed)
            {
                lock (sync)
                {
                    if (this._transaction != null)
                        _transaction.Commit();
                }
                Committed = true;
            }
        }
        /// <summary>
        /// 回滾事務
        /// </summary>
        public void Rollback()
        {
            Committed = false;
            if (this._transaction != null)
                this._transaction.Rollback();
        }
        #endregion

 

 

獲取單條記錄

 

 #region 獲取單條記錄
        /// <summary>
        /// 通過lambda表達式獲取一條記錄p=>p.id==id
        /// </summary>
        public virtual T Get(Expression<Func<T, bool>> predicate)
        {
            try
            {
                return dbSet.AsNoTracking().SingleOrDefault(predicate);
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        #endregion

 

 

增刪改操作

 

#region 增刪改操作

        /// <summary>
        /// 添加一條模型記錄，自動提交更改
        /// </summary>
        public virtual bool Save(T entity)
        {
            try
            {
                int row = 0;
                var entry = this.Context.Entry<T>(entity);
                entry.State = System.Data.Entity.EntityState.Added;
                row = Context.SaveChanges();
                entry.State = System.Data.Entity.EntityState.Detached;
                return row > 0;
            }
            catch (Exception e)
            {
                throw e;
            }

        }

        /// <summary>
        /// 更新一條模型記錄，自動提交更改
        /// </summary>
        public virtual bool Update(T entity)
        {
            try
            {
                int rows = 0;
                var entry = this.Context.Entry(entity);
                entry.State = System.Data.Entity.EntityState.Modified;
                rows = this.Context.SaveChanges();
                entry.State = System.Data.Entity.EntityState.Detached;
                return rows > 0;
            }
            catch (Exception e)
            {
                throw e;
            }
        }

        /// <summary>
        /// 更新模型記錄，如不存在進行添加操作
        /// </summary>
        public virtual bool SaveOrUpdate(T entity, bool isEdit)
        {
            try
            {
                return isEdit ? Update(entity) : Save(entity);
            }
            catch (Exception e) { throw e; }
        }

        /// <summary>
        /// 刪除一條或多條模型記錄，含事務
        /// </summary>
        public virtual int Delete(Expression<Func<T, bool>> predicate = null)
        {
            try
            {
                int rows = 0;
                IQueryable<T> entry = (predicate == null) ? this.dbSet.AsQueryable() : this.dbSet.Where(predicate);
                List<T> list = entry.ToList();
                if (list.Count > 0)
                {
                    for (int i = 0; i < list.Count; i++)
                    {
                        this.dbSet.Remove(list[i]);
                    }
                    rows = this.Context.SaveChanges();
                }
                return rows;
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        /// <summary>
        /// 使用原始SQL語句,含事務處理
        /// </summary>
        public virtual int DeleteBySql(string sql, params DbParameter[] para)
        {
            try
            {
                return this.Context.Database.ExecuteSqlCommand(sql, para);
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        #endregion

 

 

多模型操作

 

 #region 多模型操作

        /// <summary>
        /// 增加多模型數據，指定獨立模型集合
        /// </summary>
        public virtual int SaveList<T1>(List<T1> t) where T1 : class
        {
            try
            {
                if (t == null || t.Count == 0) return 0;
                this.Context.Set<T1>().Local.Clear();
                foreach (var item in t)
                {
                    this.Context.Set<T1>().Add(item);
                }
                return this.Context.SaveChanges();
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        /// <summary>
        /// 增加多模型數據，與當前模型一致
        /// </summary>
        public virtual int SaveList(List<T> t)
        {
            try
            {
                this.dbSet.Local.Clear();
                foreach (var item in t)
                {
                    this.dbSet.Add(item);
                }
                return this.Context.SaveChanges();
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        /// <summary>
        /// 更新多模型，指定獨立模型集合
        /// </summary>
        public virtual int UpdateList<T1>(List<T1> t) where T1 : class
        {
            if (t.Count <= 0) return 0;
            try
            {
                foreach (var item in t)
                {
                    this.Context.Entry<T1>(item).State = System.Data.Entity.EntityState.Modified;
                }
                return this.Context.SaveChanges();
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        /// <summary>
        /// 更新多模型，與當前模型一致
        /// </summary>
        public virtual int UpdateList(List<T> t)
        {
            if (t.Count <= 0) return 0;
            try
            {
                foreach (var item in t)
                {
                    this.Context.Entry(item).State = System.Data.Entity.EntityState.Modified;
                }
                return this.Context.SaveChanges();
            }
            catch (Exception e) { throw e; }
        }
        /// <summary>
        /// 批量刪除數據，當前模型
        /// </summary>
        public virtual int DeleteList(List<T> t)
        {
            if (t == null || t.Count == 0) return 0;
            foreach (var item in t)
            {
                this.dbSet.Remove(item);
            }
            return this.Context.SaveChanges();
        }
        /// <summary>
        /// 批量刪除數據，自定義模型
        /// </summary>
        public virtual int DeleteList<T1>(List<T1> t) where T1 : class
        {
            try
            {
                if (t == null || t.Count == 0) return 0;
                foreach (var item in t)
                {
                    this.Context.Set<T1>().Remove(item);
                }
                return this.Context.SaveChanges();
            }
            catch (Exception e) { throw e; }
        }
        #endregion

 

 

存儲過程操作

 

 #region 存儲過程操作
        /// <summary>
        /// 執行返回影響行數的存儲過程
        /// </summary>
        /// <param name="procname">過程名稱</param>
        /// <param name="parameter">參數對象</param>
        /// <returns></returns>
        public virtual object ExecuteProc(string procname, params DbParameter[] parameter)
        {
            try
            {
                return ExecuteSqlCommand(procname, parameter);
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        /// <summary>
        /// 執行返回結果集的存儲過程
        /// </summary>
        /// <param name="procname">過程名稱</param>
        /// <param name="parameter">參數對象</param>
        /// <returns></returns>
        public virtual object ExecuteQueryProc(string procname, params DbParameter[] parameter)
        {
            try
            {
                return this.Context.Database.SqlFunctionForDynamic(procname, parameter);
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        #endregion

 

 

存在驗證操作

 

 #region 存在驗證操作
        /// <summary>
        /// 驗證當前條件是否存在相同項
        /// </summary>
        public virtual bool IsExist(Expression<Func<T, bool>> predicate)
        {
            var entry = this.dbSet.Where(predicate);
            return (entry.Any());
        }

        /// <summary>
        /// 根據SQL驗證實體對象是否存在
        /// </summary>
        public virtual bool IsExist(string sql, params DbParameter[] para)
        {
            IEnumerable result = this.Context.Database.SqlQuery(typeof(int), sql, para);

            if (result.GetEnumerator().Current == null || result.GetEnumerator().Current.ToString() == "0")
                return false;
            return true;
        }
        #endregion

 

 

獲取多條數據操作

 

 #region 獲取多條數據操作
        /// <summary>
        /// 返回IQueryable集合，延時加載數據
        /// </summary>
        public virtual IQueryable<T> LoadAll(Expression<Func<T, bool>> predicate)
        {
            try
            {
                if (predicate != null)
                {
                    return this.dbSet.Where(predicate).AsNoTracking<T>();
                }
                return this.dbSet.AsQueryable<T>().AsNoTracking<T>();
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        /// <summary>
        /// 返回DbQuery集合，延時加載數據
        /// </summary>
        public virtual DbQuery<T> LoadQueryAll(Expression<Func<T, bool>> predicate)
        {
            try
            {
                if (predicate != null)
                {
                    return this.dbSet.Where(predicate) as DbQuery<T>;
                }
                return this.dbSet;
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        /// <summary>
        /// 返回List集合,不采用延時加載
        /// </summary>
        public virtual List<T> LoadListAll(Expression<Func<T, bool>> predicate)
        {
            try
            {
                if (predicate != null)
                {
                    return this.dbSet.Where(predicate).AsNoTracking().ToList();
                }
                return this.dbSet.AsQueryable<T>().AsNoTracking().ToList();
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        /// <summary>
        /// 返回IEnumerable集合，采用原始T-Sql方式
        /// </summary>
        public virtual IEnumerable<T> LoadEnumerableAll(string sql, params DbParameter[] para)
        {
            try
            {
                return this.Context.Database.SqlQuery<T>(sql, para);
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        /// <summary>
        /// 返回IEnumerable動態集合，采用原始T-Sql方式
        /// </summary>
        public virtual System.Collections.IEnumerable LoadEnumerable(string sql, params DbParameter[] para)
        {
            try
            {
                return this.Context.Database.SqlQueryForDynamic(sql, para);
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        /// <summary>
        /// 返回IList集合，采用原始T-Sql方式
        /// </summary>
        public virtual List<T> SelectBySql(string sql, params DbParameter[] para)
        {
            try
            {
                return this.Context.Database.SqlQuery(typeof(T), sql, para).Cast<T>().ToList();
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        /// <summary>
        /// 指定泛型，返回IList集合，采用原始T-Sql方式
        /// </summary>
        public virtual List<T1> SelectBySql<T1>(string sql, params DbParameter[] para)
        {
            try
            {
                return this.Context.Database.SqlQuery<T1>(sql, para).ToList();
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        /// <summary>
        /// 可指定返回結果、排序、查詢條件的通用查詢方法，返回實體對象
        /// </summary>
        /// <typeparam name="TEntity">實體對象</typeparam>
        /// <typeparam name="TOrderBy">排序字段類型</typeparam>
        /// <typeparam name="TResult">數據結果，與TEntity一致</typeparam>
        /// <param name="where">過濾條件，需要用到類型轉換的需要提前處理與數據表一致的</param>
        /// <param name="orderby">排序字段</param>
        /// <param name="selector">返回結果（必須是模型中存在的字段）</param>
        /// <param name="IsAsc">排序方向，true為正序false為倒序</param>
        /// <returns>實體集合</returns>
        public virtual List<TResult> QueryEntity<TEntity, TOrderBy, TResult>
            (Expression<Func<TEntity, bool>> where,
            Expression<Func<TEntity, TOrderBy>> orderby,
            Expression<Func<TEntity, TResult>> selector,
            bool IsAsc)
            where TEntity : class
            where TResult : class
        {
            IQueryable<TEntity> query = this.Context.Set<TEntity>();
            if (where != null)
            {
                query = query.Where(where);
            }

            if (orderby != null)
            {
                query = IsAsc ? query.OrderBy(orderby) : query.OrderByDescending(orderby);
            }
            if (selector == null)
            {
                return query.Cast<TResult>().AsNoTracking().ToList();
            }
            return query.Select(selector).AsNoTracking().ToList();
        }

        /// <summary>
        /// 可指定返回結果、排序、查詢條件的通用查詢方法，返回Object對象
        /// </summary>
        /// <typeparam name="TEntity">實體對象</typeparam>
        /// <typeparam name="TOrderBy">排序字段類型</typeparam>
        /// <param name="where">過濾條件，需要用到類型轉換的需要提前處理與數據表一致的</param>
        /// <param name="orderby">排序字段</param>
        /// <param name="selector">返回結果（必須是模型中存在的字段）</param>
        /// <param name="IsAsc">排序方向，true為正序false為倒序</param>
        /// <returns>自定義實體集合</returns>
        public virtual List<object> QueryObject<TEntity, TOrderBy>
            (Expression<Func<TEntity, bool>> where,
            Expression<Func<TEntity, TOrderBy>> orderby,
            Func<IQueryable<TEntity>,
            List<object>> selector,
            bool IsAsc)
            where TEntity : class
        {
            IQueryable<TEntity> query = this.Context.Set<TEntity>();
            if (where != null)
            {
                query = query.Where(where);
            }

            if (orderby != null)
            {
                query = IsAsc ? query.OrderBy(orderby) : query.OrderByDescending(orderby);
            }
            if (selector == null)
            {
                return query.AsNoTracking().ToList<object>();
            }
            return selector(query);
        }

        /// <summary>
        /// 可指定返回結果、排序、查詢條件的通用查詢方法，返回動態類對象
        /// </summary>
        /// <typeparam name="TEntity">實體對象</typeparam>
        /// <typeparam name="TOrderBy">排序字段類型</typeparam>
        /// <param name="where">過濾條件，需要用到類型轉換的需要提前處理與數據表一致的</param>
        /// <param name="orderby">排序字段</param>
        /// <param name="selector">返回結果（必須是模型中存在的字段）</param>
        /// <param name="IsAsc">排序方向，true為正序false為倒序</param>
        /// <returns>動態類</returns>
        public virtual dynamic QueryDynamic<TEntity, TOrderBy>
            (Expression<Func<TEntity, bool>> where,
            Expression<Func<TEntity, TOrderBy>> orderby,
            Func<IQueryable<TEntity>,
            List<object>> selector,
            bool IsAsc)
            where TEntity : class
        {
            List<object> list = QueryObject<TEntity, TOrderBy>
                 (where, orderby, selector, IsAsc);
            return Common.JsonConverter.JsonClass(list);
        }
        #endregion

 

 

分頁操作

 

 #region 分頁操作
        /// <summary>
        /// 待自定義分頁函數，使用必須重寫，指定數據模型
        /// </summary>
        public virtual IList<T1> PageByListSql<T1>(string sql, IList<DbParameter> parameters, Common.PageCollection page)
        {
            return null;
        }
        /// <summary>
        /// 待自定義分頁函數，使用必須重寫，
        /// </summary>
        public virtual IList<T> PageByListSql(string sql, IList<DbParameter> parameters, Common.PageCollection page)
        {
            return null;
        }

        /// <summary>
        /// 對IQueryable對象進行分頁邏輯處理，過濾、查詢項、排序對IQueryable操作
        /// </summary>
        /// <param name="t">Iqueryable</param>
        /// <param name="index">當前頁</param>
        /// <param name="PageSize">每頁顯示多少條</param>
        /// <returns>當前IQueryable to List的對象</returns>
        public virtual Common.PageInfo<T> Query(IQueryable<T> query, int index, int PageSize)
        {
            if (index < 1)
            {
                index = 1;
            }
            if (PageSize <= 0)
            {
                PageSize = 20;
            }
            int count = query.Count();

            int maxpage = count / PageSize;

            if (count % PageSize > 0)
            {
                maxpage++;
            }
            if (index > maxpage)
            {
                index = maxpage;
            }
            if (count > 0)
                query = query.Skip((index - 1) * PageSize).Take(PageSize);
            return new Common.PageInfo<T>(index, PageSize, count, query.ToList());
        }
        /// <summary>
        /// 通用EF分頁，默認顯示20條記錄
        /// </summary>
        /// <typeparam name="TEntity">實體模型</typeparam>
        /// <typeparam name="TOrderBy">排序類型</typeparam>
        /// <param name="index">當前頁</param>
        /// <param name="pageSize">顯示條數</param>
        /// <param name="where">過濾條件</param>
        /// <param name="orderby">排序字段</param>
        /// <param name="selector">結果集合</param>
        /// <param name="isAsc">排序方向true正序 false倒序</param>
        /// <returns>自定義實體集合</returns>
        public virtual Common.PageInfo<object> Query<TEntity, TOrderBy>
            (int index, int pageSize,
            Expression<Func<TEntity, bool>> where,
            Expression<Func<TEntity, TOrderBy>> orderby,
            Func<IQueryable<TEntity>,
            List<object>> selector,
            bool isAsc)
            where TEntity : class
        {
            if (index < 1)
            {
                index = 1;
            }

            if (pageSize <= 0)
            {
                pageSize = 20;
            }

            IQueryable<TEntity> query = this.Context.Set<TEntity>();
            if (where != null)
            {
                query = query.Where(where);
            }
            int count = query.Count();

            int maxpage = count / pageSize;

            if (count % pageSize > 0)
            {
                maxpage++;
            }
            if (index > maxpage)
            {
                index = maxpage;
            }

            if (orderby != null)
            {
                query = isAsc ? query.OrderBy(orderby) : query.OrderByDescending(orderby);
            }
            if (count > 0)
                query = query.Skip((index - 1) * pageSize).Take(pageSize);
            //返回結果為null，返回所有字段
            if (selector == null)
                return new Common.PageInfo<object>(index, pageSize, count, query.ToList<object>());
            return new Common.PageInfo<object>(index, pageSize, count, selector(query).ToList());
        }
        /// <summary>
        /// 普通SQL查詢分頁方法
        /// </summary>
        /// <param name="index">當前頁</param>
        /// <param name="pageSize">顯示行數</param>
        /// <param name="tableName">表名/視圖</param>
        /// <param name="field">獲取項</param>
        /// <param name="filter">過濾條件</param>
        /// <param name="orderby">排序字段+排序方向</param>
        /// <param name="group">分組字段</param>
        /// <returns>結果集</returns>
        public virtual Common.PageInfo Query(int index, int pageSize, string tableName, string field, string filter, string orderby, string group, params DbParameter[] para)
        {
            //執行分頁算法
            if (index <= 0)
                index = 1;
            int start = (index - 1) * pageSize;
            if (start > 0)
                start -= 1;
            else
                start = 0;
            int end = index * pageSize;

            #region 查詢邏輯
            string logicSql = "SELECT";
            //查詢項
            if (!string.IsNullOrEmpty(field))
            {
                logicSql += " " + field;
            }
            else
            {
                logicSql += " *";
            }
            logicSql += " FROM (" + tableName + " ) where";
            //過濾條件
            if (!string.IsNullOrEmpty(filter))
            {
                logicSql += " " + filter;
            }
            else
            {
                filter = " 1=1";
                logicSql += "  1=1";
            }
            //分組
            if (!string.IsNullOrEmpty(group))
            {
                logicSql += " group by " + group;
            }

            #endregion

            //獲取當前條件下數據總條數
            int count = this.Context.Database.SqlQuery(typeof(int), "select count(*) from (" + tableName + ") where " + filter, para).Cast<int>().FirstOrDefault();
            string sql = "SELECT T.* FROM ( SELECT B.* FROM ( SELECT A.*,ROW_NUMBER() OVER(ORDER BY getdate()) as RN" +
                         logicSql + ") A ) B WHERE B.RN<=" + end + ") T WHERE T.RN>" + start;
            //排序
            if (!string.IsNullOrEmpty(orderby))
            {
                sql += " order by " + orderby;
            }
            var list = ExecuteSqlQuery(sql, para) as IEnumerable;
            if (list != null)
                return new Common.PageInfo(index, pageSize, count, list.Cast<object>().ToList());
            return new Common.PageInfo(index, pageSize, count, new { });
        }

        /// <summary>
        /// 最簡單的SQL分頁
        /// </summary>
        /// <param name="index">頁碼</param>
        /// <param name="pageSize">顯示行數</param>
        /// <param name="sql">純SQL語句</param>
        /// <param name="orderby">排序字段與方向</param>
        /// <returns></returns>
        public virtual Common.PageInfo Query(int index, int pageSize, string sql, string orderby, params DbParameter[] para)
        {
            return this.Query(index, pageSize, sql, null, null, orderby, null, para);
        }
        /// <summary>
        /// 多表聯合分頁算法
        /// </summary>
        public virtual Common.PageInfo Query(IQueryable query, int index, int PageSize)
        {
            var enumerable = (query as System.Collections.IEnumerable).Cast<object>();
            if (index < 1)
            {
                index = 1;
            }
            if (PageSize <= 0)
            {
                PageSize = 20;
            }

            int count = enumerable.Count();

            int maxpage = count / PageSize;

            if (count % PageSize > 0)
            {
                maxpage++;
            }
            if (index > maxpage)
            {
                index = maxpage;
            }
            if (count > 0)
                enumerable = enumerable.Skip((index - 1) * PageSize).Take(PageSize);
            return new Common.PageInfo(index, PageSize, count, enumerable.ToList());
        }
        #endregion

 

 

ADO.NET增刪改查方法

 

#region ADO.NET增刪改查方法
        /// <summary>
        /// 執行增刪改方法,含事務處理
        /// </summary>
        public virtual object ExecuteSqlCommand(string sql, params DbParameter[] para)
        {
            try
            {
                return this.Context.Database.ExecuteSqlCommand(sql, para);
            }
            catch (Exception e)
            {
                throw e;
            }

        }
        /// <summary>
        /// 執行多條SQL，增刪改方法,含事務處理
        /// </summary>
        public virtual object ExecuteSqlCommand(Dictionary<string, object> sqllist)
        {
            try
            {
                int rows = 0;
                IEnumerator<KeyValuePair<string, object>> enumerator = sqllist.GetEnumerator();
                using (Transaction)
                {
                    while (enumerator.MoveNext())
                    {
                        rows += this.Context.Database.ExecuteSqlCommand(enumerator.Current.Key, enumerator.Current.Value);
                    }
                    Commit();
                }
                return rows;
            }
            catch (Exception e)
            {
                Rollback();
                throw e;
            }

        }
        /// <summary>
        /// 執行查詢方法,返回動態類，接收使用var，遍歷時使用dynamic類型
        /// </summary>
        public virtual object ExecuteSqlQuery(string sql, params DbParameter[] para)
        {
            try
            {
                return this.Context.Database.SqlQueryForDynamic(sql, para);
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        #endregion

 

 

我們引用的類庫和解決方案

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Data.Common;
using System.Data.Entity;
using System.Data.Entity.Infrastructure;
using Domain;
using System.Linq.Expressions;
using System.Collections;

 

 

完整的 RepositoryBase.cs

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Data.Common;
using System.Data.Entity;
using System.Data.Entity.Infrastructure;
using Domain;
using System.Linq.Expressions;
using System.Collections;

namespace Service
{
    /// <summary>
    /// 數據操作基本實現類，公用實現方法
    /// add yuangang by 2016-05-10
    /// </summary>
    /// <typeparam name="T">具體操作的實體模型</typeparam>
    public abstract class RepositoryBase<T> : IRepository<T> where T : class
    {
        #region 固定公用幫助，含事務

        private DbContext context = new MyConfig().db;
        /// <summary>
        /// 數據上下文--->根據Domain實體模型名稱進行更改
        /// </summary>
        public DbContext Context
        {
            get
            {
                context.Configuration.ValidateOnSaveEnabled = false;
                return context;
            }
        }
        /// <summary>
        /// 數據上下文--->拓展屬性
        /// </summary>
        public MyConfig Config
        {
            get
            {
                return new MyConfig();
            }
        }
        /// <summary>
        /// 公用泛型處理屬性
        /// 注:所有泛型操作的基礎
        /// </summary>
        public DbSet<T> dbSet
        {
            get { return this.Context.Set<T>(); }
        }
        /// <summary>
        /// 事務
        /// </summary>
        private DbContextTransaction _transaction = null;
        /// <summary>
        /// 開始事務
        /// </summary>
        public DbContextTransaction Transaction
        {
            get
            {
                if (this._transaction == null)
                {
                    this._transaction = this.Context.Database.BeginTransaction();
                }
                return this._transaction;
            }
            set { this._transaction = value; }
        }
        /// <summary>
        /// 事務狀態
        /// </summary>
        public bool Committed { get; set; }
        /// <summary>
        /// 異步鎖定
        /// </summary>
        private readonly object sync = new object();
        /// <summary>
        /// 提交事務
        /// </summary>
        public void Commit()
        {
            if (!Committed)
            {
                lock (sync)
                {
                    if (this._transaction != null)
                        _transaction.Commit();
                }
                Committed = true;
            }
        }
        /// <summary>
        /// 回滾事務
        /// </summary>
        public void Rollback()
        {
            Committed = false;
            if (this._transaction != null)
                this._transaction.Rollback();
        }
        #endregion

        #region 獲取單條記錄
        /// <summary>
        /// 通過lambda表達式獲取一條記錄p=>p.id==id
        /// </summary>
        public virtual T Get(Expression<Func<T, bool>> predicate)
        {
            try
            {
                return dbSet.AsNoTracking().SingleOrDefault(predicate);
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        #endregion

        #region 增刪改操作

        /// <summary>
        /// 添加一條模型記錄，自動提交更改
        /// </summary>
        public virtual bool Save(T entity)
        {
            try
            {
                int row = 0;
                var entry = this.Context.Entry<T>(entity);
                entry.State = System.Data.Entity.EntityState.Added;
                row = Context.SaveChanges();
                entry.State = System.Data.Entity.EntityState.Detached;
                return row > 0;
            }
            catch (Exception e)
            {
                throw e;
            }

        }

        /// <summary>
        /// 更新一條模型記錄，自動提交更改
        /// </summary>
        public virtual bool Update(T entity)
        {
            try
            {
                int rows = 0;
                var entry = this.Context.Entry(entity);
                entry.State = System.Data.Entity.EntityState.Modified;
                rows = this.Context.SaveChanges();
                entry.State = System.Data.Entity.EntityState.Detached;
                return rows > 0;
            }
            catch (Exception e)
            {
                throw e;
            }
        }

        /// <summary>
        /// 更新模型記錄，如不存在進行添加操作
        /// </summary>
        public virtual bool SaveOrUpdate(T entity, bool isEdit)
        {
            try
            {
                return isEdit ? Update(entity) : Save(entity);
            }
            catch (Exception e) { throw e; }
        }

        /// <summary>
        /// 刪除一條或多條模型記錄，含事務
        /// </summary>
        public virtual int Delete(Expression<Func<T, bool>> predicate = null)
        {
            try
            {
                int rows = 0;
                IQueryable<T> entry = (predicate == null) ? this.dbSet.AsQueryable() : this.dbSet.Where(predicate);
                List<T> list = entry.ToList();
                if (list.Count > 0)
                {
                    for (int i = 0; i < list.Count; i++)
                    {
                        this.dbSet.Remove(list[i]);
                    }
                    rows = this.Context.SaveChanges();
                }
                return rows;
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        /// <summary>
        /// 使用原始SQL語句,含事務處理
        /// </summary>
        public virtual int DeleteBySql(string sql, params DbParameter[] para)
        {
            try
            {
                return this.Context.Database.ExecuteSqlCommand(sql, para);
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        #endregion

        #region 多模型操作

        /// <summary>
        /// 增加多模型數據，指定獨立模型集合
        /// </summary>
        public virtual int SaveList<T1>(List<T1> t) where T1 : class
        {
            try
            {
                if (t == null || t.Count == 0) return 0;
                this.Context.Set<T1>().Local.Clear();
                foreach (var item in t)
                {
                    this.Context.Set<T1>().Add(item);
                }
                return this.Context.SaveChanges();
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        /// <summary>
        /// 增加多模型數據，與當前模型一致
        /// </summary>
        public virtual int SaveList(List<T> t)
        {
            try
            {
                this.dbSet.Local.Clear();
                foreach (var item in t)
                {
                    this.dbSet.Add(item);
                }
                return this.Context.SaveChanges();
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        /// <summary>
        /// 更新多模型，指定獨立模型集合
        /// </summary>
        public virtual int UpdateList<T1>(List<T1> t) where T1 : class
        {
            if (t.Count <= 0) return 0;
            try
            {
                foreach (var item in t)
                {
                    this.Context.Entry<T1>(item).State = System.Data.Entity.EntityState.Modified;
                }
                return this.Context.SaveChanges();
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        /// <summary>
        /// 更新多模型，與當前模型一致
        /// </summary>
        public virtual int UpdateList(List<T> t)
        {
            if (t.Count <= 0) return 0;
            try
            {
                foreach (var item in t)
                {
                    this.Context.Entry(item).State = System.Data.Entity.EntityState.Modified;
                }
                return this.Context.SaveChanges();
            }
            catch (Exception e) { throw e; }
        }
        /// <summary>
        /// 批量刪除數據，當前模型
        /// </summary>
        public virtual int DeleteList(List<T> t)
        {
            if (t == null || t.Count == 0) return 0;
            foreach (var item in t)
            {
                this.dbSet.Remove(item);
            }
            return this.Context.SaveChanges();
        }
        /// <summary>
        /// 批量刪除數據，自定義模型
        /// </summary>
        public virtual int DeleteList<T1>(List<T1> t) where T1 : class
        {
            try
            {
                if (t == null || t.Count == 0) return 0;
                foreach (var item in t)
                {
                    this.Context.Set<T1>().Remove(item);
                }
                return this.Context.SaveChanges();
            }
            catch (Exception e) { throw e; }
        }
        #endregion

        #region 存儲過程操作
        /// <summary>
        /// 執行返回影響行數的存儲過程
        /// </summary>
        /// <param name="procname">過程名稱</param>
        /// <param name="parameter">參數對象</param>
        /// <returns></returns>
        public virtual object ExecuteProc(string procname, params DbParameter[] parameter)
        {
            try
            {
                return ExecuteSqlCommand(procname, parameter);
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        /// <summary>
        /// 執行返回結果集的存儲過程
        /// </summary>
        /// <param name="procname">過程名稱</param>
        /// <param name="parameter">參數對象</param>
        /// <returns></returns>
        public virtual object ExecuteQueryProc(string procname, params DbParameter[] parameter)
        {
            try
            {
                return this.Context.Database.SqlFunctionForDynamic(procname, parameter);
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        #endregion

        #region 存在驗證操作
        /// <summary>
        /// 驗證當前條件是否存在相同項
        /// </summary>
        public virtual bool IsExist(Expression<Func<T, bool>> predicate)
        {
            var entry = this.dbSet.Where(predicate);
            return (entry.Any());
        }

        /// <summary>
        /// 根據SQL驗證實體對象是否存在
        /// </summary>
        public virtual bool IsExist(string sql, params DbParameter[] para)
        {
            IEnumerable result = this.Context.Database.SqlQuery(typeof(int), sql, para);

            if (result.GetEnumerator().Current == null || result.GetEnumerator().Current.ToString() == "0")
                return false;
            return true;
        }
        #endregion

        #region 獲取多條數據操作
        /// <summary>
        /// 返回IQueryable集合，延時加載數據
        /// </summary>
        public virtual IQueryable<T> LoadAll(Expression<Func<T, bool>> predicate)
        {
            try
            {
                if (predicate != null)
                {
                    return this.dbSet.Where(predicate).AsNoTracking<T>();
                }
                return this.dbSet.AsQueryable<T>().AsNoTracking<T>();
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        /// <summary>
        /// 返回DbQuery集合，延時加載數據
        /// </summary>
        public virtual DbQuery<T> LoadQueryAll(Expression<Func<T, bool>> predicate)
        {
            try
            {
                if (predicate != null)
                {
                    return this.dbSet.Where(predicate) as DbQuery<T>;
                }
                return this.dbSet;
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        /// <summary>
        /// 返回List集合,不采用延時加載
        /// </summary>
        public virtual List<T> LoadListAll(Expression<Func<T, bool>> predicate)
        {
            try
            {
                if (predicate != null)
                {
                    return this.dbSet.Where(predicate).AsNoTracking().ToList();
                }
                return this.dbSet.AsQueryable<T>().AsNoTracking().ToList();
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        /// <summary>
        /// 返回IEnumerable集合，采用原始T-Sql方式
        /// </summary>
        public virtual IEnumerable<T> LoadEnumerableAll(string sql, params DbParameter[] para)
        {
            try
            {
                return this.Context.Database.SqlQuery<T>(sql, para);
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        /// <summary>
        /// 返回IEnumerable動態集合，采用原始T-Sql方式
        /// </summary>
        public virtual System.Collections.IEnumerable LoadEnumerable(string sql, params DbParameter[] para)
        {
            try
            {
                return this.Context.Database.SqlQueryForDynamic(sql, para);
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        /// <summary>
        /// 返回IList集合，采用原始T-Sql方式
        /// </summary>
        public virtual List<T> SelectBySql(string sql, params DbParameter[] para)
        {
            try
            {
                return this.Context.Database.SqlQuery(typeof(T), sql, para).Cast<T>().ToList();
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        /// <summary>
        /// 指定泛型，返回IList集合，采用原始T-Sql方式
        /// </summary>
        public virtual List<T1> SelectBySql<T1>(string sql, params DbParameter[] para)
        {
            try
            {
                return this.Context.Database.SqlQuery<T1>(sql, para).ToList();
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        /// <summary>
        /// 可指定返回結果、排序、查詢條件的通用查詢方法，返回實體對象
        /// </summary>
        /// <typeparam name="TEntity">實體對象</typeparam>
        /// <typeparam name="TOrderBy">排序字段類型</typeparam>
        /// <typeparam name="TResult">數據結果，與TEntity一致</typeparam>
        /// <param name="where">過濾條件，需要用到類型轉換的需要提前處理與數據表一致的</param>
        /// <param name="orderby">排序字段</param>
        /// <param name="selector">返回結果（必須是模型中存在的字段）</param>
        /// <param name="IsAsc">排序方向，true為正序false為倒序</param>
        /// <returns>實體集合</returns>
        public virtual List<TResult> QueryEntity<TEntity, TOrderBy, TResult>
            (Expression<Func<TEntity, bool>> where,
            Expression<Func<TEntity, TOrderBy>> orderby,
            Expression<Func<TEntity, TResult>> selector,
            bool IsAsc)
            where TEntity : class
            where TResult : class
        {
            IQueryable<TEntity> query = this.Context.Set<TEntity>();
            if (where != null)
            {
                query = query.Where(where);
            }

            if (orderby != null)
            {
                query = IsAsc ? query.OrderBy(orderby) : query.OrderByDescending(orderby);
            }
            if (selector == null)
            {
                return query.Cast<TResult>().AsNoTracking().ToList();
            }
            return query.Select(selector).AsNoTracking().ToList();
        }

        /// <summary>
        /// 可指定返回結果、排序、查詢條件的通用查詢方法，返回Object對象
        /// </summary>
        /// <typeparam name="TEntity">實體對象</typeparam>
        /// <typeparam name="TOrderBy">排序字段類型</typeparam>
        /// <param name="where">過濾條件，需要用到類型轉換的需要提前處理與數據表一致的</param>
        /// <param name="orderby">排序字段</param>
        /// <param name="selector">返回結果（必須是模型中存在的字段）</param>
        /// <param name="IsAsc">排序方向，true為正序false為倒序</param>
        /// <returns>自定義實體集合</returns>
        public virtual List<object> QueryObject<TEntity, TOrderBy>
            (Expression<Func<TEntity, bool>> where,
            Expression<Func<TEntity, TOrderBy>> orderby,
            Func<IQueryable<TEntity>,
            List<object>> selector,
            bool IsAsc)
            where TEntity : class
        {
            IQueryable<TEntity> query = this.Context.Set<TEntity>();
            if (where != null)
            {
                query = query.Where(where);
            }

            if (orderby != null)
            {
                query = IsAsc ? query.OrderBy(orderby) : query.OrderByDescending(orderby);
            }
            if (selector == null)
            {
                return query.AsNoTracking().ToList<object>();
            }
            return selector(query);
        }

        /// <summary>
        /// 可指定返回結果、排序、查詢條件的通用查詢方法，返回動態類對象
        /// </summary>
        /// <typeparam name="TEntity">實體對象</typeparam>
        /// <typeparam name="TOrderBy">排序字段類型</typeparam>
        /// <param name="where">過濾條件，需要用到類型轉換的需要提前處理與數據表一致的</param>
        /// <param name="orderby">排序字段</param>
        /// <param name="selector">返回結果（必須是模型中存在的字段）</param>
        /// <param name="IsAsc">排序方向，true為正序false為倒序</param>
        /// <returns>動態類</returns>
        public virtual dynamic QueryDynamic<TEntity, TOrderBy>
            (Expression<Func<TEntity, bool>> where,
            Expression<Func<TEntity, TOrderBy>> orderby,
            Func<IQueryable<TEntity>,
            List<object>> selector,
            bool IsAsc)
            where TEntity : class
        {
            List<object> list = QueryObject<TEntity, TOrderBy>
                 (where, orderby, selector, IsAsc);
            return Common.JsonConverter.JsonClass(list);
        }
        #endregion

        #region 分頁操作
        /// <summary>
        /// 待自定義分頁函數，使用必須重寫，指定數據模型
        /// </summary>
        public virtual IList<T1> PageByListSql<T1>(string sql, IList<DbParameter> parameters, Common.PageCollection page)
        {
            return null;
        }
        /// <summary>
        /// 待自定義分頁函數，使用必須重寫，
        /// </summary>
        public virtual IList<T> PageByListSql(string sql, IList<DbParameter> parameters, Common.PageCollection page)
        {
            return null;
        }

        /// <summary>
        /// 對IQueryable對象進行分頁邏輯處理，過濾、查詢項、排序對IQueryable操作
        /// </summary>
        /// <param name="t">Iqueryable</param>
        /// <param name="index">當前頁</param>
        /// <param name="PageSize">每頁顯示多少條</param>
        /// <returns>當前IQueryable to List的對象</returns>
        public virtual Common.PageInfo<T> Query(IQueryable<T> query, int index, int PageSize)
        {
            if (index < 1)
            {
                index = 1;
            }
            if (PageSize <= 0)
            {
                PageSize = 20;
            }
            int count = query.Count();

            int maxpage = count / PageSize;

            if (count % PageSize > 0)
            {
                maxpage++;
            }
            if (index > maxpage)
            {
                index = maxpage;
            }
            if (count > 0)
                query = query.Skip((index - 1) * PageSize).Take(PageSize);
            return new Common.PageInfo<T>(index, PageSize, count, query.ToList());
        }
        /// <summary>
        /// 通用EF分頁，默認顯示20條記錄
        /// </summary>
        /// <typeparam name="TEntity">實體模型</typeparam>
        /// <typeparam name="TOrderBy">排序類型</typeparam>
        /// <param name="index">當前頁</param>
        /// <param name="pageSize">顯示條數</param>
        /// <param name="where">過濾條件</param>
        /// <param name="orderby">排序字段</param>
        /// <param name="selector">結果集合</param>
        /// <param name="isAsc">排序方向true正序 false倒序</param>
        /// <returns>自定義實體集合</returns>
        public virtual Common.PageInfo<object> Query<TEntity, TOrderBy>
            (int index, int pageSize,
            Expression<Func<TEntity, bool>> where,
            Expression<Func<TEntity, TOrderBy>> orderby,
            Func<IQueryable<TEntity>,
            List<object>> selector,
            bool isAsc)
            where TEntity : class
        {
            if (index < 1)
            {
                index = 1;
            }

            if (pageSize <= 0)
            {
                pageSize = 20;
            }

            IQueryable<TEntity> query = this.Context.Set<TEntity>();
            if (where != null)
            {
                query = query.Where(where);
            }
            int count = query.Count();

            int maxpage = count / pageSize;

            if (count % pageSize > 0)
            {
                maxpage++;
            }
            if (index > maxpage)
            {
                index = maxpage;
            }

            if (orderby != null)
            {
                query = isAsc ? query.OrderBy(orderby) : query.OrderByDescending(orderby);
            }
            if (count > 0)
                query = query.Skip((index - 1) * pageSize).Take(pageSize);
            //返回結果為null，返回所有字段
            if (selector == null)
                return new Common.PageInfo<object>(index, pageSize, count, query.ToList<object>());
            return new Common.PageInfo<object>(index, pageSize, count, selector(query).ToList());
        }
        /// <summary>
        /// 普通SQL查詢分頁方法
        /// </summary>
        /// <param name="index">當前頁</param>
        /// <param name="pageSize">顯示行數</param>
        /// <param name="tableName">表名/視圖</param>
        /// <param name="field">獲取項</param>
        /// <param name="filter">過濾條件</param>
        /// <param name="orderby">排序字段+排序方向</param>
        /// <param name="group">分組字段</param>
        /// <returns>結果集</returns>
        public virtual Common.PageInfo Query(int index, int pageSize, string tableName, string field, string filter, string orderby, string group, params DbParameter[] para)
        {
            //執行分頁算法
            if (index <= 0)
                index = 1;
            int start = (index - 1) * pageSize;
            if (start > 0)
                start -= 1;
            else
                start = 0;
            int end = index * pageSize;

            #region 查詢邏輯
            string logicSql = "SELECT";
            //查詢項
            if (!string.IsNullOrEmpty(field))
            {
                logicSql += " " + field;
            }
            else
            {
                logicSql += " *";
            }
            logicSql += " FROM (" + tableName + " ) where";
            //過濾條件
            if (!string.IsNullOrEmpty(filter))
            {
                logicSql += " " + filter;
            }
            else
            {
                filter = " 1=1";
                logicSql += "  1=1";
            }
            //分組
            if (!string.IsNullOrEmpty(group))
            {
                logicSql += " group by " + group;
            }

            #endregion

            //獲取當前條件下數據總條數
            int count = this.Context.Database.SqlQuery(typeof(int), "select count(*) from (" + tableName + ") where " + filter, para).Cast<int>().FirstOrDefault();
            string sql = "SELECT T.* FROM ( SELECT B.* FROM ( SELECT A.*,ROW_NUMBER() OVER(ORDER BY getdate()) as RN" +
                         logicSql + ") A ) B WHERE B.RN<=" + end + ") T WHERE T.RN>" + start;
            //排序
            if (!string.IsNullOrEmpty(orderby))
            {
                sql += " order by " + orderby;
            }
            var list = ExecuteSqlQuery(sql, para) as IEnumerable;
            if (list != null)
                return new Common.PageInfo(index, pageSize, count, list.Cast<object>().ToList());
            return new Common.PageInfo(index, pageSize, count, new { });
        }

        /// <summary>
        /// 最簡單的SQL分頁
        /// </summary>
        /// <param name="index">頁碼</param>
        /// <param name="pageSize">顯示行數</param>
        /// <param name="sql">純SQL語句</param>
        /// <param name="orderby">排序字段與方向</param>
        /// <returns></returns>
        public virtual Common.PageInfo Query(int index, int pageSize, string sql, string orderby, params DbParameter[] para)
        {
            return this.Query(index, pageSize, sql, null, null, orderby, null, para);
        }
        /// <summary>
        /// 多表聯合分頁算法
        /// </summary>
        public virtual Common.PageInfo Query(IQueryable query, int index, int PageSize)
        {
            var enumerable = (query as System.Collections.IEnumerable).Cast<object>();
            if (index < 1)
            {
                index = 1;
            }
            if (PageSize <= 0)
            {
                PageSize = 20;
            }

            int count = enumerable.Count();

            int maxpage = count / PageSize;

            if (count % PageSize > 0)
            {
                maxpage++;
            }
            if (index > maxpage)
            {
                index = maxpage;
            }
            if (count > 0)
                enumerable = enumerable.Skip((index - 1) * PageSize).Take(PageSize);
            return new Common.PageInfo(index, PageSize, count, enumerable.ToList());
        }
        #endregion

        #region ADO.NET增刪改查方法
        /// <summary>
        /// 執行增刪改方法,含事務處理
        /// </summary>
        public virtual object ExecuteSqlCommand(string sql, params DbParameter[] para)
        {
            try
            {
                return this.Context.Database.ExecuteSqlCommand(sql, para);
            }
            catch (Exception e)
            {
                throw e;
            }

        }
        /// <summary>
        /// 執行多條SQL，增刪改方法,含事務處理
        /// </summary>
        public virtual object ExecuteSqlCommand(Dictionary<string, object> sqllist)
        {
            try
            {
                int rows = 0;
                IEnumerator<KeyValuePair<string, object>> enumerator = sqllist.GetEnumerator();
                using (Transaction)
                {
                    while (enumerator.MoveNext())
                    {
                        rows += this.Context.Database.ExecuteSqlCommand(enumerator.Current.Key, enumerator.Current.Value);
                    }
                    Commit();
                }
                return rows;
            }
            catch (Exception e)
            {
                Rollback();
                throw e;
            }

        }
        /// <summary>
        /// 執行查詢方法,返回動態類，接收使用var，遍歷時使用dynamic類型
        /// </summary>
        public virtual object ExecuteSqlQuery(string sql, params DbParameter[] para)
        {
            try
            {
                return this.Context.Database.SqlQueryForDynamic(sql, para);
            }
            catch (Exception e)
            {
                throw e;
            }
        }
        #endregion
    }
}

 

 

需要用的Common公共幫助類

這寫類庫，大家去【C#公共幫助類】找一下。有些公共幫助類，我還沒來得及發布，請大家耐心等待一下哈~~~理解、理解~~

PS1：大家的實現類 是不是找不到SqlFunctionForDynamic 這個方法，這是我的失誤，因為剛才有點工作的事，忘記了，現在補充上

我們在Service類庫下面新建一個 查詢動態類 DatabaseExtensions

 

 

代碼如下：添加上這個類之后 那個方法就有了

 

using System;
using System.Collections;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Data.Entity;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Text;

namespace Service
{
    /// <summary>
    /// 查詢動態類
    /// add yuangang by 2016-05-10
    /// </summary>
    public static class DatabaseExtensions
    {
        /// <summary>
        /// 自定義Connection對象
        /// </summary>
        private static IDbConnection DefaultConnection 
        {
            get
            {
                return Domain.MyConfig.DefaultConnection;
            }
        }
        /// <summary>
        /// 自定義數據庫連接字符串，與EF連接模式一致
        /// </summary>
        private static string DefaultConnectionString 
        {
            get 
            {
                return Domain.MyConfig.DefaultConnectionString;
            }
        }
        /// <summary>
        /// 動態查詢主方法
        /// </summary>
        /// <returns></returns>
        public static IEnumerable SqlQueryForDynamic(this Database db,
                string sql,
                params object[] parameters)
        {
            IDbConnection defaultConn = DefaultConnection;

            //ADO.NET數據庫連接字符串
            db.Connection.ConnectionString = DefaultConnectionString;

            return SqlQueryForDynamicOtherDB(db, sql, defaultConn, parameters);
        }
        private static IEnumerable SqlQueryForDynamicOtherDB(this Database db,  string sql, IDbConnection conn, params object[] parameters)
        {
            conn.ConnectionString = db.Connection.ConnectionString;

            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            IDbCommand cmd = conn.CreateCommand();
            cmd.CommandText = sql;
            if (parameters != null)
            {
                foreach (var item in parameters)
                {
                    cmd.Parameters.Add(item);
                }
            }

            using (IDataReader dataReader = cmd.ExecuteReader())
            {

                if (!dataReader.Read())
                {
                    return null; //無結果返回Null
                }

                #region 構建動態字段

                TypeBuilder builder = DatabaseExtensions.CreateTypeBuilder(
                    "EF_DynamicModelAssembly",
                    "DynamicModule",
                    "DynamicType");

                int fieldCount = dataReader.FieldCount;
                for (int i = 0; i < fieldCount; i++)
                {
                    Type t = dataReader.GetFieldType(i);
                    switch (t.Name.ToLower())
                    {
                        case "decimal":
                            t = typeof(Decimal?);
                            break;
                        case "double":
                            t = typeof(Double?);
                            break;
                        case "datetime":
                            t = typeof(DateTime?);
                            break;
                        case "single":
                            t = typeof(float?);
                            break;
                        case "int16":
                            t = typeof(int?);
                            break;
                        case "int32":
                            t = typeof(int?);
                            break;
                        case "int64":
                            t = typeof(int?);
                            break;
                        default:
                            break;
                    }
                    DatabaseExtensions.CreateAutoImplementedProperty(
                        builder,
                        dataReader.GetName(i),
                        t);
                }

                #endregion

                cmd.Parameters.Clear();
                dataReader.Close();
                dataReader.Dispose();
                cmd.Dispose();
                conn.Close();
                conn.Dispose();

                Type returnType = builder.CreateType();

                if (parameters != null)
                {
                    return db.SqlQuery(returnType, sql, parameters);
                }
                else
                {
                    return db.SqlQuery(returnType, sql);
                }
            }
        }

        private static TypeBuilder CreateTypeBuilder(string assemblyName, string moduleName, string typeName)
        {
            TypeBuilder typeBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(
              new AssemblyName(assemblyName),
              AssemblyBuilderAccess.Run).DefineDynamicModule(moduleName).DefineType(typeName,
              TypeAttributes.Public);
            typeBuilder.DefineDefaultConstructor(MethodAttributes.Public);
            return typeBuilder;
        }

        private static void CreateAutoImplementedProperty(TypeBuilder builder, string propertyName, Type propertyType)
        {
            const string PrivateFieldPrefix = "m_";
            const string GetterPrefix = "get_";
            const string SetterPrefix = "set_";

            // Generate the field.
            FieldBuilder fieldBuilder = builder.DefineField(
              string.Concat(
                PrivateFieldPrefix, propertyName),
              propertyType,
              FieldAttributes.Private);

            // Generate the property
            PropertyBuilder propertyBuilder = builder.DefineProperty(
              propertyName,
              System.Reflection.PropertyAttributes.HasDefault,
              propertyType, null);

            // Property getter and setter attributes.
            MethodAttributes propertyMethodAttributes = MethodAttributes.Public
              | MethodAttributes.SpecialName
              | MethodAttributes.HideBySig;

            // Define the getter method.
            MethodBuilder getterMethod = builder.DefineMethod(
                string.Concat(
                  GetterPrefix, propertyName),
                propertyMethodAttributes,
                propertyType,
                Type.EmptyTypes);

            // Emit the IL code.
            // ldarg.0
            // ldfld,_field
            // ret
            ILGenerator getterILCode = getterMethod.GetILGenerator();
            getterILCode.Emit(OpCodes.Ldarg_0);
            getterILCode.Emit(OpCodes.Ldfld, fieldBuilder);
            getterILCode.Emit(OpCodes.Ret);

            // Define the setter method.
            MethodBuilder setterMethod = builder.DefineMethod(
              string.Concat(SetterPrefix, propertyName),
              propertyMethodAttributes,
              null,
              new Type[] { propertyType });

            // Emit the IL code.
            // ldarg.0
            // ldarg.1
            // stfld,_field
            // ret
            ILGenerator setterILCode = setterMethod.GetILGenerator();
            setterILCode.Emit(OpCodes.Ldarg_0);
            setterILCode.Emit(OpCodes.Ldarg_1);
            setterILCode.Emit(OpCodes.Stfld, fieldBuilder);
            setterILCode.Emit(OpCodes.Ret);

            propertyBuilder.SetGetMethod(getterMethod);
            propertyBuilder.SetSetMethod(setterMethod);
        }

        public static dynamic SqlFunctionForDynamic(this Database db,
                string sql,
                params object[] parameters)
        {
            IDbConnection conn = DefaultConnection;

            //ADO.NET數據庫連接字符串
            conn.ConnectionString = DefaultConnectionString;

            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            IDbCommand cmd = conn.CreateCommand();
            cmd.CommandText = sql;
            cmd.CommandType = CommandType.StoredProcedure;
            if (parameters != null)
            {
                foreach (var item in parameters)
                {
                    cmd.Parameters.Add(item);
                }
            }
            //1、DataReader查詢數據
            using (IDataReader dataReader = cmd.ExecuteReader())
            {
                if (!dataReader.Read())
                {
                    return null;
                }
                //2、DataReader轉換Json
                string jsonstr = Common.JsonConverter.ToJson(dataReader);
                dataReader.Close();
                dataReader.Dispose();
                cmd.Dispose();
                conn.Close();
                conn.Dispose();
                //3、Json轉換動態類
                dynamic dyna = Common.JsonConverter.ConvertJson(jsonstr);
                return dyna;
            }
        }
        /// <summary>
        /// 對可空類型進行判斷轉換(*要不然會報錯)
        /// </summary>
        /// <param name="value">DataReader字段的值</param>
        /// <param name="conversionType">該字段的類型</param>
        /// <returns></returns>
        private static object CheckType(object value, Type conversionType)
        {
            if (conversionType.IsGenericType && conversionType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
            {
                if (value == null)
                    return null;
                System.ComponentModel.NullableConverter nullableConverter = new System.ComponentModel.NullableConverter(conversionType);
                conversionType = nullableConverter.UnderlyingType;
            }
            return Convert.ChangeType(value, conversionType);
        }

        /// <summary>
        /// 判斷指定對象是否是有效值
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        private static bool IsNullOrDBNull(object obj)
        {
            return (obj == null || (obj is DBNull)) ? true : false;
        }
    }
}

 

 

 

 

原創文章 轉載請尊重勞動成果 http://yuangang.cnblogs.com