如何写一个监听程序啊？

Question

我有一个winform程序，是要一直运行的，他的功能是从GDS那里不停地获取最新数据，然后将最新的数据缓存到内存中，我现在要写一个程序去监听这个winform程序是否是在运行，如果程序停止了运行我就采用相应的方法通知管理员，但是我没有写过这种监听程序，我们头告诉我可以采用socket或者是采用监听进程的方法，哪位大大能提供点这方面的经验啊？当然了，我自己也在不停的百度，google，所以建议我百度，google的就别说了

Answer 1

搜索Socket服务端，一大堆都是，怎么会找不到呢
 private void InitServer()
        {
            //启动程序
            IPAddress[] addrIP = Dns.GetHostAddresses(Dns.GetHostName());
            IPAddress ip = addrIP[0];
            //int myprot = 36829;
            int myprot = 9000;
            serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);            serverSocket.Bind(new IPEndPoint(ip, myprot));
            serverSocket.Listen(1000);
        }        private void button1_Click(object sender, EventArgs e)
        {
            //开始监听
            while (true)
            {
                allDone.Reset();
                serverSocket.BeginAccept(new AsyncCallback(AcceptCallback), serverSocket);
                allDone.WaitOne();
            }
        }        public void AcceptCallback(IAsyncResult ar)
        {
            //等待接受
            allDone.Set();
            Socket listener = (Socket)ar.AsyncState;
            Socket handler = listener.EndAccept(ar);            uint dummy = 0;//判断客户端失去连接
            byte[] inOptionValues = new byte[Marshal.SizeOf(dummy) * 3];
            BitConverter.GetBytes((uint)1).CopyTo(inOptionValues, 0);
            BitConverter.GetBytes((uint)5000).CopyTo(inOptionValues, Marshal.SizeOf(dummy));
            BitConverter.GetBytes((uint)5000).CopyTo(inOptionValues, Marshal.SizeOf(dummy) * 2);
            handler.IOControl(IOControlCode.KeepAliveValues, inOptionValues, null);
                        StateObject state = new StateObject();
            state.workSocket = handler;
            state.buffer = new byte[StateObject.BUFFER_SIZE];
            state.tmpAl = new ArrayList(2048);
            //加入客户端列表
            if (!list.Contains(state))
            {
                list.Add(state);
            }            handler.BeginReceive(state.buffer, 0, StateObject.BUFFER_SIZE, 0, out errorCode, new AsyncCallback(ReadCallback), state);
        }        //异步回调
        public void ReadCallback(IAsyncResult ar)
        {
            string content = string.Empty;
            StateObject state = (StateObject)ar.AsyncState;
            Socket handler = state.workSocket;
            int bytesRead = 0;
            try
            {
                bytesRead = handler.EndReceive(ar, out errorCode);
                if (errorCode == SocketError.Success)
                {
                    if (bytesRead > 0)
                    {
                        byte[] tmpbytes = new byte[bytesRead];
                        Array.Copy(state.buffer, 0, tmpbytes, 0, bytesRead);
                        state.tmpAl.AddRange(tmpbytes);
                        //如果此处接收的数据包长度大于BUFFER_SIZE,那么就会出现数据包不齐,下一个数据包就会粘连!
                        //如果数据超过BUFFER_SIZE的大小则循环取                         if (handler.Available > 0)
                        {
                            state.buffer = new byte[handler.Available];
                            handler.BeginReceive(state.buffer, 0, handler.Available, 0, out errorCode, new AsyncCallback(ReadCallback), state);
                        }
                        else
                        {
                            byte[] endreceive = new byte[state.tmpAl.Count];
                            state.tmpAl.CopyTo(endreceive);
                            state.tmpAl.Clear();
                            content = Encoding.UTF8.GetString(endreceive);
                            Array.Clear(endreceive, 0, endreceive.Length);                            //省略处理数据 
                                // data =  
                            //发送给客户端                            if (!string.IsNullOrEmpty(data))
                            {
                                Send(handler, data);
                            }
                        }
                    }
                    Array.Clear(state.buffer, 0, state.buffer.Length);
                    handler.BeginReceive(state.buffer, 0, state.buffer.Length, 0, out errorCode, new AsyncCallback(ReadCallback), state);
                }                else
                {
                    if (errorCode == SocketError.ConnectionReset)
                    {
                        if (state != null && !state.workSocket.Connected)
                        {
                            if (list.Contains(state))
                            {
                                list.Remove(state);
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                handler.BeginReceive(state.buffer, 0, state.buffer.Length, 0, out errorCode, new AsyncCallback(ReadCallback), state);
            }
        }        private void Send(Socket handler, string data)
        {
            byte[] byteData = Encoding.UTF8.GetBytes(data);            handler.BeginSend(byteData, 0, byteData.Length, 0, new AsyncCallback(SendCallback), handler);
        }        private void SendCallback(IAsyncResult ar)
        {
            Socket handler = (Socket)ar.AsyncState;
            int bytesSent = handler.EndSend(ar, out errorCode);
            if (errorCode != SocketError.Success)
            {
            }
        }        private void button2_Click(object sender, EventArgs e)
        {
            strMeaOK = textBoxMeaOK.Text;
            strMeaFinish = textBoxMeaFinish.Text;
            strMeaStop = txtMeaStop.Text;
            strPrtFlag = txtPrtFlag.Text;
            strMeaAbandon = txtMeaAbandon.Text;
            
        }

Answer 2

 //参考下 
  public void Getprocess(string name)
        {
            Process[] p = Process.GetProcessesByName(name);
            if(p.Length<=0)
            {
                Process.Start("KillProcess");
            }
        }