PureMVC

一： PureMVC 目录结构。
     分三大目录，共21一个类（接口）。
     Core: 包含三大核心类： Model 、View、Controller
     Interface： 包含十个接口。
     Pattern: 其他辅助类。
            Mediator、Proxy、SimpleCommand(MarocCommand)。
     
Notification: 消息封装类：
  包含 Name、Body 、Type 三个重要的字段，本身这个类的作用，就是一种消息的封装载体。
 
    Notifer:  传递消息使用，里面存在SendNotification() 三个方法重载类，本质是引用 Façade 类中 SendNotification()的方法。
           
*Observer: 对指定对象调用指定方法。
   核心方法： NotifyObserver() 就是这个类的核心方法，我们在应用框架开发时候，使用SnedNotifacation() 方法的消息，最终消息的执行，就是由这个方法最终完成。

二： 三大核心类：
  Core 文件夹下： Model、View、Controller
 分析三大核心类共同特性：
   1:  都具备注册、查询(Controller类除外）、是否存在、移除方法。
   2： 都是“线程安全”、“延迟加载”的单例类。
   3： 核心类，存在大量虚方法，方便我们不改变框架源代码基础上，重构进一步丰富框架实现。
   4： View与Model 类都会执行 OnRegister() ,OnRemove（） 虚方法。
  
 Model 类不具备处理消息的能力。
所以不能给模型层实现类发消息。

 Controller 类，具备两大功能： 1： 缓存所有控制层实现类对象。
                                2： 可以接受“命令消息”，且自动执行（继承ICommand 的类）的Excute() 方法。

 View 类，
分两大功能：1： 整个框架的消息中心。
             2： 对于Mediator 做存储，查询，以及处理。


三： 入口与辅助类。

  Façade 入口类，就是框架三大核心类的一个简化入口。
  Mediator : 视图层需要继承的父类。
  SimpleCommand:  命令类
  MecroCommand:   多个命令类的集合。  
  Proxy :  模型代理类。
  Notify: 是  Mediator、SimpleCommand、Proxy父类，目的是方便我们做消息传递。


四： 分析PureMVC 消息的流转：

1： GameStart 脚本，执行Start() 方法。

2： ApplicationFacade 实例化（三层的初始化方法被执行）
       [例如： InitializeView() 都执行]
                     
3： 执行 StartupApplication 控制层，执行 Excute() 方法。

4： 执行SendNotifacation() 。

5： 执行父类SimplyCommand 的父类Notifier.cs 中的  SendNotifacation()                                        
6： Notifer 是引用的Facade 类中的方法。
7： Facade 类是PureMVC 的一个“空壳”，聚集了三大核心类中主要的对外公布的方法。
8：  Facade 最终是引用核心类：View 中“消息执行”NotifyObservers() 方法.

主要的设计模式

目录结构

三大核心类

Facade

/* 
     核心层： 控制类
*/
using System;
using System.Collections.Generic;
using PureMVC.Interfaces;
using PureMVC.Patterns;
namespace PureMVC.Core{
    public class Controller : IController{
        protected IView m_view;                             //IView 的引用
        protected IDictionary<string, Type> m_commandMap;   //Command 类引用的（通知名）映射
        protected static volatile IController m_instance;   //接口实例
        protected readonly object m_syncRoot = new object();//锁对象
        protected static readonly object m_staticSyncRoot = new object();//静态锁

        protected Controller(){
            m_commandMap = new Dictionary<string, Type>();
            InitializeController();                         //初始化
        }
        static Controller() {}
        public static IController Instance{
            get{
                if (m_instance == null){
                    lock (m_staticSyncRoot){
                        if (m_instance == null) m_instance = new Controller();
                    }
                }
                return m_instance;
            }
        }
        protected virtual void InitializeController(){
            m_view = View.Instance;
        }
       public virtual void ExecuteCommand(INotification note){
            Type commandType = null;
            lock (m_syncRoot){
                if (!m_commandMap.ContainsKey(note.Name)) return;
                commandType = m_commandMap[note.Name];
            }
            object commandInstance = Activator.CreateInstance(commandType);
            if (commandInstance is ICommand){
                ((ICommand) commandInstance).Execute(note);
            }
        }
public virtual void RegisterCommand(string notificationName, Type commandType){
    lock (m_syncRoot){
        if (!m_commandMap.ContainsKey(notificationName)){
            m_view.RegisterObserver(notificationName, new Observer("executeCommand", this));
        }
        m_commandMap[notificationName] = commandType;
    }
}//RegisterCommand_end

public virtual bool HasCommand(string notificationName){
    lock (m_syncRoot){
        return m_commandMap.ContainsKey(notificationName);
    }
}

public virtual void RemoveCommand(string notificationName){
    lock (m_syncRoot){
        if (m_commandMap.ContainsKey(notificationName)){
            m_view.RemoveObserver(notificationName, this);
            m_commandMap.Remove(notificationName);
        }
    }
}
}//Class_end
}


/* 
核心层： 模型类
*/
namespace PureMVC.Core{
    public class Model : IModel{
        protected static volatile IModel m_instance;        //本类实例
        protected IDictionary<string, IProxy> m_proxyMap;   //代理集合类
        protected readonly object m_syncRoot = new object();//同步锁定对象（配合Lock关键字）
        protected static readonly object m_staticSyncRoot = new object();//静态同步锁定对象
       
protected Model(){
            m_proxyMap = new Dictionary<string, IProxy>();
            InitializeModel();
      }
       static Model(){}

        public static IModel Instance{
            get{
                if (m_instance == null){
                    lock (m_staticSyncRoot){
                        if (m_instance == null) m_instance = new Model();
                    }
                }
                return m_instance;
            }
        }
        protected virtual void InitializeModel(){}

       public virtual void RegisterProxy(IProxy proxy){
            lock (m_syncRoot){
                m_proxyMap[proxy.ProxyName] = proxy;
            }
            proxy.OnRegister();
       }
      public virtual IProxy RetrieveProxy(string proxyName){
            lock (m_syncRoot){
                if (!m_proxyMap.ContainsKey(proxyName)) return null;
                return m_proxyMap[proxyName];
            }
      }
      public virtual bool HasProxy(string proxyName){
            lock (m_syncRoot){
                return m_proxyMap.ContainsKey(proxyName);
            }
      }

      public virtual IProxy RemoveProxy(string proxyName){
            IProxy proxy = null;

            lock (m_syncRoot){
                if (m_proxyMap.ContainsKey(proxyName)){
                    proxy = RetrieveProxy(proxyName);
                    m_proxyMap.Remove(proxyName);
                }
            }
            if (proxy != null) proxy.OnRemove();
            return proxy;
        }
    }
}
/* 
    核心类： 视图层
*/
namespace PureMVC.Core{
    public class View : IView{
        protected IDictionary<string, IMediator> m_mediatorMap;//缓存IMediator实例集合
        protected IDictionary<string, IList<IObserver>> m_observerMap;
        protected static volatile IView m_instance;    
        protected readonly object m_syncRoot = new object();
        protected static readonly object m_staticSyncRoot = new object();

        protected View(){
            m_mediatorMap = new Dictionary<string, IMediator>();
            m_observerMap = new Dictionary<string, IList<IObserver>>();
             InitializeView();
        }

        static View(){}

        public static IView Instance{
            get
            {
                if (m_instance == null)
                {
                    lock (m_staticSyncRoot)
                    {
                        if (m_instance == null) m_instance = new View();
                    }
                }
                return m_instance;
            }
        }
        protected virtual void InitializeView(){ }

        public virtual void RegisterObserver(string notificationName, IObserver observer){            
            lock (m_syncRoot){
                if (!m_observerMap.ContainsKey(notificationName)){
                    m_observerMap[notificationName] = new List<IObserver>();
                }
                m_observerMap[notificationName].Add(observer);
            }
        }


        public virtual void NotifyObservers(INotification notification){
            IList<IObserver> observers = null;
            lock (m_syncRoot){
                if (m_observerMap.ContainsKey(notification.Name)){
                    IList<IObserver> observers_ref = m_observerMap[notification.Name];
                    observers = new List<IObserver>(observers_ref);
                }
            }
            if (observers != null){
                // Notify Observers from the working array              
                for (int i = 0; i < observers.Count; i++){
                    IObserver observer = observers[i];
                    observer.NotifyObserver(notification);
                }
            }
        }
        public virtual void RemoveObserver(string notificationName, object notifyContext){
            lock (m_syncRoot){
                if (m_observerMap.ContainsKey(notificationName)){
                    IList<IObserver> observers = m_observerMap[notificationName];

                    for (int i = 0; i < observers.Count; i++){
                        if (observers[i].CompareNotifyContext(notifyContext)){
                            observers.RemoveAt(i);
                            break;
                        }
                    }
                    if (observers.Count == 0){
                        m_observerMap.Remove(notificationName);
                    }
                }
            }
        }
        public virtual void RegisterMediator(IMediator mediator){
            lock (m_syncRoot){
                if (m_mediatorMap.ContainsKey(mediator.MediatorName)) return;
                m_mediatorMap[mediator.MediatorName] = mediator;
                IList<string> interests = mediator.ListNotificationInterests();
                if (interests.Count > 0){
                    IObserver observer = new Observer("handleNotification", mediator);
                    for (int i = 0; i < interests.Count; i++){
                        RegisterObserver(interests[i].ToString(), observer);
                    }
                }
            }
            mediator.OnRegister();
        }

        public virtual IMediator RetrieveMediator(string mediatorName)
        {
            lock (m_syncRoot)
            {
                if (!m_mediatorMap.ContainsKey(mediatorName)) return null;
                return m_mediatorMap[mediatorName];
            }
        }

        public virtual IMediator RemoveMediator(string mediatorName){
            IMediator mediator = null;
            lock (m_syncRoot)
            {
                if (!m_mediatorMap.ContainsKey(mediatorName)) return null;
                mediator = (IMediator) m_mediatorMap[mediatorName];

                IList<string> interests = mediator.ListNotificationInterests();

                for (int i = 0; i < interests.Count; i++){
                    RemoveObserver(interests[i], mediator);
                }
    
                m_mediatorMap.Remove(mediatorName);
            }

            if (mediator != null) mediator.OnRemove();
            return mediator;
        }

        public virtual bool HasMediator(string mediatorName)
        {
            lock (m_syncRoot)
            {
                return m_mediatorMap.ContainsKey(mediatorName);
            }
        }
    }
}


/*
    Facade 核心入口类
 */
namespace PureMVC.Patterns{
    public class Facade : IFacade{
        protected IController m_controller;
        protected IModel m_model;
        protected IView m_view;
        protected static volatile IFacade m_instance;
        protected static readonly object m_staticSyncRoot = new object();

        protected Facade() {
            InitializeFacade();
        }

        public static IFacade Instance{
            get{
                if (m_instance == null){
                    lock (m_staticSyncRoot){
                        if (m_instance == null) m_instance = new Facade();
                    }
                }
                return m_instance;
            }
        }

        static Facade(){}

        protected virtual void InitializeFacade(){
            InitializeModel();
            InitializeController();
            InitializeView();
        }

        public virtual void RegisterProxy(IProxy proxy){
            m_model.RegisterProxy(proxy);
        }

        public virtual IProxy RetrieveProxy(string proxyName){
            return m_model.RetrieveProxy(proxyName);
        }
        public virtual IProxy RemoveProxy(string proxyName){
            return m_model.RemoveProxy(proxyName);
        }

        public virtual bool HasProxy(string proxyName){
            return m_model.HasProxy(proxyName);
        }

        public virtual void RegisterCommand(string notificationName, Type commandType){
            m_controller.RegisterCommand(notificationName, commandType);
        }

        public virtual void RemoveCommand(string notificationName){
            m_controller.RemoveCommand(notificationName);
        }

        public virtual bool HasCommand(string notificationName){
            return m_controller.HasCommand(notificationName);
        }

        public virtual void RegisterMediator(IMediator mediator){
            m_view.RegisterMediator(mediator);
        }

        public virtual IMediator RetrieveMediator(string mediatorName){
            return m_view.RetrieveMediator(mediatorName);
        }

        public virtual IMediator RemoveMediator(string mediatorName){
            return m_view.RemoveMediator(mediatorName);
        }

        public virtual bool HasMediator(string mediatorName){
            return m_view.HasMediator(mediatorName);
        }

        public virtual void NotifyObservers(INotification notification){
            m_view.NotifyObservers(notification);
        }

        public virtual void SendNotification(string notificationName){
            NotifyObservers(new Notification(notificationName));
        }

        public virtual void SendNotification(string notificationName, object body){
            NotifyObservers(new Notification(notificationName, body));
        }

        public virtual void SendNotification(string notificationName, object body, string type){
            NotifyObservers(new Notification(notificationName, body, type));
        }

        protected virtual void InitializeController(){
            if (m_controller != null) return;
            m_controller = Controller.Instance;
        }

        protected virtual void InitializeModel(){
            if (m_model != null) return;
            m_model = Model.Instance;
        }
        
        protected virtual void InitializeView(){
            if (m_view != null) return;
            m_view = View.Instance;
        }
    }
}























/***
 *  简单命令类
*/
namespace PureMVC.Patterns{
    public class SimpleCommand : Notifier, ICommand, INotifier{
        public virtual void Execute(INotification notification){}
    }
}
/* 
 *  大量命令类
*/
namespace PureMVC.Patterns{
    public class MacroCommand : Notifier, ICommand, INotifier{
        private IList<Type> m_subCommands;

        public MacroCommand(){
            m_subCommands = new List<Type>();
            InitializeMacroCommand();
        }

        public virtual void Execute(INotification notification){
            while (m_subCommands.Count > 0){
                Type commandType = m_subCommands[0];
                object commandInstance = Activator.CreateInstance(commandType);

                if (commandInstance is ICommand){
                    ((ICommand) commandInstance).Execute(notification);
                }

                m_subCommands.RemoveAt(0);
            }
        }

        protected virtual void InitializeMacroCommand(){}

         protected void AddSubCommand(Type commandType){
            m_subCommands.Add(commandType);
        }
    }
}




/***
 * 视图类 
*/
namespace PureMVC.Patterns{
    public class Mediator : Notifier, IMediator, INotifier{
        protected string m_mediatorName;
        protected object m_viewComponent;
       public const string NAME = "Mediator";

       public virtual string MediatorName{
            get { return m_mediatorName; }
       }
      public virtual object ViewComponent{
            get { return m_viewComponent; }
            set { m_viewComponent = value; }
      }

        public Mediator()
            : this(NAME, null){}
        public Mediator(string mediatorName)
            : this(mediatorName, null){}
        public Mediator(string mediatorName, object viewComponent){
            m_mediatorName = (mediatorName != null) ? mediatorName : NAME;
            m_viewComponent = viewComponent;
        }
        public virtual IList<string> ListNotificationInterests(){
            return new List<string>();
        }

        public virtual void HandleNotification(INotification notification){}
        public virtual void OnRegister(){}
        public virtual void OnRemove(){}

    }
}









/* 
    通知类
*/
namespace PureMVC.Patterns{
    public class Notification : INotification{
        private string m_name;
        private string m_type;
        private object m_body;
public virtual string Name{
            get { return m_name; }
        }
        public virtual object Body{
            get{
                return m_body;
            }
            set{
                m_body = value;
            }
        }
        public virtual string Type{
            get{
                return m_type;
            }
            set{
                m_type = value;
            }
        }
        public Notification(string name)
            : this(name, null, null){ }
        public Notification(string name, object body)
            : this(name, body, null){ }
        public Notification(string name, object body, string type){
            m_name = name;
            m_body = body;
            m_type = type;
        }
        public override string ToString(){
            string msg = "Notification Name: " + Name;
            msg += "\nBody:" + ((Body == null) ? "null" : Body.ToString());
            msg += "\nType:" + ((Type == null) ? "null" : Type);
            return msg;
        }
    }
}
/* 
    通知者类
*/

using System;
using PureMVC.Interfaces;
using PureMVC.Patterns;

namespace PureMVC.Patterns
{
    public class Notifier : INotifier
    {
        private IFacade m_facade = PureMVC.Patterns.Facade.Instance;
        
protected IFacade Facade{
            get { return m_facade; }
        }

        public virtual void SendNotification(string notificationName) {
            m_facade.SendNotification(notificationName);
        }
        public virtual void SendNotification(string notificationName, object body){
            m_facade.SendNotification(notificationName, body);
        }

        public virtual void SendNotification(string notName, object body, string type){
            m_facade.SendNotification(notName, body, type);
        }
    }
}














/* 观察者类 */
namespace PureMVC.Patterns{
    public class Observer : IObserver{
        private string m_notifyMethod;                        //通知方法名称
        private object m_notifyContext;                       //通知上下文
        protected readonly object m_syncRoot = new object();  //锁定
        public virtual string NotifyMethod{
            private get{
                return m_notifyMethod;
            }
            set{
                m_notifyMethod = value;
            }
        }
        public virtual object NotifyContext{
            private get{
                return m_notifyContext;
            }
            set{
                m_notifyContext = value;
            }
        }
        public Observer(string notifyMethod, object notifyContext){
            m_notifyMethod = notifyMethod;
            m_notifyContext = notifyContext;
        }
        public virtual void NotifyObserver(INotification notification){
            object context;
            string method;
            lock (m_syncRoot){
                context = NotifyContext;
                method = NotifyMethod;
            }
            Type t = context.GetType();
            BindingFlags f = BindingFlags.Instance | BindingFlags.Public | BindingFlags.IgnoreCase;
            MethodInfo mi = t.GetMethod(method, f);
            mi.Invoke(context, new object[] { notification });
        }
        public virtual bool CompareNotifyContext(object obj){
            lock (m_syncRoot){
                return NotifyContext.Equals(obj);
            }
        }   }}
/* 
    代理类
*/

using System;
using PureMVC.Interfaces;
using PureMVC.Patterns;

namespace PureMVC.Patterns{
    public class Proxy : Notifier, IProxy, INotifier{
        protected string m_proxyName;
        protected object m_data;
        public static string NAME = "Proxy";

        public virtual string ProxyName{
            get { return m_proxyName; }
        }

        public virtual object Data{
            get { return m_data; }
            set { m_data = value; }
        }

        public Proxy() 
            : this(NAME, null){}
        public Proxy(string proxyName)
            : this(proxyName, null){}
        public Proxy(string proxyName, object data){
            m_proxyName = (proxyName != null) ? proxyName : NAME;
            if (data != null) m_data = data;
        }

        public virtual void OnRegister(){}
        public virtual void OnRemove(){}
    }
}
------------------------------------------(接口)--------------------------------------------
namespace PureMVC.Interfaces
{
    public interface ICommand
    {
        void Execute(INotification notification);
    }
}
namespace PureMVC.Interfaces{
    public interface IProxy
    {
        string ProxyName { get; }
        object Data { get; set; }
        void OnRegister();
         void OnRemove();
    }
}
namespace PureMVC.Interfaces{
    public interface IView{
        void RegisterObserver(string notificationName, IObserver observer);
        void RemoveObserver(string notificationName, object notifyContext);
        void NotifyObservers(INotification note);
         void RegisterMediator(IMediator mediator);
        IMediator RetrieveMediator(string mediatorName);
         IMediator RemoveMediator(string mediatorName);
        bool HasMediator(string mediatorName);
    }
}
namespace PureMVC.Interfaces{
    public interface IObserver{
        string NotifyMethod { set; }
        object NotifyContext { set; }
         void NotifyObserver(INotification notification);
        bool CompareNotifyContext(object obj);
    }
}
namespace PureMVC.Interfaces{
    public interface INotifier{
        void SendNotification(string notificationName);
        void SendNotification(string notificationName, object body);
        void SendNotification(string notificationName, object body, string type);
    }
}
namespace PureMVC.Interfaces{
    public interface INotification{
        string Name { get; }
        object Body { get; set; }
        string Type { get; set; }
         string ToString();
    }
}

namespace PureMVC.Interfaces{
    public interface IModel{
        void RegisterProxy(IProxy proxy);
        IProxy RetrieveProxy(string proxyName);
         IProxy RemoveProxy(string proxyName);
        bool HasProxy(string proxyName);
    }
}
namespace PureMVC.Interfaces{
    public interface IMediator{
        string MediatorName { get; }
        object ViewComponent { get; set; }
         IList<string> ListNotificationInterests();
        void HandleNotification(INotification notification);
        void OnRegister();
        void OnRemove();
    }
}
namespace PureMVC.Interfaces{
    public interface IFacade : INotifier{
        void RegisterProxy(IProxy proxy);
        IProxy RetrieveProxy(string proxyName);
         IProxy RemoveProxy(string proxyName);
        bool HasProxy(string proxyName);
         void RegisterCommand(string notificationName, Type commandType);
        void RemoveCommand(string notificationName);
        bool HasCommand(string notificationName);
        void RegisterMediator(IMediator mediator);
        IMediator RetrieveMediator(string mediatorName);
         IMediator RemoveMediator(string mediatorName);
        bool HasMediator(string mediatorName);
        void NotifyObservers(INotification note);
    }
}
namespace PureMVC.Interfaces{
    public interface IController{
         void RegisterCommand(string notificationName, Type commandType);
        void ExecuteCommand(INotification notification);
        void RemoveCommand(string notificationName);
        bool HasCommand(string notificationName);
    }
}