即时信息交流

此即时交流系统分为服务器端和客户端，服务器端仅为新上线的用户提供在线用户列表，客户端与客户端之间完成其余的所有功能，真正实现了点对点的通讯。
一，架构说明

 

二，类库说明：

1， 枚举类（Command）：Login：登录；PersonalMessage：私聊；ClientList：在线用户列表；

Logout：下线

2， 发送的消息类(Message)：

 （1）,属性：Sender：发送者；Receiver：接受者；MessageCommand：命令；MessageDetail：消息的详细内容。

 （2），方法：GetRawMessage：把消息的详细信息序列化

3，描述客户端类（EndPoint）：

（1），属性：Name：姓名；Ksname：科室名称；Zyname：专业名称；IPAddress：IP地址；Port：监听的端口

（2），方法：SendMessage：发送消息。

4，客户端集合（EndPointCollection）

5，客户端处理受到消息类（ServerSocket）：详见代码。

三，主要代码：
1，Command类和Message类

public enum Command
    {
        Login            = 0,
        PersonalMessage    = 1,
        ClientList        = 2,
        Conference        = 3,
        Logout            = 4
    }
    public class Common
    {
        public const string ServerName    = "Server";
        public const string All            = "All";
        
    }
    public class Message
    {
        
        string strSender;
        string strReceiver;
        Command cmdMessageCommand;
        string strMessageDetail;

        public Message ()
        {

        }

        public Message (byte [] rawMessage)
        {
            string strRawStringMessage 
                = System.Text.Encoding.Default.GetString(rawMessage);            
            string [] strRawStringMessageArray
                = strRawStringMessage.Split(new char []{'|'});
            
            this.strSender            = strRawStringMessageArray[1];
            this.strReceiver        = strRawStringMessageArray[2];
            this.cmdMessageCommand    = (Command) Convert.ToInt32(strRawStringMessageArray[3]);
            this.MessageDetail        = strRawStringMessageArray[4];
        }

        public string Sender
        {
            get{ return strSender;}
            set{ strSender = value;}
        }

        public string Receiver
        {
            get{ return strReceiver;}
            set{ strReceiver = value;}
        }
        public Command MessageCommand
        {
            get{ return cmdMessageCommand ;}
            set{ cmdMessageCommand = value;}
        }
        public string MessageDetail
        {
            get{ return strMessageDetail ;}
            set{ strMessageDetail = value;}
        }        

        public byte [] GetRawMessage ()
        {
            System.Text.StringBuilder sbMessage 
                = new System.Text.StringBuilder ("nmds");
            sbMessage.Append("|");
            sbMessage.Append(strSender);
            sbMessage.Append("|");
            sbMessage.Append(strReceiver);
            sbMessage.Append("|");
            sbMessage.Append((int)cmdMessageCommand);
            sbMessage.Append("|");
            sbMessage.Append(strMessageDetail);
            sbMessage.Append("|");

            return System.Text.Encoding.Default.GetBytes(sbMessage.ToString());
        }

2，EndPoint类和EndPointCollection类

public class EndPoint
    {
        string strName;
        private string ks;
        private string zy;
        private string ipaddress;
        private int port;
        TcpClient tcpClient;//和本机连接的socket
        public EndPoint()
        {
            this.tcpClient=null;
        }
        public string Name 
        {
            get{return strName;}
            set{ this.strName = value;}            
        }
        public string Ksname
        {
            get
            {
            return this.ks;
            }
            set
            {
            this.ks=value;
            }
        }
        public string Zyname
        {
            get
            {
            return this.zy;
            }
            set
            {
            this.zy=value;
            }
        }

        public string IPAddress
        {
            get
            {
                return this.ipaddress;
            }
            set
            {
            this.ipaddress=value;
            }
        }
        public int Port
        {
            get
            {
            return this.port;
            }
            set
            {
            this.port=value;
            }
        }
            public TcpClient Socket
        {
            get{return tcpClient;}
            set{ this.tcpClient = value;}
        }
        private  void Connect()
        {
            this.tcpClient=new TcpClient();
            IPEndPoint iep=new IPEndPoint(System.Net.IPAddress.Parse(this.ipaddress),this.port);
            try
            {
                this.tcpClient.Connect(iep);
            }
            catch
            {
            throw new Exception("连接失败");
            }
                     
        }
        public void SendMessage (Message sendMessage,ref int errcode)
        {
            errcode=0;
            if(this.tcpClient==null)
            {
            //this.tcpClient.Close();
                try
                {
                    this.Connect();
                }
                catch
                {
                    errcode=1;
                    return;
                    
                }

                

            }
            try
            {

                NetworkStream stream = tcpClient.GetStream();
                stream.Write(sendMessage.GetRawMessage() , 0, sendMessage.GetRawMessage().Length);            
            }
            catch
            {
            errcode=2;
            }
        }
    }
    public class EndPointCollection: System.Collections.CollectionBase
    {
        public EndPointCollection()
        {
        }
        public EndPoint this[int index]
        {
            get {return (EndPoint) List[index];}
            set { List[index] = (EndPoint)value; }
        }
        public void Add (EndPoint client)
        {
            List.Add(client);
        }
        public void Remove (string clientName)
        {
            for (int i=0;i<List.Count;i++)
            {
                if (((EndPoint) List[i]).Name.Equals(clientName))
                {
                    List.Remove(List[i]);
                }
            }

        }
        public bool Contains (string name)
        {
            for (int i=0;i<List.Count;i++)
            {
                if (((EndPoint) List[i]).Name.Equals(name))
                {
                    return true;
                }
            }
            return false;
        }
    }

3,ServerSocket类：

public class SocketServer
    {
        
        private TcpListener listener;//本机的侦听器
        private IPAddress ipaAddress;//本级的ip地址
        private int iPort;//本机的侦听端口
        private string name;
        public delegate void ListenForMessageDelegate(EndPoint client) ;
        public delegate void ClientConnectedEventHandler (object sender, EndPoint  client);
        public delegate void ClientDisconnectingEventHandler (object sender, string clientName);
        public delegate void MessageReceivedEventHandler (object sender, Message clientMessage);
        public delegate void CommandReceivedEventHandler (object sender, ChatMessage commandMessage);

        public event ClientConnectedEventHandler ClientConnected;//和对方机器连接发生的事件
        public event ClientDisconnectingEventHandler ClientDisconnecting;//和对方机器断开发生的事件
        public event MessageReceivedEventHandler MessageReceived;//收到消息的事件
        public event CommandReceivedEventHandler CommandReceived;//client列表
  
        Thread thrListenForClients;
        
        ListenForMessageDelegate listenForMessageDelegate ;
        
            

        bool bListenForClients;
        SocketServer的构造函数#region SocketServer的构造函数
        public SocketServer(string ipAddress, string port,string strname)
        {
            ipaAddress    = IPAddress.Parse(ipAddress);
            iPort        = int.Parse(port);
            this.name=strname;

            IPEndPoint endPoint 
                = new IPEndPoint (ipaAddress, iPort);

            listener = new TcpListener (endPoint);
            listener.Start();
        }
        #endregion
        得到姓名#region 得到姓名
        public string Name
        {
            get
            {
                return this.name;
            }
        }
        #endregion
        得到本机的IP地址#region 得到本机的IP地址
        public IPAddress SocketIPAddress
        {
            get{return ipaAddress;}
        }
        #endregion
        得到本机的侦端口#region 得到本机的侦端口
        public int Port
        {
            get{return iPort;}
        }
        #endregion
        启动侦听器#region 启动侦听器
        public void Listen ()
        {
            thrListenForClients = new Thread (new ThreadStart(ListenForClients));
            thrListenForClients.Start();        
        }
        #endregion
        停止侦听#region 停止侦听
        public void Stop ()
        {
            listener.Stop();
            
            
        }
        #endregion
        侦听来自客户端的消息#region 侦听来自客户端的消息
        private void ListenForClients ()
        {
            bListenForClients = true;

            while (bListenForClients)
            {
                EndPoint acceptClient = new EndPoint ();
                try
                {                    
                    acceptClient.Socket = listener.AcceptTcpClient();
                    //this.ListenForMessages(acceptClient);
                    

                    listenForMessageDelegate 
                        = new ListenForMessageDelegate (ListenForMessages);

                    listenForMessageDelegate.BeginInvoke
                        (acceptClient, new AsyncCallback(ListenForMessagesCallback), "Completed");
                    

                }
                catch (Exception ee)
                {

                    // 
                    // Ang daya!
                      //
                    bListenForClients = false;
                    
                    
                }
            }
        }
        #endregion
        处理来自客户端的消息#region 处理来自客户端的消息
        private void ListenForMessages (EndPoint client)
        {
            
        
            while (true)
            {
                
                NetworkStream stream = client.Socket.GetStream();
                byte [] bytAcceptMessage = new byte [1024];
                stream.Read(bytAcceptMessage, 0, bytAcceptMessage.Length);
                if(bytAcceptMessage.Length>0)
                {
                    //stream.Flush();
                    //stream.Close();
                    Message message = new ChatLib.Message(bytAcceptMessage);
                    if (message.MessageCommand.Equals(Command.Login))
                    {
                        if (ClientConnected != null)
                        {
                            client.Name=message.Sender.Split(new char[]{'@'})[0];
                            client.IPAddress=message.Sender.Split(new char[]{'@'})[1];
                            client.Port=int.Parse(message.Sender.Split(new char[]{'@'})[2]);
                            client.Zyname=message.Sender.Split(new char[]{'@'})[3];
                            client.Ksname=message.Sender.Split(new char[]{'@'})[4];
//                             client.Socket.Close();
//                             client.Socket=null;
//                            
                            //client.Name    = message.Sender;
                        
                            ClientConnected(this, client);                                  
                        }
                    }
                    if (message.MessageCommand.Equals(Command.PersonalMessage)||
                        message.MessageCommand.Equals(Command.Conference)
                        )
                    {
                        if (MessageReceived != null)
                        {
                            
                            MessageReceived(this, message);
                        }
                    }
                    if (message.MessageCommand.Equals(Command.Logout))
                    {
                        if (ClientDisconnecting != null)
                        {
                            
                            string sender=message.Sender;
                            ClientDisconnecting(this, sender);
                        }
                    }
                    if (message.MessageCommand.Equals(Command.ClientList))
                    {
//                        client.Socket.Close();
//                        client.Socket=null;
                        CommandReceived(this, message );
                        //return;
                    }
                }
                
            }
        }
        #endregion
        连接客户端#region 连接客户端
        #endregion
        private void ListenForMessagesCallback (IAsyncResult ar)
        {
            listenForMessageDelegate.EndInvoke(ar);
        }    

        
        
        
        客户上线#region  客户上线
        public  void Login(TcpClient tcpClient)
        {
            ChatMessage loginMessage    = new ChatLib.Message ();
            loginMessage.Receiver        = ChatLib.Common.ServerName;;
            loginMessage.Sender            = this.name+"@"+this.ipaAddress+"@"+this.iPort.ToString();            
            loginMessage.MessageCommand    = ChatLib.Command.Login;
            NetworkStream stream    = tcpClient.GetStream();            
            byte [] bytRawMessage    = loginMessage.GetRawMessage();        
            stream.Write(bytRawMessage, 0, bytRawMessage.Length);
            
            
            
//            for(int i=0;i<epc.Count;i++)
//            {
//                loginMessage.Receiver        = epc[i].Name;
//                loginMessage.Sender            = this.name+"@"+this.ipaAddress+"@"+this.iPort.ToString();            
//                loginMessage.MessageCommand    = ChatLib.Command.Login;
//                NetworkStream stream    = tcpClient.GetStream();            
//                byte [] bytRawMessage    = loginMessage.GetRawMessage();        
//                stream.Write(bytRawMessage, 0, bytRawMessage.Length);
//                epc[i].SendMessage(loginMessage);
//            }
//            
            
        
        }
        #endregion
    }

详细代码:/Files/nethawker/Instance.rar