ProcessWatchImpl/Rusk/ProcessWatcher.cs

using System;
using System.Threading;
using dbg = SeedCreate.CommonLibrary.DebugHelper;
using diag = System.Diagnostics;

namespace Toast.ProcessControl
{
        public class ProcessWatcher:IDisposable
        {
                private static readonly TimeSpan DefaultDelay = new TimeSpan(0, 0, 1);

                private readonly object syncRoot_ = new object();
                private Timer timer_;
                private bool isRun_;

                private bool isTargetProcessRun_;
                private int CheckCount_;

                public event EventHandler DetectProcessStart;
                public event EventHandler DetectProcessTerminate;

                public ProcessWatcher()
                {
                        timer_ = new Timer(new TimerCallback(TimerMain));
                        isRun_ = false;
                        TargetProcessName = null;
                        isTargetProcessRun_ = false;
                        CheckCountThreshold = 0;
                        CheckCount_ = 0;
                }

                public string TargetProcessName
                {
                        get;
                        private set;
                }

                public int CheckCountThreshold
                {
                        get;
                        private set;
                }

                public TimeSpan Interval
                {
                        get;
                        private set;
                }


                public bool Start(int checkCount,TimeSpan interval, string processName)
                {
                        if (interval.Ticks <= 0)
                        {
                                throw new ArgumentOutOfRangeException("interval");
                        }

                        if(processName==null)
                        {
                                throw new ArgumentNullException("processName");
                        }

                        if (checkCount < 0)
                        {
                                throw new ArgumentOutOfRangeException("checkCount");
                        }


                        lock (syncRoot_)
                        {
                                if (isRun_)
                                {
                                        return false;
                                }

                                TargetProcessName = processName;

                                isRun_ = true;
                                isTargetProcessRun_ = false;
                                CheckCountThreshold = checkCount;
                                Interval = interval;

                                timer_.Change(DefaultDelay, interval);

                        }

                        return true;
                }


                private void TimerMain(object dummy)
                {
                        lock (syncRoot_)
                        {
                                timer_.Change(Timeout.Infinite, Timeout.Infinite);

                                diag::Process[] Ret= diag::Process.GetProcessesByName(TargetProcessName);

                                if (Ret.Length != 0 && !isTargetProcessRun_)
                                {
                                        OnDetectProcessStart(this, EventArgs.Empty);
                                        isTargetProcessRun_ = true;
                                }
                                else if (Ret.Length == 0 && isTargetProcessRun_)
                                {
                                        dbg::TinyDebugWriter.WriteLine("CheckCouht:{0}", CheckCount_);
                                        if (++CheckCount_ >= CheckCountThreshold)
                                        {
                                                OnDetectProcessTerminated(this, EventArgs.Empty);
                                                isTargetProcessRun_ = false;
                                                CheckCount_ = 0;
                                        }
                                }
                                else
                                {
                                        CheckCount_ = 0;
                                }


                                timer_.Change(Interval, Interval);
                        }
                }

                private void OnDetectProcessStart(object sender, EventArgs e)
                {
                        dbg::TinyDebugWriter.WriteLine("Detect process start");

                        if (DetectProcessStart != null)
                        {
                                DetectProcessStart(sender, e);
                        }
                }

                private void OnDetectProcessTerminated(object sender, EventArgs e)
                {
                        dbg::TinyDebugWriter.WriteLine("Detect process terminate");

                        if (DetectProcessTerminate != null)
                        {
                                DetectProcessTerminate(sender, e);
                        }
                }

                #region IDisposable メンバ

                public void Dispose()
                {
                        lock (syncRoot_)
                        {
                                timer_.Change(Timeout.Infinite, Timeout.Infinite);
                                DetectProcessTerminate = null;
                                DetectProcessStart = null;
                                timer_.Dispose();
                        }
                }

                #endregion
        }
}