Spring.Net IoC容器+Observer模式

Spring.Net IoC容器+Observer模式
欣喜地看到使用Spring.Net的人越来越多了，网络上介绍Spring.Net的文章也多了起来，不过看来看去，初级的例子总逃不掉Martin Fowler的那个MovieFinder-MovieList，本人自己写了另一个例子，并加入了用Delegate-Event实现的Observer模式，而Subject与Observer的绑定使用IoC Container和属性注入完成，可供大家参考。
Observer模式大家应已熟悉，故此处不多做阐述，首先是自定义的事件参数类型与Delegate定义的EventHandler

    public class ObserverEventArgs : EventArgs, IObserverEventArgs
    ...{
        private ArrayList arl = new ArrayList();
        public object this[int index]
        ...{
            get
            ...{
                if (index >= arl.Count)
                    return null;
                else
                    return arl[index];
            }
            set
            ...{
                if (index >= arl.Count)
                    arl.Add(value);
                else
                    arl[index] = value;
            }
        }
        public int Count
        ...{
            get
            ...{
                return arl.Count;
            }
        }
    }
    public delegate void ObserverEventHandler(Object source, IObserverEventArgs eargs); 

 

下面是Subject的实现

    public interface ISubject
    ...{
        void registerobserver(IObserver ob);
        void removeobserver(IObserver ob);
        void triggerevent(IObserverEventArgs oea);
    } 

    public class Subject : ISubject
    ...{
        private event ObserverEventHandler evhdl;
        private IObserver _Observer;
        public IObserver Observer
        ...{
            set
            ...{
                _Observer = value;
                evhdl += new ObserverEventHandler(new ObserverEventHandler(((IObserver)value).RecieveEvent));
            }
        }
        public void registerobserver(IObserver ob)
        ...{
            evhdl += new ObserverEventHandler(new ObserverEventHandler(ob.RecieveEvent));
        }
        public void removeobserver(IObserver ob)
        ...{
            evhdl -= (ObserverEventHandler)(ob.RecieveEvent);
        }
        public void triggerevent(IObserverEventArgs oea)
        ...{
            this.evhdl(this,oea);
        }
    } 

 

接下来是Observer的实现

    public interface IObserver
    ...{
        void RecieveEvent(object obj, IObserverEventArgs ea);
    }
    public class Observer : IObserver
    ...{
        private static int id;
        private int id_instance;
        public Observer()
        ...{
            id_instance = ++id;
        }
        public void RecieveEvent(Object obj, IObserverEventArgs oea)
        ...{
            Console.WriteLine("Observer{0} is triggered!", id_instance);
            for(int i = 0; i<oea.Count; i++)
                Console.WriteLine("Parameters[{0}]: {1}",i,oea[i].ToString());
        }
    } 

 

好了，综上，我们传统的Observer模式的创建便告一段落，接下来我们用Spring.Net的IoC Container(IApplicationContext)来在运行时创建加载配置在文件中的类，并用属性注入的方式对其进行依赖绑定。
首先是配置文件：

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <configSections>
    <sectionGroup name="spring">
      <section name="context" type="Spring.Context.Support.ContextHandler, Spring.Core"/>
      <section name="objects" type="Spring.Context.Support.DefaultSectionHandler, Spring.Core"/>
    </sectionGroup>
  </configSections>
  <spring>
    <context>
      <resource uri="config://spring/objects"/>
    </context>
    <objects xmlns="http://www.springframework.net">
      <description>An example of Spring + Observer</description>
      <object name="subject" type="RichardObserverPattern.Subject, MandyObserverPattern">
        <property name="Observer" ref="observer1"/>
      </object>
      <object name="observer1" type="RichardObserverPattern.Observer, MandyObserverPattern"/>
    </objects>
  </spring>
</configuration> 

 

其次是客户端的调用：

    public class Program
    ...{
        static void Main(string[] args)
        ...{
            Program p = new Program();
            p.RunningTrunk();
        }
        public void RunningTrunk()
        ...{
            IApplicationContext ctx = ContextRegistry.GetContext();
            ISubject sb = (ISubject)ctx.GetObject("subject");
            IObserverEventArgs oea = new ObserverEventArgs();
            oea[0] = "1";
            oea[1] = "2";
            sb.triggerevent(oea);
            Console.ReadLine();
        }
    } 

 

我们在这里实实在在地体会到了Spring.Net给我们带来的方便与快捷，不仅如此，还有良好的可扩展与松耦合。
在此需要声明的一点是，此例作为学习用例虽让Subject与Observer进行了较紧密的耦合，但在实际实践中Subject与Observer的关系却应该更松一些，也就是只通过Delegate建立方法间的绑定，而非类级别的。另外作为.Net的功能来讲，Delegate乃是其特有的的优秀之处，所以我建议Spring.Net的作者能够在属性注入和构造器注入之外增加方法注入和委托注入，以支持类之间的轻量级的装订与拆卸。