Chemmy's Blog

class Program
{
    static void Main(string[] args)
    {
        FlyweightFactory factory=new FlyweightFactory();
        IFlyweight f01=factory.GetFlyweight("a");
        IFlyweight f02=factory.GetFlyweight("a");
        IFlyweight f03=factory.GetFlyweight("a");
        IFlyweight f11=factory.GetFlyweight("b");
        IFlyweight f12=factory.GetFlyweight("b");       
        f01.Operation(new UnsharedConcreteFlyweight("第1次调用a。"));       
        f02.Operation(new UnsharedConcreteFlyweight("第2次调用a。"));       
        f03.Operation(new UnsharedConcreteFlyweight("第3次调用a。"));       
        f11.Operation(new UnsharedConcreteFlyweight("第1次调用b。"));       
        f12.Operation(new UnsharedConcreteFlyweight("第2次调用b。"));
        Console.ReadLine();
    }
}


public class UnsharedConcreteFlyweight
{
    private String info;
    public UnsharedConcreteFlyweight(String info)
    {
        this.info=info;
    }
    public String GetInfo()
    {
        return info;
    }
    public void SetInfo(String info)
    {
        this.info=info;
    }
}


public interface IFlyweight
{
    void Operation(UnsharedConcreteFlyweight state);
}


public class ConcreteFlyweight : IFlyweight
{
    private String key;
    public ConcreteFlyweight(String key)
    {
        this.key=key;
        Console.WriteLine("具体享元"+key+"被创建！");
    }
    public void Operation(UnsharedConcreteFlyweight outState)
    {
        Console.WriteLine("具体享元"+key+"被调用，");
        Console.WriteLine("非享元信息是:" + outState.GetInfo());
    }
}


public class FlyweightFactory
{
    private Dictionary<String, IFlyweight> flyweights = new Dictionary<String, IFlyweight>();
    public IFlyweight GetFlyweight(String key)
    {
        IFlyweight flyweight;
        flyweights.TryGetValue(key,out flyweight);
        if(flyweight!=null)
        {
            Console.WriteLine("具体享元" + key + "已经存在，被成功获取！");
        }
        else
        {
            flyweight=new ConcreteFlyweight(key);
            flyweights.Add(key, flyweight);
        }
        return flyweight;
    }
}

具体享元a被创建！
具体享元a已经存在，被成功获取！
具体享元a已经存在，被成功获取！
具体享元b被创建！
具体享元b已经存在，被成功获取！
具体享元a被调用，非享元信息是:第1次调用a。
具体享元a被调用，非享元信息是:第2次调用a。
具体享元a被调用，非享元信息是:第3次调用a。
具体享元b被调用，非享元信息是:第1次调用b。
具体享元b被调用，非享元信息是:第2次调用b。

class Program
{
    static void Main(string[] args)
    {
        
        Proxy proxy=new Proxy();
        proxy.Request();       
        Console.ReadKey();
    }
}


public interface ISubject
{
    void Request();
}


public class RealSubject :ISubject
{
    public void Request()
    {
        Console.WriteLine("访问真实主题方法...");
    }
}


public class Proxy : ISubject
{
    private RealSubject realSubject;
    public void Request()
    {
        if (realSubject==null)
        {
            realSubject=new RealSubject();
        }
        PreRequest();
        realSubject.Request();
        PostRequest();
    }
    public void PreRequest()
    {
        Console.WriteLine("访问真实主题之前的预处理。");
    }
    public void PostRequest()
    {
        Console.WriteLine("访问真实主题之后的后续处理。");
    }
}

访问真实主题之前的预处理。
访问真实主题方法...
访问真实主题之后的后续处理。

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("***\r\n Begin program - logging with decorator\r\n");
        IRepository<Customer> customerRepository =RepositoryFactory.Create<Customer>();
        var customer = new Customer()
        {
            Id = 1,
            Name = "Customer 1",
            Address = "Address 1"
        };
        customerRepository.Add(customer);
        customerRepository.Update(customer);
        customerRepository.Delete(customer);
        Console.WriteLine("\r\nEnd program - logging with decorator\r\n***");
        Console.ReadLine();
    }
}

public class Customer
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Address { get; set; }
}


public interface IRepository<T>
{
    void Add(T entity);
    void Delete(T entity);
    void Update(T entity);
    IEnumerable<T> GetAll();
    T GetById(int id);
}


public class Repository<T> : IRepository<T>
{
    public void Add(T entity)
    {
        Console.WriteLine("Adding {0}", entity);
    }
    public void Delete(T entity)
    {
        Console.WriteLine("Deleting {0}", entity);
    }
    public void Update(T entity)
    {
        Console.WriteLine("Updating {0}", entity);
    }
    public IEnumerable<T> GetAll()
    {
        Console.WriteLine("Getting entities");
        return null;
    }
    public T GetById(int id)
    {
        Console.WriteLine("Getting entity {0}", id);
        return default(T);
    }
} 


class DynamicProxy<T> : RealProxy
{
    private readonly T _decorated;
    public DynamicProxy(T decorated) : base(typeof(T))
    {
        _decorated = decorated;
    }
    private void Log(string msg, object arg = null)
    {
        Console.ForegroundColor = ConsoleColor.Red;
        Console.WriteLine(msg, arg);
        Console.ResetColor();
    }
    public override IMessage Invoke(IMessage msg)
    {
        var methodCall = msg as IMethodCallMessage;
        var methodInfo = methodCall.MethodBase as MethodInfo;
        Log("In Dynamic Proxy - Before executing '{0}'",methodCall.MethodName);
        try
        {
            var result = methodInfo.Invoke(_decorated, methodCall.InArgs);
            Log("In Dynamic Proxy - After executing '{0}' ",methodCall.MethodName);
            return new ReturnMessage(result, null, 0,methodCall.LogicalCallContext, methodCall);
        }
        catch (Exception e)
        {
            Log(string.Format("In Dynamic Proxy- Exception {0} executing '{1}'", e),methodCall.MethodName);
            return new ReturnMessage(e, methodCall);
        }
    }
}


