#region Abstract Handler Class
public abstract class Handler
{
#region Properties
/// <summary>
/// The request limit that the current handler
/// can process
/// </summary>
public int RequestLimit { get; private set; }
/// <summary>
/// The next handler in the chain
/// </summary>
public Handler NextHandler { get; private set; }
#endregion
#region Methods
public abstract void HandleRequest(int request);
#endregion
#region Ctor
public Handler(Handler handler, int requestLimit)
{
NextHandler = handler;
RequestLimit = requestLimit;
}
#endregion
}
#endregion
#region Concrete Handlers
public class Worker : Handler
{
#region Ctor
/// <summary>
/// Construct a new worker object with
/// the given handler
/// </summary>
/// <param name="handler">The given handler</param>
public Worker(Handler handler)
: base(handler, 10000)
{
}
#endregion
#region Methods
public override void HandleRequest(int request)
{
if (request < RequestLimit)
{
Console.WriteLine("{0} handled a {1} request",
GetType().Name, request);
}
else
{
if (NextHandler != null)
{
NextHandler.HandleRequest(request);
}
}
}
#endregion
}
public class Manager : Handler
{
#region Ctor
/// <summary>
/// Construct a new manager object with
/// the given handler
/// </summary>
/// <param name="handler">The given handler</param>
public Manager(Handler handler)
: base(handler, 20000)
{
}
#endregion
#region Methods
public override void HandleRequest(int request)
{
if (request < RequestLimit)
{
Console.WriteLine("{0} handled a {1} request",
GetType().Name, request);
}
else
{
if (NextHandler != null)
{
NextHandler.HandleRequest(request);
}
}
}
#endregion
}
public class SeniorManager : Handler
{
#region Ctor
/// <summary>
/// Construct a new senior manager object with
/// the given handler
/// </summary>
/// <param name="handler">The given handler</param>
public SeniorManager(Handler handler)
: base(handler, 50000)
{
}
#endregion
#region Methods
public override void HandleRequest(int request)
{
if (request < RequestLimit)
{
Console.WriteLine("{0} handled a {1} request",
GetType().Name, request);
}
else
{
if (NextHandler != null)
{
NextHandler.HandleRequest(request);
}
}
}
#endregion
}
#endregion
The example is simple. I have three types of workers: worker,
manager and a senior manager. Every worker type can handle request
that are lower than the request limit they have. Whenever a request
that is bigger than the request limit arrives the worker type deliver the
request to the next handler in the chain until there is no one who can
handle the request. The following example shows a use case of the example
classes:
class Program
{
static void Main(string[] args)
{
// Setup Chain of Responsibility
SeniorManager seniorManager = new SeniorManager(null);
Manager manager = new Manager(seniorManager);
Worker worker = new Worker(manager);
// Run requests along the chain
worker.HandleRequest(5000);
worker.HandleRequest(15000);
worker.HandleRequest(35000);
Console.WriteLine();
manager.HandleRequest(5000);
manager.HandleRequest(15000);
manager.HandleRequest(35000);
Console.WriteLine();
seniorManager.HandleRequest(5000);
seniorManager.HandleRequest(15000);
seniorManager.HandleRequest(35000);
// Wait for user
Console.Read();
}
}