form1.cs

用C#写的一个小东东

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.IO;
using System.Diagnostics;
using System.Threading;
using System.Net;
namespace C盘监控器1._._._
{
    public partial class Form1 : Form
    {
        //Process pro = new Process();
        string newname = "";
        private int length = 0;
        private string[] processStr=new string[50];//保存第一次采集到的进程
        
        private Process[] process=new Process[50];//第一次采集进程
        Process[] process1=new Process[50];//第二次采集进程，即实时监控进程的变化
        //private string[] yuanPorcess = new string[20];//
        //int yuan = 0;

        //private string[] processStr1 = new string[50];
        private string[] tongJi = new string[5];//保存被通辑的进程
        private int tongJiIndex = 0;

        private bool  flagstop = true;
        private bool autostop = true;
        private bool auto = false;
        private int kong = 0;
        public Form1()
        {
            InitializeComponent();
            gongGao.Text = "本人在此说明：\n此软件只做为个人学习用，\n代码暂不公开。\n文件系统只监控*.ini,\n*.exe,*.inf文件.\n如果发生还有别的文件\n须要监控请发email给我！\[e-mail]";
            //for (int chu = 0; chu < 20; chu++)
            //    yuanPorcess[chu] = "";
            timer2.Enabled = true;//开定时器２，用于实时结束被通辑的进程
        }


        private void Form1_Load(object sender, EventArgs e)
        {
            string[] u = Directory.GetLogicalDrives();//获取硬盘符
            foreach (string y in u)
            {
                comboBox2.Items.Add(y);//显示
            }
            comboBox2.SelectedIndex = 0;//选中第一个硬盘符
            //comboBox1.SelectedItem = "fjdksjfkdjs";
            IPHostEntry ip = new IPHostEntry();
            try
            {
                string name = Dns.GetHostName();
                IPHostEntry IPP = Dns.GetHostEntry(name);
                this.Text = "监控器1.3**邢增谋**" + "你的计算机名：" + Dns.GetHostName() + "**IP：" + IPP.AddressList[0].ToString();
            }
            catch
            {
            }
        }

        private void kaiShiProcess_Click(object sender, EventArgs e)
        {

        }