public class RepositoryFactory
{
    public static IRepository<T> Create<T>()
    {
        var repository = new Repository<T>();
        var dynamicProxy = new DynamicProxy<IRepository<T>>(repository);
        return dynamicProxy.GetTransparentProxy() as IRepository<T>;
    }
}    

public class Program
{
    static void Main(string[] args)
    {
        
        Proxy<ISubject> proxy = new Proxy<ISubject>(new RealSubject());
        ISubject subject = (ISubject)proxy.GetTransparentProxy();
        int arg = 0;
        subject.Request(out arg); 
        Console.WriteLine(arg);
        Console.ReadKey();
    }
}

public class Proxy<T> : RealProxy where T: class
{    
    MarshalByRefObject myMarshalByRefObject;
    public Proxy(MarshalByRefObject realT) : base(typeof(T))
    {        
        myMarshalByRefObject = realT;
    }
    public override IMessage Invoke(IMessage myMessage)
    {        
        IMethodCallMessage myCallMessage = (IMethodCallMessage)myMessage;
        Console.WriteLine("动态代理方法中：执行前");
        IMethodReturnMessage myIMethodReturnMessage = RemotingServices.ExecuteMessage(myMarshalByRefObject, myCallMessage);
        Console.WriteLine("动态代理方法中：执行后");
        return myIMethodReturnMessage;
    }
}


public interface ISubject
{
    void Request(out int arg);
}


public class RealSubject : MarshalByRefObject,ISubject
{
    public void Request(out int arg)
    {
        arg = 1;
        Console.WriteLine("访问真实主题方法...");       
    }
}

class Program
{
    static void Main(string[] args)
    {
        Facade f = new Facade();
        f.method();
        Console.ReadLine();
    }
}


public class Facade
{
    private SubSystem01 obj1=new SubSystem01();
    private SubSystem02 obj2=new SubSystem02();
    private SubSystem03 obj3=new SubSystem03();
    public void method()
    {
        obj1.Method1();
        obj2.Method2();
        obj3.Method3();
    }
}

public class SubSystem01
{
    public  void Method1()
    {
        Console.WriteLine("子系统01的Method1()被调用！");
    }   
}


public class SubSystem02
{
    public  void Method2()
    {
        Console.WriteLine("子系统02的Method2()被调用！");
    }   
}


public class SubSystem03
{
    public  void Method3()
    {
        Console.WriteLine("子系统03的Method3()被调用！");
    }   
}

子系统01的Method1()被调用！
子系统02的Method2()被调用！
子系统03的Method3()被调用！

class Program
{
    static void Main(string[] args)
    {
        IComponent c0=new Composite(); 
        IComponent c1=new Composite(); 
        IComponent leaf1=new Leaf("1"); 
        IComponent leaf2=new Leaf("2"); 
        IComponent leaf3=new Leaf("3");          
        c0.Add(leaf1); 
        c0.Add(c1);
        c1.Add(leaf2); 
        c1.Add(leaf3);          
        c0.Operation(); 
        Console.Read();
    }
}


public interface IComponent
{
    void Add(IComponent c);
    void Remove(IComponent c);
    IComponent GetChild(int i);
    void Operation();
}


public class Leaf : IComponent
{
    private String name;
    public Leaf(String name)
    {
        this.name=name;
    }
    public void Add(IComponent c){ }           
    public void Remove(IComponent c){ }   
    public IComponent GetChild(int i)
    {
        return null;
    }   
    public void Operation()
    {
        Console.WriteLine("树叶"+name+"：被访问！"); 
    }
}


public class Composite : IComponent
{
    private List<IComponent> children=new List<IComponent>();   
    public void Add(IComponent c)
    {
        children.Add(c);
    }   
    public void Remove(IComponent c)
    {
        children.Remove(c);
    }   
    public IComponent GetChild(int i)
    {
        return children[i];
    }   
    public void Operation()
    {
        foreach (var obj in children)
    {
    obj.Operation();
    }       
    }    
}

树叶1：被访问！
树叶2：被访问！
树叶3：被访问！

class Program
{
    static void Main(string[] args)
    {            
        IComponent p=new ConcreteComponent();
        p.Operation();
        Console.WriteLine("---------------------------------");
        IComponent d=new ConcreteDecoratorA(p);
        d.Operation();
        Console.ReadLine();
    }
}


public interface  IComponent
{
    void Operation();
}


public class ConcreteComponent : IComponent
{
    public ConcreteComponent()
    {
        Console.WriteLine("创建具体构件角色");       
    }   
    public void Operation()
    {
        Console.WriteLine("调用具体构件角色的方法Operation()");           
    }
}


public abstract class Decorator : IComponent
{
    private IComponent component;   
    public Decorator(IComponent component)
    {
        this.component=component;
    }   
    public virtual void Operation()
    {
        component.Operation();
    }
}


public class ConcreteDecoratorA : Decorator
{
    public ConcreteDecoratorA(IComponent component)
        : base(component)
    {
       
    }   
    public override void Operation()
    {
        base.Operation();        
        AddedFunction();
    }
    public void AddedFunction()
    {
        Console.WriteLine("为具体构件角色增加额外的功能AddedFunction()");           
    }
}

创建具体构件角色
调用具体构件角色的方法Operation()
---------------------------------
调用具体构件角色的方法Operation()
为具体构件角色增加额外的功能AddedFunction()

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;
    }
}