一个模式

控制器

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace RGeos.FrameWork.MVC
{
    //控制类
    public interface IController
    {
        string Name { get; }
        IExecutor Executor { get; }
        IObserver Observer { get; }
    }
    public abstract class AbstractController : IController
    {
        protected string mName;
        protected IExecutor mExecutor;
        protected IObserver mObserver;
        //从外部传入被观察者
        //控制器内部构造观察者，并向被观察者注册，观察者和控制器总是成对出现
        protected AbstractController(string name, IExecutor executor)
        {
            this.mName = name;
            this.mExecutor = executor;
        }

        public virtual IExecutor Executor
        {
            get
            {
                return this.mExecutor;
            }
        }

        public virtual string Name
        {
            get
            {
                return this.mName;
            }
        }

        public virtual IObserver Observer
        {
            get
            {
                return this.mObserver;
            }
        }
        //业务逻辑
        public virtual void HandExecuter()
        {
        }
        public virtual bool OnRemove(object o, params object[] assistant)
        {
            return this.mExecutor.OnRemove(o, assistant);
        }
        public virtual bool OnAdd(object o, params object[] assistant)
        {
            return this.mExecutor.OnAdd(o, assistant);
        }
        public virtual bool OnReplace(object o, params object[] assistant)
        {
            return this.mExecutor.OnReplace(o, assistant);
        }

    }
}

被观察者

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace RGeos.FrameWork.MVC
{
   //被观察者，执行者
    public interface IExecutor
    {
        string Name { get; }

        bool IsStateChanged { get; }

        bool NeedRefresh { get; }
        //观察者集合
        List<IObserver> Observers { get; }

        bool OnAdd(object o, params object[] assistant);
        bool OnRemove(object o, params object[] assistant);
        bool OnReplace(object o, params object[] assistant);

        void NotifyObservers();
        //添加观察者
        bool RegisterObserver(IObserver view);
        //注销观察者
        bool UnRegisterObserver(IObserver view);
        //注销所有观察者
        bool UnRegisterObservers();
    }
    public abstract class AbstractExecutor : IExecutor, ICloneable
    {
        protected bool mIsStateChanged;
        protected string mName;
        protected bool mNeedRefresh;
        protected List<IObserver> m_observers;
        public bool IsStateChanged
        {
            get
            {
                return this.mIsStateChanged;
            }
        }

        public string Name
        {
            get
            {
                return this.mName;
            }
        }
        public bool NeedRefresh
        {
            get
            {
                return this.mNeedRefresh;
            }
        }

        public List<IObserver> Observers
        {
            get
            {
                return this.m_observers;
            }
        }

        protected AbstractExecutor(string name)
        {
            this.mName = name;
            this.mNeedRefresh = true;
            this.mIsStateChanged = false;
            this.m_observers = new List<IObserver>();
        }
        protected AbstractExecutor()
        {
            this.mNeedRefresh = true;
            this.mIsStateChanged = false;
            this.m_observers = new List<IObserver>();
        }


        public virtual object Clone()
        {
            return null;
        }

        public virtual bool RegisterObserver(IObserver observer)
        {
            if (this.m_observers == null)
            {
                this.m_observers = new List<IObserver>();
            }
            if (!this.m_observers.Contains(observer))
            {
                this.m_observers.Add(observer);
                return true;
            }
            return false;
        }

        public virtual bool UnRegisterObserver(IObserver observer)
        {
            if (this.m_observers != null)
            {
                while (this.m_observers.Contains(observer))
                {
                    return this.m_observers.Remove(observer);
                }
            }
            return false;
        }

        public virtual bool UnRegisterObservers()
        {
            if (this.m_observers != null)
            {
                this.m_observers.Clear();
                this.m_observers = null;
                return true;
            }
            return false;
        }

        public virtual bool OnAdd(object o, params object[] assistant)
        {
            this.mIsStateChanged = true;
            this.NotifyObservers();
            return true;
        }
        public virtual bool OnRemove(object o, params object[] assistant)
        {
            this.mIsStateChanged = true;
            this.NotifyObservers();
            return true;
        }
        public virtual bool OnReplace(object o, params object[] assistant)
        {
            this.mIsStateChanged = true;
            this.NotifyObservers();
            return true;
        }
        public virtual void NotifyObservers()
        {
            if (this.mNeedRefresh)
            {
                if (this.mIsStateChanged)
                {
                    foreach (IObserver observer in this.m_observers)
                    {
                        observer.OnUpdate(this);
                    }
                }
            }
            this.mIsStateChanged = false;
        }
    }

}

观察者

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace RGeos.FrameWork.MVC
{
    //观察者
    public interface IObserver
    {
        IController Controller { get; }
        IExecutor Executor { get; }
        string Name { get; }

        void InitializeObserver();
        //更新观察者
        void OnUpdate(IExecutor currentExecutor);
    }
    public abstract class AbstractObserver : IObserver
    {
        protected IController mController;
        protected IExecutor mExecutor;
        protected string mName;

        public abstract void InitializeObserver();
        public abstract void OnUpdate(IExecutor currentExecutor);

        public virtual IController Controller
        {
            get
            {
                return this.mController;
            }
        }

        public virtual IExecutor Executor
        {
            get
            {
                return this.mExecutor;
            }
        }

        public virtual string Name
        {
            get
            {
                return this.mName;
            }
        }
        //观察者通过控制器引用，调用被观察者的方法，更新其他的观察者。
        //此时观察者和被观察者不通信
        protected AbstractObserver(string name, IController controller)
        {
            this.mName = name;
            this.mController = controller;
            this.mExecutor = controller.Executor;
        }
        //在控制器中构造观察者时，将被观察者传入观察者，这样观察者可以调用被观察者中的数据。
        //此时观察者和被观察者通信
        protected AbstractObserver(string name, IController controller, IExecutor executor)
        {
            this.mName = name;
            this.mController = controller;
            this.mExecutor = executor;
        }
    }

}

这个是MVC还是MVP？说不清。