设计模式摘录（一）

l 工厂模式（简单、雷锋、抽象）

l 单例模式

l 策略模式

一.工厂模式

1.简单工厂模式：客户类和工厂类分开。消费者任何时候需要某种产品，只需向工厂请求即可。消费者无须修改就可以接纳新产品。缺点是当产品修改时，工厂类也要做相应的修改。如：如何创建及如何向客户端提供。



代码：
class Program
{
static void Main(string[] args)
{
//创建实例并赋值属性，进行运算
Operation oper=OperateFactory.CreateInstance("+");
oper.Num1 = 10;
oper.Num2 = 12;
int a=oper.GetResult();
Console.WriteLine(a);
Console.ReadKey();
}
}
/// <summary>
/// 工厂类
/// </summary>
public partial class OperateFactory {
//创建实例方法
public static Operation CreateInstance(string operater){
Operation oper = null;
switch (operater)
{
case "+":
oper = new Add();
break;
//根据运算符而添加，需要修改该方法
}
return oper;
}
}
//运算基类
public partial class Operation
{
private int num1;

public int Num1
{
get { return num1; }
set { num1 = value; }
}
private int num2;

public int Num2
{
get { return num2; }
set { num2 = value; }
}
public virtual int GetResult() {
int result = 0;
return result;
}
}
//加（其他运算与此类似）
public partial class Add :Operation
{
public override int GetResult()
{
return Num1 + Num2;
}
}
2.工厂方法模式(雷锋工厂)：核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。相比较于简单工厂，雷锋工厂克服了简单工厂违背开放-封闭原则的缺点，又保持了封装对象创建过程的优点。把简单工厂的内部逻辑判断移到了客户端代码来进行。缺点：每加一个产品，就需要加一个产品工厂，增加了开发量。







代码：
class Program
{
static void Main(string[] args)
{
//创建实例并赋值属性，进行运算
IFactory fac = new AddFactory();
Operation oper=fac.CreateInstance();
oper.Num1 = 10;
oper.Num2 = 12;
int a=oper.GetResult();
Console.WriteLine(a);
Console.ReadKey();
}
}
//工厂接口
public interface IFactory{
Operation CreateInstance();
}
//运算基类
public partial class Operation
{
private int num1;

public int Num1
{
get { return num1; }
set { num1 = value; }
}
private int num2;

public int Num2
{
get { return num2; }
set { num2 = value; }
}
public virtual int GetResult() {
int result = 0;
return result;
}
}
//加（其他运算与此类似）
public partial class Add :Operation
{
public override int GetResult()
{
return Num1 + Num2;
}
}
//加法工厂
public partial class AddFactory : IFactory {

public Operation CreateInstance()
{
return new Add();
}
}
3.抽象工厂模式：





代码：class Program
{
static void Main(string[] args)
{
User user = new User();
Department dept = new Department();

IUser iu = DataAccess.CreateUser();

iu.Insert(user);
iu.GetUser(1);
//调用创建实例
IDepartment id = DataAccess.CreateDepartment();
id.Insert(dept);
id.GetDepartment(1);

Console.Read();
}
}
//用户类
class User
{
private int _id;
public int ID
{
get { return _id; }
set { _id = value; }
}

private string _name;
public string Name
{
get { return _name; }
set { _name = value; }
}
}
//部门类
class Department
{
private int _id;
public int ID
{
get { return _id; }
set { _id = value; }
}

private string _deptName;
public string DeptName
{
get { return _deptName; }
set { _deptName = value; }
}
}
//用户接口
interface IUser
{
void Insert(User user);

User GetUser(int id);
}
//sqlserver实现
class SqlserverUser : IUser
{
public void Insert(User user)
{
Console.WriteLine("在Sqlserver中给User表增加一条记录");
}

public User GetUser(int id)
{
Console.WriteLine("在Sqlserver中根据ID得到User表一条记录");
return null;
}
}
//accessuser实现
class AccessUser : IUser
{
public void Insert(User user)
{
Console.WriteLine("在Access中给User表增加一条记录");
}

public User GetUser(int id)
{
Console.WriteLine("在Access中根据ID得到User表一条记录");
return null;
}
}

interface IDepartment
{
void Insert(Department department);

Department GetDepartment(int id);
}

class SqlserverDepartment : IDepartment
{
public void Insert(Department department)
{
Console.WriteLine("在Sqlserver中给Department表增加一条记录");
}

public Department GetDepartment(int id)
{
Console.WriteLine("在Sqlserver中根据ID得到Department表一条记录");
return null;
}
}

class AccessDepartment : IDepartment
{
public void Insert(Department department)
{
Console.WriteLine("在Access中给Department表增加一条记录");
}

public Department GetDepartment(int id)
{
Console.WriteLine("在Access中根据ID得到Department表一条记录");
return null;
}
}
//根据反射获取程序集信息，创建需要的对象（实现数据库灵活的切换）
class DataAccess
{
private static readonly string AssemblyName = "抽象工厂模式";
private static readonly string db = ConfigurationManager.AppSettings["DB"];

public static IUser CreateUser()
{
string className = AssemblyName + "." + db + "User";
return (IUser)Assembly.Load(AssemblyName).CreateInstance(className);
}

public static IDepartment CreateDepartment()
{
string className = AssemblyName + "." + db + "Department";
return (IDepartment)Assembly.Load(AssemblyName).CreateInstance(className);
}
}
二.单例模式（保证一个类竟有一个或几个实例）







代码：
class Program
{
static void Main(string[] args)
{
Person per = Person.CreatePerson();
Person per2 = Person.CreatePerson();
Console.WriteLine("s");
Console.ReadKey();
}
}
/// <summary>
/// 单例模式
/// </summary>
public partial class Person
{
private Person()
{

}
private static Person per;
public static Person CreatePerson() {
if (per == null)
{
per = new Person();
}
return per;
}
}
多线程中的单例模式更改部分代码：（一般保证线程内实例唯一即可）
//双重锁定
public static Person CreatePerson()
{
if (per == null)
{
lock("threadSingleton"){
if(per==null)
{
per = new Person();
}
}
}
return per;
}

三.策略模式：策略模式针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。策略模式把行为和环境分开。环境类负责维持和查询行为类，各种算法在具体的策略类中提供。由于算法和环境独立开来，算法的增减，修改都不会影响到环境和客户端。缺点：具体的实现职责留给了客户端，带来选择压力。可以考虑在Context中结合抽象工厂的factory进行改进，尽量将改变留在配置文件中。





代码：
class Program
{
static void Main(string[] args)
{
//具体实现延迟到客户端
Context context = null;
context = new Context(new ConcreteStrategyA());
context.ContextInstance();
Console.ReadKey();
}
}
/// <summary>
/// 公共接口
/// </summary>
public partial interface IStrategy
{
void Algorithmlnterface();
}
#region 三种实现
public partial class ConcreteStrategyA :IStrategy
{
public void Algorithmlnterface()
{
Console.WriteLine("实现方法一");
}
}

public partial class ConcreteStrategyB : IStrategy
{
public void Algorithmlnterface()
{
Console.WriteLine("实现方法二");
}
}
public partial class ConcreteStrategyC : IStrategy
{
public void Algorithmlnterface()
{
Console.WriteLine("实现方法三");
}
}
#endregion
/// <summary>
/// 根据引用对象调用不同的实现
/// </summary>
public class Context {
private IStrategy strate;
public Context(IStrategy strategy)
{
strate = strategy;
}
public void ContextInstance() {
strate.Algorithmlnterface();
}
}