Chemmy's Blog

Java&Quartz实现任务调度

发表于 2015-10-31 更新于 2024-03-27 分类于 Java Valine：

1.Quartz的作用

定时自动执行任务

2.预备

3.Quartz核心

3.1.Job接口

被调度的任务,只有一个方法execute(JobExecutionContext xontext),Job运行时的信息保存在JobDataMap中

3.2.JobDetail类

实现Job接口,用来描述Job的相关信息,包含Name,Group,JobDataMap等

3.3 JobExecutionContext类

定时程序执行的run-time的上下文环境,用于得到Job的名字、配置的参数等

3.3 JobDataMap类

用来描述一个作业的参数,参数可以为金和基本类型或者某个对象的引用

3.3 JobListener接口

监听作业状态

3.3 TriggaerListener接口

监听触发器状态

3.3 JobStore

3.3.Tigger抽象类

触发器,描述执行Job的触发规则,有SimpleTrigger和CronTrigger两个子类

3.3.1.SimpleTrigger类

继承自Trigger类,每隔xx毫秒/秒执行一次,主要实现固定一次或者固定时间周期类任务的触发

3.3.2.CronTrigger类

继承自Trigger类,使用Cron表达式,实现各种复杂时间规则调度方案,如每天的某个时间,或每周的某几天触发执行之类

3.4.Calendar包

一些日历特定时间点的集合,包内包含以下几个类

3.4.1 BaseCalendar类

3.4.2 AnnualCalendar类

排除每一年中指定的一天或者多天

3.4.3 CalendarComparator类

3.4.4 CronCalendar类

使用表达式排除某时间段不执行

3.4.5 DailyCalendar类

指定的时间范围内每天不执行

3.4.6 HolidayCalendar类

排除节假日

3.4.7 MonthlyCalendar类

配出月份中的数天

3.4.8 WeeklyCalendar类

排除没周中的一天或者多天

3.5.Scheduler类

任务调度器,代表一个Quartz独立容器。

Scheduler可以将JobDetail和Trigger绑定,当Trigger触发时,对应的Job就会被执行,Job和Trigger是1:n(一对多)的关系

3.6Misfire类

错误的任务,本该执行单没有执行的任务调度

4.实现

1.单任务实现

1.定义一个任务,新建任务类继承自Job类

package com;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

public class DemoJob implements Job {

@Override
public void execute(JobExecutionContext arg0) throws JobExecutionException {
System.out.println(new SimpleDateFormat("HH:mm:ss").format(new Date()));
}

}

2.新建类执行这个任务(SimpleTrigger)

package com;

import java.util.Date;

import org.quartz.DateBuilder;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

public class QuartzDemo {

public void simpleRun() throws SchedulerException {

SchedulerFactory factory = new StdSchedulerFactory();

 

    Date runTime = DateBuilder.evenSecondDateAfterNow();  


JobDetail jobDetail = JobBuilder.newJob(DemoJob.class)
.withIdentity("demo_job", "demo_group")
.build();

Trigger trigger = TriggerBuilder.newTrigger()
.withIdentity("demo_trigger", "demo_group")

.startAt(new Date())
.withSchedule(
SimpleScheduleBuilder
.simpleSchedule()
.withIntervalInSeconds(1)
.withRepeatCount(5)
).build();


Scheduler scheduler = factory.getScheduler();

scheduler.scheduleJob(jobDetail,trigger);
System.out.println(jobDetail.getKey() + " 运行在: " + runTime);   
scheduler.start();  
}

public static void main(String[] args) {
QuartzDemo demo = new QuartzDemo();
try {
demo.simpleRun();
} catch (SchedulerException e) {
e.printStackTrace();
}
}
}

2.多任务实现

测试任务类
新建两个DemoJonOne和DemoJobTwo,都实现Job接口,内容如下

@Override
public void execute(JobExecutionContext arg0) throws JobExecutionException {
System.out.println(new SimpleDateFormat("HH:mm:ss").format(new Date())+" Runed "+getClass().getName());
}

2.新建QuartzUtil类,内容如下

package com;

import org.quartz.Job;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

public class QuartzUtil {
private final static String JOB_GROUP_NAME = "QUARTZ_JOBGROUP_NAME";
private final static String TRIGGER_GROUP_NAME = "QUARTZ_TRIGGERGROUP_NAME";


public static void addJob(String jobName, String triggerName, Class<? extends Job> jobClass, int seconds)
throws SchedulerException {


SchedulerFactory sf = new StdSchedulerFactory();

Scheduler sche = sf.getScheduler();

JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, JOB_GROUP_NAME).build();

Trigger trigger = TriggerBuilder.newTrigger()
.withIdentity(triggerName, TRIGGER_GROUP_NAME)
.startNow()
.withSchedule(
SimpleScheduleBuilder
.simpleSchedule()
.withIntervalInSeconds(seconds)
.repeatForever()
).build();


sche.scheduleJob(jobDetail, trigger);

sche.start();
}

public static void main(String[] args) {
try {

QuartzUtil.addJob("job1", "trigger1", DemoJobOne.class, 2);


QuartzUtil.addJob("Job2", "trigger2", DemoJobTwo.class, 5);
} catch (SchedulerException e) {
e.printStackTrace();
}
}
}

以上方法属于手动调用,如果是web项目中就不同了
添加POM

<dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>servlet-api</artifactId>
  <version>2.5</version>
</dependency>

package servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;

import org.quartz.SchedulerException;

import com.DemoJobOne;
import com.DemoJobTwo;
import com.QuartzUtil;

public class InitServlet extends HttpServlet {

private static final long serialVersionUID = 8507188690597926975L;


public void init() throws ServletException {
try {

QuartzUtil.addJob("job1", "trigger1", DemoJobOne.class, 2);

QuartzUtil.addJob("Job2", "trigger2", DemoJobTwo.class, 5);
} catch (SchedulerException e) {
e.printStackTrace();
}
}

}

2.注册servlet

<servlet>
  <servlet-name>InitServlet</servlet-name>
  <servlet-class>servlet.InitServlet</servlet-class>
  
  <load-on-startup>0</load-on-startup>
</servlet>

<servlet-mapping>
  <servlet-name>InitServlet</servlet-name>
  <url-pattern>/InitServlet</url-pattern>
</servlet-mapping>

3.复杂规则任务调度(CronTrigger)

在每分钟的1-30秒执行示例

package com;

import org.quartz.CronScheduleBuilder;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

public class CronTriggerDemo {
public static void main(String[] args) throws SchedulerException {

SchedulerFactory factory = new StdSchedulerFactory();
Scheduler scheduler = factory.getScheduler();

JobDetail job = JobBuilder
.newJob(DemoJobOne.class)
.withIdentity("job","group")
.build();

Trigger trigger = TriggerBuilder
.newTrigger()
.withIdentity("trigger", "group")
.startNow().withSchedule(
CronScheduleBuilder
.cronSchedule("1-30 * * * * ?")
).build();

scheduler.scheduleJob(job,trigger);
scheduler.start();

}
}

5.Cron表达式

规则

格式

1	s M h d m w [y]

s:seconds,取值0-59,允许- * /;

M:minutes,取值0-59,允许- * /;

h:hour,取值0-23,允许- * /;

d:day of month,取值1-31,允许- * ? / L W;

m:month,取值1-12/JAN-DEC,允许- * /;

w:day of week,取值1-7/SUN-SAT,允许- * ? / L #;

y:year,可选,取值empty、1970-2099,允许- * /;

符号解释

、指定枚举值,如在秒字段使用10、12,则表示只有第10秒和第12秒执行
- 指定区间范围,配合使用,如在小时字段使用10-12,表示在10、11、12时都会触发

* 代表所有值,单独使用,如在秒字段使用,表示每秒触发

? 代表不确定值,单独使用,不用关心的值

/ 用于递增触发,配合使用,n/m,从n开始,每次增加m,如在秒字段设置5/15,表示从第5秒开始,每15秒触发一次

L 表示最后,单独使用,如在秒字段使用,代表第59秒触发,如果在前面加上数字,则表示该数据的最后一个,如在周字段使用6L,则表示本月最后一个周五
W 表示最近的工作日,不会跨月,比如30W，30号是周六，则不会顺延至下周一来执行,如在月字段使用15W,则表示到本月15日最近的工作日(周一到周五)
# 用来指定x的第n个工作日,如在周字段使用6#3则表示该月的第三个星期五

月取值

一月:JAN/0
二月:FEB/1
三月:MAR/2
四月:APR/3
五月:MAY/4
六月:JUN/5
七月:JUL/6
八月:AUG/7
九月:SEP/8
十月:OCT/9
十一月:NOV/10
十二月:DEC/11

周取值

周日:SUN/1
周一:MON/2
周二:TUE/3
周三:WED/4
周四:THU/5
周五:FRI/6
周六:SAT/7

示例

