Chemmy's Blog

public class Program
{
    static void Main(string[] args)
    {
        
        Console.WriteLine("类适配器模式测试：");
        ITarget target = new ClassAdapter();
        target.Request();
        Console.ReadLine();
    }
}


public interface ITarget
{
    void Request();
}


public class Adaptee
{
    public void SpecificRequest()
    {       
        Console.WriteLine("适配者中的业务代码被调用！");
    }
}


public class ClassAdapter : Adaptee,ITarget
{
    public void Request()
    {
        SpecificRequest();
    }
}

类适配器模式测试：
适配者中的业务代码被调用！

public class Program
{
    static void Main(string[] args)
    {
        
        Console.WriteLine("类适配器模式测试：");
        Adaptee adaptee = new Adaptee();
        ITarget target = new ObjectAdapter(adaptee);
        target.Request();
        Console.ReadLine();
    }
}


class ObjectAdapter : ITarget
{
    private Adaptee adaptee;
    public ObjectAdapter(Adaptee adaptee)
    {
        this.adaptee=adaptee;
    }
    public void Request()
    {
        adaptee.SpecificRequest();
    }
}

类适配器模式测试：
适配者中的业务代码被调用！

public class Program
{
    static void Main(string[] args)
    {
        
        Console.WriteLine("类适配器模式测试：");
        ITwoWayTarget target = new TargetRealize();        
        ITwoWayAdaptee adaptee = new AdapteeRealize();        
        Console.WriteLine("目标通过双向适配器访问适配者：");
        ITwoWayTarget twoWayTarget = new TwoWayAdapter(adaptee);
        twoWayTarget.Request();
        Console.WriteLine("-------------------");
        Console.WriteLine("适配者通过双向适配器访问目标：");
        ITwoWayAdaptee twoWayAdaptee = new TwoWayAdapter(target);
        twoWayAdaptee.SpecificRequest();
        Console.ReadLine();
    }
}


public interface ITwoWayTarget
{
    void Request();
}


public interface ITwoWayAdaptee
{
    void SpecificRequest();
}


public class TargetRealize :ITwoWayTarget
{
    public void Request()
    {       
        Console.WriteLine("目标代码被调用！");
    }
}


public class AdapteeRealize : ITwoWayAdaptee
{
    public void SpecificRequest()
    {       
        Console.WriteLine("适配者代码被调用！");
    }
}


public class TwoWayAdapter : ITwoWayTarget, ITwoWayAdaptee
{
    private ITwoWayTarget target;
    private ITwoWayAdaptee adaptee;
    public TwoWayAdapter(ITwoWayTarget target)
    {
        this.target=target;
    }
    public TwoWayAdapter(ITwoWayAdaptee adaptee)
    {
        this.adaptee=adaptee;
    }
    public void Request()
    {
        adaptee.SpecificRequest();
    }
    public void SpecificRequest()
    {       
        target.Request();
    }
}

class Program
{    
    static void Main(string[] args)
    {
        Mediator md=new ConcreteMediator();
        Colleague c1,c2;
        c1=new ConcreteColleague1();
        c2=new ConcreteColleague2();
        md.Register(c1);
        md.Register(c2);
        c1.Send();
        Console.WriteLine("-------------");
        c2.Send();

        Console.Read();        
    }
}


public abstract class Mediator
{
    
    public abstract void Register(Colleague colleague);
    
    public abstract void Relay(Colleague colleague); 
}


public class ConcreteMediator : Mediator
{
    private List<Colleague> colleagues=new List<Colleague>();
    public override void Register(Colleague colleague)
    {
        if(!colleagues.Contains(colleague))
        {
            colleagues.Add(colleague);
            colleague.SetMediator(this);
        }
    }
    public override void Relay(Colleague colleague)
    {
        foreach (var item in colleagues)
    {
            if (!item.Equals(colleague))
            {
                item.Receive();
            }
    }       
    }
}


public abstract class Colleague
{
    protected Mediator mediator;
    public void SetMediator(Mediator mediator)
    {
        this.mediator=mediator;
    }   
    public abstract void Receive();   
    public abstract void Send();
}


