ASP.NET MVC 开源项目Kigg解读（1）

Kigg是一个很好的ASP.NET MVC范例项目，本着研究的目的，对Kigg进行解读。

•  
  • ASP.NET MVC
  • Linq To SQL
  • MS Patterns & Practices – Enterprise Library (Logging & Caching)
  • MS Patterns & Practices - Unity
  • jQuery
  • xUnit.net
  • Moq
  • HtmlAgilityPack
  • DotNetOpenId
  • jQuery UI & Markitup

Kigg介绍：

KiGG 是一个微软技术支持部门开发的Web 2.0 风格的社会新闻软件，采用如下的开发组件：

 

可以从http://kigg.codeplex.com/ 下载全部源代码

示例站点： KiGG v2.6 Beta

一、启动篇

就如一个操作系统，开机时需要boot，于是kigg也从boot开始！

在Kigg.Core中，定义了IBootstrapperTask接口

public interface IBootstrapperTask
{
void Execute();
}

纵观Kigg的源代码，我们可以发现共有4个Boot Task,如下图所示：

这4个task分别是创建默认用户，注册Controller工厂，注册路由，和启动后台任务（Background Tasks）

怎么在系统启动的时候调用IBootstrapperTask？Kigg专门建立了一个静态类Bootstrapper：

  public static class Bootstrapper
    {
        static Bootstrapper()
        {
            try
            {
                IoC.InitializeWith(new DependencyResolverFactory());
            }
            catch (ArgumentException)
            {
                // Config file is Missing
            }
        }

        public static void Run()
        {
            IoC.ResolveAll<IBootstrapperTask>().ForEach(t => t.Execute());
        }
    }

在该类的静态构造函数里，进行的是IOC（这里用的是Unity）的初始化工作。同时，Bootstrapper类还有个Run方法，该方法调用IOC Resolve所有实现了IBootstrapperTask接口的任务，然后ForEach（一个扩展方法，遍历集合）每个任务并Execute。

于是，我们在Kigg的GlobalApplication里看到了华丽丽的Bootstrapper.Run();

    public class GlobalApplication : HttpApplication
    {
        public static void OnStart()
        {
            Bootstrapper.Run();
            Log.Info("Application Started");
        }
   }

二、后台任务

其实分析IBootstrapperTask的初衷是对Kigg的后台任务（BackgroundTask）感兴趣：

public interface IBackgroundTask
    {
        bool IsRunning
        {
            get;
        }

        void Start();

        void Stop();
    }

在Kigg中，共有5种后台任务：

这些后台任务的开启，是在实现了IBootstrapperTask接口的StartBackgroundTasks中开启的：

    public class StartBackgroundTasks : IBootstrapperTask
    {
        private readonly IBackgroundTask[] _tasks;

        public StartBackgroundTasks(IBackgroundTask[] tasks)
        {
            Check.Argument.IsNotEmpty(tasks, "tasks");

            _tasks = tasks;
        }

        public void Execute()
        {
            _tasks.ForEach(t => t.Start());
        }
    }

StartBackgroundTasks 类的构造函数参数是通过IOC搞定的（后面会单独介绍IOC）

三、事件聚合器IEventAggregator

在分析BackgroundTask的代码时，发现所有的BackgroundTask都继承于BaseBackgroundTask：

在查看BaseBackgroundTask时，发现了令人惊喜的东西——IEventAggregator

EventAggregator是何许玩意呢？按字面意思，事件聚合器？姑且这么叫吧！这个接口只有一个方法：

public interface IEventAggregator

{

TEventType GetEvent<TEventType>() where TEventType : BaseEvent;

}

作用是获取一个继承BaseEvent的事件（Event）.

为了弄清楚EventAggregator到底有什么用，我们先来看看与BaseEvent相关的几个类：

首先是一个事情订阅接口，包含一个订阅Token，一个获取可执行函数的方法。

public interface IEventSubscription
    {
        SubscriptionToken SubscriptionToken
        {
            get;
            set;
        }

        Action<object[]> GetExecutionStrategy();
    }

订阅Token，实现了IEquatable接口，可以进行比较，这里的Token没什么特别的作用，仅仅用来标识一个订阅，这样在移除订阅的时候通过Token能方便的找到并移除

    public class SubscriptionToken : IEquatable<SubscriptionToken>
    {
        private readonly Guid _token = Guid.NewGuid();

        [DebuggerStepThrough]
        public bool Equals(SubscriptionToken other)
        {
            return (other != null) && Equals(_token, other._token);
        }

        [DebuggerStepThrough]
        public override bool Equals(object obj)
        {
            return ReferenceEquals(this, obj) || Equals(obj as SubscriptionToken);
        }

        [DebuggerStepThrough]
        public override int GetHashCode()
        {
            return _token.GetHashCode();
        }

        [DebuggerStepThrough]
        public override string ToString()
        {
            return _token.ToString();
        }
    }

