Application_Start事件启动?

Question

iis6中部署一个网站，平时用户的访问量比较少Global.asax 中的Application_Start事件用有代码实现一些定时运行任务(每20分钟一次循环)由于网站平时用户的访问量比较少，要是iis重新启动或者服务器电脑重新启动后,如果没有用户访问这个网站，那么Application_Start事件就没有启动，这样定时任务也就没有运行!有什么办法让iis重新启动或者服务器电脑重新启动后，如果没有用户访问这个网站，Application_Start事件能触发启动?(除开人为的派一人在启动后去点击网站页面，以便启动Application_Start事件)

Answer 1

怎么自己触发一下网站，我就是不想人为的去点一下网站页面，去触发Application_Start

Answer 2

iis7.5里面提供了
startMode="AlwaysRunning"
方法，你的iis什么版本？

Answer 3

用B/S来实现定时任务，不是好主意。我当年作定时任务功能的时候，得多加个任务，定时N分钟重复循环访问自己网站。这样就避免iis探测到20分钟闲置而停掉网站。

Answer 4

iis6我觉得写一个简单的服务程序去处理，还是比较简单吧，这样不用人为处理，机器启动就能起作用

Answer 5

最近也做了个相关的 设定定时器 
机制就是 如果有人访问了后 启动Application 但是当IIS回收 或者IIS重启 或者 机子重启后就失效拉 关于IIS重启 以及机子重启没有好的办法 只能再次访问下 但是IIS的自动回收机制 我们还是有方法去处理的
比如：void Application_End(object sender, EventArgs e) 
    {
        //在应用程序关闭时运行的代码        //解决应用池回收问题
        System.Threading.Thread.Sleep(5000);
        string strUrl = "http://LOCALHOST/WEBEPGCLIENT/Default.aspx";        System.Net.HttpWebRequest _HttpWebRequest = (System.Net.HttpWebRequest)System.Net.WebRequest.Create(strUrl);
        System.Net.HttpWebResponse _HttpWebResponse = (System.Net.HttpWebResponse)_HttpWebRequest.GetResponse();
        System.IO.Stream _Stream = _HttpWebResponse.GetResponseStream();//得到回写的字节流
        _HttpWebResponse.Close();
    }这样的话 不重启电脑 以及IIS的情况下 只要访问一次 那么这个Application就会一直在

Answer 6

我知道写一个windows服务或者一个windows Form程序，在windows启动时会自动启动它们，这样定时任务就会自动运行
但是这样，客户那部署麻烦，我现在就是只想部署网站，就可以把我的系统全部运行起来！

Answer 7

