[c#基础]使用抽象工厂实现三层

引言

昨天加了一天班，今天闲来无事，就在想如何将之前的三层和最近一直在学的设计模式给联系在一起，然后就动手弄了个下面的小demo。

项目结构

项目各个层实现

Wolfy.Model层中有一个抽象类BaseModel.cs，User.cs是用户实体类，继承与BaseModel类，是用于类型安全考虑的，让各实体类有个统一的父类，在其他层使用的时候，可以使用里氏替换原则的考虑。

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

namespace Wolfy.Model
{
   /// <summary>
   /// 该抽象类为所有实体类的父类，
   /// 所有实体类继承该抽象类， 为保持类型一致而设计的父类，也是出于安全性的考虑
   /// </summary>
   public abstract class BaseModel
   {
   }
}

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

namespace Wolfy.Model
{
   /// <summary>
   /// 实体类user继承自BaseModel
   /// 调用时就可以通过BaseModel model=new UserModel();
   /// </summary>
   public class UserModel : BaseModel
   {
       public int Id { get; set; }
       public string UserName { set; get; }
       public string Password { set; get; }
   }
}

Wolfy.FactoryDAL层是用于反射获取实例，其中只有一个类。

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

namespace Wolfy.FactoryDAL
{
   public class DataAccess<T> where T : class
   {
       //获取配置路径
       private static readonly string path = System.Configuration.ConfigurationManager.AppSettings["DAL"];
       private DataAccess() { }
       /// <summary>
       /// 创建实例 反射创建实例
       /// </summary>
       /// <param name="type"></param>
       /// <returns></returns>
       public static T CreateDAL(string type)
       {
           string className = string.Format(path + ".{0}", type);
           try
           {
               return (T)System.Reflection.Assembly.Load(path).CreateInstance(className);

           }
           catch (Exception ex)
           {
               throw new Exception(ex.Message.ToString());
           }
       }
   }
}

Wolfy.IDAL层依赖与Wolfy.Model，其中包含一个基接口IBaseDAL.cs，还有一个用于定义一些基接口中没有方法的接口IUserDAL，继承基接口IBaseDAL<T>

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

namespace Wolfy.IDAL
{
   /// <summary>
   /// 所有的dal基本都有增删改查等功能，提取到dal接口层，
   /// 所有实现该接口的类必须实现所有的未实现的成员
   /// </summary>
   /// <typeparam name="T"></typeparam>
   public interface IBaseDAL<T> where T : Model.BaseModel, new()
   {
       bool Add(T model);
       bool Detele(int ID);
       bool Update(T model);
       T GetModel(int ID);
   }
}

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

namespace Wolfy.IDAL
{
   /// <summary>
   /// 需有特殊的方法的 可定义子接口 
   /// </summary>
   public interface  IUserDAL:IBaseDAL<Model.UserModel>
   {
       /// <summary>
       /// 判断用户名是否存在
       /// </summary>
       /// <param name="userName"></param>
       /// <returns></returns>
       bool Exists(string userName);
       /// <summary>
       /// 登录
       /// </summary>
       /// <param name="name"></param>
       /// <param name="pwd"></param>
       /// <returns></returns>
       Model.UserModel Login(string name, string pwd);
   }
}

Wolfy.DAL层，处理数据库的操作。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data;
using System.Data.SqlClient;
namespace Wolfy.DAL
{
   public class UserDAL : Wolfy.IDAL.IUserDAL
   {
       public bool Exists(string userName)
       {
           string sql = "select count(*) from Users where UserName=@UserName";
           SqlParameter[] sp = { 
                               new SqlParameter("@UserName",userName)
                               };

           return (int)SqlHelper.ExecuteScalar(CommandType.Text, sql, sp) > 0;
       }

       public bool Add(Model.UserModel model)
       {
           string sql = "insert into Users values(@UserName,@UserPwd)";
           SqlParameter[] sp = { 
                               new SqlParameter("@UserName",model.UserName),
                                   new SqlParameter("@UserName",model.Password)
                               };
           return SqlHelper.ExecuteNonQuery(CommandType.Text, sql, sp) > 0;
       }

       public bool Detele(int ID)
       {
           string sql = "delete from Users where id=" + ID;
           return SqlHelper.ExecuteNonQuery(CommandType.Text, sql) > 0;
       }

       public bool Update(Model.UserModel model)
       {
           string sql = string.Format("update Users set UserName={0},UserPwd={1} where id={2}", model.UserName, model.Password, model.Id);
           return SqlHelper.ExecuteNonQuery(CommandType.Text, sql) > 0;
       }

       public Model.UserModel GetModel(int ID)
       {
           string sql = "select * from Users where id=" + ID;
           DataTable dt = SqlHelper.ExecuteDataTable(sql);
           if (dt != null && dt.Rows.Count > 0)
           {
               return new Model.UserModel() { UserName = dt.Rows[0]["UserName"].ToString(), Password = dt.Rows[0]["UserPwd"].ToString() };
           }
           else
           {
               return null;
           }
       }


       public Model.UserModel Login(string name, string pwd)
       {
           Model.UserModel model = null;
           string sql = "select * from Users where UserName=@UserName and UserPwd=@UserPwd";
           SqlParameter[] sp = { 
                               new SqlParameter("@UserName",name),
                               new SqlParameter("@UserPwd",pwd)
                               };
           SqlDataReader reader = SqlHelper.ExecuteReader(CommandType.Text, sql, sp);
           if (reader != null && !reader.IsClosed && reader.HasRows)
           {
               model = new Model.UserModel();
               while (reader.Read())
               {
                   model.Id = Convert.ToInt32(reader[0]);
                   model.UserName = reader[1].ToString();
                   model.Password = reader[2].ToString();
               }
           }
           reader.Dispose();
           return model;
       }
   }
}

using System;
using System.Data;
using System.Xml;
using System.Data.SqlClient;
using System.Collections;
using System.Configuration;
using System.IO;
using System.Web;


namespace Wolfy.DAL
{
   /// <summary>
   /// 数据库的通用访问代码
   /// 此类为抽象类，不允许实例化，在应用时直接调用即可
   /// </summary>
   public abstract class SqlHelper
   {
       //获取数据库连接字符串，其属于静态变量且只读，项目中所有文档可以直接使用，但不能修改
       public static readonly string connectionString = ConfigurationManager.ConnectionStrings["SqlConnect"].ConnectionString;


       // 哈希表用来存储缓存的参数信息，哈希表可以存储任意类型的参数。
       private static Hashtable parmCache = Hashtable.Synchronized(new Hashtable());

       /// <summary>
       ///执行一个不需要返回值的SqlCommand命令，通过指定专用的连接字符串。
       /// 使用参数数组形式提供参数列表 
       /// </summary>
       /// <remarks>
       /// 使用示例：
       ///  int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
       /// </remarks>
       /// <param name="connectionString">一个有效的数据库连接字符串</param>
       /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
       /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
       /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
       /// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
       public static int ExecuteNonQuery(CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
       {
           SqlCommand cmd = new SqlCommand();
           using (SqlConnection conn = new SqlConnection(connectionString))
           {
               //通过PrePareCommand方法将参数逐个加入到SqlCommand的参数集合中
               PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
               int val = cmd.ExecuteNonQuery();
               //清空SqlCommand中的参数列表
               cmd.Parameters.Clear();
               return val;
           }
       }

       /// <summary>
       ///执行一条不返回结果的SqlCommand，通过一个已经存在的数据库连接 
       /// 使用参数数组提供参数
       /// </summary>
       /// <remarks>
       /// 使用示例：  
       ///  int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
       /// </remarks>
       /// <param name="conn">一个现有的数据库连接</param>
       /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
       /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
       /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
       /// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
       public static int ExecuteNonQuery(SqlConnection connection, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
       {
           SqlCommand cmd = new SqlCommand();
           PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
           int val = cmd.ExecuteNonQuery();
           cmd.Parameters.Clear();
           return val;
       }

       /// <summary>
       /// 执行一条不返回结果的SqlCommand，通过一个已经存在的数据库事物处理 
       /// 使用参数数组提供参数
       /// </summary>
       /// <remarks>
       /// 使用示例： 
       ///  int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
       /// </remarks>
       /// <param name="trans">一个存在的 sql 事物处理</param>
       /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
       /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
       /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
       /// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
       public static int ExecuteNonQuery(SqlTransaction trans, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
       {
           SqlCommand cmd = new SqlCommand();
           PrepareCommand(cmd, trans.Connection, trans, cmdType, cmdText, commandParameters);
           int val = cmd.ExecuteNonQuery();
           cmd.Parameters.Clear();
           return val;
       }

       /// <summary>
       /// 执行一条返回结果集的SqlCommand命令，通过专用的连接字符串。
       /// 使用参数数组提供参数
       /// </summary>
       /// <remarks>
       /// 使用示例：  
       ///  SqlDataReader r = ExecuteReader(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
       /// </remarks>
       /// <param name="connectionString">一个有效的数据库连接字符串</param>
       /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
       /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
       /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
       /// <returns>返回一个包含结果的SqlDataReader</returns>
       public static SqlDataReader ExecuteReader(CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
       {
           SqlCommand cmd = new SqlCommand();
           SqlConnection conn = new SqlConnection(connectionString);
           // 在这里使用try/catch处理是因为如果方法出现异常，则SqlDataReader就不存在，
           //CommandBehavior.CloseConnection的语句就不会执行，触发的异常由catch捕获。
           //关闭数据库连接，并通过throw再次引发捕捉到的异常。
           try
           {
               PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
               SqlDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
               cmd.Parameters.Clear();
               return rdr;
           }
           catch
           {
               conn.Close();
               throw;
           }
       }

       /// <summary>
       /// 执行一条返回第一条记录第一列的SqlCommand命令，通过专用的连接字符串。 
       /// 使用参数数组提供参数
       /// </summary>
       /// <remarks>
       /// 使用示例：  
       ///  Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
       /// </remarks>
       /// <param name="connectionString">一个有效的数据库连接字符串</param>
       /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
       /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
       /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
       /// <returns>返回一个object类型的数据，可以通过 Convert.To{Type}方法转换类型</returns>
       public static object ExecuteScalar(CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
       {
           SqlCommand cmd = new SqlCommand();
           using (SqlConnection connection = new SqlConnection(connectionString))
           {
               PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
               object val = cmd.ExecuteScalar();
               cmd.Parameters.Clear();
               return val;
           }
       }

       /// <summary>
       /// 执行一条返回第一条记录第一列的SqlCommand命令，通过已经存在的数据库连接。
       /// 使用参数数组提供参数
       /// </summary>
       /// <remarks>
       /// 使用示例： 
       ///  Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
       /// </remarks>
       /// <param name="conn">一个已经存在的数据库连接</param>
       /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
       /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
       /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
       /// <returns>返回一个object类型的数据，可以通过 Convert.To{Type}方法转换类型</returns>
       public static object ExecuteScalar(SqlConnection connection, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
       {
           SqlCommand cmd = new SqlCommand();
           PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
           object val = cmd.ExecuteScalar();
           cmd.Parameters.Clear();
           return val;
       }

       /// <summary>
       /// 缓存参数数组
       /// </summary>
       /// <param name="cacheKey">参数缓存的键值</param>
       /// <param name="cmdParms">被缓存的参数列表</param>
       public static void CacheParameters(string cacheKey, params SqlParameter[] commandParameters)
       {
           parmCache[cacheKey] = commandParameters;
       }

       /// <summary>
       /// 获取被缓存的参数
       /// </summary>
       /// <param name="cacheKey">用于查找参数的KEY值</param>
       /// <returns>返回缓存的参数数组</returns>
       public static SqlParameter[] GetCachedParameters(string cacheKey)
       {
           SqlParameter[] cachedParms = (SqlParameter[])parmCache[cacheKey];
           if (cachedParms == null)
               return null;
           //新建一个参数的克隆列表
           SqlParameter[] clonedParms = new SqlParameter[cachedParms.Length];
           //通过循环为克隆参数列表赋值
           for (int i = 0, j = cachedParms.Length; i < j; i++)
               //使用clone方法复制参数列表中的参数
               clonedParms[i] = (SqlParameter)((ICloneable)cachedParms[i]).Clone();
           return clonedParms;
       }

       /// <summary>
       /// 为执行命令准备参数
       /// </summary>
       /// <param name="cmd">SqlCommand 命令</param>
       /// <param name="conn">已经存在的数据库连接</param>
       /// <param name="trans">数据库事物处理</param>
       /// <param name="cmdType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
       /// <param name="cmdText">Command text，T-SQL语句 例如 Select * from Products</param>
       /// <param name="cmdParms">返回带参数的命令</param>
       private static void PrepareCommand(SqlCommand cmd, SqlConnection conn, SqlTransaction trans, CommandType cmdType, string cmdText, SqlParameter[] cmdParms)
       {
           //判断数据库连接状态
           if (conn.State != ConnectionState.Open)
               conn.Open();
           cmd.Connection = conn;
           cmd.CommandText = cmdText;
           //判断是否需要事物处理
           if (trans != null)
               cmd.Transaction = trans;
           cmd.CommandType = cmdType;
           if (cmdParms != null)
           {
               foreach (SqlParameter parm in cmdParms)
                   cmd.Parameters.Add(parm);
           }
       }

       /// <summary>
       /// 获取dataset数据
       /// </summary>
       /// <param name="sql"></param>
       /// <returns></returns>
       public static DataTable ExecuteDataTable(string sql)
       {
           using (SqlConnection conn = new SqlConnection(connectionString))
           {
               SqlDataAdapter da = new SqlDataAdapter(sql, conn);
               DataTable dst = new DataTable();
               da.Fill(dst);
               return dst;
           }
       }
   }
}

Wolfy.BLL业务逻辑层中包含了一个用于继承的基类BaseBLL<T>和用户业务逻辑UserBLL类，这层依赖Wolfy.IDAL,Wolfy.Model,Wolfy.FactoryDAL库

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

namespace Wolfy.BLL
{
   public class BaseBLL<T> where T : Wolfy.Model.UserModel, new()
   {
       protected Wolfy.IDAL.IBaseDAL<T> Dal;
       public BaseBLL(string type)
       {
           //通过工厂得到 dal
           Dal = Wolfy.FactoryDAL.DataAccess<Wolfy.IDAL.IBaseDAL<T>>.CreateDAL(type);
       }
       public virtual bool Add(T model)
       {
           return Dal.Add(model);
       }
       public virtual bool Delete(int ID)
       { return Dal.Detele(ID); }
       public virtual bool Update(T model)
       { return Dal.Update(model); }
       public virtual T GetModel(int ID)
       {
           return Dal.GetModel(ID);
       }
      
   }
}

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

namespace Wolfy.BLL
{
   public class UserBLL : BaseBLL<Wolfy.Model.UserModel>
   {
       private const string _Type = "UserDAL";
       private Wolfy.IDAL.IUserDAL _DAL;
       public UserBLL()
           : base(_Type)
       {
           _DAL = base.Dal as Wolfy.IDAL.IUserDAL;
           if (_DAL == null)
           {
               throw new NullReferenceException(_Type);
           }
       }
       public bool Exists(string userName)
       {
           return _DAL.Exists(userName);
       }
       public Model.UserModel Login(string name, string pwd)
       { return _DAL.Login(name, pwd); }
   }
}

web.config程序集名称，连接字符串配置

<?xml version="1.0" encoding="utf-8"?>
<!--
 有关如何配置 ASP.NET 应用程序的详细信息，请访问
 http://go.microsoft.com/fwlink/?LinkId=169433
 -->
<configuration>
 <system.web>
   <compilation debug="true" targetFramework="4.5" />
   <httpRuntime targetFramework="4.5" />

 </system.web>
 <connectionStrings>
   <add name="SqlConnect" connectionString="server=.;database=Test;uid=sa;pwd=sa"/>
 </connectionStrings>
<appSettings>
 <add key="DAL" value="Wolfy.DAL"/>
</appSettings>
</configuration>

测试

简单的ajax登录，web项目需引用Wolfy.BLL.dll和Wolfy.Model.dll和Wolfy.DAL.dll

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
   <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
   <title>wolfy信息系统登录</title>
   <script type="text/javascript" src="Scripts/jquery-1.11.0.js"></script>
   <script type="text/javascript">
       $(function () {
           $("#btnLogin").click(function () {
               var name = $("#txtUserName").val();
               var pwd = $("#txtPwd").val();
               $.ajax({
                   url: "Ashx/Login.ashx",
                   data: "name=" + name + "&pwd=" + pwd,
                   type: "Post",
                   dataType: "text",
                   success: function (msg) {
                       if (msg == "1") {
                           $("#divMsg").html("登录成功");
                       } else if(msg=="2") {
                           $("#divMsg").html("用户名或密码为空");
                       } else if(msg=="3"){
                           $("#divMsg").html("用户名不存在");
                       } else {
                           $("#divMsg").html("密码错误");
                       }
                   }


               });
           });
       });
   </script>
</head>
<body>
   <table>
       <tr>
           <td>用户名：</td>
           <td><input type="text" id="txtUserName" name="name" value="admin" /></td>
       </tr>
       <tr>
           <td>密码：</td>
           <td><input type="password" id="txtPwd" name="name" value="admin" /></td>
       </tr>
       <tr>
           <td colspan="2"><input type="button" id="btnLogin" name="name" value="登录" /></td>
       </tr>
   </table>
   <div id="divMsg"></div>
</body>
</html>

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace Wolfy.LoginDemo.Ashx
{
   /// <summary>
   /// Login 的摘要说明
   /// </summary>
   public class Login : IHttpHandler
   {

       public void ProcessRequest(HttpContext context)
       {
           context.Response.ContentType = "text/plain";
           //接收用户名和密码
           string name = context.Request["name"];
           string pwd = context.Request["pwd"];
           if (string.IsNullOrEmpty(name) || string.IsNullOrEmpty(pwd))
           {
               context.Response.Write("2");
           }
           else
           {
               BLL.UserBLL bll = new BLL.UserBLL();
               Model.UserModel model = new Model.UserModel();
               if (!bll.Exists(name))
               {
                   context.Response.Write("3");
               }
               else
               {
                   model = bll.Login(name, pwd);
                   if (model != null)
                   {
                       //登录成功记入cookie
                       context.Response.Cookies["n"].Value = name;
                       context.Response.Cookies["n"].Expires = DateTime.Now.AddDays(7);
                       context.Response.Cookies["p"].Value = pwd;
                       context.Response.Cookies["p"].Expires = DateTime.Now.AddDays(7);
                       context.Response.Write("1");
                   }
               }



           }
       }

       public bool IsReusable
       {
           get
           {
               return false;
           }
       }
   }
}

结果

源码下载：http://pan.baidu.com/s/1hqqSUrU

总结

参考文章：http://www.cnblogs.com/cmsdn/p/3494461.html

参考着这篇文章，敲了一遍，实践了一下。在博客园，虽然有很多提供代码的园友，但是自己动手实践一下，就可以发现其中好与不好的地方，也可以加深理解。

博客地址：

http://www.cnblogs.com/wolf-sun/

博客版权：

本文以学习、研究和分享为主，欢迎转载，但必须在文章页面明显位置给出原文连接。
如果文中有不妥或者错误的地方还望高手的你指出，以免误人子弟。如果觉得本文对你有所帮助不如【推荐】一下！如果你有更好的建议，不如留言一起讨论，共同进步！
再次感谢您耐心的读完本篇文章。

转载：http://www.cnblogs.com/wolf-sun/p/3562156.html