为什么我用socket连接，只能发送/接收一次数据，然后监听就自动关闭了？能不能无限监听

Question

我写了两个程序， 
一个是监听并发送数据(客户端) 
一个是连接并接收数据(服务器端) 问题是，客户端第1次监听发送数据，服务端成功连接接收；
客户端第2次发送数据的时候，服务端就连接不上了。系统提示：由于连接方在一段时间后没有正确答复或连接的主机没有反应，连接尝试失败。 "  
问题出在哪呢？ 下面是部分代码。服务器端
#region 发送命令
    public void WaitData()
    {
        try
        {
            this.ClientIp();
            System.Net.Sockets.Socket su = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            System.Net.IPEndPoint localEndPoint = new System.Net.IPEndPoint(System.Net.IPAddress.Parse(StrIp.Replace("'", "''").Trim()), 7878);
            su.Blocking = true;
            su.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveTimeout, 3000);//设置超时  
            su.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.SendTimeout, 3000);
            su.Connect(localEndPoint);
            su.Send(Encoding.Unicode.GetBytes("1"));
            //设置接收数据缓冲区的大小 
            byte[] b = new byte[1024 * 4];           
            //如何确定该数组大小 
            System.IO.MemoryStream fs = new System.IO.MemoryStream();
            int got = 0;
            int datalength = 0;
            while (true)
            {                got =  su.Receive(b);              
                fs.Write(b, 0, got);
                if (got > 0)
                    datalength = datalength + got;
                else
                    break;
            }
            Bitmap Img = new Bitmap(fs);
            //保存图片必须用物理路径
            string Path3 = Server.MapPath("..\\MyJpeg.jpg");    
            Img.Save(Path3, ImageFormat.Jpeg);
           //提取服务器端的图片可以用http路径
            string Path2 = "/pic/" + "MyJpeg" + ".jpg";
            this.Image1.ImageUrl = Path2;   
            //关闭写文件流
            fs.Close();
            //关闭接收数据的Socket 
           su.Close();           
        }
        catch (Exception se)
        {
        }
     }
    #endregion

Answer 1

客户端
#region 启动程序
        Socket s = null;
        Thread t;
        public void WaitData()
        {
            s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            //使用TCP协议 
            IPEndPoint localEndPoint = new IPEndPoint(IPAddress.Any, 7878);   //7575
            //指定IP和Port 
            try
            {
                s.Bind(localEndPoint);
                //绑定到该Socket 
                s.Listen(100);
                //侦听，最多接受100个连接 
                while (true)
                {                    byte[] bytes = new byte[1024];
                    Socket ss = s.Accept(); 
                      ss.Receive(bytes);
                     this.label1.Text = Encoding.Unicode.GetString(bytes).Trim();
                    if (this.label1.Text == "1")
                    {
                      IntPtr dc1 = CreateDC("DISPLAY", null, null, (IntPtr)null);
                      Graphics g1 = Graphics.FromHdc(dc1);
                       Bitmap MyImage = new Bitmap(Screen.PrimaryScreen.Bounds.Width, Screen.PrimaryScreen.Bounds.Height, g1);
                       Graphics g2 = Graphics.FromImage(MyImage);
                        IntPtr dc3 = g1.GetHdc();
                        IntPtr dc2 = g2.GetHdc();
                        BitBlt(dc2, 0, 0, Screen.PrimaryScreen.Bounds.Width, Screen.PrimaryScreen.Bounds.Height, dc3, 0, 0, 13369376);
                        g1.ReleaseHdc(dc3);
                        g2.ReleaseHdc(dc2);
                        MyImage.Save("..\\MyJpeg2.jpg", ImageFormat.Jpeg);                        
                         System.IO.FileStream fs = new System.IO.FileStream("..\\MyJpeg.jpg", System.IO.FileMode.OpenOrCreate, System.IO.FileAccess.Read);
                        byte[] fssize = new byte[fs.Length];
                        System.IO.BinaryReader strread = new System.IO.BinaryReader(fs);
                        strread.Read(fssize, 0, fssize.Length - 1);
                        ss.Send(fssize);
                        fs.Close();
                        ss.Close();
                    }                    else
                    {
                        ss.Send(Encoding.Unicode.GetBytes("请输入正确的指令！"));
                        ss.Close();
                    }                }
                s.Close();
            }
            catch (Exception se)
            {
                s.Close();
             }
            finally
            {
                //强制关闭发送连接 
                s.Close();
            }
       }        #endregion

Answer 2

