设计模式就是指设计代码的一些固定结构，每个结构都有不同的用处，通常都用于提高代码复用率，安全性等用途。
设计模式分类：
创建型模式：工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式。
结构型模式：适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式。
行为型模式：策略模式，模板方法模式，观察者模式，迭代子模式，责任链模式，命令模式，备忘录模式，状态模式，访问者模式，中介者模式，解释器模式。
一.单例模式
单例模式的特点：
1.只有一个私有本类静态实例
2.构造方法私有，提供一个对外调用静态实例的get属性
3.全局唯一
单例模式的作用与静态类类似，通过该类的封装结构使全局只有唯一一个该类实例，但和静态类不同的是，单例类作为非静态类仍可继承其他类的方法和变量，但因为构造方法私有，二者都不可被继承。
{
public class SingletonClass
{
private static SingletonClass _single1 = null;
public static SingletonClass single
{
get
{
if(_single1==null)
{
_single1 = new SingletonClass();
}
return _single1;
}
}
private SingletonClass()
{
Console.WriteLine("单例构造方法");
}
public void show()
{
Console.WriteLine("单例类成员方法");
}
}
class Program
{
static void Main(string[] args)
{
SingletonClass s1=SingletonClass.single;//输出:单例构造方法
s1.show();//输出:单例类成员方法
Console.ReadLine();
}
}}
二.观察者模式
一对多的模式，其意义在于当一个对象的属性、变量、行为发生变化时，其余有联系的多个对象会随之变化，而观察者模式即可以使这种模式的代码结构最为简化清晰，但没有固定的写法。
{
//这种是一个泛用的一对多结构
abstract class Subject//主体，一对多中的一
{
protected List<Observer> obs = new List<Observer>();
protected object value;
public void Add(Observer ob)
{
obs.Add(ob);
}
public void Remove(Observer ob)
{
obs.Remove(ob);
}
abstract public void notify();
}
abstract class Observer//观察者，一对多中的多
{
abstract public void Do(object value);
}
class Time:Subject
{
public Time()
{
//时间直接用随机数生成了，可以改代码变成手动赋值
Random rd = new Random();
this.value = (int)rd.Next(0,24);
}
public override void notify()
{
Console.WriteLine("时间:" + value + "点");
foreach(Observer i in obs)
{
i.Do(value);
}
}
}
class Student:Observer
{
public override void Do(object value)
{
if((int)value>7&&(int)value<17)
Console.WriteLine("学生上学");
else Console.WriteLine("学生在家休息");
}
}
class Mother : Observer
{
public override void Do(object value)
{
if ((int)value == 7 || (int)value == 17)
Console.WriteLine("母亲做饭");
else if ((int)value > 7 && (int)value < 17)
Console.WriteLine("母亲做家务");
else Console.WriteLine("母亲休息");
}
}
class Program
{
static void Main(string[] args)
{
Time t = new Time();
Student stu = new Student();
Mother mom = new Mother();
t.Add(stu);
t.Add(mom);
//这样每次改变数值，使用notify函数，即可对应调用多个对象行为
//但本例由于随机数在构造函数赋值，并不能体现这一点，稍加修改即可完成
t.notify();
Console.ReadKey();
}
}}
其中一个随机结果
三.简单工厂模式
该模式的意义在于由一个固定工具对象建立其它各种多态对象的实例，而省去了大量的对象建立的类型管理。使建造对象更加简单。就像一个工厂负责各种不同类型产品的建立而工厂使用方不需要考虑过多的产品类型。但是缺点是如果产品类型逐渐增多，工厂类也需不断更改迭增，匹配产品类型，使类的责任变得不再独立，违反了高内聚的类责任分配标准。
{
//本模式是由枚举来完成的，传递参数时需通过枚举参数来指定产品类型
public enum EnumProduct { Product1, Product2 };//产品类型枚举
public class Factory//工厂类
{
public static Product createPro(EnumProduct enumPro, object value)
{
Product pro;
switch (enumPro)
{
case EnumProduct.Product1:pro= new Product1(value); break;
case EnumProduct.Product2:pro= new Product2(value); break;
default:pro= null;break;
}
return pro;
}
}
public abstract class Product//产品基类
{
protected object value;
abstract public void Do();
}
class Product1 : Product//产品A
{
public Product1(object value)
{
this.value = value;
}
public override void Do()
{
Console.WriteLine("根据参数："+value+",做了一些行为");
}
}
class Product2 : Product//产品B
{
public Product2(object value)
{
this.value = value;
}
public override void Do()
{
Console.WriteLine("根据参数：" + value + ",做了一些行为");
}
}
class Program
{
static void Main(string[] args)
{
Product pro1 = Factory.createPro(EnumProduct.Product1,35);
Product pro2 = Factory.createPro(EnumProduct.Product1, "随机字符串");
pro1.Do();//根据参数:35，做了一些行为
pro2.Do();//根据参数:随机字符串，做了一些行为
Console.ReadKey();
}
} }
四.工厂模式
为了解决简单工厂模式类责任分配不明确的问题，人们将负责制造全部产品的工厂类改写成了抽象基类，而继承它的若干工厂类分别负责生产对应的产品类型对象。这样一来，既能在代码结构上保持工厂建立产品的现实建立对象逻辑映射,又可以在每当有新的产品类出现时，就额外生成一个工厂类，保证了其他类的代码独立性。缺点是，对象和类太多了......
{
public abstract class Factory//工厂基类
{
abstract public Product createPro(object value);
}
public class FactoryA:Factory//工厂A生产A类产品
{
public override Product createPro(object value)
{
return new ProductA(value);
}
}
public class FactoryB : Factory//工厂B生产B类产品
{
public override Product createPro(object value)
{
return new ProductB(value);
}
}
public abstract class Product//产品基类
{
protected object value;
abstract public void Do();
}
public class ProductA : Product//产品A
{
public ProductA(object value)
{
this.value = value;
}
public override void Do()
{
Console.WriteLine("根据参数:"+value+",A类产品做了一些行为");
}
}
class ProductB : Product//产品B
{
public ProductB(object value)
{
this.value = value;
}
public override void Do()
{
Console.WriteLine("根据参数:" + value + ",B类产品做了一些行为");
}
}
class Program
{
static void Main(string[] args)
{
Factory facA = new FactoryA();
Factory facB = new FactoryB();
Product pro1 = facA.createPro(34);
Product pro2 = facB.createPro("若干参数");
Product pro3 = facA.createPro(true);
pro1.Do();//根据参数:34,A类产品做了一些行为
pro2.Do();//根据参数:若干参数,B类产品做了一些行为
pro3.Do();//根据参数:True,A类产品做了一些行为
Console.ReadKey();
}
}}
五.抽象工厂模式
当我们的产品要进一步分类，但却并非独立的若干个类，而是一个类发展出若干个分类，而每个分类又发展出若干个更具体的小分类。比如:交通工具,有参数移动速度，名字，交通工具分为车类和飞机类，车类有其独立参数:车移动环境参数集，汽车专属零件参数集等，飞机类有其参数:飞机专属零件集，飞机环境参数集，车类又分为电动车和燃油汽车，各有其独立参数集，飞机又分为螺旋式飞机和喷气式飞机，各有其参数集。
这样，如果让四种交通工具直接继承交通工具类，电动车和燃油汽车就会写一部分重复的数据，螺旋飞机和喷气飞机也会有一部分重复数据，且重要的是使代码具有扩展性，如又出了好几种车，都有重复车数据，所以需要进一步分类。然而，下列代码样例只给出外壳，所以看上去是更麻烦的，但如果在某种情境下扩展，这种结构就会适当的展现出便利之处。因而，这种结构还可以根据情况进一步实现更多层次的分类继承。缺点是，如果并无大量多层结构重合数据时，使类数量更多了......
{
public abstract class Factory//工厂基类
{
abstract public Product1 createPro1();
abstract public Product2 createPro2();
}
public class FactoryA : Factory//工厂A生产A类产品
{
public override Product1 createPro1()
{
return new ProductA1();
}
public override Product2 createPro2()
{
return new ProductA2();
}
}
public class FactoryB : Factory//工厂B生产B类产品
{
public override Product1 createPro1()
{
return new ProductB1();
}
public override Product2 createPro2()
{
return new ProductB2();
}
}
public interface Product//产品基类
{
void Do();
}
public abstract class Product1 : Product//产品1，抽象类，不可实例化
{
public void Pro1Do()
{
Console.WriteLine("1类产品行为");
}
abstract public void Do();
}
public abstract class Product2 : Product//产品2，抽象类，不可实例化
{
public void Pro2Do()
{
Console.WriteLine("2类产品行为");
}
abstract public void Do();
}
public class ProductA1 : Product1//产品A1
{
public override void Do()
{
Console.WriteLine("A1产品行为");
}
}
public class ProductA2 : Product2//产品A2
{
public override void Do()
{
Console.WriteLine("A2产品行为");
}
}
public class ProductB1 : Product1//产品B1
{
public override void Do()
{
Console.WriteLine("B1产品行为");
}
}
public class ProductB2 : Product2//产品B2
{
public override void Do()
{
Console.WriteLine("B2产品行为");
}
}
class Program
{
static void Main(string[] args)
{
Factory factoryA = new FactoryA();
Factory factoryB = new FactoryB();
Product1 pro1 = factoryA.createPro1();
Product2 pro2 = factoryA.createPro2();
Product1 pro3 = factoryB.createPro1();
Product2 pro4 = factoryB.createPro2();
pro1.Do();//A1类产品行为
pro1.Pro1Do();//1类产品行为
pro2.Do();//A2类产品行为
pro2.Pro2Do();//2类产品行为
pro3.Do();//B1类产品行为
pro4.Do();//B2类产品行为
Console.ReadKey();
}
}}
六.适配器模式
该模式是为了应对为实现同一功能，但接口不同的时候，由适配器来提供接口的转换。
{
interface baseInterface
{
void Do();
}
class Interface1:baseInterface//适配器提供接口一
{
public void Do()
{
Console.WriteLine("接口一行为");
}
}
class Interface2:baseInterface//适配器提供接口二
{
public void Do()
{
Console.WriteLine("接口二行为");
}
}
class Adpater//适配器
{
private baseInterface baseInterface;
public void AdpaterDo(string enumInerface)
{
if(enumInerface.Equals("Interface1"))
baseInterface = new Interface1();
else if(enumInerface.Equals("Interface2"))
baseInterface = new Interface2();
baseInterface.Do();
}
}
class Program
{
static void Main(string[] args)
{
Adpater adpater = new Adpater();
adpater.AdpaterDo("Interface1");//接口一行为
adpater.AdpaterDo("Interface2");//接口二行为
Console.ReadKey();
}
}}