【.Net设计模式系列】仓储(Repository)模式 ( 一 )

开篇

2016新年伊始，望眼过去，不知不觉在博客园已经注册8个月啦，由于最近忙于工作，博客迟迟没有更新。直到最近一直研究.Net设计模式，对一些模式有所感悟，故拿出自己的心得与大家分享，在接下来的所有博客中我都会以【理论介绍】和【具体实践】两个方面来叙述对模式的应用。

理论介绍

仓储(Respository)是存在于工作单元和数据库之间单独分离出来的一层，是对数据访问的封装。其优点：

　　　　1）业务层不需要知道它的具体实现，达到了分离关注点。

　　　　2）提高了对数据库访问的维护，对于仓储的改变并不会改变业务的逻辑，数据库可以用Sql Server（该系列博客使用）、MySql等。

具体实践

首先，创建IRepository.cs接口定义对数据操作的契约(命令执行、重载不同查询结果集合、查询实体、查询返回结果值)。

     /// <summary>
     /// Ado.Net实现的仓储
     /// </summary>
     public interface IRepository
     {
         /// <summary>
         /// 增、删、改对象
         /// </summary>
         /// <param name="commandText">Sql语句</param>
         /// <param name="parameters">参数</param>
         /// <param name="isCommit">是否提交</param>
         /// <returns></returns>
         void Command(string commandText, IDictionary<string, object> parameters = null);

         /// <summary>
         /// 查询对象集合
         /// </summary>
         /// <typeparam name="T">返回值的实体类型</typeparam>
         /// <param name="commandText">Sql语句</param>
         /// <param name="parameters">参数</param>
         /// <param name="isCommit">是否提交</param>
         /// <returns>泛型实体集合</returns>
         List<T> QueryAll<T>(string commandText, IDictionary<string, object> parameters = null) where T : class, new();

         /// <summary>
         /// 查询对象集合
         /// </summary>
         /// <param name="commandText"></param>
         /// <param name="type"></param>
         /// <param name="parameters"></param>
         /// <param name="isCommit"></param>
         /// <returns></returns>
         List<object> QueryAll(string commandText, Type type, IDictionary<string, object> parameters = null);

         /// <summary>
         /// 查询对象
         /// </summary>
         /// <typeparam name="TEntity"></typeparam>
         /// <param name="commandText"></param>
         /// <param name="type"></param>
         /// <param name="parameters"></param>
         /// <returns></returns>
         T Query<T>(string commandText, IDictionary<string, object> parameters = null) where T : class,new();

         /// <summary>
         /// 查询数量
         /// </summary>
         /// <param name="commandText"></param>
         /// <param name="parameters"></param>
         /// <returns></returns>
         object QueryCount(string commandText, IDictionary<string, object> parameters = null);
     }

其次，定义抽象类BaseRepository.cs实现仓储。

     /// <summary>
     /// 基础库实现
     /// </summary>
     public abstract class BaseRepository : IRepository
     {
     /// <summary>
         /// 数据库连接字符串标识
         /// </summary>
         public abstract string Key { get; }

         private SqlConnection connection;

         private SqlConnection Connection
         {
             get
             {
                 if (connection == null)
                 {
                     ConnectionStringSettings settings = ConfigurationManager.ConnectionStrings[Key];
                     connection = new SqlConnection(settings.ConnectionString);
                 }
                 return connection;
             }
         }

         /// <summary>
         /// 增、删、改命令
         /// </summary>
         /// <param name="commandText"></param>
         /// <param name="parameters"></param>
         public virtual void Command(string commandText, IDictionary<string, object> parameters = null)
         {
             Func<SqlCommand, int> excute = (commend) =>
             {
                 return commend.ExecuteNonQuery();
             };
             CreateDbCommondAndExcute<int>(commandText, parameters, excute);
         }

         /// <summary>
         /// 查询实体（强类型）
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="commandText"></param>
         /// <param name="parameters"></param>
         /// <returns></returns>
         public virtual T Query<T>(string commandText, IDictionary<string, object> parameters = null,Func<IDataReader, T> load = null) where T : class, new()
         {
             Func<SqlCommand, T> excute = (dbCommand) =>
             {

                 var result = default(T);
                 using (IDataReader reader = dbCommand.ExecuteReader())
                 {
                     while (reader.Read())
                     {
                         if (load == null)
                         {
                             load = (s) => { return s.GetReaderData<T>(); };
                         }
                         result = load(reader);
                     }
                     return result;
                 }
             };
             return CreateDbCommondAndExcute<T>(commandText, parameters, excute);
         }

         /// <summary>
         /// 查询匿名对象集合
         /// </summary>
         /// <param name="commandText"></param>
         /// <param name="type"></param>
         /// <param name="parameters"></param>
         /// <returns></returns>
         public virtual List<object> QueryAll(string commandText, Type type, IDictionary<string, object> parameters = null,Action<dynamic> setItem = null)
         {
             Func<SqlCommand, List<object>> excute = (dbCommand) =>
             {
                 var result = new List<object>();

                 using (IDataReader dataReader = dbCommand.ExecuteReader())
                 {
                     while (dataReader.Read())
                     {
                         var item = dataReader.GetReaderData(type);
                         if (setItem != null)
                         {
                             setItem(item);
                         }
                         result.Add(item);
                     }
                 }
                 return result;
             };
             return CreateDbCommondAndExcute<List<object>>(commandText, parameters,
                 excute);
         }

         /// <summary>
         /// 查询强类型对象集合
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="commandText"></param>
         /// <param name="parameters"></param>
         /// <returns></returns>
         public virtual List<T> QueryAll<T>(string commandText, IDictionary<string, object> parameters = null,Func<IDataReader, T> load = null) where T : class, new()
         {
            Func<SqlCommand, List<T>> excute = (dbCommand) =>
             {
                 List<T> result = new List<T>();
                 using (IDataReader reader = dbCommand.ExecuteReader())
                 {
                     while (reader.Read())
                     {
                         if (load == null)
                         {
                             load = (s) => { return s.GetReaderData<T>(); };
                         }
                         var item = load(reader);
                         result.Add(item);
                     }
                     return result;
                 }
             };
             return CreateDbCommondAndExcute(commandText, parameters, excute);
         }

         /// <summary>
         /// 查询结果数量
         /// </summary>
         /// <param name="commandText"></param>
         /// <param name="parameters"></param>
         /// <returns></returns>
         public virtual object QueryCount(string commandText, IDictionary<string, object> parameters = null)
         {
              Func<SqlCommand, object> excute = (dbCommand) =>
             {
                 return dbCommand.ExecuteScalar();
             };
             return CreateDbCommondAndExcute(commandText, parameters, excute);
         }

     /// <summary>
         /// 创建命令并执行
         /// </summary>
         /// <typeparam name="TValue"></typeparam>
         /// <param name="commandText"></param>
         /// <param name="parameters"></param>
         /// <param name="excute"></param>
         /// <returns></returns>
         private TValue CreateDbCommondAndExcute<TValue>(string commandText,
             IDictionary<string, object> parameters, Func<SqlCommand, TValue> excute)
         {
             if (Connection.State == ConnectionState.Closed) { Connection.Open(); };
             using (SqlCommand command = new SqlCommand())
             {
                 command.CommandType = CommandType.Text;
                 command.CommandText = commandText;;
                 command.Connection = Connection;
                 command.SetParameters(parameters);
                 return excute(command);
             }
         }

         /// <summary>
         /// 关闭连接
         /// </summary>
         public void Dispose()
         {
             if (connection != null)
             {
                 Connection.Dispose();//非托管资源
             }
         }
     }