0/20 * * * * ? 每20秒执行一次
1-30 * * * * ? 在1-30秒执行
15 0/2 * * * ? 偶数分钟的第15秒执行
0 0/2 8-17 * * ? 从8时到17时 ,每个偶数分钟执行一次
0 0/3 17-23 * * ? 从17时到23时,每3分钟运行一次
0 0 10am 1,15 * ? 每个月的1号和15号的上午10点 运行
0,30 * * ? * MON-FRI 周一至周五,每30秒运行一次
0,30 * * ? * SAT,SUN 周六、周日,每30秒运行一次
0 0 12 * * ? 每天12点触发
0 15 10 ? * * 每天10点15分触发
0 15 10 * * ? 每天10点15分触发
0 15 10 * * ? * 每天10点15分触发
0 15 10 * * ? 2005 2005年每天10点15分触发
0 * 14 * * ? 每天下午的 2点到2点59分每分触发
0 0/5 14 * * ? 每天下午的 2点到2点59分(整点开始，每隔5分触发)
0 0/5 14,18 * * ? 每天下午的 2点到2点59分(整点开始，每隔5分触发) 每天下午的 18点到18点59分(整点开始，每隔5分触发)
0 0-5 14 * * ?  每天下午的 2点到2点05分每分触发
0 10,44 14 ? 3 WED 3月分每周三下午的 2点10分和2点44分触发
0 15 10 ? * MON-FRI 从周一到周五每天上午的10点15分触发
0 15 10 15 * ? 每月15号上午10点15分触发
0 15 10 L * ? 每月最后一天的10点15分触发
0 15 10 ? * 6L 每月最后一周的星期五的10点15分触发
0 15 10 ? * 6L 2002-2005 从2002年到2005年每月最后一周的星期五的10点15分触发
0 15 10 ? * 6#3 每月的第三周的星期五开始触发
0 0 12 1/5 * ? 每月的第一个中午开始每隔5天触发一次
0 11 11 11 11 ? 每年的11月11号 11点11分触发(光棍节)

6.Spring整合Quartz

需要Spring-context-support包支持,POM如下

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context-support</artifactId>
    <version>4.3.5.RELEASE</version>
</dependency>

新建两种Job测试类–>DemoSimpleJob类和DemoCronJob类,并继承自QuartzJobBean,代码如下

package com;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;

public class DemoJob extends QuartzJobBean {

    @Override
    protected void executeInternal(JobExecutionContext arg0) throws JobExecutionException {
        System.out.println(new SimpleDateFormat("hh:mm:ss").format(new Date()) + " 输出自:" + getClass().getName());
    }

}

配置spring bean如下

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-4.3.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">

    
    
    
    <bean id="demoCronJob"
        class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
        <property name="jobClass" value="com.DemoCronJob" />
    </bean>
    <bean id="demoSimpleJob"
        class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
        <property name="jobClass" value="com.DemoSimpleJob" />
    </bean>
    
    
    <bean id="simpleTrigger"
        class="org.springframework.scheduling.quartz.SimpleTriggerFactoryBean">
        <property name="jobDetail" ref="demoSimpleJob" />
        <property name="startDelay" value="1000" />  
        <property name="repeatInterval" value="2000" />  
    </bean>
    <bean id="cornTrigger"
        class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
        <property name="jobDetail" ref="demoCronJob" />
        <property name="cronExpression" value="1-30 * * * * ?" />
    </bean>
    
    <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="triggers">
            <list>
                <ref bean="cornTrigger" />
                <ref bean="simpleTrigger" />
            </list>
        </property>
    </bean>

启动

package com;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Demo {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

    }
}

有待补充

C#使用EmguCV实现视频读取和播放，及多个视频一起播放的问题

发表于 2015-10-24 更新于 2024-03-27 分类于 C#/.NET Valine：

WinForm程序

1）第一种方法，使用委托：


private delegate void SetTextCallback(string text);
private void SetText(string text)
{
    // InvokeRequired需要比较调用线程ID和创建线程ID
    // 如果它们不相同则返回true
    if (this.txt_Name.InvokeRequired)
    {
        SetTextCallback d = new SetTextCallback(SetText);
        this.Invoke(d, new object[] { text });
    }
    else {
        this.txt_Name.Text = text;
    }
}

2）第二种方法，使用匿名委托

private void SetText(Object obj)
{
    if (this.InvokeRequired)
    {
        this.Invoke(new MethodInvoker(delegate {
            this.txt_Name.Text = obj;
        }));
    }
    else {
        this.txt_Name.Text = obj;
    }
}

这里说一下BeginInvoke和Invoke和区别：BeginInvoke会立即返回，Invoke会等执行完后再返回。

WPF程序

1）可以使用Dispatcher线程模型来修改

如果是窗体本身可使用类似如下的代码：

this.lblState.Dispatcher.Invoke(new Action(delegate
{
this.lblState.Content = “状态：” + this._statusText;
}));

那么假如是在一个公共类中弹出一个窗口、播放声音等呢？这里我们可以使用：System.Windows.Application.Current.Dispatcher，如下所示

System.Windows.Application.Current.Dispatcher.Invoke(new Action(() =>
{
if (path.EndsWith(“.mp3”) || path.EndsWith(“.wma”) || path.EndsWith(“.wav”))
{
_player.Open(new Uri(path));
_player.Play();
}
}));

关键问题：多个视频同时播放，以上几种方法不足以解决，多个视频播放中主界面卡死和播放显示刷新不了的问题。

目前笔者的解决方法是

pinturebox.CreateGraphics().DrawImage(imgSrc.Bitmap, new System.Drawing.Rectangle(0, 0, pinturebox.Width, pinturebox.Height));

EmguCV中的Capture类可以完成视频文件的读取，并捕捉每一帧，可以利用Capture类完成实现WinForm中视频检测跟踪环境的搭建。本文只实现最简陋的WinForm + EmguCV上的avi文件读取和播放框架，复杂的检测和跟踪算法在之后添加进去。

这里使用WinForm实现视频的播放，主要是PictureBox类，它是支持基于事件的异步模式的典型组件，不使用EmguCV自带的UI控件等。

图1.效果图

直接在UI线程中完成视频的播放的话整个程序只有一个线程，由于程序只能同步执行，播放视频的时候UI将停止响应用户的输入，造成界面的假死。所以视频的播放需要实现异步模式。主要有三种方法：第一是使用异步委托；第二种是使用BackgroundWorker组件；最后一种就是使用多线程（不使用CheckForIllegalCrossThreadCalls =false的危险做法）。

Windows窗体控件，唯一可以从创建它的线程之外的线程中调用的是Invoke()、BegionInvoke()、EndInvoke()方法和InvokeRequired属性。其中BegionInvoke()、EndInvoke()方法是Invoke()方法的异步版本。这些方法会切换到创建控件的线程上，以调用赋予一个委托参数的方法，该委托参数可以传递给这些方法。

（一）使用多线程
首先定义监控的类及其对应的事件参数类和异常类：
判断是否继续执行的布尔型成员会被调用线程改变，因此声名为volatile，不进行优化。

/// <summary>
/// 红外检测子。
/// </summary>
public class ThermalSurveillant
{
    #region Private Fields
 
    /// <summary>
    /// 是否停止线程，此变量供多个线程访问。
    /// </summary>
    private volatile bool shouldStop = false;
 
    #endregion
    #region Public Properties
 
    #endregion
    #region Public Events
 
    /// <summary>
    /// 帧刷新事件。
    /// </summary>
    public EventHandler<FrameRefreshEventArgs> FrameRefresh;
 
    /// <summary>
    /// 播放完成。
    /// </summary>
    public EventHandler<CompletedEventArgs> Completed;
 
    #endregion
    #region Protected Methods
 
    /// <summary>
    /// 处理帧刷新事件。
    /// </summary>
    /// <param name="e"></param>
    protected virtual void OnFrameRefresh(FrameRefreshEventArgs e)
    {
        if (this.FrameRefresh != null)
        {
            this.FrameRefresh(this, e);
        }
    }
 
    /// <summary>
    /// 处理视频读完事件。
    /// </summary>
    /// <param name="e"></param>
    protected virtual void OnCompleted(CompletedEventArgs e)
    {
        if (this.Completed != null)
        {
            this.Completed(this, e);
        }
    }
 
    #endregion
    #region Public Methods
 
    /// <summary>
    /// 视频监控。
    /// </summary>
    /// <param name="capture">捕捉。</param>
    public void DoSurveillance(Object oCapture)
    {
        Capture capture = oCapture as Capture;
        int id = 1;
        if (capture == null)
        {
            throw new InvalidCaptureObjectException("传递的Capture类型无效。");
        }
        while (!shouldStop)
        {
            Image<Bgr, byte> frame = capture.QueryFrame();
            if (frame != null)
            {
                FrameRefreshEventArgs e = new FrameRefreshEventArgs(frame.ToBitmap(), id++);
                // 触发刷新事件
                this.OnFrameRefresh(e);
            }
            else
            {
                break;
            }
        }
        // 触发完成事件
        this.OnCompleted(new CompletedEventArgs(id));
    }
 
    /// <summary>
    /// 请求停止线程。
    /// </summary>
    public void Cancel()
    {
        this.shouldStop = true;
    }
 
    #endregion
}

UI线程中启动播放线程：

声明：

/// <summary>
/// 监控线程。 
/// </summary>
private Thread threadSurveillance = null; 
/// <summary>
/// 捕获视频帧。 
/// </summary>
private Capture captureSurveillance; 
/// <summary>
/// 监控子。 
/// </summary>
private ThermalSurveillant surveillant = new ThermalSurveillant();

读入视频文件：

captureSurveillance = new Capture(this.videoFilePath);
captureSurveillance.SetCaptureProperty(CAP_PROP.CV_CAP_PROP_FRAME_WIDTH, this.width);
captureSurveillance.SetCaptureProperty(CAP_PROP.CV_CAP_PROP_FRAME_HEIGHT, this.height);
Image<Bgr, byte> frame = captureSurveillance.QueryFrame();
this.pictureBox.Image = frame.ToBitmap();

播放视频文件：

UI线程中响应监控类的事件：

定义异步调用的委托：

添加事件委托：

1 2	this.surveillant.FrameRefresh += OnRefreshFrame; this.surveillant.Completed += OnCompleted;

