Socket服务端如何向多个客户端发送消息

[沧海1梦]

一个服务端向客户端发送消息的程序中，服务端能过与多个客户端建立连接，但是只能向一个客户端发送数据，并且当这个客户端关闭后，还是不能向其他客户端发送数据，代码如下，请大家帮忙看下

namespace SunCreate.Server
{
    using log4net;
    using MainFlowDemo;
    using Maticsoft.BLL;
    using Maticsoft.Model;
    using SunCreate.Common;
    using SunCreate.Database;
    using SunCreate.DBConfig;
    using System;
    using System.Collections.Generic;
    using System.Net;
    using System.Net.Sockets;
    using System.Text;
    using System.Threading;
    using System.Timers;

    public class CETCBackServer
    {
        private Maticsoft.BLL.USER_IP currentuserBll = new Maticsoft.BLL.USER_IP();
        private IPAddress ipaddress;
        private int ipPort;
        private static ILog log = LogManager.GetLogger(typeof(CETCBackServer));
        public static CETCBackServer main;
        private Maticsoft.BLL.MESSAGE messageBll = new Maticsoft.BLL.MESSAGE();
        private Maticsoft.Model.MESSAGE messageModel = new Maticsoft.Model.MESSAGE();
        private static ManualResetEvent myReset = new ManualResetEvent(false);
        private static object obj = new object();
        private Thread ServerThread;
        private Socket sockServer;
        private string str;
        private System.Timers.Timer time = new System.Timers.Timer();
        private Maticsoft.Model.USER_IP userModel = new Maticsoft.Model.USER_IP();
        private List<Maticsoft.Model.USER_IP> userModelList = new List<Maticsoft.Model.USER_IP>();

        public CETCBackServer()
        {
            log.Info("服务器初始化");
            DatabaseConfig.OracleConnectString = DBConfigClass.GetOracleConnectString();
            main = this;
            this.CETCBackServerInit();
        }

        public void AcceptLinkCallback(IAsyncResult ar)
        {
            Socket socket2 = ((Socket) ar.AsyncState).EndAccept(ar);
            StateObject state = new StateObject {
                workSocket = socket2
            };
            try
            {
                myReset.Set();
                socket2.BeginReceive(state.buffer, 0, 0xfa000, SocketFlags.None, new AsyncCallback(this.ReadLinkCallback), state);
            }
            catch (Exception exception)
            {
                log.Error(exception.Message.ToString());
            }
        }

        private void AnalysisLinkData(string recv, Socket handler)
        {
            log.Info((handler.RemoteEndPoint as IPEndPoint).Address.ToString() + ": " + recv);
            this.str = string.Empty;
            string[] strArray = recv.Split(new char[] { '|' });
            if ((strArray.Length >= 3) && (strArray[2] == "0"))
            {
                serverLinkClient client;
                StringBuilder builder = new StringBuilder("1=1");
                builder.Append(" AND USER_ID = '" + strArray[0] + "'");
                builder.Append(" AND USER_DOMAIN =  '" + strArray[1] + "'");
                List<Maticsoft.Model.USER_IP> modelList = this.currentuserBll.GetModelList(builder.ToString());
                if ((modelList == null) || (modelList.Count == 0))
                {
                    if (strArray[3] == "0")
                    {
                        this.userModel = new Maticsoft.Model.USER_IP();
                        this.userModel.ID = this.currentuserBll.GetMaxId();
                        this.userModel.USER_ID = strArray[0];
                        this.userModel.USER_DOMAIN = strArray[1];
                        this.userModel.TOUSER_IP = (handler.RemoteEndPoint as IPEndPoint).Address.ToString();
                        this.userModel.USER_PORT = new decimal?((handler.RemoteEndPoint as IPEndPoint).Port);
                        this.userModel.SYS_TIME = DateTime.Now.ToString();
                        this.currentuserBll.Add(this.userModel);
                        this.userModelList.Add(this.userModel);
                        client = new serverLinkClient(handler) {
                            CLIENTIPADDRESS = this.userModel.TOUSER_IP,
                            CLIENTPORT = this.userModel.USER_PORT.ToString(),
                            CLIENTTOUSERID = this.userModel.USER_ID
                        };
                        if (serverLinkClientGroup.CheckClient(this.userModel.TOUSER_IP + ":" + this.userModel.USER_PORT) == null)
                        {
                            serverLinkClientGroup.AddNewClient(client);
                            client.CLIENTIPADDRESS = (handler.RemoteEndPoint as IPEndPoint).Address.ToString();
                            client.CLIENTPORT = (handler.RemoteEndPoint as IPEndPoint).Port.ToString();
                        }
                    }
                }
                else if (modelList.Count == 1)
                {
                    modelList[0].TOUSER_IP = (handler.RemoteEndPoint as IPEndPoint).Address.ToString();
                    modelList[0].USER_PORT = new decimal?((handler.RemoteEndPoint as IPEndPoint).Port);
                    this.currentuserBll.Update(modelList[0]);
                    if (serverLinkClientGroup.CheckClient(modelList[0].TOUSER_IP + ":" + modelList[0].USER_PORT) == null)
                    {
                        client = new serverLinkClient(handler);
                        serverLinkClientGroup.AddNewClient(client);
                        client.CLIENTTOUSERID = strArray[0];
                        client.CLIENTIPADDRESS = (handler.RemoteEndPoint as IPEndPoint).Address.ToString();
                        client.CLIENTPORT = (handler.RemoteEndPoint as IPEndPoint).Port.ToString();
                    }
                }
            }
        }