public class ConcreteColleague1 : Colleague
{
    public override void Receive()
    {
        Console.WriteLine("具体同事类1收到请求。");
    }
    public override void Send()
    {
        Console.WriteLine("具体同事类1发出请求。");
        mediator.Relay(this); 
    }
}


public class ConcreteColleague2 : Colleague
{
    public override void Receive()
    {
        Console.WriteLine("具体同事类2收到请求。");
    }
    public override void Send()
    {
        Console.WriteLine("具体同事类2发出请求。");
        mediator.Relay(this); 
    }
}

具体同事类1发出请求。
具体同事类2收到请求。
-------------
具体同事类2发出请求。
具体同事类1收到请求。

class Program
{    
    static void Main(string[] args)
    {
        ISimpleColleague c1,c2;
        c1=new SimpleConcreteColleague1();
        c2=new SimpleConcreteColleague2();
        c1.Send();
        Console.WriteLine("-----------------");
        c2.Send();
        Console.Read();        
    }
}


public class SimpleMediator
{
    private static SimpleMediator smd=new SimpleMediator();   
    private List<ISimpleColleague> colleagues=new List<ISimpleColleague>();   
    private SimpleMediator(){}   
    public static SimpleMediator GetMediator()
    {    
        return smd;   
    }
    public void Register(ISimpleColleague colleague)
    {
        if(!colleagues.Contains(colleague))
        {
            colleagues.Add(colleague);
        }
    }
    public void Relay(ISimpleColleague scl)
    {    
        foreach (var item in colleagues)
    {
            if (!item.Equals(scl))
            {
                item.Receive();
            }
    }
    }
}

public interface ISimpleColleague
{
    void Receive();   
    void Send();
}


public class SimpleConcreteColleague1 : ISimpleColleague
{
    public SimpleConcreteColleague1()
    {
        SimpleMediator smd=SimpleMediator.GetMediator();
        smd.Register(this);
    }
    public void Receive()
    {    
        Console.WriteLine("具体同事类1：收到请求。");    
    }   
    public void Send()
    {
        SimpleMediator smd=SimpleMediator.GetMediator();
        Console.WriteLine("具体同事类1：发出请求...");
        smd.Relay(this); 
    }
}


public class SimpleConcreteColleague2 : ISimpleColleague
{
    public SimpleConcreteColleague2()
    {
        SimpleMediator smd=SimpleMediator.GetMediator();
        smd.Register(this);
    }
    public void Receive()
    { 
        Console.WriteLine("具体同事类2：收到请求。"); 
    }   
    public void Send()
    {
        SimpleMediator smd=SimpleMediator.GetMediator();
        Console.WriteLine("具体同事类2：发出请求...");
        smd.Relay(this); 
    }
}

具体同事类1：发出请求...
具体同事类2：收到请求。
-----------------
具体同事类2：发出请求...
具体同事类1：收到请求。

class Program
{    
    static void Main(string[] args)
    {
        ICommand cmd=new ConcreteCommand();
        Invoker ir=new Invoker(cmd);
        Console.WriteLine("客户访问调用者的Call()方法...");
        ir.Call();
        Console.Read();
        
    }
}


public class Invoker
{
    private ICommand command;
    public Invoker(ICommand command)
    {
        this.command=command;
    }
    public void SetCommand(ICommand command)
    {
        this.command=command;
    }
    public void Call()
    {
        Console.WriteLine("调用者执行命令command...");
        command.Execute();
    }
}


public interface ICommand
{
    void Execute();
}


public class ConcreteCommand : ICommand
{
    private Receiver receiver;
    public ConcreteCommand()
    {
        receiver=new Receiver();
    }
    public void Execute()
    {
        receiver.Action();
    }
}


public class Receiver
{
    public void Action()
    {
        Console.WriteLine("接收者的Action()方法被调用...");
    }
}

客户访问调用者的Call()方法...
调用者执行命令command...
接收者的Action()方法被调用...

