浅谈.NET策略模式

　　策略模式在我们日常开发中经常被用到，这篇文章不是策略模式的深入讨论和学术研究，只是让初学者能有个基本的了解。

　　什么叫策略：1. 可以实现目标的方案集合；2. 根据形势发展而制定的行动方针和斗争方法；3. 有斗争艺术，能注意方式方法。

　　什么叫模式：模式（Pattern）其实就是解决某一类问题的方法论。把解决某类问题的方法总结归纳到理论高度，那就是模式。模式是一种指导，在一个良好的指导下，有助于你完成任务，有助于你作出一个优良的设计方案，达到事半功倍的效果。而且会得到解决问题的***办法。

　　什么叫策略模式：策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。

　　从上面的官方解释来看，我们已经有了一个基本的雏形。其实设计模式就是前辈们所总结出来的，用来解决某类问题的方法论；这些方法论是经过身经百战的专家们提炼出来的，比较规范的、比较科学的模型。

　　其实设计模式对初学者来说可能有点头疼，比较抽象。大概就是因为初学者对一些概念不能深度的理解，一些理论知识还没能够融会贯通，不过不要紧经过一段时间的实践锻炼就能理解了；下面我们循环渐进的来讲解什么叫策略模式。我们拿真实项目中遇到的问题来讲解吧，这样能更好的吸引注意力。

　　情景引入：

　　您是否遇到过这样一个头疼的问题，在我们开发信息系统的时候，经常需要切换不同的数据库。但是由于我们前期开发项目的时候没有考虑到后期的变更，所以这个时候问题就来了。如果需要更换数据库，将大动干戈把代码翻个底朝天。将诸如一些Sql、Oledb、Oracle之类的对象进行全局替换。这样的设计永远都无法满足日后的数据库变更需求。所以在前期设计的时候，我们就需要考虑到系统后期可能存在哪些可能变化的地方，在系统的架构上就需要变通设计(比如：依赖接口而不是具体的对象，通过依赖注入等方式进行策略的变更；)。其实这个时候我们很需要一种模式能解决此类问题，恰好前辈们为我们准备好了(策略模式)。[设计模式的设计原则：尽可能的考虑系统后期的变化；]

　　1.没有分析之前的系统结构：

情景分析：

　　我们暂且不谈设计模式，我们试着自己分析一下问题。我们需要一种机制，能在需要的时候自动变更后台数据源的连接对象；我们来收集问题，既然要自动变更后台数据源连接对象，那么我们在编码的过程中就不能直接使用一些诸如SqlConnection、SqlCommand等对象，必须进行提取形成接口，消除类之间的强耦合。[面向对象编程原则：面向接口编程，而不是面向实现编程；]

　　2.分析之后的系统结构图：

情景分析->接口提取：

