C#

private static void ReceiveCallback(IAsyncResult ar)
{
    // End Receive
    StateObject stateObject = (StateObject)ar.AsyncState;

    if (stateObject == null)
    {
        return;
    }

    lock (stateObject)
    {
        if (stateObject.Socket == null)
        {
            // done!
            return;
        }

        int bytesReceived = 0;

        try
        {
            bytesReceived = stateObject.Socket.EndReceive(ar);
        }
        catch (SocketException)
        {
            // non-recoverable
            return;
        }
        catch (ObjectDisposedException)
        {
            // non-recoverable
            return;
        }

        if (bytesReceived > 0)
        {
            // Parse Data
            SocketConnection.ParseReceiveBuffer(stateObject);
        }

        // Begin Receive
        stateObject.Socket.BeginReceive(stateObject.DataBuffer, 0, stateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), stateObject);
    }
}

public void CloseConnections()
{
    // Receive
    lock(_recvState)
    {
        if (_recvSocket != null)
        {
            _recvSocket.Shutdown(SocketShutdown.Both);
            _recvSocket.Close();
            _recvSocket = null;
            _recvState.Socket = null; // setting this to null will signify that we've closed the connection
            _recvState = null; // don't reset this to null, if we do then we can't lock on it without first checking it
        }
    }

    // then something similar for sending . . 
}

namespace App_Domain
{
    class Program
    {
        static void Main(string[] args)
        {
            System.Net.Sockets.Socket rec_socket = blah, blah,
                send_socket = blah,blah;

            System.Threading.Thread rec_pumper = new System.Threading.Thread(
                new System.Threading.ParameterizedThreadStart(Pump_Messages));
            rec_pumper.Name = "Receive data socket handler";
            rec_pumper.Start(rec_socket);
            //go on about your GUI, and when you're ready to quit,
            //set Keep_Running to false.
        }
        public static bool Keep_Running  = true;
        private const int DATA_LENGTH = 256;
        public readonly static Queue<byte[]> _messages = new System.Collections.Generic.Queue<byte[]>();
        private static void Pump_Messages(object param)
        {
            System.Net.Sockets.Socket connected_socket = param as System.Net.Sockets.Socket;
            if (connected_socket == null)
                throw new System.ArgumentNullException("You must pass a System.Net.Sockets.Socket to me");
            byte[] buffer;
            //establish connection
            while (Keep_Running)
            {
                if (!connected_socket.Connected)
                {
                    break;
                }
                if (connected_socket.Available >= DATA_LENGTH)
                {
                    buffer = new byte[DATA_LENGTH];
                    connected_socket.Receive(buffer);
                    _messages.Enqueue(buffer);
                    buffer = null;
                }
                System.Threading.Thread.Sleep(300);
            }
            if (connected_socket.Connected)
            {
                connected_socket.Close();
            }
            if (Keep_Running)
            {
                //if we're here, we have abnormal termination.
                //log it.
                System.Console.WriteLine("Crap!  Abnormal termination!!  Check the client, he's off his bunker!");
            }
        }
    }
}

GrenMeera wrote:

You were correct on both of your guesses. I do have an outstanding call to BeginReceive. My problem is that I don't know how to NOT have an outstanding call to BeginReceive. I was under the impression that Socket.Shutdown and Socket.Close were supposed to clear those.

jschell wrote:

there is no way to ensure that an action in thread 1 will only occur at point x in thread 2

if (b == null)
    a = null;
else
    a = a.ToString(); //this rarely makes sense, didn't you mean b.ToString()?

The conditional operator is right-associative. The expression a ? b : c ? d : e  is evaluated as a ? b : (c ? d : e), not as (a ? b : c) ? d : e.<br />
<br />
The conditional operator cannot be overloaded.

The conditional operator (?:) returns one of two values depending on the value of a Boolean expression.

I are Troll