class Program
{    
    static void Main(string[] args)
    {
        IAbstractCommand cmd1=new ConcreteCommand1();
        IAbstractCommand cmd2=new ConcreteCommand2();
        CompositeInvoker ir=new CompositeInvoker();
        ir.Add(cmd1);
        ir.Add(cmd2);
        Console.WriteLine("客户访问调用者的Execute()方法...");
        ir.Execute();
        Console.Read();
        
    }
}


public interface IAbstractCommand
{
    void Execute();
}


public class ConcreteCommand1 : IAbstractCommand
{
    private CompositeReceiver receiver;
    public ConcreteCommand1()
    {
        receiver=new CompositeReceiver();
    }
    public void Execute()
    {       
        receiver.Action1();
    }
}


public class ConcreteCommand2 : IAbstractCommand
{
    private CompositeReceiver receiver;
    public ConcreteCommand2()
    {
        receiver=new CompositeReceiver();
    }
    public void Execute()
    {       
        receiver.Action2();
    }
}


public class CompositeInvoker : IAbstractCommand
{
    private List<IAbstractCommand> children = new List<IAbstractCommand>();   
    public void Add(IAbstractCommand c)
    {
        children.Add(c);
    }   
    public void Remove(IAbstractCommand c)
    {
        children.Remove(c);
    }   
    public IAbstractCommand GetChild(int i)
    {
        return children[i];
    }   
    public void Execute()
    {
        foreach (var child in children)
    {
            child.Execute(); 
    }        
    }    
}


public class CompositeReceiver
{
    public void Action1()
    {
        Console.WriteLine("接收者的Action1()方法被调用...");
    }
    public void Action2()
    {
        Console.WriteLine("接收者的Action2()方法被调用...");
    }
}

客户访问调用者的Execute()方法...
接收者的Action1()方法被调用...
接收者的Action2()方法被调用...

class Program
{
    static void Main(string[] args)
    {
        Originator or = new Originator();
        Caretaker cr = new Caretaker();
        or.SetState("S0");
        Console.WriteLine("初始状态:" + or.GetState());
        cr.SetMemento(or.CreateMemento()); 
        or.SetState("S1");        
        Console.WriteLine("新的状态:" + or.GetState());
        or.RestoreMemento(cr.GetMemento()); 
        Console.WriteLine("恢复状态:" + or.GetState());        
        Console.Read();        
    }
}


public class Memento
{ 
    private String state; 
    public Memento(String state)
    { 
        this.state=state; 
    }     
    public void SetState(String state)
    { 
        this.state=state; 
    }
    public String GetState()
    { 
        return state; 
    }
}


public class Originator
{ 
    private String state;     
    public void SetState(String state)
    { 
        this.state=state; 
    }
    public String GetState()
    { 
        return state; 
    }
    public Memento CreateMemento()
    { 
        return new Memento(state); 
    }
    public void RestoreMemento(Memento memento)
    {
        this.SetState(memento.GetState()); 
    } 
}


public class Caretaker
{ 
    private Memento memento;       
    public void SetMemento(Memento memento)
    { 
        this.memento=memento; 
    }
    public Memento GetMemento()
    { 
        return memento; 
    }
}

初始状态:S0
新的状态:S1
恢复状态:S0

class Program
{
    static void Main(string[] args)
    {
        OriginatorPrototype or=new OriginatorPrototype();
        PrototypeCaretaker cr=new PrototypeCaretaker();       
        or.SetState("S0"); 
        Console.WriteLine("初始状态:"+or.GetState());           
        cr.SetMemento(or.CreateMemento()); 
        or.SetState("S1"); 
        Console.WriteLine("新的状态:"+or.GetState());        
        or.RestoreMemento(cr.GetMemento()); 
        Console.WriteLine("恢复状态:"+or.GetState());      
        Console.Read();        
    }
}


class OriginatorPrototype  : ICloneable
{ 
    private String state;     
    public void SetState(String state)
    { 
        this.state=state; 
    }
    public String GetState()
    { 
        return state; 
    }
    public OriginatorPrototype CreateMemento()
    {
        return (OriginatorPrototype)this.Clone(); 
    } 
    public void RestoreMemento(OriginatorPrototype opt)
    { 
        this.SetState(opt.GetState()); 
    }
    public object Clone()
    {
        try
        {
            return base.MemberwiseClone();
        }
        catch(Exception ex)
        {
            Console.WriteLine(ex.Message);
        }
        return null;
    }
}