/*----------------------------------------------------------------  
　　* 作者：王清培  
　　* 时间：2010-10-29  
　　* ----------------------------------------------------------------*/ 
　　using System;  
　　using System.Collections.Generic;  
　　using System.Text;  
　　using System.Data;  
　　using System.Data.SqlClient;  
　　namespace W.Data  
　　{  
　　/// <summary>  
　　/// 通用数据源类型接口，  
　　/// 确定每种数据源必须实现基本的对IDbConnection，IDbCommand，IDbTransaction 三者的包装；  
　　/// </summary>  
　　public interface IDataSourceType  
　　{  
　　#region 属性  
　　/// <summary>  
　　/// 获取或设置数据源连接字符串。  
　　/// </summary>  
　　string ConnectionString { get; set; }  
　　#endregion  
　　/// <summary>  
　　/// 开始数据库事务。  
　　/// </summary>  
　　void BeginTransaction();  
　　/// <summary>  
　　/// 提交事务处理。  
　　/// </summary>  
　　void Commit();  
　　/// <summary>  
　　/// 从挂起状态回滚事务。  
　　/// </summary>  
　　void Rollback();  
　　/// <summary>  
　　/// 执行查询，并返回查询所返回的结果集DataSet。  
　　/// </summary>  
　　/// <param name="cmdText">要执行的命令文本</param>  
　　/// <returns>DataSet</returns>  
　　DataSet ExecuteDataSet(string commandtext);  
　　/// <summary>  
　　/// 执行查询，并返回查询所返回的结果集DataSet。  
　　/// </summary>  
　　/// <param name="commandtype"> 指定如何解释命令字符串。</param>  
　　/// <param name="commandtext">命令文本</param>  
　　/// <param name="parameter">IDbDataParameter参数列表</param>  
　　/// <returns>DataSet</returns>  
　　DataSet ExecuteDataSet(CommandType commandtype, string commandtext, params IDataParameter[] parameter);  
　　/// <summary>  
　　/// 对连接执行 Transact-SQL 语句并返回受影响的行数。  
　　/// </summary>  
　　/// <param name="cmdText">命令文本</param>  
　　/// <returns>受影响的行数</returns>  
　　int ExecuteNonQuery(string cmdText);  
　　/// <summary>  
　　/// 对连接执行 Transact-SQL 语句并返回受影响的行数。  
　　/// </summary>  
　　/// <param name="commandtype">指定如何解析命令字符串</param>  
　　/// <param name="commandtext">命令文本</param>  
　　/// <param name="parameter">IDbDataParameter参数列表</param>  
　　/// <returns>受影响的行数</returns>  
　　int ExecuteNonQuery(CommandType commandtype, string commandtext, params IDataParameter[] parameter);  
　　/// <summary>  
　　/// 对连接执行 Transact-SQL 语句并返回受影响的行数。  
　　/// </summary>  
　/// <param name="conn">IDbConnection对象</param>  
　/// <param name="cmdType">指定如何解析命令字符串</param>  
　　/// <param name="cmdText">命令文本</param>  
　　/// <param name="commandParameters">IDbDataParameter参数列表</param>  
　/// <returns>受影响的行数</returns>  
　　int ExecuteNonQuery(IDbConnection conn, CommandType cmdType, string cmdText, params IDataParameter[] parameter);  
　　/// <summary>  
　　///对连接执行 Transact-SQL 语句并返回受影响的行数。已事务的方式执行  
　　/// </summary>  
　　/// <param name="trans">IDbTransaction对象。</param>  
　　/// <param name="cmdType">指定如何解析命令字符串。</param>  
　　/// <param name="cmdText">命令文本。</param>  
　　/// <param name="commandParameters">IDbDataParameter参数列表。</param>  
　　/// <returns>受影响的行数。</returns>  
　　int ExecuteNonQuery(IDbTransaction trans, CommandType cmdType, string cmdText, params IDataParameter[] parameter);  
　　/// <summary>  
　　/// 将 System.Data.SqlClient.SqlCommand.CommandText 发送到  
　　/// System.Data.SqlClient.SqlCommand.Connection 并生成一个 System.Data.SqlClient.SqlDataReader。  
　　/// </summary>  
　　/// <param name="cmdText">执行的命令文本</param>  
　　/// <returns>IDataReader对象</returns>  
　　IDataReader ExecuteReader(string cmdText);  
　　/// <summary>  
　　/// 将 System.Data.SqlClient.SqlCommand.CommandText 发送到  
　　/// System.Data.SqlClient.SqlCommand.Connection 并生成一个 System.Data.SqlClient.SqlDataReader。  
　　/// </summary>  
　　/// <param name="cmdType">指定如何解析命令字符串</param>  
　　/// <param name="cmdText">命令文本</param>  
　　/// <param name="commandParameters">IDataParameter参数列表</param>  
　　/// <returns>IDataReader对象</returns>  
　　IDataReader ExecuteReader(CommandType cmdType, string cmdText, params IDataParameter[] parameter);  
　　/// <summary>  
　　/// 执行查询，并返回查询所返回的结果集中***行的***列。忽略其他列或行。  
　　/// </summary>  
　　/// <param name="cmdText">命令文本</param>  
　　/// <returns>结果集中***行的***列；如果结果集为空，则为空引用（在 Visual Basic 中为 Nothing）</returns>  
　　object ExecuteScalar(string cmdText);  
　　/// <summary>  
　　/// 执行查询，并返回查询所返回的结果集中***行的***列。忽略其他列或行。  
　　/// </summary>  
　　/// <param name="cmdType">指定如何解析命令字符串</param>  
　　/// <param name="cmdText">命令文本</param>  
　　/// <param name="commandParameters">IDataParameter参数列表</param>  
　　/// <returns>结果集中***行的***列；如果结果集为空，则为空引用（在 Visual Basic 中为 Nothing）。</returns>  
　　object ExecuteScalar(CommandType cmdType, string cmdText, params IDataParameter[] parameter);  
　　/// <summary>  
　　/// 执行查询，并返回查询所返回的结果集DataTable。  
　　/// </summary>  
　　/// <param name="cmdText">命令文本</param>  
　　/// <returns>DataTable</returns>  
　　DataTable ExecuteTable(string cmdText);  
　　/// <summary>  
　　///执行查询，并返回查询所返回的结果集DataTable。  
　　/// </summary>  
　　/// <param name="cmdType">指定如何解析命令字符串</param>  
　　/// <param name="cmdText">命令文本</param>  
　　/// <param name="commandParameters">IDataParameter参数列表</param>  
　　/// <returns>DataTable</returns>  
　　DataTable ExecuteTable(CommandType cmdType, string cmdText, params IDataParameter[] parameter);  
　　/// <summary>  
　　/// 关闭数据库连接。  
　　/// </summary>  
　　void Close();  
　　/// <summary>  
　　/// 执行与释放或重置非托管资源相关的应用程序定义的任务。  
　　/// </summary>  
　　void Dispose();  
　　}  
　　} 

