示例#1
0
        /// <summary>
        /// Called when new data arrives. Checks to see how much data has arrived:
        ///
        /// If 0: connection has been closed (presumably by the server)
        /// If > 0: get SocketState out of stateAsArObject and call the callMe provided
        /// </summary>
        /// <param name="stateAsArObject">
        /// SyncResult containing the SocketState where callMe is saved away.
        /// </param>
        public static void ReceiveCallback(IAsyncResult stateAsArObject)
        {
            SocketState ss = (SocketState)stateAsArObject.AsyncState;

            try
            {
                if (ss.Connected)
                {
                    int bytesRead = ss.TheSocket.EndReceive(stateAsArObject);

                    // If the socket is still open
                    if (bytesRead > 0)
                    {
                        string theMessage = Encoding.UTF8.GetString(ss.MessageBuffer, 0, bytesRead);
                        // Append the received data to the growable buffer.
                        // It may be an incomplete message, so we need to start building it up piece by piece
                        ss.SB.Append(theMessage);
                    }

                    ss.CallMe(ss);
                }
            }
            catch (Exception e)
            {
                System.Diagnostics.Debug.WriteLine(e.Message);
                ss.Connected = false;
            }
        }
示例#2
0
        /// <summary>
        /// BeginAcceptSocket's callback function. When connection comes in, this method:
        /// (1) extracts the state containing the TcpListener and the callMe function from ar.
        /// (2) creates a new socket by using lister.EndAcceptSocket
        /// (3) save socket in new SocketState
        /// (4) call the callMe method and pass it to the new SocketState. This is how the server
        ///     gets a copy of the SocketState corresponding to this client. The callMe should
        ///     save the SocketState in a list of clients.
        /// (5) Await a new connection request (coninued in the event loop) with BeginAcceptSocket.
        ///     This means that the networking code assumes we want to always continue the event loop.
        /// </summary>
        /// <param name="ar">contains the callMe and the TcpListener</param>
        public static void AcceptNewClient(IAsyncResult ar)
        {
            ConnectionState cs = (ConnectionState)ar.AsyncState;
            SocketState     ss = new SocketState(cs.Lstn.EndAcceptSocket(ar), ++IDCounter);

            ss.CallMe = cs.CallMe;
            ss.CallMe(ss);
            cs.Lstn.BeginAcceptSocket(AcceptNewClient, cs);
        }
示例#3
0
        /// <summary>
        /// Reference by BeginConnect above and is called when socket connects to
        /// server. Once connection established, saved callMe is then called
        /// (originally passed in the ConnectToServer in SocketState)
        /// </summary>
        /// <param name="stateAsArObject">
        /// Contains a field "AsyncState" which contains SocketState saved away for
        /// later use.
        /// </param>
        public static void ConnectedCallback(IAsyncResult stateAsArObject)
        {
            SocketState ss = (SocketState)stateAsArObject.AsyncState;

            try
            {
                // Complete the connection.
                ss.TheSocket.EndConnect(stateAsArObject);
                System.Diagnostics.Debug.WriteLine("connected to server");
            }
            catch (Exception e)
            {
                System.Diagnostics.Debug.WriteLine("Unable to connect to server. Error occured: " + e);
                return;
            }

            ss.CallMe(ss);
        }