        private void killProcess_Click(object sender, EventArgs e)//这是个按钮“杀”
        {
            try
            {
                Process[] prc = Process.GetProcessesByName(processStr[yanJingChenProcess.SelectedIndex]);//获取要结束的进程
                //listBoxProcess1.Items.Add(processStr[yanJingChenProcess.SelectedIndex]);
                prc[0].Kill();//结束进程
            }
            catch //(Exception err)
            {
                //MessageBox.Show(err.Message);
            }
        }
        private void button2_Click(object sender, EventArgs e)//按钮“获取进程”
        {
            button2.Enabled = false;//关按钮
            process = Process.GetProcesses();//第一次获取进程
            //yanJingChenProcess.Items.Clear();
            foreach (Process pr in process)
            {

                yanJingChenProcess.Items.Add(pr.ProcessName.ToString() + "      " + pr.PrivateMemorySize64 / 1024 + "K");//在“原进程”中显示

                processStr[length] = pr.ProcessName.ToString();//保存第一次采集的进程
                length += 1;

            }
            //yuanjingchen();
            timer1.Enabled = true;//开第一个定时器
           
        }
        private void yuanjingchen()//刷新函数
        {
            process = Process.GetProcesses();//与实时进程比较后，进行刷新
            groupBox4.Text = "原进程" + process.Length;

        }
        private void timer1_Tick(object sender, EventArgs e)//实时监控
        {
            //int v = 0;
            timer1.Enabled = false;//先关了定时器
            process1 = Process.GetProcesses();//第二次获取进程，即实时进程
            //foreach (Process p in process1)
            //{
            //    processStr1[v++] = p.ProcessName.ToString();
            //}
            xingZhengJinCheng();//比较第一次获取到的和第二次获取到的进程
            timer1.Enabled = true;//比较后开定时器
        }
        private  void xingZhengJinCheng()//比较函数
        {
            int i=0;
            int ii = 0;
            bool flag0 = false;
            bool flag1 = false;
           string nam="";
            string mena="";
            if (process1.Length > process.Length)//有新运行的进程，下面把新运行的进程从process1中提取出来，并显示
            {
                foreach (Process pr in process1)//实时进程
                {
                    foreach (Process po in process)//第一次获取到进程
                    {

                        i++;//用以计第一次获取到的进程数，以免重复比较
                        int c = string.Compare(pr.ProcessName.ToString(), po.ProcessName.ToString());//实时进程和第一次获取的进程是否相等
                        if (c == 0)//相等
                        {
                            i = 0;
                            break;
                        }
                        if (i == process.Length)//已经到了第一次获取到的进程的最后一个进程且和实时进程不相等
                        {
                            i = 0;
                            //listBoxWatch.Items.Add("fkjdksjf");
                            //listBoxWatch.Items.Add("po.ProcessName:" + po.ProcessName.ToString());
                            //listBoxWatch.Items.Add(i);
                            flag0 = true;//有新运行的进程标志
                            nam = pr.ProcessName.ToString();//取出新运行的进程名
                            long size = pr.PrivateMemorySize64 / 1024;//取出新运行的进程所占的内存大小
                            mena = pr.ProcessName.ToString() + "      " + size.ToString() + "K";
                        }


                    }
                    if (flag0)//有新运行的进程
                    {
                        flag0 = false;//设置为假，以免重复显示新运行的进程
                        int c = string.Compare(pr.ProcessName.ToString(), newname);//新运行的进程是否已经显示过？
                        if (c != 0)//不是
                        {
                            yanJingChenProcess.Items.Insert(yanJingChenProcess.Items.Count, (object)mena);//把新运行的进程显示在”原进程“里
                            processStr[length] = pr.ProcessName.ToString();//更新保存第一次采集到的进程字符串数组
                            length += 1;
                            //yanJingChenProcess.Refresh();//
                            listBoxProcess1.Items.Add(nam);//在“新添加的进程”里显示新运行的进程
                            newname = pr.ProcessName.ToString();//保存新运行的进程
                        }
                    }
                }
            }
            //下面是提取结束了的进程，提醒：当进程被结束后process1里的进程没有了结束了的进程，因为process1是实时的，而process里还有，所以从process里可以找出被结束了的进程
                foreach (Process pr in process)
                {
                    foreach (Process p in process1)
                    {
                        ii++;//用于计process1的进程数，以免重复比较
                        int c = string.Compare(pr.ProcessName.ToString(), p.ProcessName.ToString());//比较是否相等
                        if (c == 0)//相等，不是结束的进程
                        {
                            ii = 0;
                            break;//跳出再比较
                        }
                        if (ii == process1.Length)//找到结束了的进程
                        {
                            ii = 0;
                            flag1 = true;//设置找到结束了的进程标志
                            nam = pr.ProcessName.ToString();//提取结束了的进程名
                            long size = pr.PrivateMemorySize64 / 1024;
                            mena = pr.ProcessName.ToString() +"      "+ size.ToString() + "K";
                        }
                    }
                    int cc = 0;
                   
                    if (flag1)//找到结束了的进程
                    {
                        flag1 = false;//关标志，
                        
                        try
                        {
                            for (int bb = 0; bb < length; bb++)
                            {
                               cc = string.Compare(nam, processStr[bb]);//寻找结束了的进程在processStr字符数组里的序号，提醒：processStr里的进程序号和”原进程“里的进程序号是一样的
                                if(cc==0)//找到
                                {
                                    cc=bb;//所序号赋给全局变量
                                    bb = 0;
                                    break;
                                }     
                            }
                            //listBoxProcess2.Items.Add("bb="+cc);
                        }
                        catch (Exception err)
                        {
                            MessageBox.Show(err.Message);
                        }
                        yanJingChenProcess.Items.RemoveAt(cc);//从“原进程”里删除结束了的进程
                      
                        for (int dd = cc; dd < length; dd++)
                        {
                            processStr[dd] = processStr[dd + 1];//调整保持与”原进程“一致
                        }
                        cc = 0;
                        length = length - 1;//少了一个进程，总数自然减１
                        listBoxProcess1.Items.Remove((object)nam);//删除退出的进程
                        if (nam == newname)//退出的进程是否与新添加的进程相等，相等则清空newname
                            newname = "";
                        //listBoxProcess1.Refresh();
                    }
            }
            yuanjingchen();//刷新process,和processStr，（process与process1比较后，要更新process和processStr保持与process1有相同的进程。）
            //当有新进程添加或进程退出，process1先检测到，process总是先与它比较一次后才更新。
         }