　　情景分析->OLEDB数据源实现：

/*----------------------------------------------------------------    
 * 作者：王清培    
 * 时间：2010-10-29    
 * ----------------------------------------------------------------*/   
using System;    
using System.Collections.Generic;    
using System.Text;    
using System.Configuration;    
using System.Data.OleDb;    
using System.Data;    
namespace W.Data    
{    
    /// <summary>    
    /// OLEDB数据源    
    /// </summary>    
    public sealed class OledbSource : IDataSourceType, IDisposable    
    {    
        #region 字段    
        /// <summary>    
        /// 是否已开始数据库事务处理    
        /// </summary>    
        private bool _begin = false;    
        /// <summary>    
       /// IDbConnection对象（包装的SqlConnection对象）    
        /// </summary>    
        private OleDbConnection _connection;    
        /// <summary>    
        /// IDbTransaction对象（包装的SqlTransaction对象）    
        /// </summary>    
       private OleDbTransaction _transaction;    
        /// <summary>    
        /// 静态全局（SQLServerSource数据源）实例连接字符串对象；    
        /// </summary>    
        private static string _globalconnectionstring = string.Empty;    
       #endregion    
        #region 属性    
        /// <summary>    
        /// 获取，静态全局SQLServerSource数据源实例连接字符串对象；    
        /// </summary>    
        public static string GlobalConnectionString    
        {    
            get { return _globalconnectionstring; }    
        }    
        /// <summary>    
        /// 获取或设置本次执行的数据源的连接字符串    
        /// </summary>    
        public string ConnectionString    
        {    
            get { return _connection.ConnectionString; }    
            set { _connection.ConnectionString = value; }    
        }    
        /// <summary>    
        /// 获取包装的SqlTransaction对象    
        /// </summary>    
        public OleDbTransaction SqlTransaction    
        {    
            get { return _transaction; }    
        }    
        #endregion    
        #region 构造函数    
        /// <summary>    
        /// 静态构造函数。    
        /// </summary>    
        static OledbSource()    
        {    
            //设置全局（SQLServerSource实例）对象的默认连接字符串    
            _globalconnectionstring = ConfigurationManager.ConnectionStrings["ConnectionString"].ConnectionString;    
        }    
        /// <summary>    
        ///默认实例构造函数    
        /// </summary>    
        public OledbSource()    
        {    
            _connection = new OleDbConnection(_globalconnectionstring);    
        }    
        /// <summary>    
        /// 重载构造函数，使用指定连接字符串来初始化 CommandLib.Data.SQLServerSource  类的新实例。默认所有的SQLServerSource实例均使用    
        /// 配置文件中的SQLServerConnectionString类型的连接字符串。    
        /// </summary>    
        /// <param name="connectionstring">连接字符串</param>    
        public OledbSource(string connectionstring)    
        {    
            _connection = new OleDbConnection(connectionstring);    
        }    
        #endregion    
        #region 实例方法    
        /// <summary>    
        /// 开始数据库事务。    
        /// </summary>    
        public void BeginTransaction()    
        {    
           _begin = true;    
            _connection.Open();    
            _transaction = _connection.BeginTransaction();//新建数据源的事务对象    
        }    
        /// <summary>    
        /// 提交事务处理。    
        /// </summary>    
        public void Commit()    
        {    
            _begin = false;    
            _transaction.Commit();    
            _transaction = null;//事务执行完毕全部清除（事务不是很常用不需要一直保留）    
            _connection.Close();    
        }    
        /// <summary>    
        /// 从挂起状态回滚事务。    
        /// </summary>    
        public void Rollback()    
        {    
            _begin = false;    
            _transaction.Rollback();    
            _transaction = null;//事务执行完毕全部清除（事务不是很常用不需要一直保留）    
            _connection.Close();    
        }    
        /// <summary>    
       ///  执行查询，并返回查询所返回的结果集DataSet。    
        /// </summary>    
        /// <param name="commandtext">命令文本</param>    
        /// <returns>DataSet</returns>    
        public DataSet ExecuteDataSet(string commandtext)    
        {    
            return ExecuteDataSet(CommandType.Text, commandtext, null);    
        }    
        /// <summary>    
        /// 执行查询，并返回查询所返回的结果集DataSet。    
        /// </summary>    
        /// <param name="commandtype">指定如何解释命令字符串</param>    
        /// <param name="commandtext">命令文本</param>    
        /// <param name="parameter">IDbDataParameter参数列表</param>    
        /// <returns>DataSet</returns>    
        public DataSet ExecuteDataSet(CommandType commandtype, string commandtext, params IDataParameter[] parameter)    
        {    
            if (_connection.State == ConnectionState.Closed)    
                _connection.Open();    
            OleDbCommand commmand = InitSqlCommand(commandtype, commandtext, parameter);    
            OleDbDataAdapter adapter = new OleDbDataAdapter(commmand);    
            DataSet ds = new DataSet();    
            adapter.Fill(ds);    
            return ds;    
        }    
        /// <summary>    
        /// 对连接执行 Transact-SQL 语句并返回受影响的行数。    
        /// </summary>    
        /// <param name="cmdText">命令文本</param>    
        /// <returns>受影响的行数</returns>    
        public int ExecuteNonQuery(string cmdText)    
        {    
            return ExecuteNonQuery(CommandType.Text, cmdText, null);    
        }    
        /// <summary>    
        /// 对连接执行 Transact-SQL 语句并返回受影响的行数。    
        /// </summary>    
        /// <param name="commandtype">IDbConnection对象</param>    
        /// <param name="commandtext">指定如何解析命令字符串</param>    
        /// <param name="parameter">命令文本</param>    
        /// <returns>受影响的行数</returns>    
        public int ExecuteNonQuery(CommandType commandtype, string commandtext, params IDataParameter[] parameter)    
        {    
            if (_connection.State == ConnectionState.Closed)    
                _connection.Open();    
            OleDbCommand command = InitSqlCommand(commandtype, commandtext, parameter);    
            return command.ExecuteNonQuery();    
        }    
        /// <summary>    
        /// 重载ExecuteNonQuery方法。    
        /// </summary>    
        /// <param name="conn">IDbConnection对象</param>    
        /// <param name="cmdType">指定如何解析命令字符串</param>    
        /// <param name="cmdText">命令文本</param>    
        /// <param name="commandParameters">IDbDataParameter参数列表</param>    
        /// <returns>受影响的行数</returns>    
        public int ExecuteNonQuery(IDbConnection conn, CommandType cmdType, string cmdText, params IDataParameter[] parameter)    
        {    
            OleDbCommand command = InitSqlCommand(cmdType, cmdText, parameter);    
            command.Connection = (conn as OleDbConnection);    
            return command.ExecuteNonQuery();    
        }    
        /// <summary>    
        /// 重载ExecuteNonQuery方法。以事务的方式执行    
        /// </summary>    
        /// <param name="trans">IDbTransaction对象。</param>    
        /// <param name="cmdType">指定如何解析命令字符串。</param>    
        /// <param name="cmdText">命令文本。</param>    
        /// <param name="commandParameters">IDbDataParameter参数列表。</param>    
        /// <returns>受影响的行数。</returns>    
        public int ExecuteNonQuery(IDbTransaction trans, CommandType cmdType, string cmdText, params IDataParameter[] parameter)    
        {    
            OleDbCommand command = InitSqlCommand(cmdType, cmdText, parameter);    
            command.Transaction = (trans as OleDbTransaction);    
            return command.ExecuteNonQuery();    
        }    
        /// <summary>    
        /// 将 System.Data.SqlClient.SqlCommand.CommandText 发送到    
        /// System.Data.SqlClient.SqlCommand.Connection 并生成一个 System.Data.SqlClient.SqlDataReader。    
        /// </summary>    
        /// <param name="cmdText">执行的命令文本</param>    
       /// <returns>IDataReader对象</returns>    
        public IDataReader ExecuteReader(string cmdText)    
        {    
            return ExecuteReader(CommandType.Text, cmdText, null);    
        }    
        /// <summary>    
        /// 将 System.Data.SqlClient.SqlCommand.CommandText 发送到    
        /// System.Data.SqlClient.SqlCommand.Connection 并生成一个 System.Data.SqlClient.SqlDataReader。    
        /// </summary>    
        /// <param name="cmdType">指定如何解析命令字符串</param>    
        /// <param name="cmdText">命令文本</param>    
        /// <param name="commandParameters">IDataParameter参数列表</param>    
        /// <returns>IDataReader对象</returns>    
        public IDataReader ExecuteReader(CommandType cmdType, string cmdText, params IDataParameter[] parameter)    
        {    
            OleDbCommand command = InitSqlCommand(cmdType, cmdText, parameter);    
            return command.ExecuteReader();    
        }    
        /// <summary>    
        /// 执行查询，并返回查询所返回的结果集中***行的***列。忽略其他列或行。    
        /// </summary>    
        /// <param name="cmdText">命令文本</param>    
        /// <returns>结果集中***行的***列；如果结果集为空，则为空引用（在 Visual Basic 中为 Nothing）</returns>    
        public object ExecuteScalar(string cmdText)    
        {    
            return ExecuteScalar(CommandType.Text, cmdText, null);    
        }    
        /// <summary>    
        ///  执行查询，并返回查询所返回的结果集中***行的***列。忽略其他列或行。    
        /// </summary>    
        /// <param name="cmdType">指定如何解析命令字符串</param>    
        /// <param name="cmdText">命令文本</param>    
        /// <param name="commandParameters">IDataParameter参数列表</param>    
        /// <returns>结果集中***行的***列；如果结果集为空，则为空引用（在 Visual Basic 中为 Nothing）。</returns>    
        public object ExecuteScalar(CommandType cmdType, string cmdText, params IDataParameter[] parameter)    
        {    
            OleDbCommand command = InitSqlCommand(cmdType, cmdText, parameter);    
            return command.ExecuteScalar();    
        }    
        /// <summary>    
        /// 执行查询，并返回查询所返回的结果集DataTable。    
        /// </summary>    
        /// <param name="cmdText">命令文本</param>    
        /// <returns>DataTable</returns>    
        public DataTable ExecuteTable(string cmdText)    
        {    
            return ExecuteTable(CommandType.Text, cmdText, null);    
        }    
        /// <summary>    
        ///执行查询，并返回查询所返回的结果集DataTable。    
        /// </summary>    
        /// <param name="cmdType">指定如何解析命令字符串</param>    
        /// <param name="cmdText">命令文本</param>    
        /// <param name="commandParameters">IDataParameter参数列表</param>    
        /// <returns>DataTable</returns>    
        public DataTable ExecuteTable(CommandType cmdType, string cmdText, params IDataParameter[] parameter)    
        {    
            OleDbCommand command = InitSqlCommand(cmdType, cmdText, parameter);    
            DataTable resulttb = new DataTable();    
            OleDbDataAdapter adapter = new OleDbDataAdapter(command);    
            adapter.Fill(resulttb);    
            return resulttb;    
        }    
        /// <summary>    
        /// 私有方法实现内部类的SqlCommand的初始化    
        /// </summary>    
        /// <param name="commandtype">IDbConnection对象</param>    
        /// <param name="commandtext">指定如何解析命令字符串</param>    
        /// <param name="parameter">命令文本</param>    
        /// <returns>SqlCommand</returns>    
        private OleDbCommand InitSqlCommand(CommandType commandtype, string commandtext, params IDataParameter[] parameter)    
        {    
            OleDbCommand command = new OleDbCommand(commandtext, _connection);    
            command.CommandType = commandtype;    
            if (_transaction != null)    
                command.Transaction = _transaction;    
            if (parameter != null)    
                command.Parameters.AddRange(parameter);    
            return command;    
        }    
        /// <summary>    
        /// 关闭数据库连接。    
        /// </summary>    
        public void Close()    
        {    
            _connection.Close();    
        }    
        /// <summary>    
        /// 执行与释放或重置非托管资源相关的应用程序定义的任务。    
        /// </summary>    
        public void Dispose()    
        {    
            _connection.Dispose();    
        }    
        #endregion    
    }    
}  