以下方法中都是由监控线程中的事件委托方法，应该使用BeginInvoke方法，这样可以优雅的结束线程，如果使用Invoke方法，则调用方式为同步调用，此时如果使用Thread.Join()方法终止线程将引发死锁（正常播放没有问题），Thread.Join()方法的使用使调用线程阻塞等待当前线程完成，在这里即UI线程阻塞等待监控线程完成，而监控线程中又触发UI线程中pictureBox的刷新，使用Invoke方法就造成了监控线程等待UI线程刷新结果，而UI线程已经阻塞，形成了死锁。死锁时只能用Thread.Abort()方法才能结束线程。或者直接强制结束应用程序。

使用BeginInvoke方法时为异步调用，监控线程不等待刷新结果直接继续执行，可以正常结束。结束后UI才进行刷新，不会造成死锁。

图2.线程关系

/// <summary>
/// 刷新UI线程的pixtureBox的方法。
/// </summary>
/// <param name="frame">要刷新的帧。</param>
private void RefreshFrame(Bitmap frame)
{
    this.pictureBox.Image = frame;
    // 这里一定不能刷新！2012年8月2日1:50:16
    //this.pictureBox.Refresh();
}


/// <summary>
/// 响应pictureBox刷新。
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnRefreshFrame(object sender, FrameRefreshEventArgs e)
{
    // 判断是否需要跨线程调用
    if (this.pictureBox.InvokeRequired == true)
    {
        FrameRefreshDelegate fresh = this.RefreshFrame;
        this.BeginInvoke(fresh, e.Frame);
    }
    else
    {
        this.RefreshFrame(e.Frame);
    }
}


/// <summary>
/// 响应Label刷新信息。
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnCompleted(object sender, CompletedEventArgs e)
{
    // 判断是否需要跨线程调用
    CompletedDelegate fresh = this.RefreshStatus;
    string message = "视频结束，共 " + e.FrameCount + " 帧。";
    this.BeginInvoke(fresh, message);
}
　　

        关闭时需要中止播放线程之后再退出：

/// <summary>
/// 关闭窗体时发生。
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnFormClosed(object sender, FormClosedEventArgs e)
{
    // 检测子算法请求终止
    surveillant.Cancel();

    // 阻塞调用线程直到检测子线程终止
    if (threadSurveillance != null)
    {
        if (threadSurveillance.IsAlive == true)
        {
            threadSurveillance.Join();
        }
    }
}

（二）使用异步委托

创建线程的一个更简单的方法是定义一个委托，并异步调用它。委托是方法的类型安全的引用。Delegate类还支持异步地调用方法。在后台，Delegate类会创建一个执行任务的线程。

// asynchronous by using a delegate
PlayVideoDelegate play = this.PlayVideoFile;
IAsyncResult status = play.BeginInvoke(null, null);
 
/// <summary>
/// 播放视频文件。
/// </summary>
private void PlayVideoFile()
{
    while (true)
    {
        Image<Bgr, byte> frame = capture.QueryFrame();
        if (frame != null)
        {
            Image<Gray, byte> grayFrame = frame.Convert<Gray, byte>();
            grayFrame.Resize(this.width, this.height, INTER.CV_INTER_CUBIC);
            RefreshPictureBoxDelegate fresh = this.RefreshPictureBox;
            try
            {
                this.BeginInvoke(fresh, grayFrame.ToBitmap());
            }
            catch (ObjectDisposedException ex)
            {
                Thread.CurrentThread.Abort();
            }
        }
        else
        {
            break;
        }
    }
}
 
/// <summary>
/// 刷新UI线程的pixtureBox的方法。
/// </summary>
/// <param name="frame">要刷新的帧。</param>
private void RefreshPictureBox(Bitmap frame)
{
    this.pictureBox.Image = frame;
}

（三）使用BackgroundWorker组件

BackgroundWorker类是异步事件的一种实现方案，异步组件可以选择性的支持取消操作，并提供进度信息。RunWorkerAsync()方法启动异步调用。CancelAsync()方法取消。

图3.BackgroundWorker组件

/// <summary>
/// 播放视频文件。
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void detectItemPlay_Click(object sender, EventArgs e)
{
    if (this.videoFilePath != null)
    {
        // run async
        this.backgroundWorker.RunWorkerAsync(capture);
    }
}
 
/// <summary>
/// 异步调用。
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnDoWork(object sender, DoWorkEventArgs e)
{
    Emgu.CV.Capture capture = e.Argument as Emgu.CV.Capture;
    while (!e.Cancel)
    {
        Image<Bgr, byte> frame = capture.QueryFrame();
        if (frame != null)
        {
            Image<Gray, byte> grayFrame = frame.Convert<Gray, byte>();
            grayFrame.Resize(this.width, this.height, INTER.CV_INTER_CUBIC);
            if (this.backgroundWorker.CancellationPending == true)
            {
                e.Cancel = true;
                break;
            }
            else
            {
                if (this.pictureBox.InvokeRequired == true)
                {
                    RefreshPictureBoxDelegate fresh = this.RefreshPictureBox;
                    this.BeginInvoke(fresh, grayFrame.ToBitmap());
                }
                else
                {
                    this.RefreshPictureBox(grayFrame.ToBitmap());
                }
            }
        }
        else
        {
            break;
        }
    }
}
 
/// <summary>
/// 关闭窗体时发生。
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void MainForm_FormClosed(object sender, FormClosedEventArgs e)
{
    if (this.backgroundWorker.IsBusy)
    {
        this.backgroundWorker.CancelAsync();
    }
}

在 WPF 中使用 Path 路径

发表于 2015-10-17 更新于 2024-03-27 分类于 C#/.NET ， WPF Valine：

在 WPF 中总会修改 Button 的 Style，比如一个自定义的 Close 按钮。刚入门的可能会用一张 PNG 格式的图片来做这个按钮的 Icon，但这个是不优雅的。而且你要改的时候还得去操作文件，想想都痛苦。

但是很多人苦于不知道去哪里获取 Path，当然网上已经有不少使用 Photoshop 获取图片的 Path ，但如果图片的质量不好，获取的 Path 歪歪曲曲的也不好看，更何况在这之前你还得会使用 Photoshop。

现在分享一个我经常使用的解决方案，阿里巴巴矢量图，这上面可以说有海量的图标可以用到。

流程：

　　1，进入阿里巴巴矢量图并搜索你想要的图标

　　2，下载 Icon 时使用 SVG 下载

　　3，用记事本或文本编辑器打开，标签 Path 下的 d 属性就是 Path 的 Data 数据（很多复杂一点的 Icon 可能是多个 Data 组成，使用时只要用空格把几个 Data 隔开就行）

　　例子：

　　在WPF中使用时：

Data 也可以作为资源放在独立的资源字典里，使用的 Geometry 标签

XAML：

Net作业调度(五)—quartz.net动态添加job设计

发表于 2015-10-10 更新于 2024-03-27 分类于 C#/.NET Valine：

介绍

在实际项目使用中quartz.net中，都希望有一个管理界面可以动态添加job，而避免每次都要上线发布。

也看到有园子的同学问过。这里就介绍下实现动态添加job的几种方式，也是二次开发的核心模块。

阅读目录：

传统方式

继承IJob，实现业务逻辑，添加到scheduler。

public class MonitorJob : IJob
{ public void Execute(IJobExecutionContext context)
{ //do something
Console.WriteLine(“test”);
}
} //var job = JobBuilder.Create() // .WithIdentity(“test”, “value”) // .Build(); //var trigger = (ICronTrigger) TriggerBuilder.Create() // .WithIdentity(“test”, “value”) // .WithCronSchedule(“0 0/5 * * * ?”) // .Build(); //scheduler.ScheduleJob(job, trigger);

也可以使用CrystalQuartz远程管理暂停取消。之前的博客CrystalQuartz远程管理(二)。

框架反射方式

这种方式需要定义一套接口框架。比如：

interface IcustomJob
{ void Excute(string context); void Failed(string error); void Complete(string msg);
}

1：当我们写job时同一实现这个框架接口，类库形式。

2：写完后编译成DLL，上传到我们的作业执行节点。

3：在执行节点中，通过反射拿到DLL的job信息。

4：然后构建quartz的job，添加到scheduler。

这种方式缺点：耦合性太高，开发量较大。优点：集中式管理。

系统结构如图：

进程方式

这个方式和windows任务计划类似。

1：使用方编写自己的job，无需实现任何接口，可执行应用程序形式。

2：将程序发送到执行节点，由执行节点起进程调用job程序。

执行节点调用，示例如下：

public class ConsoleJob:IJob
{ public void Execute(IJobExecutionContext context)
{
JobDataMap dataMap = context.JobDetail.JobDataMap; string content = dataMap.GetString(“jobData”); var jd = new JavaScriptSerializer().Deserialize(content);

        Process p \= new Process();
        p.StartInfo.UseShellExecute \= true;
        p.StartInfo.FileName \= jd.Path;
        p.StartInfo.Arguments \= jd.Parameters;   //空格分割
        p.StartInfo.WindowStyle = ProcessWindowStyle.Minimized;
        p.Start();
    }
}

这种方式相对来说：耦合性中等，执行节点和job相互不关心，没有依赖，开发量较小。

系统结构如图：

URL方式

URL方式和第三种类似，不过调用的不在是执行程序，而是URL。

1：使用方在网页或服务中，实现业务逻辑。

2：然后将Url，交给执行节点post或get执行。

执行节点调用，示例如下：

