关于使用 SOCKET 类的求助！！

Question

下面这个网址有一篇源码 " 基于事件的异步Socket(TCP连接方式)"
http://blog.csdn.net/yeerh/archive/2006/09/25/1280111.aspx我正学习SOCKET编程，这个已经封装的类不会使用，谁能帮我写上简单的 “向每个客户发送和接收文本 ”的使用例子，或者直接给我一个SOCKET服务器端的类（带使用例子），就马上给分，不过分不多了，我是新手，希望高手大哥们帮帮我，谢谢啦

Answer 1

饿有一个Socket类的聊天程序，要吗，要的话，中午贴上去

Answer 2

发一个我最近用过的。    public class TCPClient : StreamChannel
    {
        private Socket clientSocket;
        private IPEndPoint serverEndPoint;
        private ByteArrayCircBuffer bacbRecv;        private Thread tWaitForConnect;
        private Thread tRecving;        public ushort RawRecvBufferSize { get; set; }   //读取数据时的缓冲大小                public TCPClient(string name, string IP, string port, int bacbRecvSize)
            : base(name)
        {
            init(IP, port, bacbRecvSize);
        }        private void init(string IP, string port, int bacbRecvSize)
        {
            clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            serverEndPoint = new IPEndPoint(IPAddress.Parse(IP), Int32.Parse(port));            bacbRecv = new ByteArrayCircBuffer(bacbRecvSize);
            RawRecvBufferSize = 110;
        }        public override bool Connected
        {
            get
            {
                if (clientSocket != null)
                    return clientSocket.Connected;
                else
                    return false;
            }
        }        public override int Available
        {
            get
            {
                return bacbRecv.AvailableSize;
            }
        }        public override int DataSize
        {
            get
            {
                return bacbRecv.DataSize;
            }
        }        public override void Start()
        {
            Running = true;            //启动连接等待线程
            tWaitForConnect = new Thread(new ThreadStart(ConnectServer));
            tWaitForConnect.IsBackground = true;
            tWaitForConnect.Start();
            //启动接收数据的线程。读取数据至缓冲区。
            tRecving = new Thread(new ThreadStart(Receiving));
            tRecving.IsBackground = true;
            tRecving.Start();
        }        public override void Stop()
        {
            Running = false;            tWaitForConnect.Abort();
            tRecving.Abort();            tWaitForConnect.Join(1200);
            tRecving.Join(1200);            if (Connected)
            {
                try
                {
                    clientSocket.Close();
                }
                catch
                {
                }
            }
        }        public override int Send(byte[] buffer)
        {
            if (Connected)
            {
                lock (clientSocket)
                {
                    return clientSocket.Send(buffer);
                }
            }
            else
                return COMM_FAILURE;
        }        public override byte[] PullData(int c)
        {
            return bacbRecv.PullData(c);
        }        public override byte[] GetData(int c)
        {
            return bacbRecv.GetByteData(c);
        }        private void Recv()
        {
            if (Connected)
            {
                lock (clientSocket)
                {
                    byte[] buffer = new byte[this.RawRecvBufferSize];
                    if (clientSocket.Connected && clientSocket.Available > 0)
                    {
                        int k = clientSocket.Receive(buffer);
                        byte[] data = ByteArrayUtils.GetSubByteArray(buffer, 0, k);
                        int pushin = bacbRecv.PushData(data);
                    }
                }
            }
        }        private void Receiving()
        {
            while (Running)
            {
                Recv();
                Thread.Sleep(1000);
            }
        }        public void ConnectServer()
        {
            while (Running)
            {
                if (clientSocket != null && serverEndPoint != null)
                {
                    try
                    {
                        clientSocket.Connect(serverEndPoint);
                        if (this.Connected)
                        {
                            LogWriter.SLog(this, 1001, 1, System.Diagnostics.EventLogEntryType.Information, null, null);
                            break;
                        }
                    }
                    catch
                    {
                        //为了减少消息数量。此日志被屏蔽。  
                        //连接服务器失败
                        //LogWriter.SLInfoOnly(this, 1002, 1);
                    }
                    finally
                    {
                        Thread.Sleep(1000);
                    }
                }
                else
                {
                    break;
                }
            }
        }
    }

Answer 3

支持楼上。。但例子有问题。。RawRecvBufferSize没有限制啊。。没有仔细看。你这么只能传字符串吧。没有分包处理。

Answer 4

phy 这个是客户端呀，我只想要一个服务器端，而且要能接受多个客户端连接，最好就是我顶楼上那个网址的类的使用例子，谢谢你呀

Answer 5

这问题弄了几天了一直没有解决，都想哭了，非常感谢和感激 greystar 帮了我的大忙，大恩不言谢了，greystar大哥进来回贴的话，我把我的分都给他了过来广州的话，我一定请他吃饭。

Answer 6

另外开贴给分，这个贴就无满意答案结贴，不过也很感谢楼上的几位回复，但我答应 greystar 大哥把全部分都给他，楼上的几位大哥以后我有分了一定补给大家