public class Job
    {
        #region Private Members        private IJob _ijob;
        private bool _enabled = true;
        private Type _jobType;
        private string _name;
        private int _minutes = 15;
        private Timer _timer = null;
        private XmlNode _node = null;
        private bool _isRunning;        #endregion        #region Constructors        public Job(Type ijob, XmlNode node)
        {
            _node = node;
            _jobType = ijob;
            XmlAttribute att = null;            att = node.Attributes["name"];
            if (att != null)
            {
                this._name = att.Value;
            }
            att = node.Attributes["enabled"];
            if (att != null && !string.IsNullOrEmpty(att.Value))
            {
                try
                {
                    this._enabled = bool.Parse(att.Value);
                }
                catch
                {
                    this._enabled = true;
                }
            }
            att = node.Attributes["minutes"];
            if (att != null && !string.IsNullOrEmpty(att.Value))
            {
                try
                {
                    this._minutes = Int32.Parse(att.Value);
                }
                catch
                {
                    this._minutes = 15;
                }
            }
        }        #endregion        #region Public Properities        public string Name
        {
            get { return this._name; }
        }        public bool Enabled
        {
            get { return this._enabled; }
        }        public int Minutes
        {
            get { return _minutes; }
            set { _minutes = value; }
        }        public int Interval
        {
            get
            {
                return Minutes * 60000;
            }
        }        public bool IsRunning
        {
            get { return _isRunning; }
        }        public Type JobType
        {
            get { return this._jobType; }
        }        #endregion        #region Public Events        public event EventHandler PreJob;
        public event EventHandler PostJob;        #endregion        #region Public Methods        public void Start()
        {
            if (Enabled && _timer == null)
            {
                _timer = new Timer(new TimerCallback(timer_Callback), null, Interval, Interval);
                Execute();
            }
        }        public void Stop()
        {
            if (_timer != null)
            {
                lock (this)
                {
                    _timer.Dispose();
                    _timer = null;
                }
            }
        }        #endregion        #region Private Methods        private void Execute()
        {
            OnPreJob();
            _isRunning = true;            if (_ijob == null)
            {
                _ijob = CreateJobInstance();
            }
            try
            {
                _ijob.Execute(this._node);
            }
            catch
            {
            }            _isRunning = false;
            OnPostJob();
        }
        private void timer_Callback(object state)
        {
            if (!Enabled)
            {
                return;
            }
            _timer.Change(Timeout.Infinite, Timeout.Infinite);
            Execute();
            if (Enabled)
            {
                _timer.Change(Interval, Interval);
            }
            else
            {
                this.Stop();
            }
        }
        private void OnPreJob()
        {
            try
            {
                if (PreJob != null)
                {
                    PreJob(this, EventArgs.Empty);
                }
            }
            catch
            {
            }
        }
        private void OnPostJob()
        {
            try
            {
                if (PostJob != null)
                {
                    PostJob(this, EventArgs.Empty);
                }
            }
            catch
            {
            }
        }
        private IJob CreateJobInstance()
        {
            if (_jobType != null)
            {
                _ijob = Activator.CreateInstance(_jobType) as IJob;
            }
            _enabled = (_ijob != null);
            if (!_enabled)
            {
                this.Stop();
            }
            return _ijob;
        }        #endregion
    }public class JobManager
    {
        #region Private Members        private static readonly JobManager _jobManager = null;
        private Hashtable jobList = new Hashtable();        #endregion        #region Constructors        static JobManager()
        {
            _jobManager = new JobManager();
        }        #endregion        #region Public Properties        public static JobManager Instance
        {
            get
            {
                return _jobManager;
            }
        }        public Hashtable JobList
        {
            get { return jobList; }
        }        #endregion        #region Public Methods        public void StartAllJobs()
        {
            foreach (Job job in Configuration.Instance.Jobs.Values)
            {
                job.Start();
            }
        }        public void StartJob(string jobName)
        {
            Job job = GetJob(jobName);
            if (job != null)
            {
                job.Start();
            }
        }        public void StopAllJobs()
        {
            if (jobList != null)
            {
                foreach (Job job in jobList.Values)
                {
                    job.Stop();
                }
            }
        }        public void StopJob(string jobName)
        {
            Job job = GetJob(jobName);
            if (job != null)
            {
                job.Stop();
            }
        }        public Job GetJob(string jobName)
        {
            return jobList[jobName] as Job;
        }        public bool IsJobEnabled(string jobName)
        {
            Job job = GetJob(jobName);
            if (job == null)
            {
                return false;
            }
            return job.Enabled;
        }        #endregion
    }    public interface IJob
    {
        void Execute(XmlNode node);
    }    public class UpdateOnlineUsersJob : IJob
    {
        public void Execute(XmlNode node)
        {
            OnlineMemberManager.Instance.RefreshAllUsers(Configuration.Instance.UserOnlineTimeWindow);
        }
    } <!--设置用户timeout-->
  <coreConfig userOnlineTimeWindow="10">
    <jobs>
      <job name="UpdateOnlineUsersJob" minutes="5" type="MvcApplication.UpdateOnlineUsersJob"/>
    </jobs>
  </coreConfig>
自己做一个Jop管理，以前这个我是用来刷新当前在线用户的

Answer 8

   protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();            RegisterGlobalFilters(GlobalFilters.Filters);
            RegisterRoutes(RouteTable.Routes);            JobManager.Instance.StartAllJobs();        }
        private void Application_End()
        {
            JobManager.Instance.StopAllJobs();        }

Answer 9

这个方法好像也不太行嘛，IIS回收之后，只能执行一次。
我将IIS应用程序池的回收时间设置成1分钟，然后记录日志，在Application_End里打开一次。不会一直在

Answer 10

 
void Application_End(object sender, EventArgs e)
        {
            //  在应用程序关闭时运行的代码
            E_Log log = new E_Log();
            log.Module = "打开主页再来一次";
            log.ExceptionMessage = "Application_End";
            log.CreateDate = DateTime.Now;
            new B_Log().AddLog(log);
            System.Threading.Thread.Sleep(5000);
            string strUrl = "http://192.168.2.87:8088/View/Login/Login.htm";
            System.Net.HttpWebRequest _HttpWebRequest = (System.Net.HttpWebRequest)System.Net.WebRequest.Create(strUrl);
            System.Net.HttpWebResponse _HttpWebResponse = (System.Net.HttpWebResponse)_HttpWebRequest.GetResponse();
            System.IO.Stream _Stream = _HttpWebResponse.GetResponseStream();//得到回写的字节流
            _HttpWebResponse.Close();
        }
ID Module          ExceptionMessage UserID CreateDate
93 测试线程运行 0 2013-08-23 10:28:37.913
92 打开主页再来一次     Application_End 0 2013-08-23 10:28:36.007
91 测试线程运行 0 2013-08-23 10:28:32.467
90 测试线程运行 0 2013-08-23 10:28:27.463
89 测试线程运行 0 2013-08-23 10:28:22.463
88 测试线程运行 0 2013-08-23 10:28:17.460
87 测试线程运行 0 2013-08-23 10:28:12.460
86 测试线程运行 0 2013-08-23 10:28:07.460
85 测试线程运行 0 2013-08-23 10:28:02.460
84 测试线程运行 0 2013-08-23 10:27:57.460
83 测试线程运行 0 2013-08-23 10:27:52.457
82 测试线程运行 0 2013-08-23 10:27:47.457
81 测试线程运行 0 2013-08-23 10:27:42.440