public class HttpJob : IJob
{ public void Execute(IJobExecutionContext context)
{ var dataMap = context.JobDetail.JobDataMap; var content = dataMap.GetString(“jobData”); var jd = new JavaScriptSerializer().Deserialize(content); if (jd.Parameters == null)
jd.Parameters = string.Empty; if (jd.Timeout == 0)
jd.Timeout = 5*60; var result = RequestHelper.Post(jd.Url, jd.ContentType, jd.Timeout, jd.Parameters, jd.heads);
}
}

这种方式耦合比较低，使用方不需要单独写应用程序了，和平常业务开发一样。

执行节点的职权，仅仅作为一个触发器。

有2点需要注意的是：

1：请求URL时，注意双方约定token加密，防止非执行节点执行调用。

2：使用方，如果有耗时操作，建议异步执行。

系统结构如图：

框架配置方式

1：使用方直接使用quartz.net框架，实现自己的job。从管理方拉取执行节点配置，然后自行管理执行节点。

2：使用方也可以暴露端口给管理方，以实现监控，修改配置。

这种形式，耦合性最低。是把管理方当成一个配置中心。 ps：几乎和传统方式+CrystalQuartz一样了。

通过context.JobDetail.JobDataMap，可以保存job的需要的信息。

本篇介绍主流的几种实现方案，供大家参考使用。

Net作业调度(四)—quartz.net持久化和集群

发表于 2015-10-03 更新于 2024-03-27 分类于 C#/.NET Valine：

介绍

在实际使用quartz.net中，持久化能保证实例重启后job不丢失、集群能均衡服务器压力和解决单点问题。

quartz.net在这两方面配置都比较简单。

持久化

quartz.net的持久化，是把job、trigger一些信息存储到数据库里面，以解决内存存储重启丢失。

下载sql脚本

https://github.com/quartznet/quartznet/blob/master/database/tables/tables\_sqlServer.sql

创建个数据库，并执行脚本

QRTZ_BLOB_TRIGGERS 以Blob 类型存储的触发器。

QRTZ_CALENDARS 存放日历信息， quartz.net可以指定一个日历时间范围。

QRTZ_CRON_TRIGGERS cron表达式触发器。

QRTZ_JOB_DETAILS job详细信息。

QRTZ_LOCKS 集群实现同步机制的行锁表

QRTZ_SCHEDULER_STATE 实例信息，集群下多使用。

quartz.net 配置

//===持久化==== //存储类型
properties[“quartz.jobStore.type”] = “Quartz.Impl.AdoJobStore.JobStoreTX, Quartz”; //表明前缀
properties[“quartz.jobStore.tablePrefix”] = “QRTZ_“; //驱动类型
properties[“quartz.jobStore.driverDelegateType”] = “Quartz.Impl.AdoJobStore.SqlServerDelegate, Quartz”; //数据源名称
properties[“quartz.jobStore.dataSource”] = “myDS”; //连接字符串
properties[“quartz.dataSource.myDS.connectionString”] = @”Data Source=(local);Initial Catalog=JobScheduler;User ID=sa;Password=123465”; //sqlserver版本
properties[“quartz.dataSource.myDS.provider”] = “SqlServer-20”;

启动客户端

var properties = JobsManager.GetProperties(); var schedulerFactory = new StdSchedulerFactory(properties);
scheduler = schedulerFactory.GetScheduler();
scheduler.Start(); //var job = JobBuilder.Create() // .WithIdentity(“test”, “value”) // .Build(); //var trigger = (ICronTrigger) TriggerBuilder.Create() // .WithIdentity(“test”, “value”) // .WithCronSchedule(“0 0/5 * * * ?”) // .Build(); //scheduler.ScheduleJob(job, trigger);

补充

1：持久化后，job只有添加一次了(数据库已经有了)，所以不能再执行端写添加job的行为。这时候需要一个管理工具，动态添加操作。

2： quartz.net 支持sql server、sqlite、mysql、oracle、mongodb(非官方版)。

部署图：

如图quartz.net 的集群模式是依赖数据库表的，所以要持久化配置。集群节点之间是不通信的，这样分布式的架构，很方便进行水平扩展。

1: 除了线程池数量，instanceId可以不同外，各个节点的配置必须是一样的。

2：集群中节点的系统时间一致。

3：多线程、集群中。quartz.net 利用数据库锁来保证job不会重复执行。

源码在DBSemaphore.cs、UpdateLockRowSemaphore.cs、StdRowLockSemaphore.cs

4：集群化后，某节点失效后，剩余的节点能保证job继续执行下去。

实例配置后启动。

//cluster
properties[“quartz.jobStore.clustered”] = “true”;
properties[“quartz.scheduler.instanceId”] = “AUTO”;

简单管理界面：

Net作业调度(三) — Quartz.Net进阶

发表于 2015-09-26 更新于 2024-03-27 分类于 C#/.NET Valine：

介绍

前面介绍Quartz.Net的基本用法，但在实际应用中，往往有更多的特性需求，比如记录job执行的执行历史，发邮件等。

阅读目录

Quartz.Net插件
TriggerListener,JobListener
Cron表达式
Quartz.Net线程池
总结

Quartz.Net插件

Quartz.net 自身提供了一个插件接口(ISchedulerPlugin)用来增加附加功能，看下官方定义：

public interface ISchedulerPlugin

{

void Initialize(``string pluginName, IScheduler sched);

void Shutdown();

void Start();

}

　继承接口，实现自己的插件。

public class MyPlugin : ISchedulerPlugin

{

public void Initialize(``string pluginName, IScheduler sched)

{

Console.WriteLine(``"实例化"``);

}

public void Start()

{

Console.WriteLine(``"启动"``);

}

public void Shutdown()

{

Console.WriteLine(``"关闭"``);

}

　　主函数里面配置要实现的插件，注释部分，一句话搞定。

static void Main(``string``[] args)

{

var properties = new NameValueCollection();

properties[``"quartz.plugin.MyPlugin.type"``] = "QuartzDemo3.MyPlugin,QuartzDemo3"``;

var schedulerFactory = new StdSchedulerFactory(properties);

var scheduler = schedulerFactory.GetScheduler();

var job = JobBuilder.Create<HelloJob>()

.WithIdentity(``"myJob"``, "group1"``)

.Build();

var trigger = TriggerBuilder.Create()

.WithIdentity(``"mytrigger"``, "group1"``)

.WithCronSchedule(``"/2 * * ? * *"``)

.Build();

scheduler.ScheduleJob(job, trigger);

scheduler.Start();

Thread.Sleep(6000);

scheduler.Shutdown(``true``);

Console.ReadLine();

}

运行结果如下：

— Quartz.Net进阶/172151135196757.png)

TriggerListener，JobListener

这2个是对触发器和job本身的行为监听器，这样更好方便跟踪Job的状态及运行情况。

ITriggerListener是官方定义的接口，这里我们直接继承实现。

public class MyTriggerListener : ITriggerListener
{ private string name; public void TriggerComplete(ITrigger trigger, IJobExecutionContext context, SchedulerInstruction triggerInstructionCode)
{
Console.WriteLine(“job完成时调用”);
} public void TriggerFired(ITrigger trigger, IJobExecutionContext context)
{
Console.WriteLine(“job执行时调用”);
} public void TriggerMisfired(ITrigger trigger)
{
Console.WriteLine(“错过触发时调用(例：线程不够用的情况下)”);
} public bool VetoJobExecution(ITrigger trigger, IJobExecutionContext context)
{ //Trigger触发后，job执行时调用本方法。true即否决，job后面不执行。
return false;
} public string Name { get { return name; } set { name = value; } }
}

主函数添加：

scheduler.ListenerManager.AddTriggerListener(myJobListener, KeyMatcher<TriggerKey>.KeyEquals(``new TriggerKey(``"mytrigger"``, "group1"``)));

////添加监听器到指定分类的所有监听器。

////添加监听器到指定的2个分组。

////添加监听器到所有的触发器上。

scheduler.Start();

JobListener同理，这里不多做描述。

Cron表达式

quartz中的cron表达式和Linux下的很类似，比如 “/5 * * ? * * *“ 这样的7位表达式，最后一位年非必选。

表达式从左到右，依此是秒、分、时、月第几天、月、周几、年。下面表格是要遵守的规范：

字段名

允许的值

允许的特殊字符

Seconds

0-59

, - * /

Minutes

0-59

, - * /

Hours

0-23

, - * /

Day of month

1-31

, - * ? / L W

Month

1-12 or JAN-DEC

, - * /

Day of week

1-7 or SUN-SAT

, - * ? / L #

Year

空, 1970-2099

, - * /

特殊字符

解释

或的意思。例：分钟位 5,10 即第5分钟或10分都触发。

a/b。 a：代表起始时间，b频率时间。例；分钟位 3/5，从第三分钟开始，每5分钟执行一次。

频率。即每一次波动。例；分钟位 * 即表示每分钟

区间。例：分钟位 5-10 即5到10分期间。

任意值。即每一次波动。只能用在DayofMonth和DayofWeek，二者冲突。指定一个另一个一个要用?

表示最后。只能用在DayofMonth和DayofWeek，4L即最后一个星期三

工作日。表示最后。只能用在DayofWeek

4#2。只能用DayofMonth。某月的第二个星期三

实例介绍

”0 0 10,14,16 * * ?” 每天10点，14点，16点触发。

“0 0/5 14,18 * * ?” 每天14点或18点中，每5分钟触发。

“0 4/15 14-18 * * ?” 每天14点到18点期间, 从第四分钟触发，每15分钟一次。

“0 15 10 ? * 6L” 每月的最后一个星期五上午10:15触发。

Quartz.Net线程池

线程池数量设置：

