设计模式学习篇（一）

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml.Linq;
using System.IO;
using System.Net;
using System.Text.RegularExpressions;
using System.Threading;
using ConsoleApp.svcTest;
using System.Xml;

namespace ConsoleApp
{
internal class Program
{
private static void Main(string[] args)
{
//简单工厂模式
if (false)
{
Operate op = SimpleFactory.CreateOperate("+");
op.NumberA = 20;
op.NumberB = 30;
var result = op.GetResult();
Console.WriteLine(result);
}
//策略模式
if (false)
{
StrategyPattern sp = new StrategyPattern("-");
var result = sp.GetResult(30, 20);
Console.WriteLine(result);
}
//装饰模式
if (false)
{
OuStyle os = new OuStyle();
os.AddStyle(new PingFang());
os.Show();  //  欧式风格  这是平房

ChineseStyle cs = new ChineseStyle();
cs.AddStyle(os);  //用欧式风格装饰中国风
cs.Show();// 中国分隔 欧式风格  这是平房

}
//代理模式
if (false)
{
IGiveGifts sender = new Persuit();
Agent agent = new Agent(sender);
agent.GiveDolls();

}
//工厂方法模式
if (false)
{
IFactory factory = new AddOperateFactory();
Operate op = factory.CreateOperate();
op.NumberA = 20;
op.NumberB = 30;
Console.WriteLine(op.GetResult());
}
//状态模式
if (false)
{
Worke w = new Worke {Hour = 10};
w.WritePrograme();
w.Hour = 13;
w.WritePrograme();
w.Hour = 16;
w.WritePrograme();
w.Hour = 9;
w.WritePrograme();
}
//适配器模式
if (true)
{
Player p1 = new Forwards() {Name = "科比"};
Player p2=new Translater(){Name = "姚明"};
p1.Attack();
p1.Defense();
p2.Attack();
p2.Defense();
}

Console.ReadKey();
}
}

#region 1、简单工厂模式

public abstract class Operate
{
public int NumberA { get; set; }
public int NumberB { get; set; }

public virtual int GetResult()
{
return 0;
}
}

internal class AddOperate : Operate
{
public override int GetResult()
{
return this.NumberA + this.NumberB;
}
}

internal class SubOperate : Operate
{
public override int GetResult()
{
return this.NumberA - this.NumberB;
}
}

/// <summary>
/// 1、简单工厂模式
/// </summary>
internal class SimpleFactory
{
public static Operate CreateOperate(string flag)
{
switch (flag)
{
case "+":
return new AddOperate();
break;
case "-":
return new SubOperate();
break;
default:
return null;
}
}
}

#endregion

#region 2、策略模式

/// <summary>
/// 在简单工厂模式的基础上，在工厂（类）中，对对象方法进行了再封装 而不是返回对象
/// </summary>
internal class StrategyPattern
{
private Operate op = null;

public StrategyPattern(string flag)
{
switch (flag)
{
case "+":
op = new AddOperate();
break;

case "-":
op = new SubOperate();
break;
default:
op = null;
break;
}
}

public int GetResult(int a, int b)
{
op.NumberA = a;
op.NumberB = b;
return op.GetResult();
}
}

#endregion

#region 3、装饰模式

/// <summary>
/// 抽象接口
/// </summary>
internal abstract class House
{
public abstract void Show();
}

internal class PingFang : House
{
public override void Show()
{
Console.WriteLine("这是平房");
}
}

internal class LouFang : House
{
public override void Show()
{
Console.WriteLine("这是楼房");
}
}

/// <summary>
/// 装饰模式：在当前类中定义继承的类成员，再加个初始该成员的方法，用实现继承类的其它类对象来武装装饰自己
/// </summary>
internal class OuStyle : House
{
/// <summary>
/// 将定义用来装饰的对象方法的接口 定义在当前（需要装饰的）类中
/// </summary>
private House home = null;

public override void Show()
{
if (null != this.home)
{
home.Show();
}
Console.WriteLine("欧式风格");

}

/// <summary>
/// 动态添加特定的实现了接口House的类，以便给本类来调用其方法来装饰（武装）自己，
/// </summary>
/// <param name="h"></param>
public void AddStyle(House h)
{
this.home = h;
}

}

internal class ChineseStyle : House
{
private House h = null;

public override void Show()
{
if (null != h)
{
h.Show();
}
Console.WriteLine("这是中国风");

}

public void AddStyle(House house)
{
this.h = house;
}

}

#endregion

#region 4、代理模式

public interface IGiveGifts
{
void GiveDolls();
void GiveFlowers();
}

public class Persuit : IGiveGifts
{

public void GiveDolls()
{
Console.WriteLine("送芭比娃娃");
}

public void GiveFlowers()
{
Console.WriteLine("送花");
}
}

/// <summary>
/// 什么是代理模式：本来有一个类A可以直接执行自己的方法就可以实现一个功能，现在先将这个类A作为一个属性传递给一个代理类，代理类在通过自己的方法调用A对象的方法，同时可以添加一些新的功能
/// </summary>
public class Agent : IGiveGifts
{
private IGiveGifts sender;

public Agent(IGiveGifts ig)
{
this.sender = ig;
}

public void GiveDolls()
{
sender.GiveDolls();
Console.WriteLine("我是**代理 送芭比娃娃");
}

public void GiveFlowers()
{
sender.GiveFlowers();
Console.WriteLine("我是**代理 送花");

}

}

#endregion

#region 5、工厂方法模式

/// <summary>
/// 工厂模式存在类与switch语句的高耦合，增加新的类 需要去增加case分支，违背了开放-封闭原则 工厂方法模式可以解决这个问题。
/// </summary>
public interface IFactory
{
Operate CreateOperate();
}

public class AddOperateFactory : IFactory
{
public Operate CreateOperate()
{
return new AddOperate();
}
}

public class SubOperateFactory : IFactory
{

public Operate CreateOperate()
{
return new SubOperate();
}
}

#endregion

#region 6、状态模式

//状态抽象类
public abstract class State
{
public abstract void WritePrograme(Worke w);
}

/// <summary>
/// 子状态A
/// </summary>
public class StateA : State
{
public override void WritePrograme(Worke w)
{
if (w.Hour<12)
{
Console.WriteLine("当前{0}点，工作状态良",w.Hour);
}
else
{
w.CurrentState=new StateB();
w.WritePrograme();

}
}
}

/// <summary>
/// 子状态B
/// </summary>
public class StateB : State
{
public override void WritePrograme(Worke w)
{
if (w.Hour<14)
{
Console.WriteLine("当前时间{0},午休中，切勿打扰");
}
else
{
w.CurrentState = new StateC();
w.WritePrograme();
}

}
}

/// <summary>
/// 当前状态C
/// </summary>
public class StateC:State
{
public override void WritePrograme(Worke w)
{
if (w.Hour<18)
{
Console.WriteLine("当前时间{0}，下午工作状态略低",w.Hour);
}
}
}

//工作类
public class Worke
{
/// <summary>
/// 当前状态
/// </summary>
public State CurrentState { get; set; }

public Worke()
{
this.CurrentState=new  StateA();
}

/// <summary>
/// 构造方法
/// </summary>
public Worke(State s,int hour)
{
this.CurrentState = s;
this.Hour = hour;
}

/// <summary>
/// 当前时间
/// </summary>
public int Hour { get; set; }

public void WritePrograme()
{
CurrentState.WritePrograme(this);
}
}

#endregion

#region 适配器模式

public abstract class Player
{
public string Name { get; set; }

public abstract void Attack();

public abstract void Defense();

}

public class Forwards : Player
{
public override void Attack()
{
Console.WriteLine("中锋进攻");
}

public override void Defense()
{
Console.WriteLine("中锋防守");
}
}

public class ForeignPlayer
{
public string Name { get; set; }

public void 进攻()
{
Console.WriteLine("外籍球员进攻");
}

public void 防守()
{
Console.WriteLine("外籍球员防守");
}
}

public class Translater : Player
{
private ForeignPlayer play=new ForeignPlayer();

public override void Attack()
{
play.进攻();
}

public override void Defense()
{
play.防守();
}
}

#endregion

internal class Person
{
public string Name { get; set; }
public int Age { get; set; }
}
}