        private void yanJingChenProcess_DoubleClick(object sender, EventArgs e)//在”原进程“中双击进程
        {
            try
            {
                Process[] prc = Process.GetProcessesByName(processStr[yanJingChenProcess.SelectedIndex]);//获取被双击的进程
                prc[0].Kill();//结束该进程
            }
            catch //(Exception err)
            {
                //MessageBox.Show(err.Message);
            }
        }

        private void chaKanProcess_Click(object sender, EventArgs e)//”>>”按钮
        {

            ProcessModuleCollection modules;//进程模块
            Process[] proc;
            proc = Process.GetProcessesByName(listBoxProcess1.SelectedItem.ToString());//获取选中的进程
            try
            {
                modules = proc[0].Modules;//获取进程模块
                listBoxProcess2.Items.Clear();
                foreach (ProcessModule mod in modules)
                {
                    listBoxProcess2.Items.Add(mod.FileName);//显示模块完整的路径和模块名
                }
            }
            catch 
            {
                MessageBox.Show("该进程已经死了！");
            }
        }

        private void kaiShi_Click(object sender, EventArgs e)//“开始”按钮
        {
            try
            {
                if (flagstop)//为“真”则开始文件系统监控
                {
                    if (fileSystemWatcher1.Path == "")//如果文件系统的监控路径为空，则提示
                    {
                        MessageBox.Show("请选择一条路径", "选择路径！");
                        return;
                    }
                    kaiShi.Text = "停止";
                    flagstop = false;
                    fileSystemWatcher1.EnableRaisingEvents = true;//启动文件系统监控

                }
                else//flagstop为假，则停止监控
                {
                    fileSystemWatcher1.EnableRaisingEvents = false;//停止监控
                    kaiShi.Text = "开始";
                    flagstop = true;
                }
            }
            catch (Exception err)
            {
                MessageBox.Show(err.Message);
            }
        }

        private void fileSystemWatcher1_Changed(object sender, FileSystemEventArgs e)//文件系统监控器的修改事件
        {
            try
            {
               // MessageBox.Show("changed!");
                int Extension = e.FullPath.LastIndexOf(".");
                string ExtensionName = e.FullPath.Substring(Extension + 1);//获取扩展名
                if (ExtensionName == "ini" || ExtensionName == "INI" || ExtensionName == "exe" || ExtensionName == "EXE" || ExtensionName == "inf" || ExtensionName == "INF")
                {
                    listBoxWatch.Items.Add("被修改的文件：" + e.FullPath.ToString());
                    listBoxWatch.Items.Add("修改时间:" + File.GetLastAccessTime(e.FullPath));
                    StreamWriter wr;
                    wr = File.AppendText("watch.txt") ;
                    wr.WriteLine("被修改的文件：" + e.FullPath.ToString());
                    wr.WriteLine("修改时间:" + File.GetLastAccessTime(e.FullPath).ToString());

                    if (auto)
                    {
                        File.Delete(e.FullPath);
                        wr.WriteLine("删除被修改的文件：" + e.FullPath);
                        wr.WriteLine("删除时间：" + File.GetLastAccessTime(e.FullPath).ToString());
                    }
                    wr.Flush();
                    wr.Close();
                }
            }
            catch
            {

            }
        }

        private void fileSystemWatcher1_Created(object sender, FileSystemEventArgs e)//文件系统的创建事件
        {
            try
            {
                //MessageBox.Show("create!");