        private void BeginDisconnectCallback(IAsyncResult ar)
        {
            StateObject asyncState = (StateObject) ar.AsyncState;
            asyncState.workSocket.EndDisconnect(ar);
            myReset.Set();
        }

        private void CETCBackServerInit()
        {
            try
            {
                this.userModelList = this.currentuserBll.GetModelList(" 1=1 ");
                string configString = ConfigHelper.GetConfigString("serverIp");
                this.ipaddress = IPAddress.Parse(configString);
                this.ipPort = ConfigHelper.GetConfigInt("serverPort");
                this.Run();
                log.Info("服务器已启动");
                this.time.Elapsed += new ElapsedEventHandler(this.time_Elapsed);
                this.time.Enabled = true;
                this.time.Interval = ConfigHelper.GetConfigInt("TIME");
            }
            catch (Exception exception)
            {
                log.Error(exception.Message.ToString());
            }
        }

        public void Dispose()
        {
            try
            {
                if (this.ServerThread.IsAlive)
                {
                    this.ServerThread.IsBackground = true;
                    this.ServerThread.Join(0x3e8);
                }
            }
            catch (Exception)
            {
            }
        }

        public static bool IPAddressValidate(string str)
        {
            string[] strArray = str.Split(new char[] { '.' });
            if (strArray.Length != 4)
            {
                return false;
            }
            foreach (string str2 in strArray)
            {
                try
                {
                    if ((int.Parse(str2) > 0xff) || (int.Parse(str2) < 0))
                    {
                        return false;
                    }
                }
                catch (Exception)
                {
                    return false;
                }
            }
            return true;
        }

        public void ReadLinkCallback(IAsyncResult ar)
        {
            StateObject asyncState = (StateObject)ar.AsyncState;//从异步state对象中获取state和socket对象.
            Socket workSocket = asyncState.workSocket;
            try
            {
                int count = workSocket.EndReceive(ar);//从客户socket读取数据，count为读取的长度。
                if (count > 0)
                {
                    lock (obj)
                    {
                        this.AnalysisLinkData(Encoding.Default.GetString(asyncState.buffer, 0, count), workSocket);
                    }
                    workSocket.BeginReceive(asyncState.buffer, 0, 0xfa000, SocketFlags.None, new AsyncCallback(this.ReadLinkCallback), asyncState);
                }
            }
            catch (Exception exception)
            {
                log.Error(exception.Message.ToString());
            }
        }

        public void Run()
        {
            this.ServerThread = new Thread(new ThreadStart(this.RunLink));
            this.ServerThread.IsBackground = true;
            this.ServerThread.Start();
        }

       

[沧海1梦]

 private void RunLink()
        {
            try
            {
                //bool flag;
                IPEndPoint localEP = new IPEndPoint(this.ipaddress, this.ipPort);
                this.sockServer = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);//地址族、 套接字类型和协议
                this.sockServer.Bind(localEP);
                this.sockServer.Listen(0x3e8);
                myReset.Reset();
                if (this.sockServer != null)
                {
                    this.sockServer.BeginAccept(new AsyncCallback(this.AcceptLinkCallback), this.sockServer);
                }
                myReset.WaitOne();
            }

            catch (Exception exception)
            {
                log.Error(exception.Message.ToString());
            }
        }

       
        public void Send(Socket handler, string data)
        {
            byte[] bytes = Encoding.Default.GetBytes(data);
            handler.BeginSend(bytes, 0, bytes.Length, SocketFlags.None, new AsyncCallback(this.SendCallback), handler);//开始发送数据给远程目标(数据bytes)，回调函数SendCallback。容器handler
        }

        public void SendCallback(IAsyncResult ar)
        {
            try
            {
                int num = ((Socket) ar.AsyncState).EndSend(ar);//完成数据的发送
            }
            catch (Exception exception)
            {
                log.Error(exception.Message.ToString());
            }
        }

        public void SendTestStatus(Socket handler)
        {
            try
            {
                byte[] bytes = Encoding.Default.GetBytes("");
                handler.BeginSend(bytes, 0, bytes.Length, SocketFlags.None, new AsyncCallback(this.SendCallback), handler);
            }
            catch (Exception)
            {
            }
        }

