dottext阅读之系统调度分析

//自定义的配置节处理器必须实现IConfigurationSectionHandler接口
    public class XmlSerializerSectionHandler : IConfigurationSectionHandler
    {
        public object Create(object parent, object configContext, System.Xml.XmlNode section)
        {
            XPathNavigator nav = section.CreateNavigator();
            string typename = (string) nav.Evaluate("string(@type)");//是从当前XML（配置文件是一个符合xml要求的文档）节点处，获取”type”属性
            Type t = Type.GetType(typename);//然后按照属性描述，获得一个.net的类型
            /*这种生成类的方法是区别于new 方法生成具体类的另外途径，好处就是灵活根据具
             * 体环境内容（甚至是用户交互输入的类型描述字符串）就可以生成获得托管类型。（此处反射细节请参考MSDN）。
             * 坏处就是可能隐藏着类型错误，运行时出错，导致不可预料（好像这个词在windows编程时代相当的常见）例外甚至系统崩溃。
             */

            //当然，上面仅仅创建了类型是不够用的，还需要通过一定途径来确定生成类的具体状态，
            //这有用到OOP语言的重要特性—序列化，将一个对象存储器来，以及从存储中还原具体对象的机制。

            //这里使用的是System提供的 XmlSerializer 类的反序列化方法Deserialize。反序列化后面还有很多
            //代码涉及到，我认为现在就大致理解为“通过这个反序列化，我们刚刚得到的类实例中的属性、成员变
            //量获得了赋值，进入到某个状态，就好像我们此处运行了new 语法和进行了对象的构造以及赋值”即可。更进一步的可以从权威资料MSDN获取。

            XmlSerializer ser = new XmlSerializer(t);
            return ser.Deserialize(new XmlNodeReader(section));
        }

//.NET1.1方式
BlogConfigurationSettings bs = (BlogConfigurationSettings)System.Configuration.ConfigurationSettings.GetConfig("BlogConfigurationSettings");
//.NET2.0方式
BlogConfigurationSettings bs = (BlogConfigurationSettings)System.Configuration.ConfigurationManager.GetSection("BlogConfigurationSettings");

public class SearchEngineSchedule : Dottext.Framework.ScheduledEvents.IEvent
    {
        public SearchEngineSchedule()
        {
            //
            // TODO: Add constructor logic here
            //
        }
        #region IEvent Members

        public void Execute(object state)
        {
            Log log = new Log();
            log.Title = "Search Index";
            log.Message = string.Format("Daily ({0}) Build",log.StartDate.ToShortDateString());

            IndexManager.RebuildSafeIndex(30);

            log.EndDate = DateTime.Now;

            LogManager.Create(log);

        }

        #endregion
    }

namespace Dottext.Framework.ScheduledEvents
{
    /// <summary>
    /// Interface for defining an event.
    /// </summary>
    public interface IEvent
    {
        void Execute(object state);
    }
}

Event.cs

using System;

using System.Xml.Serialization;

using Dottext.Framework.Providers;

namespace Dottext.Framework.ScheduledEvents

{

/// <summary>

/// Event is the configuration of an IEvent.

/// </summary>

[Serializable]

public class Event

{

public Event()

{

}

private IEvent _ievent =null;

/// <summary>

/// The current implementation of IEvent

/// </summary>

[XmlIgnoreAttribute]

public IEvent IEventInstance

{

get

{

LoadIEvent();

return _ievent;

}

/// <summary>

/// Private method for loading an instance of IEvent

/// </summary>

private void LoadIEvent()

{

if(_ievent == null)

{

if(this.ScheduleType == null)

{

throw new BlogProviderException("A Scheduled Event (IEvent) does not have its type property defined");

}

_ievent = (IEvent)Activator.CreateInstance(Type.GetType(this.ScheduleType));

if(_ievent == null)

{

throw new BlogProviderException(string.Format("The Scheduled Event {0} could not be loaded",this.ScheduleType));

}

private string _key;

/// <summary>

/// A unique key used to query the database. The name of the Server will also be used to ensure the "Key" is

/// unique in a cluster

/// </summary>

[XmlAttribute("key")]

public string Key

{

get {return this._key;}

set {this._key = value;}

}

private int _timeOfDay =-1;

/// <summary>

/// Absolute time in mintues from midnight. Can be used to assure event is only

/// executed once per-day and as close to the specified

/// time as possible. Example times: 0 = midnight, 27 = 12:27 am, 720 = Noon

/// </summary>

[XmlAttribute("timeOfDay")]

public int TimeOfDay

{

get {return this._timeOfDay;}

set {this._timeOfDay = value;}

}

private int _minutes = 60;

/// <summary>

/// The scheduled event interval time in minutes. If TimeOfDay has a value >= 0, Minutes will be ignored.

/// This values should not be less than the Timer interval.

/// </summary>

[XmlAttribute("minutes")]

public int Minutes

{

get

{

if(this._minutes < EventManager.TimerMinutesInterval)

{

return EventManager.TimerMinutesInterval;

}

return this._minutes;

}

set {this._minutes = value; }

}

private string _scheduleType;

/// <summary>

/// The Type of class which implements IEvent

/// </summary>

[XmlAttribute("type")]

public string ScheduleType

{

get {return this._scheduleType;}

set {this._scheduleType = value;}

}

private DateTime _lastCompleted;

/// <summary>

/// Last Date and Time this event was processed/completed.

/// </summary>

[XmlIgnoreAttribute]

public DateTime LastCompleted

{

get {return this._lastCompleted;}

set

{

dateWasSet = true;

this._lastCompleted = value;

}

//internal testing variable

bool dateWasSet = false;

[XmlIgnoreAttribute]

public bool ShouldExecute

{

get

{

if(!dateWasSet) //if the date was not set (and it can not be configured), check the data store

{

LastCompleted = DTOProvider.Instance().GetLastExecuteScheduledEventDateTime(this.Key,Environment.MachineName);

}

//If we have a TimeOfDay value, use it and ignore the Minutes interval

if(this.TimeOfDay > -1)

{

//Now

DateTime dtNow = DateTime.Now; //now

//We are looking for the current day @ 12:00 am

DateTime dtCompare = new DateTime(dtNow.Year,dtNow.Month,dtNow.Day);

//Check to see if the LastCompleted date is less than the 12:00 am + TimeOfDay minutes

return LastCompleted < dtCompare.AddMinutes(this.TimeOfDay);

}

else

{

//Is the LastCompleted date + the Minutes interval less than now?

return LastCompleted.AddMinutes(this.Minutes) < DateTime.Now;

}

/// <summary>

/// Call this method BEFORE processing the ScheduledEvent. This will help protect against long running events

/// being fired multiple times. Note, it is not absolute protection. App restarts will cause events to look like

/// they were completed, even if they were not. Again, ScheduledEvents are helpful

but not 100% reliable

/// </summary>

public void UpdateTime()

{

this.LastCompleted = DateTime.Now;

DTOProvider.Instance().SetLastExecuteScheduledEventDateTime(this.Key,Environment.MachineName,this.LastCompleted);

}

public class EventHttpModule : System.Web.IHttpModule
    {
        static Timer eventTimer;//这里很重要

        public EventHttpModule()
        {
            //
            // TODO: Add constructor logic here
            //
        }
        #region IHttpModule Members

        //Init方法是实现了IHttpModule中的方法,它在应用程序接受到请求时就会执行
        public void Init(System.Web.HttpApplication application)
        {
            if (eventTimer == null)
            {
                /* 这里是关键用了一个Timer来实现定时执行任务初始访问 1分钟后会调用ScheduledEventWorkCallback
                 * 方法.之后每EventManager.TimerMinutesInterval分钟执行一次.具体看配置
                 * 这里有几点需要注意 eventTimer 变量不能定义在本方法内部,一定要是一个类中的静态变量
                 * 否则,当线程执行完本方法后,.NET GC垃圾回收机制,会随时将它回收,达不到应用效果.
                 * 将eventTimer定义为静态的并且在这里有一个引用.这样可以保证它一直是活动的
                 * 当然有情况会断掉,一是IIS服务器关闭了,二是IIS进程回收也会停止
                 */
                eventTimer = new Timer(new TimerCallback(ScheduledEventWorkCallback), application.Context, 60000, EventManager.TimerMinutesInterval * 60000);
            }
        }

        private void ScheduledEventWorkCallback(object sender)
        {
            try
            {
                EventManager.Execute();
            }
            catch(Exception ex)
            {
                LogManager.CreateExceptionLog(ex,"Failed ScheduledEventCallBack");
            }

        }

        public void Dispose()
        {
            eventTimer = null;
        }

        #endregion
    }

/// <summary>
    /// EventManager is called from the EventHttpModule (or another means of scheduling a Timer). Its sole purpose
    /// is to iterate over an array of Events and deterimine of the Event's IEvent should be processed. All events are
    /// added to the managed threadpool.
    /// 它是任务的管理器,负责取出并调用线程池中线程来执行这些任务
    /// </summary>
    public class EventManager
    {
        private EventManager()
        {
        }

        public static readonly int TimerMinutesInterval = 5;

        public static void Execute()
        {
            //第一步取出所有需要执行的任务
            Event[] items = Config.Settings.ScheduledItems;//这里系统是从配置文件中读取到所有的Events子节点Event
            Event item = null;

            //第二步将这些任务一个个放入线程池队列中等待执行
            if(items != null)
            {
                for(int i = 0; i<items.Length; i++)
                {
                    item = items[i];
                    if(item.ShouldExecute)
                    {
                        item.UpdateTime();
                        IEvent e = item.IEventInstance;//接口编程,将实例转成IEvent接口
                        //将任务放入线程池队列中等待执行接口IEvent的Execute方法
                        ManagedThreadPool.QueueUserWorkItem(new WaitCallback(e.Execute));
                    }
                }
            }
        }
    }