这个是我最近写的一个socket 他可以无限监听 可以多用户使用  你自己看下改下就好了
namespace TCP_IPClient
{
    class Program
    {
        static void Main(string[] args)
        {
            string message;
            byte[] buffer=new byte[1024];
            Socket service = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            IPAddress address = IPAddress.Parse("10.6.11.76");
            IPEndPoint IPEP = new IPEndPoint(address, 13000);
            service.Connect(IPEP);
            int i = service.Receive(buffer);
            message = Encoding.ASCII.GetString(buffer, 0, i);
            Console.WriteLine(message);
            while (true)
            {
                Console.WriteLine();
                Console.Write("请输入要传输的信息");
                message = Console.ReadLine();
                if (message == "exit")
                {
                    break;
                }
                else
                {
                    buffer = new byte[1024];
                    buffer = Encoding.ASCII.GetBytes(message);
                    i = service.Send(buffer);
                    if (i > 0)
                    {
                        Console.WriteLine("信息发送成功！");
                    }
                }
                
            }
            service.Close();
            Console.WriteLine("用户断开连接.....");
            Console.ReadLine();
        }
    }
}

Answer 3

namespace TCP_IPServer
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Socket server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                Console.WriteLine("waiting for a message from client");
                IPEndPoint IPEP = new IPEndPoint(IPAddress.Any, 13000);
                server.Bind(IPEP);
                server.Listen(10);
                Socket Server = server.Accept();
                IPEndPoint remoteIPEP = (IPEndPoint)Server.RemoteEndPoint;
                
                Console.WriteLine("Connect with {0} at port {1}", remoteIPEP.Address, remoteIPEP.Port);
                string welcome = "welcome to connect with Server";
                byte[] buffer = new byte[1024];
                buffer = Encoding.ASCII.GetBytes(welcome);
                Server.Send(buffer);//, SocketFlags.None);
                while (true)
                {
                    buffer = new byte[1024];
                    int i = Server.Receive(buffer);
                    if (i == 0)
                    {
                        break;
                    }
                    else
                    {
                        string message = Encoding.ASCII.GetString(buffer, 0, i);
                        Console.WriteLine("收到来自客户端的信息:{0}", message);
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                Console.ReadLine();
            }
        }
    }
}

Answer 4

你去我的Blog看一下关于：Socket异步编程的文章。
http://wzd24.cnblogs.com

Answer 5

我是这样的顺序，客户端监听----服务器端连接-----服务器端发送“1”---客户端accept后收到“1”----客户端开始截屏------服务器端接收---服务器端显示，就这样的 

Answer 6

监听应该放到一个线程里面去。不断的去while(true)

Answer 7

我把客户端修改了一下代码，反而截不了屏了，请大家帮忙看下是哪里改的不合适了。 Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
 IPEndPoint locEP = new IPEndPoint(IPAddress.Any, 7171);
  ///监听
   private void AcceptWorkThread()
        {
          while (true)
            {
               Socket accept = listener.Accept();             
               Thread receiveThread = new Thread(new ParameterizedThreadStart(ReceiveWorkThread));
                receiveThread.Start(accept);
             }
        }     ///截屏
      private void ReceiveWorkThread(object obj)
      {
          try
          {
              Socket socket = (Socket)obj;
              byte[] bytes = new byte[1024];
              while (true)
              {
                  socket.Receive(bytes);
                  this.label1.Text = Encoding.Unicode.GetString(bytes).Trim();
                  if (this.label1.Text == "1")
                  {                       IntPtr dc1 = CreateDC("DISPLAY", null, null, (IntPtr)null); 
                      Graphics g1 = Graphics.FromHdc(dc1); 
                      Bitmap MyImage = new Bitmap(Screen.PrimaryScreen.Bounds.Width, Screen.PrimaryScreen.Bounds.Height, g1); 
                      Graphics g2 = Graphics.FromImage(MyImage); 
                        IntPtr dc3 = g1.GetHdc(); 
                        IntPtr dc2 = g2.GetHdc(); 
                        BitBlt(dc2, 0, 0, Screen.PrimaryScreen.Bounds.Width, Screen.PrimaryScreen.Bounds.Height, dc3, 0, 0, 13369376); 
                        g1.ReleaseHdc(dc3); 
                        g2.ReleaseHdc(dc2); 
                        MyImage.Save("..\\MyJpeg2.jpg", ImageFormat.Jpeg);                        
                        System.IO.FileStream fs = new System.IO.FileStream("..\\MyJpeg.jpg", System.IO.FileMode.OpenOrCreate, System.IO.FileAccess.Read); 
                        byte[] fssize = new byte[fs.Length]; 
                        System.IO.BinaryReader strread = new System.IO.BinaryReader(fs); 
                        strread.Read(fssize, 0, fssize.Length - 1); 
                        socket.Send(fssize);
                      fs.Close();
                  }
                  else
                  {
                      socket.Close();
                      break;
                  }
              }
          }
          catch(SocketException ex)
          {
              string s = ex.ToString();
          }        
       }    
       
   #region 初始化
        private void Form4_Load(object sender, EventArgs e)
        {    
            listener.Blocking = true;
            listener.Bind(locEP);
            listener.Listen(100);     
            Thread acceptThread = new Thread(new ThreadStart(AcceptWorkThread));
            acceptThread.Start();
        }    #endregion