Socket.EndReceive的问题

一次只能收到一个,当你把这个处理完了以后,再重新begionRecive
好好研究这个，相信对你会非常有用的。
using System;
using System.Net;
using System.Net.Sockets;
using System.Collections;
using System.Text;
using System.Threading;namespace SignalTestsServer
{
    public class TCPSimpleServer : System.ComponentModel.Component
    {
#region 成员变量
// Private properties
        private int port = 10000;
        private bool active = false;
        private static Thread mainThread;
        private static Hashtable stateObjectDictionary = new Hashtable();        public readonly int InstanceID;
        private static int NextInstanceID = 0;
        private static long ClassInstanceCount = 0;
#endregion #region 事件与委托
// Delegates
        public delegate void OnConnectDelegate(Object sender, Socket socket);
        public delegate void OnDisconnectDelegate(Object sender, IPEndPoint peer);
        public delegate void OnDataAvailableDelegate(Object sender, Socket socket, string data);
        public delegate void OnDataSentDelegate(Object sender, Socket socket);
        public delegate void OnErrorDelegate(Object sender, string errorMessage);        // Events
        public event OnConnectDelegate OnConnect;
        public event OnDisconnectDelegate OnDisconnect;
        public event OnDataAvailableDelegate OnDataAvailable;
        public event OnDataSentDelegate OnDataSent;
        public event OnErrorDelegate OnError;        // Thread signal.
        public static ManualResetEvent mainDone = new ManualResetEvent(false); #endregion

#region 构造与析构
public TCPSimpleServer()
{
            InstanceID = NextInstanceID++;
            ClassInstanceCount++;
        }        ~TCPSimpleServer() {
            ClassInstanceCount--;
        }
#endregion
#region 属性

#region InstanceCount
public static long InstanceCount
        {
            get { return ClassInstanceCount; }
        }
#endregion #region Port
public int Port
        {
            set { port = value; }
            get { return port; }
        }
#endregion #region Active
public bool Active
        {
            set {
                if (value == true)
                {
                    mainThread = new Thread(new ThreadStart(MainThread));
                    mainThread.IsBackground = true;
                    mainThread.Start();
                    active = value;
                }
                else
                {
                    active = value;
                    foreach (Socket socket in stateObjectDictionary.Values)
                    {
                        try
                        {
                            socket.Close();
                        }
                        catch (Exception e)
                        {
                            if (OnError != null)
                                OnError(this, e.ToString());
                            return;
                        }
                    }
                    stateObjectDictionary.Clear();
                }
            }
            get { return active; }
        }
#endregion
#endregion

}
#region 成员函数 #region MainThread()
private void MainThread()
{
            byte[] bytes = new Byte[1024];            IPEndPoint localEndPoint = new IPEndPoint(0, this.port);            Socket listener = new Socket(AddressFamily.InterNetwork,SocketType.Stream, ProtocolType.Tcp );            try {
                listener.Bind(localEndPoint);
                listener.Listen(100);                while (active) {
                    mainDone.Reset();                    listener.BeginAccept(new AsyncCallback(AcceptCallback),listener);                    while (active)
                        if (mainDone.WaitOne(100, true))
                            break;
                }
                listener.Close();            } catch (Exception e) {
                if (OnError != null)
                    OnError(this, e.ToString());
            }
        }
#endregion #region AcceptCallback(IAsyncResult ar)
private void AcceptCallback(IAsyncResult ar)
{
            mainDone.Set();            Socket listener = (Socket) ar.AsyncState;
            Socket handler;
            try
            {
                handler = listener.EndAccept(ar);
            }
            catch { return; }            if (OnConnect != null)
                OnConnect(this, handler);

            StateObject state = new StateObject();            state.workSocket = handler;
            state.endPoint = (IPEndPoint) handler.RemoteEndPoint;
            stateObjectDictionary.Add(state, state.workSocket);
            //handler.BeginReceive( state.buffer, 0, StateObject.BufferSize, 0,new AsyncCallback(ReadCallback), state);
handler.BeginReceive( state.buffer, 0, 2048, 0,new AsyncCallback(ReadCallback), state);
        }
#endregion #region ReadCallback(IAsyncResult ar)
private void ReadCallback(IAsyncResult ar)
{
            String content = String.Empty;
            StateObject state = (StateObject) ar.AsyncState;
            Socket handler = state.workSocket;            int bytesRead = 0;
            try
            {
                bytesRead = handler.EndReceive(ar);
            }
            catch (SocketException)
            {
                // Connection closed by peer
                if (OnDisconnect != null)
                    OnDisconnect(this, state.endPoint);
                return;
            }
            catch (ObjectDisposedException)
            {
                // Connection closed by client
                if (OnDisconnect != null)
                    OnDisconnect(this, state.endPoint);
                return;
            }
            catch (Exception e)
            {
                if (OnError != null)
                    OnError(this, e.ToString());
                return;
            }            if (bytesRead > 0) {
                string data = Encoding.ASCII.GetString(state.buffer, 0, bytesRead);
                if (OnDataAvailable != null)
                    OnDataAvailable(this, handler, data);
                try
                {
                    handler.BeginReceive(state.buffer, 0, 2048, SocketFlags.None,new AsyncCallback(ReadCallback), state);
                }
                catch (Exception e)
                {
                    if (OnError != null)
                        OnError(this, e.Message);
                }
            }
            else
            {
                handler.Shutdown(SocketShutdown.Both);
handler.Close();
handler = null;

// Connection closed by peer
                if (OnDisconnect != null)
                    OnDisconnect(this, state.endPoint);
            }
        }
#endregion

#region Send(Socket handler, String data)
public void Send(Socket handler, String data)
{
            byte[] byteData = Encoding.ASCII.GetBytes(data);            handler.BeginSend(byteData, 0, byteData.Length, SocketFlags.None,new AsyncCallback(SendCallback), handler);
        }
#endregion #region SendCallback(IAsyncResult ar)
private void SendCallback(IAsyncResult ar)
{
            try {
                Socket handler = (Socket) ar.AsyncState;
                int bytesSent = handler.EndSend(ar);
                if (OnDataSent != null)
                    OnDataSent(this, handler);
            } catch (Exception e) {
                if (OnError != null)
                    OnError(this, e.ToString());
            }
        }
#endregion
#endregion #region class StateObject
public class StateObject
        {
            public Socket workSocket = null;
            public const int BufferSize = 2048;
            public byte[] buffer = new byte[BufferSize];
            public StringBuilder sb = new StringBuilder();
            public IPEndPoint endPoint;
        }
#endregion
    }

调试易

Socket.EndReceive的问题

解决方案 »