        private void time_Elapsed(object sender, ElapsedEventArgs e)
        {
            lock (obj)
            {
                StringBuilder builder = new StringBuilder("1=1");
                builder.Append(" AND STATUS = '0' ");
                List<Maticsoft.Model.MESSAGE> modelList = this.messageBll.GetModelList(builder.ToString());
                Console.WriteLine("count:" + serverLinkClientGroup.ClientGroup.Count);
                foreach (serverLinkClient client in serverLinkClientGroup.ClientGroup)
                {
                    foreach (Maticsoft.Model.MESSAGE message in modelList)
                    {
                        if (client.CLIENTTOUSERID == message.TO_USERID)
                        {
                            this.SendTestStatus(client.CLIENTSOCKET);
                            this.str = message.TO_USERID;
                            this.str = this.str + "|" + message.ID;
                            this.str = this.str + "|" + message.FROM_USERNAME;
                            this.str = this.str + "|" + message.TO_USERMANE;
                            this.str = this.str + "|" + message.WF_NAME;
                            this.str = this.str + "|" + message.SENDDATE;
                            this.str = this.str + "|" + message.WF_ID;
                            //message.STATUS = "1";
                            this.messageBll.Update(message);
                            this.Send(client.CLIENTSOCKET, this.str);
                            Thread.Sleep(0x3e8);

                            //if (client.CLIENTSOCKET.Connected)//error
                            //{
                            //    this.SendTestStatus(client.CLIENTSOCKET);
                            //    this.str = message.TO_USERID;
                            //    this.str = this.str + "|" + message.ID;
                            //    this.str = this.str + "|" + message.FROM_USERNAME;
                            //    this.str = this.str + "|" + message.TO_USERMANE;
                            //    this.str = this.str + "|" + message.WF_NAME;
                            //    this.str = this.str + "|" + message.SENDDATE;
                            //    this.str = this.str + "|" + message.WF_ID;
                            //    //message.STATUS = "1";
                            //    this.messageBll.Update(message);
                            //    this.Send(client.CLIENTSOCKET, this.str);
                            //    Thread.Sleep(0x3e8);
                            //}
                        }
                    }
                }
            }
        }     
    }
}

[以专业开发人员为伍]

谁知道你的 serverLinkClientGroup 是什么呢？

[沧海1梦]

引用 2 楼 sp1234 的回复:

谁知道你的 serverLinkClientGroup 是什么呢？

这是写的一个类

namespace MainFlowDemo
{
    using SunCreate.Server;
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Net.Sockets;

    public class serverLinkClientGroup
    {
        public static ArrayList ClientGroup = new ArrayList();
        private static object obj = new object();

        public static int AddNewClient(serverLinkClient client)
        {
            lock (obj)
            {
                ClientGroup.Add(client);
                return ClientGroup.Count;
            }
        }

        public static serverLinkClient CheckClient(string terminalID)
        {
            lock (obj)
            {
                int num;
                serverLinkClient client;
                string[] strArray = terminalID.Split(new char[] { ':' });
                string cLIENTIPADDRESS = strArray[0];
                string cLIENTPORT = strArray[1];
                List<serverLinkClient> list = new List<serverLinkClient>();
                for (num = 0; num < ClientGroup.Count; num++)
                {
                    client = (serverLinkClient) ClientGroup[num];
                    if ((client.CLIENTIPADDRESS + ":" + client.CLIENTPORT) == terminalID)
                    {
                        CETCBackServer.main.SendTestStatus(client.CLIENTSOCKET);
                        if (client.CLIENTSOCKET.Connected)
                        {
                            cLIENTIPADDRESS = client.CLIENTIPADDRESS;
                            cLIENTPORT = client.CLIENTPORT;
                            return client;
                        }
                        list.Add(client);
                        return null;
                    }
                }
                for (num = 0; num < ClientGroup.Count; num++)
                {
                    client = (serverLinkClient) ClientGroup[num];
                    if ((client.CLIENTIPADDRESS == cLIENTIPADDRESS) && (client.CLIENTPORT != cLIENTPORT))
                    {
                        list.Add(client);
                    }
                }
                foreach (serverLinkClient client2 in list)
                {
                    ClientGroup.Remove(client2);
                }
            }
            return null;
        }

        public static void RefreshSocket()
        {
            for (int i = 0; i < ClientGroup.Count; i++)
            {
                serverLinkClient client = (serverLinkClient) ClientGroup[i];
                if (client.CLIENTSOCKET.Poll(0x3e8, SelectMode.SelectRead))
                {
                    ClientGroup.Remove(ClientGroup[i]);
                }
            }
        }

        public static void RemoveAllClient()
        {
            for (int i = 0; i < ClientGroup.Count; i++)
            {
                ClientGroup.Remove(ClientGroup[i]);
            }
        }

        public static int RemoveClient(serverLinkClient client)
        {
            ClientGroup.Remove(client);
            return ClientGroup.Count;
        }
    }
}