class PrototypeCaretaker
{ 
    private OriginatorPrototype opt;       
    public void SetMemento(OriginatorPrototype opt)
    { 
        this.opt=opt; 
    }
    public OriginatorPrototype GetMemento()
    { 
        return opt; 
    }
}

初始状态:S0
新的状态:S1
恢复状态:S0

class Program
{    
    static void Main(string[] args)
    {
        AbstractClass tm=new ConcreteClass();
        tm.TemplateMethod();
        
        Console.Read();
    }
}


public abstract class AbstractClass
{
    public void TemplateMethod() 
    {
        SpecificMethod();
        AbstractMethod1();          
        AbstractMethod2();
    }  
    public void SpecificMethod() 
    {
        Console.WriteLine("抽象类中的具体方法被调用...");
    }   
    public abstract void AbstractMethod1(); 
    public abstract void AbstractMethod2(); 
}


public class ConcreteClass : AbstractClass
{
    public override void AbstractMethod1()
    {
        Console.WriteLine("抽象方法1的实现被调用...");
    }
    public override void AbstractMethod2()
    {
        Console.WriteLine("抽象方法2的实现被调用...");
    }
}

抽象类中的具体方法被调用...
抽象方法1的实现被调用...
抽象方法2的实现被调用...

class Program
{    
    static void Main(string[] args)
    {
        HookAbstractClass tm = new HookConcreteClass();
        tm.TemplateMethod();
        
        Console.Read();
    }
}


public abstract class HookAbstractClass
{
    public void TemplateMethod() 
    {
        AbstractMethod1();
        HookMethod1();
        if(HookMethod2())
        {
            SpecificMethod();   
        }
         AbstractMethod2();
    }  
    public void SpecificMethod() 
    {
        Console.WriteLine("抽象类中的具体方法被调用...");
    }
    public virtual void HookMethod1(){}  
    public virtual bool HookMethod2() 
    {
        return true;
    }
    public abstract void AbstractMethod1(); 
    public abstract void AbstractMethod2(); 
}


public class HookConcreteClass : HookAbstractClass
{
    public override void AbstractMethod1()
    {
        Console.WriteLine("抽象方法1的实现被调用...");
    }
    public override void AbstractMethod2()
    {
        Console.WriteLine("抽象方法2的实现被调用...");
    }
    public override void HookMethod1()
    {
        Console.WriteLine("钩子方法1被重写...");
    }
    public override bool HookMethod2()
    {
        return false;
    }
}

class Program
{
    static void Main(string[] args)
    {
        Context context=new Context();    
        context.Handle();    
        context.Handle();
        context.Handle();
        context.Handle();
        Console.Read();        
    }
}


public class Context
{
    private State state;
    
    public Context()
    {
        this.state=new ConcreteStateA();
    }
    
    public void SetState(State state)
    {
        this.state=state;
    }
    
    public State GetState()
    {
        return(state);
    }
    
    public void Handle()
    {
        state.Handle(this);
    }
}


public abstract class State
{
    public abstract void Handle(Context context);
}


public class ConcreteStateA : State
{
    public override void Handle(Context context)
    {
        Console.WriteLine("当前状态是 A.");
        context.SetState(new ConcreteStateB());
    }
}


public class ConcreteStateB : State
{
    public override void Handle(Context context)
    {
        Console.WriteLine("当前状态是 B.");
        context.SetState(new ConcreteStateA());
    }
}

当前状态是 A.
当前状态是 B.
当前状态是 A.
当前状态是 B.

class Program
{
    static void Main(string[] args)
    {
        ShareContext context=new ShareContext(); 
        context.Handle(); 
        context.Handle();
        context.Handle();
        context.Handle();
        Console.Read();        
    }
}


