.NET Chain of Responsibility Library

Posted by Al Tenhundfeld on Sep 18, 2008

Sections

Development,

Architecture & Design

Topics

.NET Framework ,

.NET ,

Loose Coupling ,

Object Oriented Design

Tags

Design Patterns ,

Mono

Chain.NET (or NChain) is a generic implementation of Chain Of Responsibility design pattern for .NET and Mono platforms. Version 0.1, available on SourceForge, combines standard CoR design pattern with Command design pattern in order to "bring convenience and flexibility in command processing solutions."

NChain is loosely based on the Jakarta's Commons Chain package that is available for Java platform. In general, CoR is a pattern used to promote loose coupling, through separating command objects from a series of processing objects. Each processing object contains code to describe the types of command objects it can accept and will also delegate responsibility for processing incompatible objects to the next processor in the chain.

An example of a simple CoR pattern:

using System;
using System.Collections;
 
namespace Chain_of_responsibility
{
        public interface IChain
        {
                bool Process(object command);
        }
 
        public class Chain
        {
                private ArrayList _list;
 
                public ArrayList List
                {
                        get
                        {
                                return _list;
                        }
                }
 
                public Chain()
                {
                        _list = new ArrayList();
                }
 
                public void Message(object command)
                {
                        foreach ( IChain item in _list )
                        {
                                bool result = item.Process(command);
 
                                if ( result == true ) break;
                        }
                }
 
                public void Add(IChain handler)
                {
                        List.Add(handler);
                }
        }
 
        public class StringHandler : IChain
        {
                public bool Process(object command)
                {
                        if ( command is string )
                        {
                                Console.WriteLine("StringHandler can handle this message 

: {0}",(string)command);
 
                                return true;
                        }
 
                        return false;
                }
        }
 
        public class IntegerHandler : IChain
        {
                public bool Process(object command)
                {
                        if ( command is int )
                        {
                                Console.WriteLine("IntegerHandler can handle this message 

: {0}",(int)command);
 
                                return true;
                        }
 
                        return false;
                }
        }
 

 
        class TestMain
        {
                static void Main(string[] args)
                {
                        Chain chain = new Chain();
 
                        chain.Add(new StringHandler());                       
                        chain.Add(new IntegerHandler());
 
                        chain.Message("1st string value");
                        chain.Message(100);
                }
        }
}

NChain provides a similar though more robust architecture:

NChain requires further testing and performance monitoring to determine how appropriate it is for enterprise application architecture, but the project is open-source and has useful tutorials for getting started quickly. At this early stage, NChain appears to be a viable candidate for any scenario where you are considering using a command pattern but need to provide varying execution contexts for different types of commands.

• Older >