关于c# socket编程--实现一个服务器对500个用户同时长期在线接收发送数据

Question

先自己定义一些命令,用来标记信息的功能.接着
如果用udp实现,那就建一个表来保存客户端的信息,用来转发;
如果用tcp实现,那就直接保存socket表,用来转发

Answer 1

CS的？有C#的异步通讯的类的
http://dev.rdxx.com/NET/CSharp/2004-1/30/09053145.shtml，考下来，看下他的例子程序，就可以用了，
我用过的

Answer 2

to：zcygo，是cs的，而且要长期在线发送和接受消息
我试试看，再上来请教，谢谢、
谢谢各位

Answer 3

我和楼主一样啊~~~惨啊~~~~~LZ找到程序后能发一个给我吗
[email protected]

Answer 4

这么都没有人回答呢
实在是搞不定，惨了，大家帮帮忙啊
我写的代码这么运行的时候老是会不断消耗内存
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Net;
using System.Net.Sockets;
using System.Threading;namespace server
{
    public partial class server : Form
    {
        public server()
        {
            InitializeComponent();
        }        private void server_Load(object sender, EventArgs e)
        {
            IPAddress[] addresslist = Dns.GetHostByName(Dns.GetHostName()).AddressList;
            txtbox_ServIP.Text = addresslist[0].ToString();
            txtbox_ServPort.Text = "2000";
        }
        // Thread signal.
        public static ManualResetEvent allDone = new ManualResetEvent(false);
        private void btn_listen_Click(object sender, EventArgs e)
        {
            lstbox_status.Items.Add("开始监听……");
            btn_start.Enabled = false;
            ThreadStart listenThreadStart = new ThreadStart(StartListening);
            Thread listenThread = new Thread(listenThreadStart);
            listenThread.Name = "listenThread";
            listenThread.Start(); //starting the thread
        }
        public void StartListening()
        {
            // Data buffer for incoming data.
            byte[] bytes = new Byte[1024];            // Establish the local endpoint for the socket.
            // The DNS name of the computer
            // running the listener is "host.contoso.com".
            //IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName());
            //IPAddress ipAddress = ipHostInfo.AddressList[0];
            IPAddress ipAddress = IPAddress.Parse(txtbox_ServIP.Text);
            IPEndPoint localEndPoint = new IPEndPoint(ipAddress,Convert.ToInt16(txtbox_ServPort.Text));
            // Create a TCP/IP socket.
            Socket listener = new Socket(AddressFamily.InterNetwork,SocketType.Stream, ProtocolType.Tcp);            // Bind the socket to the local endpoint and listen for incoming connections.
            try
            {
                listener.Bind(localEndPoint);
                listener.Listen(10000);
                while (true)
                {
                    // Set the event to nonsignaled state.
                    //allDone.Reset();                    // Start an asynchronous socket to listen for connections.
                    //lstbox_status.Items.Add("Waiting for a connection...");
                    listener.BeginAccept(new AsyncCallback(AcceptCallback),listener);                    // Wait until a connection is made before continuing.
                    //allDone.WaitOne();
                }            }
            catch (Exception e)
            {
                MessageBox.Show(e.ToString());
            }
        }
        public static void AcceptWorkThread(IAsyncResult ar)
        {
            Socket listener = (Socket)ar.AsyncState;
            while (true)
            {
                // Set the event to nonsignaled state.
                allDone.Reset();
                // Start an asynchronous socket to listen for connections.
                //Console.WriteLine("Waiting for a connection...");
                listener.BeginAccept(new AsyncCallback(AcceptCallback), listener);
                // Wait until a connection is made before continuing.
                allDone.WaitOne();
            }
        }
        public static void AcceptCallback(IAsyncResult ar)
        {
            // Signal the main thread to continue.
            allDone.Set();
            // Get the socket that handles the client request.
            Socket listener = (Socket)ar.AsyncState;
            Socket handler = listener.EndAccept(ar);
            // Create the state object.
            StateObject state = new StateObject();
            state.workSocket = handler;
            handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,new AsyncCallback(ReadCallback),state);
        }
        public static void ReadCallback(IAsyncResult ar)
        {
            String content = String.Empty;
            // Retrieve the state object and the handler socket
            // from the asynchronous state object.
            StateObject state = (StateObject)ar.AsyncState;
            Socket handler = state.workSocket;
            // Read data from the client socket. 
            int bytesRead = handler.EndReceive(ar);
            if (bytesRead > 0)
            {
                // There   might be more data, so store the data received so far.
                state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));
                // Check for end-of-file tag. If it is not there, read 
                // more data.
                content = state.sb.ToString();
                if (content.IndexOf("<EOF>") > -1)
                {
                    // All the data has been read from the 
                    // client. Display it on the console.
                    //Console.WriteLine("Read {0} bytes from socket. \n Data : {1}",content.Length, content);
                    // Echo the data back to the client.
                    Send(handler, content);
                }
                else
                {
                    Console.WriteLine(content);
                    // Not all data received. Get more.
                    handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,new AsyncCallback(ReadCallback), state);
                }
            }
        }
        private static void Send(Socket handler, String data)
        {
            // Convert the string data to byte data using ASCII encoding.
            byte[] byteData = Encoding.ASCII.GetBytes(data);
            // Begin sending the data to the remote device.
            handler.BeginSend(byteData, 0, byteData.Length, 0,new AsyncCallback(SendCallback), handler);
        }
        private static void SendCallback(IAsyncResult ar)
        {
            try
            {
                // Retrieve the socket from the state object.
                Socket handler = (Socket)ar.AsyncState;
                // Complete sending the data to the remote device.
                int bytesSent = handler.EndSend(ar);
                Console.WriteLine("Sent {0} bytes to client.", bytesSent);
                handler.Shutdown(SocketShutdown.Both);
                handler.Close();
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
            }
        }        private void btn_stop_Click(object sender, EventArgs e)
        {
            btn_start.Enabled = true;
        }  
    }
    public class StateObject
    {
        // Client   socket.
        public Socket workSocket = null;
        // Size of receive buffer.
        public const int BufferSize = 1024;
        // Receive buffer.
        public byte[] buffer = new byte[BufferSize];
        // Received data string.
        public StringBuilder sb = new StringBuilder();
    }
}