properties[“quartz.threadPool.threadCount”] = “5”;

这个线程池的设置，是指同时间，调度器能执行Job的最大数量。

quartz是用每个线程跑一个job。上面的设置可以解释是job并发时能执行5个job，剩下的job如果触发时间恰好到了，当前job会进入暂停状态，直到有可用的线程。

如果在指定的时间范围依旧没有可用线程，会触发misfired时间。

quartz 提供了IThreadPool接口，也可以用自定义线程池来实现。

配置如下：

properties[“quartz.threadPool.type”] = “Quartz.Simpl.SimpleThreadPool, Quartz”;

一般来说作业调度很少并发触发大量job，如果有上百个JOB，可在服务器承受范围内适量增加线程数量。

总结

官方有LoggingTriggerHistoryPlugin，LoggingJobHistoryPlugin 已实现的，触发器和job历史记录的插件。

Quartz.Plugin 命名空间下有官方实现的其他一些插件，也可以自己增加扩展。

quartz中监听器还有SchedulerListener，使用方法基本一样。

本文基于自用经验和官方文档代码来写的，部分是直接翻译的。

Quartz.Net官方教程http://www.quartz-scheduler.net/documentation/quartz-2.x/tutorial/index.html

Net作业调度(二) -CrystalQuartz远程管理

发表于 2015-09-19 更新于 2024-03-27 分类于 C#/.NET Valine：

介绍

上篇已经了解Quartz.NET的基本使用方法了。但如果想方便的知道某个作业执行情况，需要暂停，启动等操作行为，这时候就需要个Job管理的界面。

本文介绍Quartz.NET如何进行远程job管理，如图:

-CrystalQuartz远程管理/011755051751192.png)

实战

一：作业服务端

static void Main(``string``[] args)

{

var properties = new NameValueCollection();

properties[``"quartz.scheduler.instanceName"``] = "RemoteServerSchedulerClient"``;

properties[``"quartz.threadPool.type"``] = "Quartz.Simpl.SimpleThreadPool, Quartz"``;

properties[``"quartz.threadPool.threadCount"``] = "5"``;

properties[``"quartz.threadPool.threadPriority"``] = "Normal"``;

properties[``"quartz.scheduler.exporter.type"``] = "Quartz.Simpl.RemotingSchedulerExporter, Quartz"``;

properties[``"quartz.scheduler.exporter.port"``] = "556"``;

properties[``"quartz.scheduler.exporter.bindName"``] = "QuartzScheduler"``;

properties[``"quartz.scheduler.exporter.channelType"``] = "tcp"``;

var schedulerFactory = new StdSchedulerFactory(properties);

var scheduler = schedulerFactory.GetScheduler();

var job = JobBuilder.Create<PrintMessageJob>()

.WithIdentity(``"myJob"``, "group1"``)

.Build();

var trigger = TriggerBuilder.Create()

.WithIdentity(``"myJobTrigger"``, "group1"``)

.StartNow()

.WithCronSchedule(``"/10 * * ? * *"``)

.Build();

scheduler.ScheduleJob(job, trigger);

scheduler.Start();

}

public class PrintMessageJob : IJob

{

public void Execute(IJobExecutionContext context)

{

Console.WriteLine(``"Hello!"``);

}

启动如下

-CrystalQuartz远程管理/011801015192327.png)

二：作业远程管理端，无需写任何代码，引用官方程序集，嵌入到已有的web网站。

PM> Install-Package CrystalQuartz.Remote

Webconfig 需要配置的地方

<configuration>

<crystalQuartz>

<provider>

<add property=``"Type" value=``"CrystalQuartz.Core.SchedulerProviders.RemoteSchedulerProvider, CrystalQuartz.Core" />

<add property=``"SchedulerHost" value=``"tcp://127.0.0.1:556/QuartzScheduler" /> 

</provider>

</crystalQuartz>

<system.webServer>

<handlers>

<add name=``"CrystalQuartzPanel" verb=``"*" path=``"CrystalQuartzPanel.axd" type=``"CrystalQuartz.Web.PagesHandler, CrystalQuartz.Web" />

</handlers>

</system.webServer>

</configuration>

　Web管理界面

-CrystalQuartz远程管理/011811269404890.png)

其他

CrystalQuartz 提供基础功能，可以继续在此基础上进行二次开发，另外推荐使用Window服务寄宿，比较方法。

参考资源

张善友　　　　　　　　 http://www.cnblogs.com/shanyou/archive/2012/01/15/2323011.html

CrystalQuartz开源的地址　　https://github.com/guryanovev/CrystalQuartz

Net作业调度(一) -Quartz.Net入门

发表于 2015-09-12 更新于 2024-03-27 分类于 C#/.NET Valine：

背景

很多时候，项目需要在不同时刻，执行一个或很多个不同的作业。

Windows执行计划这时并不能很好的满足需求了，迫切需要一个更为强大，方便管理，集群部署的作业调度框架。

介绍

Quartz 一个开源的作业调度框架，OpenSymphony的开源项目。Quartz.Net 是Quartz的C#移植版本。

它一些很好的特性：

1：支持集群，作业分组，作业远程管理。

2：自定义精细的时间触发器，使用简单，作业和触发分离。

3：数据库支持，可以寄宿Windows服务，WebSite，winform等。

实战

Quartz框架的一些基础概念解释：

　　Scheduler 作业调度器。

　　IJob 作业接口，继承并实现Execute，编写执行的具体作业逻辑。

　　JobBuilder 根据设置，生成一个详细作业信息(JobDetail)。

　　TriggerBuilder 根据规则，生产对应的Trigger

Nuget安装

PM> Install-Package Quartz

下面是简单使用例子，附带详细的注释：


static void Main(string[] args)
{
 IScheduler scheduler = StdSchedulerFactory.GetDefaultScheduler();
 scheduler.Start(); 

 IJobDetail job1 = JobBuilder.Create<HelloJob>()
 .WithIdentity("作业名称", "作业组")
 .Build();

 ITrigger trigger1 = TriggerBuilder.Create()
 .WithIdentity("触发器名称", "触发器组")
 .StartNow() 
 .WithSimpleSchedule(x => x 
 .WithIntervalInSeconds(5)
 .RepeatForever()) 
 .Build();

 scheduler.ScheduleJob(job1, trigger1); 

 IJobDetail job2= JobBuilder.Create<DumbJob>()
 .WithIdentity("myJob", "group1")
 .UsingJobData("jobSays", "Hello World!")
 .Build();

 ITrigger trigger2 = TriggerBuilder.Create()
 .WithIdentity("mytrigger", "group1")
 .StartNow()
 .WithCronSchedule("/5 * * ? * *") 
 .Build();
 scheduler.ScheduleJob(job2, trigger2); 
}

声明要执行的作业，HelloJob：


/// <summary>
/// 作业
/// </summary>
public class HelloJob : IJob
{
 public void Execute(IJobExecutionContext context)
 {
 Console.WriteLine("作业执行!");
 }
}

声明要执行的作业，DumbJob：

public class DumbJob : IJob