　　这段代码来源我自己的ORM框架中的。我假设实现一个Oledb数据源。但是怎么将对象送给前台调用者呢，方法有很多中可以通过工厂、IOC控制器、策略方法都可以，我是用的工厂实现的；这里我就不贴出代码了，给出调用代码吧，可以完整的结束了；

　　情景分析->调用代码：

　　/// <summary>  
　　/// 根据实体对象和IDataSourceType对象删除一条记录，  
　　/// 该实体必须明确主键值才能删除记录；如果该实体没有主键可自己编写SQL代码删除；  
　　/// </summary>  
　　/// <typeparam name="T">要删除的表对应的实体对象</typeparam>  
　　/// <param name="t">Model实体</param>  
　　/// <param name="idatasource">IDataSourceType数据源类型对象</param>  
　　/// <returns>删除是否成功；1成功，0失败</returns>  
　　public static int DeleteModelById<T>(T t, IDataSourceType idatasource) where T : new()  
　　{  
　　string sqlstring;//保存要执行的T-SQL语句  
　　List<IDataParameter> paramlist = (List<IDataParameter>)GetDeleteModelParameterT_SQL<T>(t, out sqlstring);//获取利用Model删除时的语句和参数列表  
　　if (idatasource != null)  
　　return idatasource.ExecuteNonQuery(CommandType.Text, sqlstring, paramlist.ToArray());  
　　return IDataSourceTypeFactory.Create().ExecuteNonQuery(CommandType.Text, sqlstring, paramlist.ToArray());  
　　} 

　　总结：调用程序使用接口统一调用数据源不需要关心后台是什么数据源，工厂通过在策略集合中找到合适的策略给调用着；策略模式大概就讲完了，谢谢。

原文链接：http://www.cnblogs.com/wangiqngpei557/archive/2011/07/20/2111450.html

【编辑推荐】

1. 看老外程序员如何向妻子解释OOD
2. 看老外程序员如何向妻子解释设计模式
3. 同是80后程序员 为什么差距却如此大
4. 设计模式 UML简介
5. 老Web前端设计者谈对div绝对定位的心得