chain-of-responsibility

In my current project, I'm using quite a few Chain of Responsibility patterns. However, I find it a bit awkward to configure the chain via dependency injection. Given this model: public interface IChainOfResponsibility { IChainOfResponsibility Next { get; } void Handle(Foo foo); } public class HandlerOne : IChainOfResponsibility { private DbContext _dbContext; public HandlerOne(IChainOfResponsibility next, DbContext dbContext) { Next = next; _dbContext = dbContext; } public IChainOfResponsibility Next { get; } public void Handle(Foo foo) { /*...*/} } public class HandlerTwo :

I'd like to implement a Chain of Responsibility pattern, taking care of the 'broken link' problem as follows: public abstract class Handler{ private Handler m_successor; public void setSuccessor(Handler successor) { m_successor = successor; } protected abstract boolean handleRequestImpl(Request request); public final void handleRequest(Request request) { boolean handledByThisNode = this.handleRequestImpl(request); if (m_successor != null && !handledByThisNode) { m_successor.handleRequest(request); } } } Seems like a common enough approach. But how is this testable with a protected abstract

I have been finding myself using the Chain of Responsibility pattern often (3 times is often for me) in my current project and I'm wondering if I have become a little over-enthusiastic about the solution. Specifically, I have been using the Apache Commons chain project . So, far I have been quite impressed by how it has simplified a number of complex interchangeable pieces of app logic into a more cohesive and organized whole. However, a few of the newer people on the project seem to have difficulty "getting it." What are your experiences with it? What problems have you encountered in its

For my understanding purpose i have implemented Chain-Of-Responsibility pattern. //Abstract Base Type public abstract class CustomerServiceDesk { protected CustomerServiceDesk _nextHandler; public abstract void ServeCustomers(Customer _customer); public void SetupHadler(CustomerServiceDesk _nextHandler) { this._nextHandler = _nextHandler; } } public class FrontLineServiceDesk:CustomerServiceDesk { public override void ServeCustomers(Customer _customer) { if (_customer.ComplaintType == ComplaintType.General) { Console.WriteLine(_customer.Name + " Complaints are registered ; will be served soon

I've been struggling with the following problem. I have a series of function objects, each with it's own input and output types defined via generic type arguments in java. I would like to arrange these in a chain so that raw data is input to the first function, transformed to the into the output type, which is the input type of the next object, and so on. of course this would be trivial to hard-code, but i'd like to have the code be pluggable to new function objects. if i just leave out type arguments (only the final output type), this is how things look: public T process() { Iterator<Context>