public class ShareContext
{
    private ShareState state;
    private Dictionary<String, ShareState> stateDic=new Dictionary<String, ShareState>();
    public ShareContext()
    {
        state=new ConcreteState1();
        stateDic.Add("1", state);
        state=new ConcreteState2();
        stateDic.Add("2", state);
        state=GetState("1");
    }
    
    public void SetState(ShareState state)
    {
        this.state=state;
    }
    
    public ShareState GetState(String key)
    {
        ShareState s=stateDic[key];
        return s;
    }
    
    public void Handle()
    {
        state.Handle(this);
    }
}


public abstract class ShareState
{
    public abstract void Handle(ShareContext context);
}


public class ConcreteState1 : ShareState
{
    public override void Handle(ShareContext context)
    {
        Console.WriteLine("当前状态是： 状态1");
        context.SetState(context.GetState("2"));
    }
}


public class ConcreteState2 : ShareState
{
    public override void Handle(ShareContext context)
    {
        Console.WriteLine("当前状态是： 状态2");
        context.SetState(context.GetState("1"));
    }
}

class Program
{    
    static void Main(string[] args)
    {
        Context c=new Context();
        IStrategy s=new ConcreteStrategyA();
        c.SetStrategy(s);
        c.StrategyMethod();
        Console.WriteLine("-----------------");
        s=new ConcreteStrategyB();
        c.SetStrategy(s);
        c.StrategyMethod();        
        Console.Read();
    }
}


public interface IStrategy
{   
    void StrategyMethod();    
}


public class ConcreteStrategyA : IStrategy
{
    public void StrategyMethod()
    {
        Console.WriteLine("具体策略A的策略方法被访问！");
    }
}


public class ConcreteStrategyB : IStrategy
{
  public void StrategyMethod()
  {
      Console.WriteLine("具体策略B的策略方法被访问！");
  }
}


public class Context
{
    private IStrategy strategy;
    public IStrategy GetStrategy()
    {
        return strategy;
    }
    public void SetStrategy(IStrategy strategy)
    {
        this.strategy=strategy;
    }
    public void StrategyMethod()
    {
        strategy.StrategyMethod();
    }
}

具体策略A的策略方法被访问！
-----------------
具体策略B的策略方法被访问！

class Program
{
    static void Main(string[] args)
    {
        Subject subject=new ConcreteSubject();
        IObserver obs1=new ConcreteObserver1();
        IObserver obs2=new ConcreteObserver2();
        subject.Add(obs1);
        subject.Add(obs2);
        subject.NotifyObserver();
        Console.Read();        
    }
}


public abstract class Subject
{
    protected List<IObserver> observers=new List<IObserver>();   
    
    public void Add(IObserver observer)
    {
        observers.Add(observer);
    }    
    
    public void Remove(IObserver observer)
    {
        observers.Remove(observer);
    }   
    public abstract void NotifyObserver(); 
}


public class ConcreteSubject : Subject
{
    public override  void NotifyObserver()
    {
        Console.WriteLine("具体目标发生改变...");
        Console.WriteLine("--------------");       
       
        foreach (var obs in observers)
    {
            obs.Response(); 
    }        
    }          
}


public interface IObserver
{
    void Response(); 
}


public class ConcreteObserver1 : IObserver
{
    public void Response()
    {
        Console.WriteLine("具体观察者1作出反应！");
    }
}


public class ConcreteObserver2 : IObserver
{
    public void Response()
    {
        Console.WriteLine("具体观察者2作出反应！");
    }
}

具体目标发生改变...
--------------
具体观察者1作出反应！
具体观察者2作出反应！

class Program
{    
    static void Main(string[] args)
    {
        
        LocationTracker provider = new LocationTracker();
        LocationReporter reporter1 = new LocationReporter("FixedGPS");
        reporter1.Subscribe(provider);
        LocationReporter reporter2 = new LocationReporter("MobileGPS");
        reporter2.Subscribe(provider);

        provider.TrackLocation(new Location(47.6456, -122.1312));
        reporter1.Unsubscribe();
        provider.TrackLocation(new Location(47.6677, -122.1199));
        provider.TrackLocation(null);
        provider.EndTransmission();

        Console.Read();        
    }
}