最后，实现方法中的扩展方法。

     /// <summary>
     /// Sql Server 扩展类
     /// </summary>
     public static class SqlServerExtension
     {
         /// <summary>
         /// 设置参数
         /// </summary>
         /// <param name="dbCommand"></param>
         /// <param name="parameters"></param>
         public static void SetParameters(this IDbCommand dbCommand, IDictionary<string, object> parameters)
         {
             if (parameters == null)
             {
                 return;
             }
             foreach (var parameter in parameters)
             {
                 if (parameter.Value != null)
                 {
                     dbCommand.Parameters.Add(new SqlParameter(parameter.Key, parameter.Value));
                 }
                 else
                 {
                     dbCommand.Parameters.Add(new SqlParameter(parameter.Key,DBNull.Value));
                 }
             }
         }

         /// <summary>
         ///  获取对应的实体
         /// </summary>
         /// <typeparam name="TEntity"></typeparam>
         /// <param name="TEntity"></param>
         /// <returns></returns>
         public static TEntity GetReaderData<TEntity>(this IDataReader reader) where TEntity : class, new()
         {
             var item = new TEntity();
             var filedList = new List<string>();
             for (int i = ; i < reader.FieldCount; i++)
             {
                 filedList.Add(reader.GetName(i));
             }
             //映射数据库中的字段到实体属性
             IEnumerable<PropertyInfo> propertys = typeof(TEntity).GetProperties().Where(s => filedList.Contains(s.Name));
             foreach (var property in propertys)
             {
                 //对实体属性进行设值
                 property.SetValue(item, reader[property.Name]);
             }
             return item;
         }

         /// <summary>
         /// 根据列名获取值
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="reader"></param>
         /// <param name="columnName"></param>
         /// <returns></returns>
         public static T GetValue<T>(this IDataReader reader, string columnName)
         {
             int index = reader.GetOrdinal(columnName);
             if (reader.IsDBNull(index))
             {
                 return default(T);
             }
             return (T)reader[index];
         }

         /// <summary>
         /// 获取对应的实体
         /// </summary>
         /// <param name="reader"></param>
         /// <param name="type"></param>
         /// <returns></returns>
         public static object GetReaderData(this IDataReader reader,Type type)
         {
             var item = Activator.CreateInstance(type);
             var filedList = new List<string>();
             for (int i = ; i < reader.FieldCount; i++)
             {
                 filedList.Add(reader.GetName(i).ToLower());
             }
             var properties = (from s in type.GetProperties()
                               let name = s.Name.ToLower().Split(new string[] { "_" }, StringSplitOptions.RemoveEmptyEntries).LastOrDefault()
                               where filedList.Contains(s.Name)
                               select new
                               {
                                   Name = s.Name,
                                   Property = s
                               }).ToList();

             foreach (var property in properties)
             {
                 property.Property.SetValue(item, reader[property.Name]);
             }
             return item;
         }
     }

至此，使用Ado.Net 实现的仓储完成啦！当然这只是非泛型版本。当需要使用ORM时，该系列会同步更新泛型版本的实现对聚合类的持久化操作的仓储模式。

后记

相信各位广大园友看到这里，一定不难看出这和DAL层好像没什么区别，没错，对于非泛型的仓储实现等同于DAL层。有人可能会认为这是一种多余的设计，对于未使用ORM的数据存储来说，这里也就只是提供一种额外的设计思路罢了。

在接下来的一篇中将实现数据访问逻辑和领域层完全解耦。