.NET(C#) 设计模式
.NET(C#) 设计模式
简介
设计模式（Design pattern）是代码设计经验的总结。设计模式主要分三个类型:创建型、结构型和行为型。创建型是对象实例化的模式，创建型模式用于解耦对象的实例化过程，主要用于创建对象。结构型是把类或对象结合在一起形成一个更大的结构，主要用于优化不同类、对象、接口之间的结构关系。行为型是类和对象如何交互，及划分责任和算法。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。
创建型
单例模式（Singleton）
单例模式，属于创建类型的一种常用的软件设计模式。通过单例模式的方法创建的类在当前进程中只有一个实例。
1）普通单例模式
using System;
namespace SingletonPattern
{
///
/// 单例模式(非线程安全)
///
public class Singleton
{
private static Singleton singleton;
private Singleton() { }
///
/// 获取实例-线程非安全模式
///
///
public static Singleton GetSingleton()
{
if (singleton == null)
singleton = new Singleton();
return singleton;
}
}
class Program
{
static void Main(string[] args)
{
var obj = Singleton.GetSingleton();
Console.ReadKey();
}
}
}
2）懒汉式单例模式
using System;
namespace ConsoleApplication
{
///
/// 单例类：一个构造对象很耗时耗资源类型
///
/// 懒汉式单例模式
///
public class Singleton// //泛型类型里面的静态字段，是随着不同的类型参数唯一的 泛型单例是不可能的
{
///
/// 构造函数耗时耗资源
///
private Singleton()
{
}
///
/// 全局唯一静态 重用这个变量
///
private static volatile Singleton _Singleton = null;
//volatile是C#中用于控制同步的关键字，其意义是针对程序中一些敏感数据，
//不允许多线程同时访问，保证数据在任何访问时刻，最多有一个线程访问，以保证数据的完整性，volatile是修饰变量的修饰符。
private static object Singleton_Lock = new object();
///
/// 2 公开的静态方法提供对象实例
///
///
public static Singleton CreateInstance()
{
if (_Singleton == null)
{
lock (Singleton_Lock)//保证只有一个线程进去判断+初始化
{
if (_Singleton == null)
{
_Singleton = new Singleton();
}
}
}
return _Singleton;
}//懒汉式 调用了方法才去构造
}
class Program
{
static void Main(string[] args)
{
var obj = Singleton.CreateInstance();
Console.ReadKey();
}
}
}
3）饿汉式单例模式
using System;
namespace ConsoleApplication
{
///
/// 单例类：一个构造对象很耗时耗资源类型
/// 饿汉式
///
public class Singleton
{
///
/// 构造函数耗时耗资源
///
private Singleton()
{
}
///
/// 静态字段：在第一次使用这个类之前，由CLR保证，初始化且只初始化一次
/// 这个比今天构造函数还早
///
private static Singleton _Singleton = new Singleton();
public static Singleton CreateInstance()
{
return _Singleton;
}//饿汉式 只要使用类就会被构造
}
class Program
{
static void Main(string[] args)
{
var obj = Singleton.CreateInstance();
Console.ReadKey();
}
}
}
或者
using System;
namespace ConsoleApplication
{
///
/// 单例类：一个构造对象很耗时耗资源类型
///
/// 饿汉式
///
public class Singleton
{
///
/// 1 构造函数耗时耗资源
///
private Singleton()
{
}
///
/// 静态构造函数:由CLR保证，程序第一次使用这个类型前被调用，且只调用一次
///
///
static Singleton()
{
_Singleton = new Singleton();
}
private static Singleton _Singleton = null;
public static Singleton CreateInstance()
{
return _Singleton;
}//饿汉式 只要使用类就会被构造
}
class Program
{
static void Main(string[] args)
{
var obj= Singleton.CreateInstance();
Console.ReadKey();
}
}
}
工厂方法模式（Factory Method）
工厂方法模式（Factory Method）的出现解决简单工厂中的难以拓展的问题，解决了其一旦添加新的产品，则需要修改简单工厂方法，进而造成简单工厂的实现逻辑过于复杂。工厂方法模式通过面向对象编程中的多态性来将对象的创建延迟到具体工厂中，把具体产品的创建推迟到子类中，此时工厂类不再负责所有产品的创建，而只是给出具体工厂必须实现的接口，工厂方法模式就可以允许系统不修改工厂类逻辑的情况下来添加新产品，也就克服了简单工厂模式中缺点。工厂方法模式也是属于创建型模式。
using System;
namespace ConsoleApplication
{
//一般每个接口或类都写在单独的.cs文件中
//本示例为了执行查看方便才写在一起
public interface IDatabase
{
void Delete();
void Insert();
}
//Sqlserver的增删
public class Sqlserver : IDatabase
{
public void Delete()
{
Console.WriteLine("delete data from sqlserver");
}
public void Insert()
{
Console.WriteLine("insert data to sqlserver");
}
}
//Mysql的增删
public class Mysql : IDatabase
{
public void Delete()
{
Console.WriteLine("delete data from Mysql");
}
public void Insert()
{
Console.WriteLine("insert data to Mysql");
}
}
public interface ICreator
{
IDatabase CreateDatabase();
}
public class MysqlFactory:ICreator
{
/// <summary>
/// 负责创建Mysql
/// </summary>
/// <returns></returns>
public IDatabase CreateDatabase()
{
return new Mysql();
}
}
public class SqlserverFactory:ICreator
{
/// <summary>
/// 负责创建Sqlserver
/// </summary>
/// <returns></returns>
public IDatabase CreateDatabase()
{
return new Sqlserver();
}
}
/*public static class IFactory
{
//根据需求创建
public static Database CreateDatabase(string dbType)
{
Database db = null;
switch (dbType)
{
case "Sqlserver":
db = new Sqlserver();
break;
case "Mysql":
db = new Mysql();
break;
default:
break;
}
return db;
}
}*/
class Program
{
static void Main(string[] args)
{
IDatabase db1 = new SqlserverFactory().CreateDatabase();
db1.Delete();
db1.Insert();
IDatabase db2 = new MysqlFactory().CreateDatabase();
db2.Delete();
db2.Insert();
//添加新数据库直接添加对应的类即可
Console.ReadKey();
}
}
}
抽象工厂模式（Abstract Factory）
抽象工厂模式（Abstract Factory Pattern）是一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。工厂方法模式是为了克服简单工厂模式的缺点而设计出来的,简单工厂模式的工厂类着产品类的增加需要增加额外的代码，而工厂方法模式每个具体工厂类只完成单个实例的创建,它具有很好的可扩展性。但是在现实生活中，一个工厂只创建单个产品比较少，工厂都多元化，一个工厂创建一系列的产品，如果我们要设计这样的系统时，工厂方法模式就不太适用，而使用抽象工厂模式却可以很好地解决。
using System;
namespace ConsoleApplication
{
//一般每个接口或类都写在单独的.cs文件中
//本示例为了执行查看方便才写在一起
public interface IDatabase
{
void Delete();
void Insert();
}
public interface IORM
{
void Delete();
void Insert();
}
//Sqlserver的增删
public class Sqlserver : IDatabase
{
public void Delete()
{
Console.WriteLine("delete data from sqlserver");
}
public void Insert()
{
Console.WriteLine("insert data to sqlserver");
}
}
//Mysql的增删
public class Mysql : IDatabase
{
public void Delete()
{
Console.WriteLine("delete data from Mysql");
}
public void Insert()
{
Console.WriteLine("insert data to Mysql");
}
}
//Sqlserver的增删
public class SqlserverORM : IORM
{
public void Delete()
{
Console.WriteLine("delete data from sqlserver by ORM");
}
public void Insert()
{
Console.WriteLine("insert data to sqlserver by ORM");
}
}
//Mysql的增删
public class MysqlORM : IORM
{
public void Delete()
{
Console.WriteLine("delete data from Mysql by ORM");
}
public void Insert()
{
Console.WriteLine("insert data to Mysql by ORM");
}
}
public interface ICreator
{
IDatabase CreateDatabase();
IORM CreateORM();
}
public class MysqlFactory:ICreator
{
///
/// 负责创建Mysql
///
///
public IDatabase CreateDatabase()
{
return new Mysql();
}
///
/// 负责创建MysqlORM
///
///
public IORM CreateORM()
{
return new MysqlORM();
}
}
public class SqlserverFactory:ICreator
{
///
/// 负责创建Sqlserver
///
///
public IDatabase CreateDatabase()
{
return new Sqlserver();
}
///
/// 负责创建SqlserverORM
///
///
public IORM CreateORM()
{
return new SqlserverORM();
}
}
/*public static class IFactory
{
//根据需求创建
public static Database CreateDatabase(string dbType)
{
Database db = null;
switch (dbType)
{
case "Sqlserver":
db = new Sqlserver();
break;
case "Mysql":
db = new Mysql();
break;
default:
break;
}
return db;
}
}*/
class Program
{
static void Main(string[] args)
{
IDatabase db1 = new SqlserverFactory().CreateDatabase();
db1.Delete();
db1.Insert();
IDatabase db2 = new MysqlFactory().CreateDatabase();
db2.Delete();
db2.Insert();
IORM db3 = new SqlserverFactory().CreateORM();
db3.Delete();
db3.Insert();
IORM db4 = new MysqlFactory().CreateORM();
db4.Delete();
db4.Insert();
//添加新数据库直接添加对应的类即可
Console.ReadKey();
}
}
}
结构型
适配器模式（Adapter Pattern）
适配器模式（Adapter Pattern）也称包装样式或者包装(wrapper)。将一个类的接口转接成用户所期待的。适配器模式是一种结构型模式，一个适配使得因接口不兼容而不能在一起工作的类工作在一起，做法是将类自己的接口包裹在一个已存在的类中。将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
1）类适配器模式
using System;
namespace ConsoleApplication
{
//目标接口
//现有的
interface ITarget
{
void request();
}
//用户所期待的
class Adaptee
{
public void specificRequest()
{
Console.WriteLine("适配者中的业务代码被调用！");
}
}
//类适配器类
class ClassAdapter : Adaptee, ITarget
{
public void request()
{
specificRequest();
}
}
//客户端代码
class Program
{
public static void Main(String[] args)
{
Console.WriteLine("类适配器模式测试：");
ITarget target = new ClassAdapter();
target.request();
}
}
}
2）对象适配器模式
using System;
namespace ConsoleApplication
{
//目标接口
//现有的
interface ITarget
{
void request();
}
//用户所期待的
class Adaptee
{
public void specificRequest()
{
Console.WriteLine("适配者中的业务代码被调用！");
}
}
//对象适配器类
class ObjectAdapter : ITarget
{
private Adaptee adaptee;
public ObjectAdapter(Adaptee adaptee)
{
this.adaptee = adaptee;
}
public void request()
{
adaptee.specificRequest();
}
}
//客户端代码
class Program
{
public static void Main(String[] args)
{
Console.WriteLine("对象适配器模式测试：");
Adaptee adaptee = new Adaptee();
ITarget target = new ObjectAdapter(adaptee);
target.request();
}
}
}
