基于C#实现进程回收管理工具

		private void timer1_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
		{
			DateTime cur_now=System.DateTime.Now;
			int cur_hour=cur_now.Hour;
			int cur_min=cur_now.Minute;
			int cur_sec=cur_now.Second;
		
			pc.CategoryName="Processor";
			pc.CounterName="% Processor Time";
			pc.InstanceName="_Total";
			
//			pc.MachineName="michaeljane";
			float pcv=pc.NextValue();
			label7.Text="CPU利用率："+(pcv).ToString()+" %";
			cpubar.Value=(int)(pcv);
 
			pcmem.CategoryName="Memory";
			pcmem.CounterName="Available MBytes";
			pcmem.InstanceName=null;
 
//			richTextBox1.Text=pcpu.NextValue().ToString()+"\r\n";
			
 
			/*			System.Diagnostics.PerformanceCounter[] mypc; 
			System.Diagnostics.PerformanceCounterCategory mycat = 
				new System.Diagnostics.PerformanceCounterCategory("process");
			// Remove the current contents of the list.
			// Retrieve the counters.
			mypc = mycat.GetCounters();
			// Add the retrieved counters to the list.
			richTextBox1.Text="";
			for (int i = 0; i < mypc.Length; i++) 
			{ 
				richTextBox1.Text+=(mypc[i].CounterName)+"\r\n";
			}
*/
 
//			float cpuLoad = pc.NextValue();
            try
            {
                label7.Text += "\r\n可用内存：" + pcmem.NextValue().ToString() + "M";
            }
            catch (Exception s)
            {
            }
			statusBar1.Text=cur_now.ToString();  //显示当前时间
			Process[] processes; //定义进程组
			processes = System.Diagnostics.Process.GetProcesses(); //获得当前进程组
			Process process;  //定义初始进程中间变量
			string _pname,_killstate="";   //定义进程名变量，及进程回收状态字符串
			bool _kill=false;  //是否要回收标志变量
			bool _phandle=checkBox2.Checked;
			int _gcSpan;  //时间差变量
			DateTime _pdatetime,_checktime,_stdtime; //进程启动的时间变量和检测时间变量
			string[] _rv;    //接受检测结果的数组
			System.TimeSpan _dd; //时间差的秒数变量
//			string[] _processid=new string[1000];
//			DateTime[] _processLastTime=new DateTime[1000];
//			int[] _processLastMem=new int[1000];
				for(int i = 0;i<processes.Length-1;i++)
				{
					process= processes[i];  //获得当前进程
					_pname=process.ProcessName.ToLower();  //获得进程名并转为小写
                try
                {
                    _pdatetime = process.StartTime;  //获得进程的启动时间
                }catch(Exception e1)
                {
                    continue;
                }
					//				_rv=GetSubValueIndex(listBox1,_pname,"|");  //得到要回收的用户指定进程
					for(int li=0;li<listBox1.Items.Count;li++)
					{
						_rv=listBox1.Items[li].ToString().Split('|');
						string ref_process=_rv[0].ToLower().Trim();
						int ref_span=int.Parse(_rv[1].ToString());
						string ref_cl=_rv[2].ToLower().Trim();
						float ref_rank=float.Parse(_rv[3].ToString());
						string ref_stdtime=_rv[4].ToLower().Trim();
						string ref_act=_rv[5].ToLower().Trim();
						string[] ref_cmd1=_rv[6].Split('↙');
						string[] ref_cmd2=_rv[7].Split('↙');
						string ref_closetime=_rv[8].Trim();
						//				richTextBox1.Text+=_rv[0]+_rv[1]+"\r\n";
					
						if(ref_process==_pname)  //如果是要回收的进程则进行处理
						{
							//如果在检测数组没有找到，则添加到检测数中
							int _curpoint=System.Array.IndexOf(_processid,process.Id);
							if(_curpoint<0)
							{
								_stdtime=process.StartTime;
								if(ref_stdtime=="bynowtime")
								{
									_stdtime=System.DateTime.Now;
								}
								System.Diagnostics.PerformanceCounter pcm=new System.Diagnostics.PerformanceCounter("Process","% Processor Time",_pname);
                            try
                            {
                                AddArray(process.Id, _stdtime, process.WorkingSet, pcm);
                            }catch(Exception e3)
                            {
 
                            }
								continue;
							}
                        //						richTextBox1.Text+=((System.Diagnostics.PerformanceCounter)_processLastCPU[_curpoint]).NextValue().ToString()+"\r\n";
                        try
                        {
                            float cur_rank = ((System.Diagnostics.PerformanceCounter)_processLastCPU[_curpoint]).NextValue();
                            _checktime = System.DateTime.Now;  //检测时间为当前时间
                                                               //开始分析CPU策略
                            if (ref_cl == "cpu")
                            {
                                //如果当前进程的CPU占用率没有超过指定的上限，则重置最后的检测时间为当前时间，继续监测。
                                if (cur_rank < ref_rank)
                                {
                                    _processLastTime[_curpoint] = _checktime;
                                }
                            }
                        }catch(Exception e2)
                        {
                            continue;
                        }
							//开始分析memory策略
							if(ref_cl=="memory")
							{
								float _curmem=process.WorkingSet/(1024*1024);
								//							richTextBox1.Text+=_pname+" "+_curmem.ToString()+"\r\n";
								//如果当前进程的内存占用没有超过指定的上限，则重置最后的检测时间为当前时间，继续监测。
								if(_curmem<ref_rank)
								{
									_processLastTime[_curpoint]=_checktime;
								}
							}
							_gcSpan=ref_span;  //得到用户指定的回收时间差
							_kill=false;
							_pdatetime=_processLastTime[_curpoint]; //得到进程的数组最后指定时间
							_dd=_checktime-_pdatetime;     //时间差以检测时间 减去 进行启动时间
							//如果时间差大于回收指定时间则可以回收进程，KILL变量为真
							if(checkBox1.Checked)
							{
								//只回收本程序启动以后的进程时间
								if((_dd.TotalSeconds>_gcSpan)&&(_starttime<_pdatetime))
								{
									_kill=true;
								}
							}
							else
							{
								if(_dd.TotalSeconds>_gcSpan)
								{
									_kill=true;
								}
							}
							//如果初期标识为可以关闭该进程，并且策略为强制性关闭，则进行内存判断
							if((_kill)&&(ref_cl=="force"))
							{
								//如果内存有变化，则表示进程仍在活动，则不进行关闭，并更新检测内容
								int _curmem=process.WorkingSet;
								label6.Text=_curmem.ToString()+"  "+_processLastMem[_curpoint];
								if(_curmem!=_processLastMem[_curpoint])
								{
									_processLastTime[_curpoint]=_checktime;
									_processLastMem[_curpoint]=_curmem;
									_kill=false;
								}
							}
							//如果指定了强制关闭时间，则进行判断
							string close_tip="";
							if(ref_closetime!="")
							{
								DateTime ref_cls=DateTime.Parse(ref_closetime);
								if((ref_cls.Hour==cur_hour)&&(ref_cls.Minute==cur_min)&&(ref_cls.Second==cur_sec))
								{
									_kill=true;
								    close_tip="强制关闭计划启动，计划时间为："+ref_closetime;
								}
							}
							//如果只回收死进程，而当前进程为激活的窗口的话，则不关闭
							if((_phandle)&&((int)process.MainWindowHandle!=0))
							{
								_kill=false;
							}
 
							//如果可以回收则在文本框中添加回收状态，并将进程关闭
							if(_kill)
							{
								if(!process.HasExited)
								{
									if(ref_act=="kill")
									{
										//								MessageBox.Show("has exited");
										_killstate=close_tip+".进程"+_pname+"已被回收，关闭策略为"+ref_cl+"，动作为："+ref_act+"。进程的启动时间为"+
											_pdatetime.ToString()+"，检测时间为："+_checktime.ToString()+
											"，现已经超时"+(_dd.TotalSeconds-_gcSpan).ToString()+
											"秒，回收时间单位是"+_gcSpan.ToString()+"秒。"+
											"进程ID："+process.Id.ToString()+
											"进程主窗口句柄："+process.MainWindowHandle.ToString();
										process.Kill();
										richTextBox1.AppendText(_killstate+"\r\n");
									}
									if(ref_act=="command")
									{
										//								MessageBox.Show("has exited");
										string _return="";
										for(int st=0;st<ref_cmd1.GetLength(0);st++)
										{
											_return+=ref_cmd1[st]+" Result:"+WinExec(ref_cmd1[st],0).ToString()+"↙";
										}
										_killstate=close_tip+".进程"+_pname+"已被回收，关闭策略为"+ref_cl+"，动作为："+ref_act+"，执行了命令："+
											ref_cmd1+"。返回值为："+_return+"。进程的启动时间为"+
											_pdatetime.ToString()+"，检测时间为："+_checktime.ToString()+
											"，现已经超时"+(_dd.TotalSeconds-_gcSpan).ToString()+
											"秒，回收时间单位是"+_gcSpan.ToString()+"秒。"+
											"进程ID："+process.Id.ToString()+
											"进程主窗口句柄："+process.MainWindowHandle.ToString();
										richTextBox1.AppendText(_killstate+"\r\n");
										//										process.Kill();
									}
									//清空当前进程检测数组元素
									_processid[_curpoint]=0;
									_processLastTime[_curpoint]=_checktime;
									_processLastMem[_curpoint]=0;
									_processLastCPU[_curpoint]=null;
								}//判断进程是否已经退出
							}
						}//if proecess
						else //如果没有找到进程名称，则二次判断任务是否提供了启动命令，如果提供，则运行它
						{
						}//end find process name
					}//li
				}//for
			processes = System.Diagnostics.Process.GetProcesses(); //获得当前进程组
			for(int ali=0;ali<listBox1.Items.Count;ali++)
			{
				_rv=listBox1.Items[ali].ToString().Split('|');
				string ref_process=_rv[0].ToLower().Trim();
				int ref_span=int.Parse(_rv[1].ToString());
				string ref_cl=_rv[2].ToLower().Trim();
				float ref_rank=float.Parse(_rv[3].ToString());
				string ref_stdtime=_rv[4].ToLower().Trim();
				string ref_act=_rv[5].ToLower().Trim();
				string[] ref_cmd1=_rv[6].Split('↙');
				string ref_start_cmd=_rv[7];
				string[] ref_cmd2=_rv[7].Split('↙');
				bool _find=false;
				if(ref_start_cmd!="")
				{
					for(int i = 0;i<processes.Length-1;i++)
				    {
					  process= processes[i];  //获得当前进程
					  string cur_pname=process.ProcessName.ToLower();  //获得进程名并转为小写
						if(cur_pname==ref_process)
						{
							_find=true;
						}
				    }
					if(!_find)
					{
						string _return="";
						for(int st=0;st<ref_cmd2.GetLength(0);st++)
						{
							_return+=ref_cmd2[st]+" Result:"+WinExec(ref_cmd2[st],0).ToString()+"↙";
						}
						_killstate="进程"+ref_process+"尝试启动，关闭策略为"+ref_cl+"，动作为："+ref_act+"，启动命令为："+
							ref_cmd2+"。返回值为："+_return+"。";
						richTextBox1.AppendText(_killstate+"\r\n");
					}
				}
			}//end for listbox
 
		}