dapper實現的簡單架構

1.首先建立空白的解決方案，然后分別創建TestData.Business（業務邏輯類類庫）引入Dapper和DapperExtensions兩個類庫，可以再網上下載下。TestData.Common（工具類類庫）TestData.Entity（實體類類庫）TestData.Filter（查詢條件類庫）TextData.Web（web應用程序）

在TextData.Web中引入mvc的架構和easyui最終情況如圖所示：

2.創建數據庫中的實體，並創建公用的實體接口：IDataEntity  它里面放着每個實體中都存在的屬性比如：主鍵、修改人、修改時間等

實體類生成小技巧：用ef生成codefirst然后刪除他的映射文件和appconfig然后所有的類繼承IDataEntity接口即可。

在實體類中添加mapping文件夾，寫入基類CustomMapping代碼如下：

using DapperExtensions.Mapper;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TestData.Entity.Mapping
{
    public class CustomMapping<T> : ClassMapper<T> where T : class,IDataEntity
    {
        public CustomMapping()
        {
            Map(x => x.Id).ReadOnly();
        }
    }
}

注：mapping的作用（過濾不想讀取的字段或設置一些字段在數據庫中的含義）

      在繼承CustomMapping的時候除了要寫一些字段的過濾意外在最后一定要寫上AutoMap();他的作用是提交所有的字段

3.在TestData.Filter中添加查詢條件的基類，因為用到了easyui他的表格要接收的東西包含rows、total、所以封裝了一個基類

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TestData.Filter
{
    /// <summary>
    /// 搜索條件的基類包含了頁數 行數  派訊
    /// </summary>
    public class BaseFilter
    {
        private int _page = 1;
        public int page
        {
            set
            {
                _page = value;
            }
            get
            {
                return _page;
            }
        }

        public int _rows = 10;

        public int rows
        {
            set { _rows = value; }
            get { return _rows; }
        }

        private string _sortName = "EditorDate";

        public string sort
        {
            get { return _sortName; }
            set { _sortName = value; }
        }
    }
}

只要在為每個實體寫搜索條件的時候繼承這個類就好咯

4.封裝業務邏輯

      1）添加鏈接對象工廠

　　 

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TestData.Business
{
    public class ConnectionFactory
    {
        private static readonly string ConnString =
            ConfigurationManager.ConnectionStrings["ShopEntity"].ConnectionString;


        private static object _obj = new object();

        public static SqlConnection Connection
        {
            get
            {
                SqlConnection connection = null;

                if (connection == null)
                {
                    lock (_obj)
                    {
                        if (connection == null)
                        {
                            connection = new SqlConnection(ConnString);
                        }
                    }
                }
                return connection;
            }
        }
    }
}

   2）編寫業務邏輯的基類

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Net.Cache;
using System.Text;
using Dapper;
using DapperExtensions;
using TestData.Entity;
using TestData.Business;

