title: Socket Error 10054 : Error Handling Issue
body: <p>Eveyone. </p>
  
  <p>How to resolve the Error code 10054 ? There are <a href="http://msdn.microsoft.com/en-us/library/windows/desktop/ms740668%28v=vs.85%29.aspx" rel="nofollow">some description</a> about this error. Here is my full source code for communication. I want to know whether my code is ok or not. </p>
  
  <blockquote>
    <blockquote>
      <p>WSAECONNRESET10054   Connection reset by peer. An existing connection
      was forcibly closed by the remote host. This normally results if the
      peer application on the remote host is suddenly stopped, the host is
      rebooted, the host or remote network interface is disabled, or the
      remote host uses a hard close (see setsockopt for more information on
      the SO_LINGER option on the remote socket). This error may also result
      if a connection was broken due to keep-alive activity detecting a
      failure while one or more operations are in progress. Operations that
      were in progress fail with WSAENETRESET. Subsequent operations fail
      with WSAECONNRESET.</p>
    </blockquote>
  </blockquote>
  
  <hr>
  
  <p><strong>Full Source Code</strong>  </p>
  
  <pre><code>using System;
  using System.Net;
  using System.Net.Sockets;
  using System.Reflection;
  using System.Threading;
  using LogManager;
  
  namespace CoreUnitPlatform
  {
      public class SocketCommCoreUnit
      {
          #region property
          private volatile bool _shouldStop;
          private LogWriter log = LogWriter.Instance;
  
          private bool m_bSocketConnected = false;
  
          private Socket m_clientSocket = null;
  
          private SocketCommType m_connectedSockType;
  
          private EventHandlerDataReceived m_evtHandlerDataReceived;
  
          private EventHandlerSocketConnected m_evtHandlerSocketConnected;
  
          private EventHandlerSocketConnectedFailed m_evtHandlerSocketConnectedFailed;
  
          private EventHandlerSocketDisconnected m_evtHandlerSocketDisconnected;
  
          private IPAddress m_IPAddress;
  
          private IPEndPoint m_IPEndPoint;
  
          private int m_portNo;
  
          private Socket m_serverSocket = null;
  
          private Thread m_threadConnectSocket = null;
  
          private string Name = string.Empty;
  
          #endregion
  
          #region constructor
          public SocketCommCoreUnit()
          {
              this.Name = "SocketCommCoreUnit";
              Instance();
          }
          #endregion
  
          #region delegatge
          public delegate void EventHandlerDataReceived(string msg);
  
          public delegate void EventHandlerSocketConnected();
  
          public delegate void EventHandlerSocketConnectedFailed();
  
          public delegate void EventHandlerSocketDisconnected();
          public enum SocketCommType { SERVER, CLIENT };
  
          public bool SocketConnected
          {
              get { lock (this) { return m_bSocketConnected; } }
              set { lock (this) { m_bSocketConnected = value; } }
          }
          #endregion
  
          #region public
          public void ConnectSocketProc()
          {
              while (!_shouldStop)
              {
                  try
                  {
                      if (SocketConnected == false)
                      {
                          if (m_connectedSockType == SocketCommType.SERVER)
                          {
                              m_clientSocket = m_serverSocket.Accept();   // If a client is connected, wait for data from client
  
                              m_evtHandlerSocketConnected();
                              SocketConnected = true;
                          }
                          else
                          {
                              m_clientSocket.Connect(m_IPAddress, m_portNo);
                              if (m_clientSocket.Connected == true)
                              {
                                  m_evtHandlerSocketConnected();
                                  SocketConnected = true;
                              }
                          }
                      }
                      else
                      {
                          try
                          {
                              byte[] buffer = new byte[1024];
                              int readBytes = this.m_clientSocket.Receive(buffer);
                              if (readBytes == 0)
                              {
                                  this.reConnect();
                              }
                              else
                              {
                                  string received = System.Text.Encoding.ASCII.GetString(buffer);
                                  m_evtHandlerDataReceived(received);
                              }
                          }
                          catch (SocketException sex)
                          {
                              if (sex.NativeErrorCode.Equals(10054))
                              {
                                  log.AddErrorLog(this.Name, MethodBase.GetCurrentMethod().Name, string.Format("Error Occured [{0}]: MESASGE[{1}]\r\nSOURCE[{2}]\r\nTRACE[{3}]", sex.NativeErrorCode, sex.Message, sex.Source, sex.StackTrace));
  
                                  this.reConnect();
                              }
                          }
                      }
                  }
                  catch
                  {
                      m_evtHandlerSocketConnectedFailed();
                  }
  
                  Thread.Sleep(100);
              }
          }
  
          public void Initialize(string IP, int port, SocketCommType sockType, EventHandlerDataReceived evtHandlerDataReceived, EventHandlerSocketConnected evtHandlerDataConnected, EventHandlerSocketDisconnected evtHandlerSocketDisconnected, EventHandlerSocketConnectedFailed evtHandlerSocketConnectedFailed)
          {
              m_connectedSockType = sockType;
              m_evtHandlerDataReceived = evtHandlerDataReceived;
              m_evtHandlerSocketDisconnected = evtHandlerSocketDisconnected;
              m_evtHandlerSocketConnected = evtHandlerDataConnected;
              m_evtHandlerSocketConnectedFailed = evtHandlerSocketConnectedFailed;
  
              m_portNo = port;
              m_IPAddress = IPAddress.Parse(IP);
              m_IPEndPoint = new IPEndPoint(m_IPAddress, m_portNo);
  
              if (sockType == SocketCommType.SERVER)
              {
                  OpenServer();
              }
              else
              {
                  OpenClient();
              }
          }
  
          public void Instance()
          {
          }
  
          public void OpenClient()
          {
              try
              {
  #if _NO_USE_SOCKET
  #else
                  RunClientSocket();
  #endif
              }
              catch (System.Exception ex)
              {
                  log.AddErrorLog(this.Name, MethodBase.GetCurrentMethod().Name, string.Format("Error Occured: MESASGE[{0}]\r\nSOURCE[{1}]\r\nTRACE[{2}]", ex.Message, ex.Source, ex.StackTrace));
              }
          }
  
          public void OpenServer()
          {
              try
              {
  #if _NO_USE_SOCKET
  #else
                  RunServerSocket();
  #endif
              }
              catch (System.Exception ex)
              {
                  log.AddErrorLog(this.Name, MethodBase.GetCurrentMethod().Name, string.Format("Error Occured: MESASGE[{0}]\r\nSOURCE[{1}]\r\nTRACE[{2}]", ex.Message, ex.Source, ex.StackTrace));
              }
          }
  
          public void Release()
          {
              try
              {
                  if (this.m_clientSocket != null &amp;&amp; this.m_clientSocket.Connected)
                  {
                      SocketConnected = false;
                      m_evtHandlerSocketDisconnected();
  
                      this.m_clientSocket.Shutdown(SocketShutdown.Both);
                      this.m_clientSocket.Close();
                  }
  
                  if (m_serverSocket != null)
                  {
                      m_serverSocket.Close();
                  }
  
                  if ((m_threadConnectSocket != null) &amp;&amp; (m_threadConnectSocket.IsAlive == true))
                  {
                      Thread.Sleep(1);
                      RequestStop();
  
                      SocketConnected = false;
                      m_threadConnectSocket.Abort();
                      m_threadConnectSocket.Join();
                  }
              }
              catch (System.Exception ex)
              {
                  log.AddErrorLog(this.Name, MethodBase.GetCurrentMethod().Name, string.Format("Error Occured: MESASGE[{0}]\r\nSOURCE[{1}]\r\nTRACE[{2}]", ex.Message, ex.Source, ex.StackTrace));
              }
          }
  
          public void RequestStop()
          {
              _shouldStop = true;
          }
  
          public void RunClientSocket()
          {
              m_clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
              ConfigureTcpSocket(m_clientSocket, SocketCommType.CLIENT);
  
              m_threadConnectSocket = new Thread(new ThreadStart(ConnectSocketProc));
              m_threadConnectSocket.Start();
          }
  
          public void RunServerSocket()
          {
              m_serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
              m_serverSocket.Bind(m_IPEndPoint);
              m_serverSocket.Blocking = true;          // The server socket is working in blocking mode
  
              ConfigureTcpSocket(m_serverSocket, SocketCommType.SERVER);
  
              m_serverSocket.Listen(1);
  
              m_threadConnectSocket = new Thread(new ThreadStart(ConnectSocketProc));
              m_threadConnectSocket.Start();
          }
  
          public void Send(byte[] msg)
          {
  #if _NO_USE_SOCKET
  #else
              if (SocketConnected == false)
              {
                  throw new Exception("SOCKET_NOT_CONNECT_BEFORE_SEND_DATA;");
              }
  
              try
              {
                  m_clientSocket.Send(msg);
              }
              catch (System.Exception ex)
              {
                  SocketConnected = false;
                  m_evtHandlerSocketDisconnected();
                  log.AddErrorLog(this.Name, MethodBase.GetCurrentMethod().Name, string.Format("Error Occured: MESASGE[{0}]\r\nSOURCE[{1}]\r\nTRACE[{2}]", ex.Message, ex.Source, ex.StackTrace));
              }
  #endif
          }
  
          #endregion
  
          #region private
  
          private void ConfigureTcpSocket(Socket tcpSocket, SocketCommType socketCommType)
          {
              //// Don't allow another socket to bind to this port.
              //tcpSocket.ExclusiveAddressUse = true;
  
              //// The socket will linger for 10 seconds after
              //// Socket.Close is called.
              //tcpSocket.LingerState = new LingerOption(true, 10);
  
              // Disable the Nagle Algorithm for this tcp socket.
              tcpSocket.NoDelay = true;
  
              //if (socketCommType == SocketCommType.CLIENT)
              //{
              //    tcpSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.DontLinger, false);
              //    tcpSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
              //    //tcpSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveTimeout, 3000);
              //    //tcpSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.SendTimeout, 3000);
  
              //    // Set the receive buffer size to 8k
              //    tcpSocket.ReceiveBufferSize = 2048;
  
              //    // Set the send buffer size to 8k.
              //    tcpSocket.SendBufferSize = 2048;
              //}
  
              //// Set the receive buffer size to 8k
              //tcpSocket.ReceiveBufferSize = 1024;
  
              // Set the timeout for synchronous receive methods to
              // 1 second (1000 milliseconds.)
              //tcpSocket.ReceiveTimeout = 1000;
  
              //// Set the send buffer size to 8k.
              //tcpSocket.SendBufferSize = 1024;
  
              // Set the timeout for synchronous send methods
              // to 1 second (1000 milliseconds.)
              //tcpSocket.SendTimeout = 1000;
  
              //// Set the Time To Live (TTL) to 42 router hops.
              //tcpSocket.Ttl = 42;
          }
  
          private void ConfigureTcpSocket(Socket tcpSocket)
          {
              //// Don't allow another socket to bind to this port.
              //tcpSocket.ExclusiveAddressUse = true;
  
              //// The socket will linger for 10 seconds after
              //// Socket.Close is called.
              //tcpSocket.LingerState = new LingerOption(true, 10);
  
              // Disable the Nagle Algorithm for this tcp socket.
              tcpSocket.NoDelay = true;
  
              //// Set the receive buffer size to 8k
              //tcpSocket.ReceiveBufferSize = 8192;
  
              // Set the timeout for synchronous receive methods to
              // 1 second (1000 milliseconds.)
              //tcpSocket.ReceiveTimeout = 1000;
  
              //// Set the send buffer size to 8k.
              //tcpSocket.SendBufferSize = 8192;
  
              // Set the timeout for synchronous send methods
              // to 1 second (1000 milliseconds.)
              //tcpSocket.SendTimeout = 1000;
  
              //// Set the Time To Live (TTL) to 42 router hops.
              //tcpSocket.Ttl = 42;
          }
  
          private void reConnect()
          {
              try
              {
                  SocketConnected = false;
                  m_evtHandlerSocketDisconnected();
                  m_clientSocket.Disconnect(true);
  
                  log.AddSystemLog(this.Name, MethodBase.GetCurrentMethod().Name, string.Format("Try Re-Connection..."));
  
                  if (m_connectedSockType == SocketCommType.SERVER)
                  {
                  }
                  else
                  {
                      m_clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                  }
              }
              catch (System.Exception exc)
              {
                  log.AddErrorLog(this.Name, MethodBase.GetCurrentMethod().Name, string.Format("Error Occured: MESASGE[{0}]\r\nSOURCE[{1}]\r\nTRACE[{2}]", exc.Message, exc.Source, exc.StackTrace));
              }
          }
          #endregion
      }
  }
  </code></pre>