再来看最为关键的BaseEvent

    /// <summary>
    /// 事件基类
    /// </summary>
    public abstract class BaseEvent
    {
        private readonly List<IEventSubscription> _subscriptions = new List<IEventSubscription>();


        /// <summary>
        /// 订阅者
        /// </summary>
        protected ICollection<IEventSubscription> Subscriptions
        {
            [DebuggerStepThrough]
            get
            {
                return _subscriptions;
            }
        }

        /// <summary>
        /// 订阅
        /// </summary>
        /// <param name="eventSubscription"></param>
        /// <returns></returns>
        protected virtual SubscriptionToken Subscribe(IEventSubscription eventSubscription)
        {
            eventSubscription.SubscriptionToken = new SubscriptionToken();

            lock (_subscriptions)
            {
                _subscriptions.Add(eventSubscription);
            }

            return eventSubscription.SubscriptionToken;
        }

        protected virtual void Publish(params object[] arguments)
        {
            List<Action<object[]>> executionStrategies = PruneAndReturnStrategies();

            foreach (var executionStrategy in executionStrategies)
            {
                executionStrategy(arguments);
            }
        }

        public virtual void Unsubscribe(SubscriptionToken token)
        {
            lock (_subscriptions)
            {
                IEventSubscription subscription = _subscriptions.FirstOrDefault(evt => evt.SubscriptionToken == token);

                if (subscription != null)
                {
                    _subscriptions.Remove(subscription);
                }
            }
        }

        public virtual bool Contains(SubscriptionToken token)
        {
            lock (_subscriptions)
            {
                IEventSubscription subscription = _subscriptions.FirstOrDefault(evt => evt.SubscriptionToken == token);

                return (subscription != null);
            }
        }

        private List<Action<object[]>> PruneAndReturnStrategies()
        {
            List<Action<object[]>> returnList = new List<Action<object[]>>();

            lock (_subscriptions)
            {
                for (int i = _subscriptions.Count - 1; i >= 0; i--)
                {
                    Action<object[]> subscriptionAction = _subscriptions[i].GetExecutionStrategy();

                    if (subscriptionAction == null)
                    {
                        _subscriptions.RemoveAt(i);
                    }
                    else
                    {
                        returnList.Add(subscriptionAction);
                    }
                }
            }

            return returnList;
        }
    }

BaseEvent包含了Subscribe，Publish这两个对事件进行处理的关键方法：

Subscribe时会添加一个IEventSubscription，Publish时会执行所有IEventSubscription中的方法。

回过头来，再来看BaseBackgroundTask：

public abstract class BaseBackgroundTask : IBackgroundTask
   {
       private readonly IEventAggregator _eventAggregator;

       protected BaseBackgroundTask(IEventAggregator eventAggregator)
       {
           Check.Argument.IsNotNull(eventAggregator, "eventAggregator");

           _eventAggregator = eventAggregator;
       }

       public bool IsRunning
       {
           get;
           private set;
       }

       protected internal IEventAggregator EventAggregator
       {
           [DebuggerStepThrough]
           get
           {
               return _eventAggregator;
           }
       }

       public void Start()
       {
           OnStart();
           IsRunning = true;
       }

       public void Stop()
       {
           OnStop();
           IsRunning = false;
       }

       protected abstract void OnStart();

       protected abstract void OnStop();

       protected internal SubscriptionToken Subscribe<TEvent, TEventArgs>(Action<TEventArgs> action) where TEvent : BaseEvent<TEventArgs> where TEventArgs : class
       {
           return _eventAggregator.GetEvent<TEvent>().Subscribe(action, true);
       }

       protected internal void Unsubscribe<TEvent>(SubscriptionToken token) where TEvent : BaseEvent
       {
           _eventAggregator.GetEvent<TEvent>().Unsubscribe(token);
       }
   }

注意下 Subscribe和Unsubscribe方法，这两个方法通过eventAggregator获取特定的TEvent，实现事件的定订阅和解除订阅。

然后再来看一个具体的Task，比如PingServer：

PingServer继承BaseBackgroundTask ，需要实现OnStart和OnStop，PingServer的作用是在发布一篇story的时候通知ping服务器，我更新了，你可以派你的爬虫过来了……因此，在OnStart方法中，Subscribe了story提交事件--StorySubmitEvent，并指定用StorySubmitted方法来处理这个事件，因此StorySubmitted方法只需要实现发送ping的代码就可以了。

        protected override void OnStart()
        {
            if (!IsRunning)
            {
                _storySubmitToken = Subscribe<StorySubmitEvent, StorySubmitEventArgs>(StorySubmitted);
                _storyApproveToken = Subscribe<StoryApproveEvent, StoryApproveEventArgs>(StoryApproved);
            }
        }

        protected override void OnStop()
        {
            if (IsRunning)
            {
                Unsubscribe<StorySubmitEvent>(_storySubmitToken);
                Unsubscribe<StoryApproveEvent>(_storyApproveToken);
            }
        }

        internal void StorySubmitted(StorySubmitEventArgs eventArgs)
        {
            SendPing();
        }

        internal void StoryApproved(StoryApproveEventArgs eventArgs)
        {
            SendPing();
        }

光有订阅是不行的，同学们，还需要有发布才行！关于发布，看看StoryService就可以了，在这个service的Create函数中有这么一段代码：

_eventAggregator.GetEvent<StorySubmitEvent>().Publish(new StorySubmitEventArgs(story,detailUrl));

 

OMG，这就是发布吗？

关注作者

欢迎关注作者微信公众号, 一起交流软件开发：