ChainOfResponsibility职责链模式

      一个请求被多个对象处理，但是每个请求只有一个接收者处理：

using System.Collections;
abstract class BaseHandler
{
    public abstract bool CanHandleRequest();
    public abstract void HandlerRequest(Request request);
}


public class AHandler : BaseHandler
{
    public override void HandlerRequest(Request request)
    { 
    }

    public override bool CanHandleRequest()
    {
    }
}

public class BHandler :BaseHandler
{
    public override void HandlerRequest(Request request)
    {
    }
    public override bool CanHandleRequest()
    {
    }
}

public class CHandler : BaseHandler
{
    public override void HandlerRequest(Request request)
    {
    }
    public override bool CanHandleRequest()
    {
    }
}



public class Sender
{
    public void Process()
    {
        Request request = new Request();

        ArrayList list = new ArrayList();

        //。。。。做决定的是请求的发送者

        list.Add(new AHandler());
        list.Add(new BHandler());
        list.Add(new CHandler());

        foreach (BaseHandler handler in list)
        {
             if(handler.CanHandleRequest)
             {
                 handler.HandlerRequest(request);
             }
        }
    }
}

 

 

职责链：

using System.Collections;

abstract class BaseHandler
{
    public BaseHandler(BaseHandler next)
    {
        this.next = next;
    }
    protected abstract bool CanHandleRequest();
    public virtual void HandlerRequest(Request request)
    {
        if (next != null)
        {
            this.next.HandlerRequest(request);
        }
    }

    private BaseHandler next;

    public BaseHandler Next
    {
        get
        {
            return this.next;
        }
        set
        {
            this.next = value;
        }

    }

}


public class AHandler : BaseHandler
{
    public AHandler(BaseHandler next)
        : base(next)
    { }

    protected override bool CanHandleRequest()
    {
        //

    }

    public override void HandlerRequest(Request request) 
    {
        if (this.CanHandleRequest())
        {
        }
        else
        {
            base.HandlerRequest(this.request);
        }
    }
}

public class BHandler : BaseHandler
{
        public BHandler(BaseHandler next)
        : base(next)
    { }

    protected override bool CanHandleRequest()
    {
        //

    }

    public override void HandlerRequest(Request request) 
    {
        if (this.CanHandleRequest())
        {
        }
        else
        {
            base.HandlerRequest(this.request);
        }
    }
}

public class CHandler : BaseHandler
{
    public CHandler(BaseHandler next)
        : base(next)
    { }

    protected override bool CanHandleRequest()
    {
        //

    }

    public override void HandlerRequest(Request request) 
    {
        if (this.CanHandleRequest())
        {
        }
        else
        {
            base.HandlerRequest(this.request);
        }
    }
}


public class DHandler : BaseHandler
{
        public DHandler(BaseHandler next)
        : base(next)
    { }

    protected override bool CanHandleRequest()
    {
        //

    }

    public override void HandlerRequest(Request request) 
    {
        if (this.CanHandleRequest())
        {
        }
        else
        {
            base.HandlerRequest(this.request);
        }
    }
}


public class Sender
{
    public void Process(BaseHandler handler)
    {
        Request request = new Request();
        handler.HandlerRequest(request);
    }
}

class App
{
    public static void Main()
    {
        Sender sender = new Sender();

        BaseHandler handler1 = new AHandler(null);
        BaseHandler handler2 = new BHandler(handler1);
        BaseHandler handler3 = new CHandler(handler2);
        BaseHandler handler4 = new DHandler(handler3);

        handler3.Next = handler4;
        handler4.Next = handler2;

        //动态的更改链表
        //handler3--> handler4 --> handler2 --> handler1
        

        sender.Process(handler3);
    }
}