{

/// <summary>

/// context 可以获取当前Job的各种状态。

/// </summary>

/// <param name="context"></param>

public void Execute(IJobExecutionContext context)

{

JobDataMap dataMap = context.JobDetail.JobDataMap;

string content = dataMap.GetString(``"jobSays"``);

Console.WriteLine(``"作业执行，jobSays:" + content);

}

其WithCronSchedule(“”) 拥有强大的Cron时间表达式，正常情况下_WithSimpleSchedule(x)_ 已经满足大部分对日期设置的要求了。

Quartz.Net官方2.X教程 http://www.quartz-scheduler.net/documentation/quartz-2.x/tutorial/index.html

Quartz.Net开源地址 https://github.com/quartznet/quartznet

SharpDevelop源码分析 (三、插件系统)

发表于 2015-09-05 更新于 2024-03-27 分类于 C#/.NET Valine：

**
三、插件系统**

上回书说到SharpDevelop入口Main函数的结构，ServiceManager.Service在InitializeServicesSubsystem方法中首次调用了AddInTreeSingleton的AddInTree实例，AddInTree在这里进行了初始化。本回进入AddInTree着重讲述SharpDevelop的插件系统。在叙述的时候为了方便起见，对于“插件”和插件具体的“功能模块”这两个词不会特别的区分，各位看官可以从上下文分辨具体的含义（而事实上，SharpDevelop中的“插件”是指.addin配置文件，每一个“插件”都可能会包含多个“功能模块”）。

1、插件的配置
   既然说到插件系统，那么我们先来看一看SharpDevelop插件系统的组织形式。
   很多时候，同一个事物从不同的角度来看会得出不一样的结论，SharpDevelop的插件系统也是如此。在看SharpDevelop的代码以前，按照我对插件的理解，我认为所谓的“插件”就是代表一个功能模块，插件的配置就是描述该插件并指定如何把这个插件挂到系统中。SharpDevelop中有插件树的思想，也就是每一个插件在系统中都有一个扩展点的路径。那么按照我最初对插件的理解，编写插件需要做的就是：
   A、根据插件接口编写功能模块实现一个Command类
   B、编写一个配置文件，指定Command类的扩展点(Extension)路径，挂到插件树中

之后按照这样的理解，我编写了一个察看插件树的插件AddinTreeView，打算挂到SharpDevelop中去。根据SharpDevelop对插件的定义，我把具体插件的AddinTreeViewCommand实现了之后，编写了一个配置文件AddinTreeView.addin如下：

在配置文件中，Runtime节指定了插件功能模块所在的库文件Addins.dll的具体路径，在Extension节中指定了扩展点路径/SharpDevelop/Workbench/MainMenu/Tools（我是打算把它挂到主菜单的工具菜单下），然后在Extension内指定了它的Codon为 MenuItem以及具体的ID、标签、Command类名。这样做，SharpDevelop运行的很不错，我的插件出现在了Tools菜单下。之后，我又编写了一个SharpDevelop的资源管理器（ResourceEditor）的插件类ResourceEditor.dll并把它挂到Tool菜单下。同样的，我也写了一个ResourceEditor.addin文件来对应。系统工作的很正常。

如果我们对于每一个插件都编写这样的一个配置文件，那么插件的库文件(.dll)、插件配置文件(.addin)是一一对应的。不过这样就带来了一个小小的问题，在这样的一个以插件为基础的系统中，每一个菜单、工具栏按钮、窗体、面板都是一个插件，那么我们需要为每一个插件编写配置文件，这样就会有很多个配置文件（似乎有点太多了，不是很好管理）。SharpDevelop也想到了这个问题，于是它允许我们把多个插件的配置合并在一个插件的配置文件中。因此，我把我的两个插件库文件合并到一个Addins工程内生成了Addins.dll，又重新编写了我的插件配置文件MyAddins.addin如下：

这样，我把两个插件的功能模块使用一个插件配置文件来进行配置。同样的，我也可以把几十个功能模块合并到一个插件配置文件中。SharpDevelop把这个插件配置文件称为“Addin(插件)”，而把具体的功能模块封装为Codon，使用Command类来包装具体的功能。SharpDevelop本身的核心配置SharpDevelopCore.addin里面就包含了所有的基本菜单、工具栏、PAD的插件配置。
我们回过头来看一下，现在我们有了两颗树。首先，插件树本身是一个树形的结构，这个树是根据系统所有插件的各个Codon的扩展点路径构造的，表示了各个Codon在插件树中的位置，各位看官可以通过我写的这个小小的AddinTreeView来看看SharpDevelop中实际的结构。其次，插件的配置文件本身也具有了一个树形的结构，这个树结构的根节点是系统的各个插件配置文件，其下是根据这个配置文件中的Extension节点的来构成的，描述了每个Extension节点下具有的Codon。我们可以通过SharpDevelop的Tools菜单下的AddinScout来看看这个树的结构。
我为了试验，把SharpDevelop的插件精简了很多，构成了一个简单的小插件系统。下面是这个精简系统的两个树的截图。各位看官可以通过这两副图理解一下插件树和插件配置文件的关系（只是看同样问题的两个角度，一个是Codon的ExtensionPath，一个是配置文件的内容）。

总结一下SharpDevelop插件的配置文件格式。首先是节点，需要指定AddIn的名称、作者之类的属性。其次，在AddIn节点下的节点内，使用<Import …>来指定本插件配置中Codon所在的库文件。如果分布在多个库文件中，可以一一指明。然后，编写具体功能模块的配置。每个功能模块的配置都以扩展点开始，指定了路径(Path)属性之后，在这个节点内配置在这个扩展点下具体的Codon。每个Codon根据具体不同的实现有不同的属性。各位看官可以研究一下SharpDevelop的核心配置文件SharpDevelopCore.addin的写法，相信很容易理解的。

2、插件系统的核心AddIn和AddInTree
前文讲到，在SharpDevelop的Main函数中，ServiceManager.Service在InitializeServicesSubsystem方法中首次调用了AddInTreeSingleton的AddInTree实例，AddinTree在这个时候进行了初始化。现在我们就来看看AddInTreeSingleton.AddInTree到底做了些什么事情，它定义在/src/Main/Core/AddIns/AddInTreeSingleton.cs文件中。

AddInTreeSingleton是插件树的一个Singleton（具体的可以去看《设计模式》了），AddInTreeSingleton.AddInTree是一个属性，返回一个IAddinTree接口。这里我注意到一点，AddInTreeSingleton是从DefaultAddInTree继承下来的。既然它是一个单件模式，包含的方法全部都是静态方法，没有实例化的必要，而且外部是通过AddInTree属性来访问插件树，为什么要从DefaultAddInTree继承呢？这好像没有什么必要。这也许是重构过程中被遗漏的一个小问题吧。

   我们先来看看IAddinTree接口的内容，它定义了这样的几个内容：
      A、属性ConditionFactory ConditionFactory　返回一个构造条件的工厂类，这里的条件是指插件配置中的条件，我们以后再详细说明。
      B、属性CodonFactory CodonFactory　返回一个构造Codon的工厂类。
      C、属性AddInCollection AddIns 返回插件树的根节点Addin（插件）集合。
      D、方法IAddInTreeNode GetTreeNode(string path) 根据扩展点路径（path）返回对应的树节点
      E、方法void InsertAddIn(AddIn addIn) 根据AddIn中的扩展点路径添加一个插件到树中
      F、方法void RemoveAddIn(AddIn addIn) 删除一个插件
      G、方法Assembly LoadAssembly(string assemblyFile) 读入插件中Runtime节的Import指定的Assembly，并构造相应的CodonFactory和CodonFactory类。

AddInTreeSingleton在首次调用AddInTree的时候会调用CreateAddInTree方法来进行初始化。CreateAddInTree方法是这样实现的：

addInTree = new DefaultAddInTree();

初始化插件树为DefaultAddInTree的实例，这里我感受到了一点重构的痕迹。首先，DefaultAddInTree从名称上看是默认的插件树（既然是默认，那么换句话说还可以有其他的插件树）。但是SharpDevelop并没有给外部提供使用自定义插件树的接口（除非我们修改这里的代码），也就是说这个名称并不像它本身所暗示的那样。其次，按照Singleton通常的写法以及前面提到AddInTreeSingleton是从DefaultAddInTree继承下来的疑问，我猜想DefaultAddinTree的内容本来是在AddinTreeSingleton里面实现的，后来也许为了代码的条理性，把实现IAddinTree内容的代码剥离了出去，形成了DefaultAddinTree类。至于继承DefaultAddInTree的问题，也许这里本来是一个AddInTree的基类。这是题外话，也未加证实，各位看官可以不必放在心上（有兴趣的可以去找找以前SharpDevelop的老版本的代码来看看）。
这里有两个察看代码的线路，一个是DefaultAddInTree的构造函数的代码，在这个构造函数中构造了Codon和Condtion的工厂类。另外一个是CreateAddInTree后面的代码，搜索插件文件，并根据插件文件进行AddIn的构造。各位看官可以选择走分支线路，也可以选择先看主线（不过这样你会漏掉不少内容）。

2.1 支线（DefaultAddInTree的构造函数）
我们把CreateAddInTree的代码中断一下压栈先，跳到DefaultAddInTree的构造函数中去看一看。DefaultAddInTree定义在/src/Main/Core/AddIns/DefaultAddInTree.cs文件中。在DefaultAddInTree的构造函数中，注意到它具有一个修饰符internal，也就是说这个类只允许Core这个程序集中的类对DefaultAddInTree进行实例化（真狠啊）。构造函数中的代码只有一句：

LoadCodonsAndConditions(Assembly.GetExecutingAssembly());

   虽然只有一行代码，不过这里所包含的内容却很精巧，是全局的关键，要讲清楚我可有得写了。首先，通过全局的Assembly对象取得入口程序的Assembly，传入LoadCodonsAndConditions方法中。在该方法中，枚举传入的Assembly中的所有数据类型。如果不是抽象的，并且是AbstractCodon的子类，并且具有对应的CodonNameAttribute属性信息，那么就根据这个类的名称建立一个对应的CodonBuilder并它加入CodonFactory中（之后对Condition也进行了同样的操作，我们专注来看Codon部分，Condition跟Codon基本上是一样的）。
   这里的CodonFactory类和CodonBuilder类构成了SharpDevelop插件系统灵活的基础，各位看官可要看仔细了。
   我们以实例来演示，以前文我编写的AddinTreeViewCommand为例。在入口的Assembly中会搜索到MenuItemCodon，它是AbstractCodon的一个子类、包装MenuItem(菜单项)Command（命令）的Codon。符合条件，执行

codonFactory.AddCodonBuilder( new CodonBuilder(type.FullName, assembly));

首先根据类名MenuItemCodon和assembly 构造CodonBuilder。CodonBuilder定义在/src/Main/Core/AddIns/Codons/CodonBuilder.cs文件中。在CodonBuilder的构造函数中根据MenuItemCodon的CodonNameAttribute属性信息取得该Codon的名称MenuItem。CodonNameAttribute描述了Codon的名称，这个MenuItem也就是在.addin配置文件中对应的标签，后文会看到它的重要用途。在CodonBuilder中除了包含了该Codon的ClassName（类名）和CodonName属性之外，就只有一个方法BuildCodon了。

