我是做Socket的新手，最近做了一個Socket客戶端程序，連接Server的時候，如果server存在，并且允許連接的話，程序無錯，正常執行；但是如果Server不存在，或者拒絕連接，程序就會卡住，此時不提示出錯。開始我以為是沒有Catch異常，但是檢查了程序，異常情況都Catch掉了，程序還是卡。

請各位大蝦幫忙指正！謝謝，以下是我這個模塊的代碼！

using System;
using System.Collections;
using System.ComponentModel;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Text;

namespace 測試程序
{
 /// <summary>
 /// ClassClient 的摘要說明。
 /// </summary>
 public class ClassClient
 {
  //方法
  public ClassClient()
  {
   //
   // TODO: 在此處添加構造函數邏輯
   //
  }

  //函數

  #region socket通信機連接函數
  /// <summary>
  /// socket通信機連接函數
  /// </summary>
  /// <param name="remoteEP">遠程終端</param>
  /// <param name="client">建立客戶端</param>
  public  byte SocketConnect(EndPoint RemoteEP, Socket Client)
  {
   //調用系統連接函數
   Client.BeginConnect(RemoteEP,new AsyncCallback(ConnectCallback), Client );
           
   ConnectDone.WaitOne();
  
   return(1);

  
  }
  #endregion

  #region socket連接返回函數
  /// <summary>
  /// socket連接返回函數
  /// </summary>
  /// <param name="ar">表示異步操作的狀態</param>
  PRivate static void ConnectCallback(IAsyncResult ar)
  {
   try
   {
    // 獲取socket連接實例
    Socket client = (Socket) ar.AsyncState;

    // 完成連接過程.
    client.EndConnect(ar);

    // 置位連接完成標志
    ConnectDone.Set();
   
    // 得到連接成功信息
    ConnectInfo="連接成功！";
   }
   catch (Exception e)
   {
    // 得到連接失敗信息
    ConnectInfo=e.ToString ();

    // 結束連接
    ConnectDone.Reset ();
   }
  }
  #endregion

  #region socket通信機關閉函數
  /// <summary>
  /// socket通信機關閉函數
  /// </summary>
  /// <param name="Client">需關閉的socket通信實例</param>
  public byte SocketClose(Socket Client)
  {
   try
   {
    if (Client!=null)
    {
     //如果仍然產生通信信息，則禁用
     if (Client.Connected)
     {
      Client.Shutdown(SocketShutdown.Both);
     }
     //關閉socket通信
     Client.Close();

     //獲得關閉成功信息
     CloseInfo = "通信機已關閉!";
    }
    return(1);
   }
   catch (Exception e)
   {
    //獲得關閉通信失敗信息
    CloseInfo = e.ToString();

    return(0);
   }
  }
  #endregion

  #region 數據發送函數
  /// <summary>
  /// 數據發送函數
  /// </summary>
  /// <param name="Client">已連接的socket通信機實例（客戶端）</param>
  /// <param name="MessageSend">需發送的信息</param>
  /// <returns>
  /// 返回發送是否成功值
  /// </returns>
  public bool SocketSend(Socket Client, String MessageSend)
  {
   //將數據轉換成Byte型ASCII碼。
   byte[] ByteData = Encoding.ASCII.GetBytes(MessageSend);

   // 向遠程設備（Server）發送數據.
   Client.BeginSend(ByteData, 0, ByteData.Length, SocketFlags.None,new AsyncCallback(SendCallback), Client);
           
   //發送標志事件等待
   SendDone.WaitOne();
           
   //返回真
   return(true);
  }
  #endregion

  #region 數據發送返回函數
  /// <summary>
  /// 數據發送返回函數
  /// </summary>
  /// <param name="ar">表示異步操作的狀態</param>
  private static void SendCallback(IAsyncResult ar)
  {
   try
   {
    // 獲取socket連接實例
    Socket Client = (Socket) ar.AsyncState;

    // 對遠程設備發送數據完成
    int bytesSent = Client.EndSend(ar);

    //置位發送完成標志
    SendDone.Set();

    // 獲得發送完成信息
    SendInfo="發送已完成！";

   }
   catch (Exception e)
   {
    //得到發送失敗信息
    SendInfo=e.ToString();

    //結束發送標志
    SendDone.Reset();
   }
  }

  #endregion

  #region 數據接收函數
  /// <summary>
  /// 數據接收函數
  /// </summary>
  /// <param name="client">已連接的socket通信機實例（客戶端）</param>
  /// <returns>
  /// 返回接收數據
  /// </returns>
  public string SocketReceive(Socket Client)
  {
   try
   {
    int i;

    // 創建實例.
    StateObject State = new StateObject();
    State.WorkSocket = Client;
   

    // 開始從遠程設備接收數據
    Client.BeginReceive( State.Buffer, 0, StateObject.BufferSize, 0,new AsyncCallback(ReceiveCallback), State);

    //將接收的byte數據轉化為字符串
    for (i=0;i<State.Buffer .Length ;i++)
    {
     RevData += State.Buffer[i].ToString ();
    }
   
    //返回接收到的數據
    return(RevData);
   }
   catch (Exception e)
   {
    //獲得接收失敗信息
    RevInfo = e.ToString();

    //返回空字符串
    return("");
   }
  }
  #endregion

  #region 數據接收返回函數
  /// <summary>
  /// 數據接收返回函數
  /// </summary>
  /// <param name="ar">表示異步操作的狀態</param>
  private static void ReceiveCallback( IAsyncResult ar )
  {
   try
   {
    // 創建實例
    StateObject State = (StateObject) ar.AsyncState;
    Socket Client = State.WorkSocket;

    // 從遠程設備讀取數據
    int BytesRead = Client.EndReceive(ar);

    if (BytesRead > 0)
    {
     // 可能有過多的數據，先存儲緩沖區內的字符串
     RevTempString = Encoding.ASCII.GetString(State.Buffer,0,BytesRead);
     State.SB.Append(RevTempString);

     // 接收剩余數據
     Client.BeginReceive(State.Buffer,0,StateObject.BufferSize,0,new AsyncCallback(ReceiveCallback), State);
    }
    else
    {
     // 所有數據都已經接收
     if (State.SB.Length > 1)
     {
      string response = State.SB.ToString();
     }

     // 置位數據已接收標志位
     ReceiveDone.Set();
    }
   }
   catch (Exception e)
   {
    // 獲得接收失敗信息
    RevInfo=e.ToString();
   }
  }
  #endregion

  #region 字段
  private static ManualResetEvent SendDone = new ManualResetEvent(false);
  private static ManualResetEvent ConnectDone = new ManualResetEvent(false);
  private static ManualResetEvent ReceiveDone = new ManualResetEvent(false);

  public static string ConnectInfo   = "";
  public static string CloseInfo     = "";
  public static string SendInfo      = "";
  public static string RevInfo       = "";
  public static string RevData       = "";
  public static string RevTempString = "";

  public class StateObject
  {
   // Client socket.
   public Socket WorkSocket    = null;
   // Size of receive buffer.
   public const int BufferSize = 2048;
   // Receive buffer.
   public byte[] Buffer        = new byte[BufferSize];
   // Received data string.
   public StringBuilder SB     = new StringBuilder();
  }
  #endregion
 
 }
}