namespace TestData.Business
{
    /// <summary>
    /// 業務邏輯的基類  包含了一些簡單的操作
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public abstract class BaseManager<T> where T : class, IDataEntity
    {
        /// <summary>
        /// 查詢所有
        /// </summary>
        /// <returns></returns>
        public IEnumerable<T> GetAll()
        {
            using (var conn = ConnectionFactory.Connection)
            {
                return conn.GetList<T>();
            }
        }

        /// <summary>
        /// 根絕sql查詢
        /// </summary>
        /// <param name="sql">sql</param>
        /// <param name="parameters">參數列表</param>
        /// <returns></returns>
        public IEnumerable<T> SelectCommond(string sql, object parameters = null)
        {
            using (var conn = ConnectionFactory.Connection)
            {
                return conn.Query<T>(sql, parameters);
            }
        }
        /// <summary>
        /// 根據表明查詢
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public IEnumerable<T> GetAll(string name)
        {
            using (var conn = ConnectionFactory.Connection)
            {
                return conn.Query<T>(string.Format("select * from {0}", name));
            }
        }
        /// <summary>
        /// 根據編號查詢
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public T GetById(int? id)
        {
            if (id == null)
                return default(T);
            using (var conn = ConnectionFactory.Connection)
            {

                return conn.Get<T>(id.Value);
            }
        }
        /// <summary>
        /// 修改實體
        /// </summary>
        /// <param name="t">實體對象</param>
        /// <returns></returns>
        public bool Update(T t)
        {
            using (var conn = ConnectionFactory.Connection)
            {
                t.EditorDate = DateTime.Now;
                return conn.Update(t);
            }
        }

        /// <summary>
        /// 得到數量
        /// </summary>
        /// <returns></returns>
        public int GetCount()
        {
            using (var conn = ConnectionFactory.Connection)
            {
                return conn.Count<T>(null);
            }
        }

        /// <summary>
        /// 分頁
        /// </summary>
        /// <param name="predicate"></param>
        /// <param name="pageindex"></param>
        /// <param name="pageSize"></param>
        /// <returns></returns>
        public Tuple<int, IEnumerable<T>> GetPaged(object predicate, int pageindex, int pageSize)
        {
            using (var conn = ConnectionFactory.Connection)
            {
                var sort = new List<ISort>
                    {
                        Predicates.Sort<T>(p=>p.EditorDate)
                    };

                var total = conn.Count<T>(predicate);
                return new Tuple<int, IEnumerable<T>>(total, conn.GetPage<T>(predicate, sort, pageindex, pageSize).ToList());
            }
        }
        /// <summary>
        /// 添加
        /// </summary>
        /// <param name="t">實體對象</param>
        /// <returns></returns>
        public bool Insert(T t)
        {
            t.EditorDate = DateTime.Now;
            return this.Add(t, false) == t.Id;
        }
        /// <summary>
        /// 添加實體集合
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        public bool Insert(List<T> list)
        {
            using (var conn = ConnectionFactory.Connection)
            {
                list.ForEach(p => p.EditorDate = DateTime.Now);
                return conn.Insert(list);
            }
        }


        /// <summary>
        /// 添加實體
        /// </summary>
        /// <param name="t">實體對象</param>
        /// <param name="isAutoGenId"></param>
        /// <returns></returns>
        public int Add(T t, bool isAutoGenId = true)
        {
            using (var conn = ConnectionFactory.Connection)
            {
                //var maxindex = conn.Query<int?>(string.Format("select max(indexs) from {0}", typeof(T).Name)).FirstOrDefault() ?? 0;
                //t.Indexs = maxindex + 1;
                return conn.Insert(t, isGenId: isAutoGenId);
            }
        }
        /// <summary>
        /// 根據編號刪除
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public bool Delete(int? id)
        {
            var obj = this.GetById(id);
            if (obj == null) return false;
            return this.Update(obj);
        }
        /// <summary>
        /// 根據編號修改
        /// </summary>
        /// <param name="id"></param>
        /// <param name="mark"></param>
        /// <returns></returns>
        public bool UpdataStatus(int? id)
        {
            var obj = this.GetById(id);
            if (obj == null) return false;
            return this.Update(obj);
        }
        /// <summary>
        /// 根據外鍵得到數據
        /// </summary>
        /// <param name="foreignKeyName">外鍵名稱</param>
        /// <param name="foreignKeyValue">外鍵的值</param>
        /// <returns></returns>
        public IEnumerable<T> GetByForeignKey(string foreignKeyName, Guid foreignKeyValue)
        {
            using (var conn = ConnectionFactory.Connection)
            {
                return conn.Query<T>(string.Format("select * from {0} where {1}=@value", typeof(T).Name, foreignKeyName), new { value = foreignKeyValue });
            }
        }
        /// <summary>
        /// 根據列查詢
        /// </summary>
        /// <param name="fieldName">列名稱</param>
        /// <param name="fieldValue">列的值</param>
        /// <returns></returns>
        public IEnumerable<T> GetByField(string fieldName, dynamic fieldValue)
        {
            using (var conn = ConnectionFactory.Connection)
            {
                return conn.Query<T>(string.Format("select * from {0} where {1}=@value", typeof(T).Name, fieldName), new { value = fieldValue });
            }
        }
        /// <summary>
        /// lxh 根據某列查詢的方法--帶排序
        /// </summary>
        /// <param name="fieldName">查詢列名</param>
        /// <param name="fieldValue">條件內容</param>
        /// <param name="sortFieldName">排序列名</param>
        /// <returns></returns>
        public IEnumerable<T> GetByField(string fieldName, dynamic fieldValue, string sortFieldName)
        {
            using (var conn = ConnectionFactory.Connection)
            {
                return conn.Query<T>(string.Format("select * from {0} where {1}=@value order by {2}", typeof(T).Name, fieldName, sortFieldName), new { value = fieldValue });
            }
        }

        /// <summary>
        /// lxh 獲取排序號的方法
        /// </summary>
        /// <returns></returns>
        public int GetNextSequence(T t)
        {
            using (var conn = ConnectionFactory.Connection)
            {
                return conn.Query<int>(string.Format("select isnull(max(Sequence),0)+1 from {0}", typeof(T).Name)).FirstOrDefault();
            }
        }
        /// <summary>
        /// 存儲過程
        /// </summary>
        /// <param name="procName"></param>
        /// <param name="obj"></param>
        /// <returns></returns>
        public List<dynamic> SelectProc(string procName, object obj = null)
        {
            using (var conn = ConnectionFactory.Connection)
            {
                return conn.Query(procName, obj, commandType: CommandType.StoredProcedure).ToList();
            }
        }
    }
}

     3）編寫一些特殊的方法、為特殊的sql所使用