   很明显，BuildCodon根据构造函数中传入的assembly和类型的ClassName，建立了具体的Codon的实例，并和具体的AddIn关联起来。
   之后，codonFactory调用AddCodonBuilder方法把这个CodonBuilder加入它的Builder集合中。我们向上一层，看看codonFactory如何使用这个CodonBuilder。
   在文件/src/Main/Core/AddIns/Codons/CodonFactory.cs中，codonFactory只有两个方法。AddCodonBuilder方法把CodonBuilder加入一个以CodonName为索引的Hashtable中。另外一个方法很重要：

在这里，addin是这个配置文件的描述（也就是插件），而这个XmlNode类型的CodonNode是什么东西？
还记得配置文件中在标签下的、、之类的标签吗？我曾经说过，这些就是Codon的描述，现在我们来看看到底是不是如此。以前文的AddinTreeView配置为例：

SharpDevelop在读入插件配置文件的标签之后，就把它的ChildNodes（XmlElement的属性）依次传入CodonFactory的CreateCodon方法中。这里它的ChildNodes[0]就是这里的节点，也就是codonNode参数了。这个XML节点的Name是MenuItem，因此CreateCodon的第一行

CodonBuilder builder = codonHashtable[codonNode.Name] as CodonBuilder;

根据节点的名称(MenuItem)查找对应的CodonBuilder。记得前面的CodonBuilder根据CodonNameAttribute取得了MenuItemCodon的CodonName吗？就是这个MenuItem了。CodonFactory找到了对应的MenuItemCodon的CodonBuilder（这个是在DefaultAddInTree的构造函数中调用LoadCodonsAndConditions方法建立并加入CodonFactory中的，还记得么？），之后使用这个CodonBuilder建立了对应的Codon，并把它返回给调用者。
就这样，通过CodonNameAttribute，SharpDevelop把addin配置文件的节点、CodonBulder、MenuItemCodon三部分串起来形成了一个构造Codon的路线。

   我们回过头来整理一下思路，SharpDevelop进行了下面这样几步工作：
      A、建立各个Codon，使用CodonNameAttribute指明它在配置节点中的名称
      B、DefaultAddInTree的构造函数中调用LoadCodonsAndConditions方法，搜索所有的Codon，根据Codon的CodonNameAttribute建立对应的CodonBuilder加入CodonFactory中。
      C、读取配置文件，在标签下遍历所有的节点，根据节点的Name使用CodonFactory建立对应的Codon。
   其中，Codon的CodonNameAttribute、CodonBuilder的CodonName以及标签下XML节点的Name是一致的。对于Condition（条件）的处理也是一样。
   抱歉，我上网不是很方便也不太会在Blog里面贴图（都是为了省事的借口^o^），否则也许更好理解这里的脉络关系。

好了，看到这里，我们看看SharpDevelop中插件的灵活性是如何体现的。首先，addin配置中的Extension节点下的Codon节点名称并没有在代码中和具体的Codon类联系起来，而是通过CodonNameAttribute跟Codon联系起来。这样做的好处是，SharpDevelop的Codon和XML的标签一样具有无限的扩展能力。假设我们要自己定义一个Codon类SplashFormCodon作用是指定某个窗体作为系统启动时的封面窗体。要做的工作很简单：首先，在SplashFormCodon中使用CodonNameAttribute指定CodonName为Splash，并且在SplashFormCodon中定义自己需要的属性。然后，在addin配置文件使用标签这样写：

是不是很简单？另外，对于Condition（条件）的处理也是一样，也就是说我们也可以使用类似的方法灵活的加入自己定义的条件。

这里我有个小小的疑问：不知道我对于设计模式的理解是不是有点小问题，我感觉CodonBuilder类的实现似乎并不如它的类名所暗示的是《设计模式》中的Builder模式，反而似乎应该是Proxy模式，因此我觉得改叫做CodonProxy是不是比较容易理解？各位看官觉得呢？
另外，虽然稍微麻烦了一小点，不过我觉得配置如果这样写会让我们比较容易和代码中具体的类关联起来:

2.2 主线 (AddInTreeSingleton. CreateAddInTree)
啊～我写的有点累了。不过还是让我们继续AddInTreeSingleton中CreateAddInTree的代码。
在建立了DefaultAddInTree的实例后，AddInTreeSingleton在插件目录中搜索后缀为.addin的文件。还记得在SharpDevelop的Main函数中曾经调用过AddInTreeSingleton. SetAddInDirectories吗，就是搜索这个传入的目录。看来SharpDevelop把在插件目录中所有后缀为.addin的文件都看做是插件了。

FileUtilityService fileUtilityService = (FileUtilityService)ServiceManager.Services.GetService( typeof (FileUtilityService));

先学习一下如何从ServiceManager取得所需要的服务，在SharpDevelop中要取得一个服务全部都是通过这种方式取得的。调用GetService传入要获取的服务类的类型作为参数，返回一个IService接口，之后转换成需要的服务。

搜索插件目录找到一个addin文件后，调用InsertAddIns把这个addin文件中的配置加入到目录树中。

InsertAddIns建立一个对应的AddIn（插件），调用AddInTree的InsertAddIn方法把它挂到插件树中。在这里有一个小小的处理，由于是通过Assembly查找和插件配置中Codon的标签对应的类，而Codon类所在的Assembly是通过Import标签导入的。因此在查找配置中某个Codon标签对应的Codon类的时候，也许Codon类所在的文件是在其他的addin文件中Import的。这个时候在前面支线中讲到CodonFactory中查找CodonBuilder会失败，因此必须等到Codon类所在的addin处理之后才能正确的找到CodonBuilder。这是一个依赖关系的处理问题。
SharpDevelop在这里处理的比较简单，调用InsertAddIns方法的时候，凡是出现CodonNotFoundException的时候，都加入一个retryList列表中返回。在CreateAddinTree处理完所有的addin文件之后，再重新循环尝试处理retryList列表中的addin。如果某次循环中再也无法成功的加入retryList中的addin，那么才提示失败错误。

我们回头来看看对AddIn的处理。

**2.2.1 addIn.Initialize （AddIn的初始化）
** 建立了AddIn的实例后，调用Initialize 方法进行初始化。AddIn是对一个.addin文件的封装，定义在/src/Main/Core/AddIns/AddIn.cs文件中。其中包含了.addin文件的根元素的描述，包括名称、作者、版权之类的属性。在节点下包括两种节点：一个是节点，包含了指定要导入的Assembly；另外一个是节点，指定Codon的扩展点。在AddIn.Initialize方法中，使用XmlDocument对象来读取对应的addin文件。首先读取name、author 、copyright之类的基本属性，之后遍历所有的ChildNodes（子节点）。

如果子节点是Runtime节点，则调用AddRuntimeLibraries方法。

通过AddInTreeSingleton.AddInTree.LoadAssembly方法把Assembly中所有的Codon和Condition的子类加入对应Factory类中（调用了LoadCodonsAndConditions方法，我们在DefaultAddInTree的构造函数中见过了），并且把该文件和对应的Assembly保存到RuntimeLibraries列表中。

如果子节点是Extension节点，则调用AddExtensions方法。

根据这个扩展点的XML描述建立Extension对象加入到AddIn的Extensions列表中，并通过AddCodonsToExtension方法把其中包括的Codon加入到建立的Extension对象中。Extension对象是AddIn的一个内嵌类，其中一个重要的属性就是CodonCollection这个列表。AddCodonsToExtension就是把在配置中出现的Codon都加入到这个列表中保存。

来看看AddCodonsToExtension方法。在代码中我略过了对Condition（条件）的处理的分析和一些无关紧要的部分，我们把注意力集中在插件的处理。首先是一个 foreach (object o in el.ChildNodes) 遍历下所有的子节点，对于每个子节点的处理如下：

我们看到了一个期待已久的调用

AddInTreeSingleton.AddInTree.CodonFactory.CreateCodon( this , curEl);

   经过了上文支线2.1代码中的铺垫，SharpDevelop使用建立好的CodonFactory，调用CreateCodon方法根据下的节点构造出实际的Codon对象，一切尽在不言中了吧。
   e.CodonCollection.Add(codon);把构造出来的Codon对象加入到Extension对象的CodonCollection列表中。
   之后，在形如菜单的这种允许无限嵌套的结构中，SharpDevelop对此进行了处理。如果该节点有嵌套的子节点，那么构造一个新的Extension对象，递归调用AddCodonsToExtension添加到这个Extension对象中。注意一点，这个新构造的Extension对象并不是分开保存在Codon中，而是直接保存在AddIn的扩展点列表中。这样是为了方便查找，毕竟保存在具体的Codon中也没有什么用处，我们可以通过Extension对象的Path属性得知它在插件树中的具体位置。

2.2.2 addInTree.InsertAddIn（把AddIn添加到AddInTree中）
对AddIn的构造完成之后，需要把AddIn的实例对象添加AddInTree中管理。

在DefaultAddInTree中，保存了两课树。一个是根据插件文件的结构形成的树，每个插件文件作为根节点，往下依次是Extension、Codon节点。addIns.Add(addIn);就是把插件加入到这个树结构中。另外一个树是根据Extension的Path＋Codon的ID作为路径构造出来的，每一个树节点是一个AddInTreeNode类，包含了在这个路径上的Codon对象。嵌套在这个节点中的Codon在通过它子节点来访问。在DefaultAddInTree中可以通过GetTreeNode来指定一个路径获得插件树上某一个节点的内容。
AddExtensions方法很简单，遍历Extension中所有的Codon，把Extension的Path＋Codon的ID作为路径，创建这个路径上的所有节点，并把Codon连接到这个AddInTreeNode上。由于Codon的ID是全局唯一的，因此每一个AddInTreeNode都具有一个唯一的Codon。

3、最后一公里（Codon和Command的关联）
   在插件树的讨论中，我们依次把AddIn－Extension－Codon的配置和他们对应的类关联了起来。不过我们一直没有涉及到Codon和它包含的Command是如何关联的。由于这个关联调用是在插件树外部的（记得在讲述SharpDevelop程序入口Main函数中，提到ServiceManager的方法InitializeServicesSubsystem么？AddServices((IService[])AddInTreeSingleton.AddInTree.GetTreeNode(servicesPath).BuildChildItems(this).ToArray(typeof(IService))); 这里就调用了BuildChildItems），因此单独在这里说明。实现这个关联的就是AddInTreeNode的BuildChildItems和BuildChildItem方法以及Codon的BuildItem方法。
   BuildChildItem方法和BuildChildItems方法仅有一字之差，BuildChildItem是根据指定的Codon的ID在所属AddInTreeNode的子节点下查找包含该Codon的节点并调用该Codon的BuildItem方法；而BuildChildItems则是首先遍历所属AddInTreeNode的所有子节点，依次调用各个子节点的Codon的BuildItem方法，之后再调用所属AddInTreeNode的Codon的BuildItem方法（也就是一个树的后根遍历）。
   重点在Codon的BuildItem方法。在AbstractCodon中，这个方法是一个抽象方法，SharpDevelop的代码注释中并没有明确说清楚这个方法是做什么用的。但是我们可以找一个Codon的实例来看看。例如ClassCodon的BuildItem：

调用AddIn的CreateObject，传入Codon的Class（类名）作为参数，建立这个类的实例。例如这个配置