public struct Location
{
    double lat, lon;

    public Location(double latitude, double longitude)
    {
        this.lat = latitude;
        this.lon = longitude;
    }

    
    
    
    public double Latitude
    { get { return this.lat; } }
    
    
    
    public double Longitude
    { get { return this.lon; } }
}




public class LocationReporter : IObserver<Location>
{
    private IDisposable unsubscriber;
    private string instName;

    public LocationReporter(string name)
    {
        this.instName = name;
    }

    public string Name
    { get { return this.instName; } }

    
    
    
    
    public virtual void Subscribe(IObservable<Location> provider)
    {
        if (provider != null)
            unsubscriber = provider.Subscribe(this);
    }

    public virtual void OnCompleted()
    {
        Console.WriteLine("位置跟踪器已将数据传输到 {0}", this.Name);
        this.Unsubscribe();
    }

    public virtual void OnError(Exception e)
    {
        Console.WriteLine("{0}: 无法确定位置", this.Name);
    }

    public virtual void OnNext(Location value)
    {
        Console.WriteLine("{2}: 当前位置是 {0}, {1}", value.Latitude, value.Longitude, this.Name);
    }

    
    
    
    public virtual void Unsubscribe()
    {
        unsubscriber.Dispose();
    }
}




public class LocationTracker : IObservable<Location>
{
    public LocationTracker()
    {
        observers = new List<IObserver<Location>>();
    }

    private List<IObserver<Location>> observers;

    
    
    
    
    
    public IDisposable Subscribe(IObserver<Location> observer)
    {
        if (!observers.Contains(observer))
            observers.Add(observer);
        return new Unsubscriber(observers, observer);
    }

    
    
    
    private class Unsubscriber : IDisposable
    {
        private List<IObserver<Location>> _observers;
        private IObserver<Location> _observer;

        public Unsubscriber(List<IObserver<Location>> observers, IObserver<Location> observer)
        {
            this._observers = observers;
            this._observer = observer;
        }

        public void Dispose()
        {
            if (_observer != null && _observers.Contains(_observer))
                _observers.Remove(_observer);
        }
    }

    public void TrackLocation(Nullable<Location> loc)
    {
        foreach (var observer in observers)
        {
            if (!loc.HasValue)
                observer.OnError(new LocationUnknownException());
            else
                observer.OnNext(loc.Value);
        }
    }

    public void EndTransmission()
    {
        foreach (var observer in observers.ToArray()) 
        {
            if (observers.Contains(observer)) 
                observer.OnCompleted();
        } 
        observers.Clear();
    }
}




public class LocationUnknownException : Exception
{
    internal LocationUnknownException()
    { }
}

FixedGPS：当前位置是47.6456，-122.1312
MobileGPS：当前位置是47.6456，-122.1312
MobileGPS：当前位置是47.6677，-122.1199
MobileGPS：无法确定位置位置
跟踪器已将数据传输到MobileGPS

〈句子〉::=〈主语〉〈谓语〉〈宾语〉
〈主语〉::=〈代词〉|〈名词〉
〈谓语〉::=〈动词〉
〈宾语〉::=〈代词〉|〈名词〉
〈代词〉你|我|他
〈名词〉7大学生I筱霞I英语
〈动词〉::=是|学习

public interface IAbstractExpression
{
    Object Interpret(String info);    
}


public class TerminalExpression : IAbstractExpression
{
    public Object Interpret(String info)
    {
        
    }
}


public class NonterminalExpression : IAbstractExpression
{
    private IAbstractExpression exp1;
    private IAbstractExpression exp2;
    public Object Interpret(String info)
    {
        
    }
}


public class Context
{
    private IAbstractExpression exp;
    public Context()
    {
        
    }
    public void Operation(String info)
    {
        
    }
}

CultureInfo ci = new CultureInfo("fr-FR");            

ExpressionContext context = new ExpressionContext();
context.ParseCulture = ci
context.Imports.AddType(typeof(Math));
            

IDynamicExpression e = context.CompileDynamic("round(100,75; 1)");
object result = e.Evaluate();