using DapperExtensions;
using System;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
using TestData.Entity;
using TestData.Filter;
using Dapper;
namespace TestData.Business
{
    public static class DataExtensions
    {

        public static bool ExecuteTransaction(this SqlConnection conn, Action<SqlConnection, SqlTransaction> action)
        {
            var transaction = conn.BeginTransaction();
            try
            {
                action(conn, transaction);
                transaction.Commit();
                return true;
            }
            catch (Exception)
            {
                transaction.Rollback();
                return false;
            }
        }

        public static PredicateGroup GetPredicate<T>(this BaseFilter filter, int? id = 0) where T : class ,IDataEntity
        {
            var predicate = new PredicateGroup
            {
                Operator = GroupOperator.And,
                Predicates = new List<IPredicate>()
            };

            if (id != 0)
                predicate.Predicates.Add(Predicates.Field<T>(p => p.Id, Operator.Eq, Convert.ToInt32(id)));

            return predicate;
        }

        public static List<ISort> GetSorts<T>(this BaseFilter filter) where T : class
        {

            var expressionparam = Expression.Parameter(typeof(T), "p");
            var bodyExp = Expression.Convert(Expression.Property(expressionparam, filter.sort), typeof(Object));
            var expression = Expression.Lambda<Func<T, object>>(bodyExp, expressionparam);

            return new List<ISort>
                    {
                        Predicates.Sort(expression)
                    };
        }

        public static int Total<T>(this IEnumerable<T> list) where T : class,IDataEntity
        {
            using (var conn = ConnectionFactory.Connection)
            {
                return conn.Count<T>(Predicates.Field<T>(p => p.Id, Operator.Eq, null));
            }
        }

        public static int Total<T>(object predicate) where T : class
        {
            using (var conn = ConnectionFactory.Connection)
            {
                return conn.Count<T>(predicate);
            }
        }

        public static IDataEntity GetSingle(IDataEntity entity)
        {
            using (var conn = ConnectionFactory.Connection)
            {
                return
                    conn.Query<IDataEntity>(string.Format("select * from {0} where id=@ii", entity.GetType().Name), new { ii = entity.Id }).FirstOrDefault();
            }
        }

        public static PageList<T> ToPageList<T>(this IEnumerable<T> iEnumerable, object predicate) where T : class
        {
            return new PageList<T>
            {
                DataList = iEnumerable.ToList(),
                Total = Total<T>(predicate)
            };
        }
    }

    public class PageList<T>
    {
        public List<T> DataList { set; get; }

        public int Total { set; get; }

    }

}

好啦這樣一個簡單的架構就實現啦！！！