   而Codon的中的Class（类名）属性就是ICSharpCode.SharpDevelop.Commands.InitializeWorkbenchCommand。也就是说，Codon的Class指的是实现具体功能模块的Command类的名称。在读取addin配置中的节的时候，AddInTree把Assembly保存到了RuntimeLibraries中，因此CreateObject方法可以通过它们来查找并建立类的实例。
   各位看官可以再看看MenuItemCodon的实现，同样是建立了对应的SdMenuCommand。
   这样，SharpDevelop本身的插件结构可以和具体的对象建立分离开来，实际的对象建立是在各个Codon的BuildItem中进行的。因此我们可以发现在SharpDevelop整个是基础插件系统部分没有任何GUI的操作，实现了很好的解耦效果。

4、问题
好了，本文对插件树构造的分析到此告一段落。我提一个小小的问题给各位看官思考：在构造插件树的过程中，如果Codon的某一个节点路径不存在（也就是说它的依赖项不存在），那么SharpDevelop会提示失败并且终止程序运行。可是实际上可能因为部署的原因或者权限的原因，某些Codon的失败并不会影响整个系统的使用，例如试用版本仅仅提供部分插件给客户使用，而并不希望系统因此而终止运行。那么就存在一个Codon依赖项失败而允许继续运行的问题。另外，我希望各个插件不在系统启动的时候全部调入系统，而是在运行期实际调用的时候才调入系统，也就是一个缓存机制，这样就可以实现系统插件的热部署。如何修改SharpDevelop的插件系统来实现这两个功能呢？

下一回书，应某位网友的要求，分析一下SharpDevelop中的服务。

SharpDevelop源码分析 (二、主程序+隐藏的初始化)

发表于 2015-08-29 更新于 2024-03-27 分类于 C#/.NET Valine：

石榴刺猬 2004-10-07 20:10:00

二、主程序

    在大学课程里面，我对于模拟电路总是搞不清楚，直到现在也是这样。我总觉得电路图很奇怪，总会问“这部分电路是做什么用的”、“为什么会有这样的效果”。在我的脑海里面，每部分的电路都应该有一定的用处，可是我总是看不明白。我妈妈说，我的思路被软件所固化的太久了，看电路图不应该总是一个个模块的看，正确的方法应该是从电源的一极顺着电路看，一直看到电源的另一极。我现在仍然不懂看电路图，可是以我看代码的经验来说，我觉得分析源代码按照这样的思路来看会比较容易把脉络理清楚。
     在SharpDevelop的代码中，由于很多的接口和插件的原因，很多代码在看到某个地方会突然失去函数/方法调用的线索。例如看某个函数的实现的时候会跳到一个接口里面去，那是因为这部分功能在运行期才会给一个实现了这个接口的对象来进行具体的执行。从这个角度来说，设计模式也给我们研究代码稍微带来了一点小小的难度。在看Linux下源代码的时候也经常遇到这种问题，在这个时候寻找代码线索比较好的方法是用一个文本搜索工具来搜索相关的关键字。在Linux下我经常会用grep，Windows下面类似UltraEdit的“批量文件查找”功能会很好用（或者“Search And Replace”之类的工具）。这个是我读代码的一点小小的经验，如果你知道有更好的方法，请告诉我让我也学习一下 ? 。
     我不想大段大段的贴代码出来占地方（空间、带宽，还有各位看官的注意力），在需要的地方我会贴上主要的代码，因此最好能够找代码来对应着看。把代码包解压缩，我把它解到了“F:/SharpDevelop”（如果没有说明，下文都是以此为代码的根目录了）。由于SharpDevelop本身对于察看代码不是很方便，没有“转到定义”之类的功能，因此我建议你把它的代码转成VS的工程来看。不过很可惜，SharpDevelop的工程导出功能现在有问题，如果导出/src/SharpDevelop.cmbx 这个总的复合工程的话会失败（我记得RC1版本是可以成功的，不知道为什么后来的版本反而会出问题），所以只能一个一个工程的导出。
     好了，让我们来看SharpDevelop的代码吧。
1、起点
    在主程序的起点在/src/Main/StartUp/SharpDevelopMain.cs，找到Main函数这就是整个程序的起点了。开始的部分是显示封面窗体并加上命令行控制，其中SplashScreenForm 定义在/src/Main/Base/Gui/Dialogs/SplashScreen.cs文件中，这部分我就不多说了。之后是

Application.ThreadException += new ThreadExceptionEventHandler(ShowErrorBox);

SharpDevelop为了有效的进行错误报告，因此自己进行了异常的控制。系统出现异常的时候，SharpDevelop会拦截下来弹出它自己的异常提示报告对话框。这个代码就是在这一行实现的。其中 ShowErrorBox 这个方法就在类SharpDevelopMain中，ExceptionBox 定义在/src/Main/StartUp/Dialogs/ExceptionBox.cs中。如果需要进行自己的异常控制，可以学习一下这里的技巧。

2、充满玄机的初始化

string [] addInDirs = ICSharpCode.SharpDevelop.AddInSettingsHandler.GetAddInDirectories( out ignoreDefaultPath );
AddInTreeSingleton.SetAddInDirectories(addInDirs, ignoreDefaultPath);

通过AddInSettingsHandler取得插件的目录，并告知AddInTreeSingleton。AddInSettingsHandler定义在/src/Main/StartUp/Dialogs/AddInTreeSettingsHandler.cs中，它通过读取系统配置（App.config）文件中的AddInDirectory节点的Path属性来确定插件的目录位置，或者你也可以通过自己定义的AddInDirectories节来指定插件目录。如果你没有做这些配置，默认的目录在SharpDevelop运行目录的../Addins目录下。

通过ServiceManager(服务管理器)加入三个系统默认的服务，消息服务、资源服务、图标服务。这三个服务中，消息服务是显示各种信息提示，另外两个是属于系统的资源，SharpDevelop通过服务来进行统一调用和管理。
ServiceManager.Services.InitializeServicesSubsystem(“/Workspace/Services”);

初始化其他的服务。SharpDevelop把服务定义在插件树的/Workspace/Services这个路径中，凡是在这个路径下的插件都被认为是服务，因此如果你自己定义了一个服务的话，也需要挂到这个路径下（这里就是系统服务的扩展点了）。

注意！这一步中，在我们的眼皮子底下悄悄的进行了一个重要的初始化工作。各位看官请看，ServiceManager 定义在/src/Main/Core/Services/ ServiceManager.cs文件中，察看它的InitializeServicesSubsystem方法，我们发现这样一行

AddServices((IService[]) AddInTreeSingleton.AddInTree.GetTreeNode(servicesPath).BuildChildItems(this).ToArray(typeof(IService)));

在这里，AddInTreeSingleton首次调用了AddInTree（插件树）的实例。按照Singleton模式，只有在首次调用的时候才会初始化实例，这里也是同样如此。整个系统的AddInTree是在这一步中进行了初始化工作，稍候我们将详细介绍AddInTree如何进行初始化工作，先顺便看看服务的初始化。在ServiceManager的InitializeServicesSubsystem方法中，通过AddInTree检索服务插件路径下的所有配置，并通过它来读取、建立具体的对象，然后加入到服务列表中。之后通过一个循环，逐个的调用各个服务的InitializeService方法初始化服务。

AddInTree的初始化工作容我们稍候再看，先把主体的代码看完。

commands = AddInTreeSingleton.AddInTree.GetTreeNode(“/Workspace/Autostart”).BuildChildItems(null);
for (int i = 0; i < commands.Count - 1; ++i)
{
((ICommand)commands[i]).Run();
}

/Workspace/Autostart是系统自动运行命令的扩展点路径，定义在这个路径下的插件会在系统启动的时候自动运行。在这里，通过插件树初始化建立处于这个路径下的Command（命令），并逐一执行。BuildChildItems方法的功能是建立这个扩展点下的Command列表，我会在介绍AddTree的时候具体说明它的实现。

主程序代码的最后，初始化完毕、关闭封面窗体，然后执行命令列表中最后一个命令（也就是系统的主界面）。在主界面退出的时候，系统卸载所有的服务。

    在这部分代码中，我们知道了两个系统指定的扩展点路径 /Workspace/Services 和 /Workspace/Autostart ，我们实现服务和指定系统自动运行命令的时候就可以挂到这两个扩展点路径下了。
     托反射的福，ServiceManager.Services可以通过类型（接口）来查找具体的实例，也就是GetServices方法。但是ServiceManager的具体实现我们可以容后再看，这里已经不是最紧要的部分了。
     接下来，我们来看看整个插件系统的核心－AddinTree的代码，看看它是如何通过插件配置进行初始化并建立起整个系统的插件树骨干。