This article will help you build a recurring task scheduler that will execute at a specified interval of time. This article overcomes the complexity of scheduling applications that you may find on this site or on internet. This small and easy to understand code overcomes the limitation of installing a Web Service (with special permissions) or a Windows Service or instantiating any other process to run a scheduler. It is safe to run on a shared hosting provider if coded carefully and with the ability to shut down the task if needed.
First of all, let me give a full credit to Michael Taper at angrycoder.com who first wrote the code (the idea behind how this works) in C# back in April 2003. I'm giving credit to this guy since it appears that he wrote that article. I ran into his code in 2008 with ASP.NET 3.5 around, and I I could not make this code run for me in VB.NET. Also, the original coder description on that site was poor in explaining what the code actually does – so I decided to convert his C# code to VB.NET to run on the current .NET version (2.0 or greater as of March 2008) and to bring it down to a level for not so advanced coders.
Using the code
I've placed the whole code in a single file that is constructed like this:
- Classes that implement the interface above
- Scheduler configuration class
- Scheduler engine class
ISchedulerJob interface is only one line of code that will execute each class that implements it.
Public Interface ISchedulerJob
That is plan simple. The
Sub Execute() line tells each class that implements it that this call must be defined and implemented for this interface. This ensures the
Execute event will fire on each scheduled job. Now, let's get to the second step implementing this interface in our classes. My need for this scheduler was to check the website database and to send an e-mail to users that satisfy a certain criteria. The logic behind this is not included since it goes beyond the scope of this article. As any other scheduler application, this code works by having the jobs created. The job can be anything you wish (anything you can code to execute), but it has to be wrapped in a class that implements the interface above.
The first class,
MailJob, actually represents a single job that will be executed on the schedule:
Public Class MailJob
Public Sub Execute() Implements ISchedulerJob.Execute
"Subject:testing schedule from mail job ",_
"Body:Body of schedule")
You can see that this class implements the
Execute sub of our Job interface, and all it does is call my
The next class is just for demonstration purposes. It represents another job that will be executed at the same time as the
Public Class OtherJob
Public Sub Execute() Implements ISchedulerJob.Execute
"Subject:testing schedule from other job ", _
"Body:Body of other job schedule")
As you can see, it does exactly the same as the previous job but the subject and body are different, so it technically is a different job to execute.
You can add as many job classes as you like. The job classes do not have to be executed. To include the job in the the execution schedule, each job class has to instantiated. Later on, I will discuss in more detail how to achieve this.
The next step is to build the configuration class. The configuration has two properties: an integer that keeps the time (in milliseconds) that you wish to wait before the scheduled jobs execute, and an
ArrayList that keeps the jobs to be executed.
Public Class SchedulerConfiguration
Private m_sleepInterval As Integer
Private m_jobs As New ArrayList()
Public ReadOnly Property SleepInterval() As Integer
Public ReadOnly Property Jobs() As ArrayList
Public Sub New(ByVal newSleepInterval As Integer)
m_sleepInterval = newSleepInterval
The scheduler engine is the one that makes the jobs run. This is where you will wan to pay some attention (design your code carefully), since the jobs are recurring and the execution is placed in an indefinite loop.
Public Class Scheduler
Private configuration As SchedulerConfiguration = Nothing
Public Sub New(ByVal config As SchedulerConfiguration)
configuration = config
Public Sub Start()
For Each job As ISchedulerJob In configuration.Jobs
If you wish to execute the jobs only once at a specific time, then simply do not use the
while/wend loop and make sure you place a check if the current time (
date.Now) is greater than the scheduled time. In this case, you may also wish to set the schedule interval to seconds or minutes. That is all it takes to make the scheduler. To add jobs and execute them, you need to do the following:
- Create a new instance of the scheduler configuration (in my case, 1 hour)
- Create the jobs by creating a new instance of each job in the scheduler configuration
- Create new instance of the scheduler using the above config
- Create a new thread that will start with the sub named
Start in the scheduler class
- Start the newly created thread
Private schedulerThread As System.Threading.Thread = Nothing
Sub Application_Start(ByVal sender As Object, ByVal e As EventArgs)
Dim config As New MailScheduler.SchedulerConfiguration(60 * 60 * 1000)
Dim scheduler As New MailScheduler.Scheduler(config)
Dim mailThreadStart As _
New System.Threading.ThreadStart(AddressOf scheduler.Start)
schedulerThread = New System.Threading.Thread(mailThreadStart)
Sub Application_End(ByVal sender As Object, ByVal e As EventArgs)
If Not IsNothing(schedulerThread) Then
I've placed the above code in the global.asax on the application start with the
schedulerThread declared as a private variable within the scope of global.asax. The is because I will need to reference it on application end to kill the same thread. That would be a perfect place for any scheduled task to run and then just continue to the site. Now, as the site is working, our jobs will execute in a separate thread that sleeps between the job executions for a specified period of time.
If you wish the code to run as long as the ASP.NET worker process is alive, leave the scheduler thread (do not abort it). It is dangerous to leave any thread open, especially on a hosting provider, as it may cause undesired results. So be warned. The safer method is to create a public reference to the scheduler thread so you can reference it from within a page and abort it by simply loading the page (on the page load event). The approach on how to start and kill the thread is up to you. This article's intention was to give a simple code for implementing the scheduler functionality for recurring tasks. You may wish to search this site for more samples on creating safe threading models for your website.