chatserver.cs

基于SOCKET的聊天室

				}
				catch(Exception ex)
				{
					this.rtbSocketMsg.AppendText(ex.Message.ToString()+ "\n");
				}
			}
		}

		private void tbSocketPort_TextChanged(object sender, System.EventArgs e)
		{
			this.btnSocketStart.Enabled = (this.tbSocketPort.Text != "");
		}


		private void btnSocketStop_Click(object sender, System.EventArgs e)
		{
			ClientSeverForm.SocketServiceFlag = false;
			this.btnSocketStart.Enabled = true;
			this.btnSocketStop.Enabled = false;
		}
		
		public void addUser(string username)
		{
			this.rtbSocketMsg.AppendText(username + " 已经加入\n");
		    //将刚连接的用户名加入到当前在线用户列表中
			this.lbSocketClients.Items.Add(username);
			this.tbSocketClientsNum.Text = System.Convert.ToString(clients.Count);
		}

		public void removeUser(string username)
		{
			this.rtbSocketMsg.AppendText(username + " 已经离开\n");
			//将刚连接的用户名加入到当前在线用户列表中
			this.lbSocketClients.Items.Remove(username);
			this.tbSocketClientsNum.Text = System.Convert.ToString(clients.Count);
		}
		
		public string GetUserList()
		{
			string Rtn="";
			for(int i=0;i<lbSocketClients.Items.Count;i++)
			{
				Rtn=Rtn+lbSocketClients.Items[i].ToString() + "|";
			}
			return Rtn;
		}

		public void updateUI(string msg)
		{
			this.rtbSocketMsg.AppendText(msg + "\n");
		}

		private void ClientSeverForm_Closing(object sender, System.ComponentModel.CancelEventArgs e)
		{
			ClientSeverForm.SocketServiceFlag = false;
		}
		
	}


	public class Client
	{
		private string name;
		private Socket currentSocket = null;
		private string ipAddress;
		private ClientSeverForm server;
		
		//保留当前连接的状态：
		//closed --> connected --> closed
		private string state = "closed";
		
		public Client(ClientSeverForm server, Socket clientSocket)
		{
			this.server = server;
			this.currentSocket = clientSocket;
			ipAddress = getRemoteIPAddress();
		}
		
		public string Name
		{
			get
			{
				return name;
			}
			set
			{
				name=value;
			}
		}
		public  Socket CurrentSocket
		{
			get
			{
				return currentSocket;
			}
			set
			{
				currentSocket=value;
			}
		}
		
		public  string IpAddress
		{
			get
			{
				return ipAddress;
			}
		}
		
		private string getRemoteIPAddress()
		{
			return ((IPEndPoint)currentSocket.RemoteEndPoint).
					Address.ToString();
		}

		//ServiceClient方法用于和客户端进行数据通信，包括接收客户端的请求，
		//根据不同的请求命令，执行相应的操作，并将处理结果返回到客户端
		public void ServiceClient()
		{
			string[] tokens=null;
			byte[] buff=new byte[1024];
			bool keepConnect=true;
			
			//用循环来不断地与客户端进行交互，直到客户端发出“EXIT”命令，
			//将keepConnect置为false，退出循环，关闭连接，并中止当前线程
			while(keepConnect && ClientSeverForm.SocketServiceFlag)
			{
				tokens = null;
				try
				{
					if (currentSocket == null ||
						currentSocket.Available < 1)
					{
						Thread.Sleep(300);
						continue;
					}

					//接收数据并存入buff数组中
					int len = currentSocket.Receive(buff);
					//将字符数组转化为字符串
					string clientCommand=System.Text.Encoding.Default.GetString(
						                                 buff, 0, len);
				
					//tokens[0]中保存了命令标志符（CONN、CHAT、PRIV、LIST或EXIT）
					tokens=clientCommand.Split(new Char[]{'|'});

					if (tokens == null) 
					{
						Thread.Sleep(200);
						continue;
					}
				} 
				catch(Exception e)
				{
					server.updateUI("发生异常："+ e.ToString());
				}
			

				if(tokens[0]=="CONN")
				{
					//此时接收到的命令格式为：
					//命令标志符（CONN）|发送者的用户名|，
					//tokens[1]中保存了发送者的用户名
					this.name = tokens[1];
					if (ClientSeverForm.clients.Contains(this.name))
					{
						SendToClient(this, "ERR|User " + this.name + " 已经存在");

					}
					else
					{
						Hashtable syncClients = Hashtable.Synchronized(
							ClientSeverForm.clients);
						syncClients.Add(this.name,this);

						//更新界面
						server.addUser(this.name);

					
						//对每一个当前在线的用户发送JOIN消息命令和LIST消息命令，
						//以此来更新客户端的当前在线用户列表
						System.Collections.IEnumerator myEnumerator = 
							ClientSeverForm.clients.Values.GetEnumerator();
						while (myEnumerator.MoveNext())
						{
							Client client = (Client)myEnumerator.Current;
							SendToClient(client, "JOIN|"+tokens[1]+"|");
							Thread.Sleep(100);
						}
						//更新状态
						state = "connected";	
						SendToClient(this, "ok");	

						//向客户端发送LIST命令，以此更新客户端的当前在线用户列表
						string msgUsers="LIST|"+server.GetUserList();
						SendToClient(this, msgUsers);
					}

				}
				else if(tokens[0]=="LIST")
				{
					if (state == "connnected")
					{
						//向客户端发送LIST命令，以此更新客户端的当前在线用户列表
						string msgUsers="LIST|"+server.GetUserList();
						SendToClient(this, msgUsers);
					}
					else
					{
						//send err to server
						SendToClient(this, "ERR|state error，Please login first");
					}
				}
				else if(tokens[0]=="CHAT")
				{
					if (state == "connected")
					{
						//此时接收到的命令的格式为：
						//命令标志符（CHAT）|发送者的用户名：发送内容|
						//向所有当前在线的用户转发此信息
						System.Collections.IEnumerator myEnumerator = 
							ClientSeverForm.clients.Values.GetEnumerator();
						while (myEnumerator.MoveNext())
						{
							Client client = (Client)myEnumerator.Current;
							//将“发送者的用户名：发送内容”转发给用户
							SendToClient(client, tokens[1]);
						}
						server.updateUI(tokens[1]);
					}
					else
					{
						//send err to server
						SendToClient(this, "ERR|state error，Please login first");
					}
				}
				else if(tokens[0]=="PRIV")
				{
					if (state == "connected")
					{
						//此时接收到的命令格式为：
						//命令标志符（PRIV）|发送者用户名|接收者用户名|发送内容|
						//tokens[1]中保存了发送者的用户名
						string sender=tokens[1];
						//tokens[2]中保存了接收者的用户名
						string receiver=tokens[2];
						//tokens[3]中保存了发送的内容
						string content=tokens[3];
						string message=sender+" ---> "+receiver+":  " + content;
						
						//仅将信息转发给发送者和接收者
						if (ClientSeverForm.clients.Contains(sender))
						{
							SendToClient(
								(Client)ClientSeverForm.clients[sender], message);
						}
						if (ClientSeverForm.clients.Contains(receiver))
						{
							SendToClient(
								(Client)ClientSeverForm.clients[receiver], message);
						}
						server.updateUI(message);
					}
					else
					{
						//send err to server
						SendToClient(this, "ERR|state error，Please login first");
					}
				}
				else if(tokens[0]=="EXIT")
				{
					//此时接收到的命令的格式为：命令标志符（EXIT）|发送者的用户名
					//向所有当前在线的用户发送该用户已离开的信息
					if (ClientSeverForm.clients.Contains(tokens[1]))
					{
						Client client = (Client)ClientSeverForm.clients[tokens[1]];

						//将该用户对应的Client对象从clients中删除
						Hashtable syncClients = Hashtable.Synchronized(
							ClientSeverForm.clients);
						syncClients.Remove(client.name);
						server.removeUser(client.name);

						//向客户端发送QUIT命令
						string message="QUIT|" + tokens[1];
							
						System.Collections.IEnumerator myEnumerator = 
							ClientSeverForm.clients.Values.GetEnumerator();
						while (myEnumerator.MoveNext())
						{
							Client c = (Client)myEnumerator.Current;
							SendToClient(c, message);
						}
						server.updateUI("QUIT");
					}

					//退出当前线程
					break;
				}
				Thread.Sleep(200);
			}
		}
		
		//SendToClient()方法实现了向客户端发送命令请求的功能
		private void SendToClient(Client client, string msg)
		{
			System.Byte[] message=System.Text.Encoding.Default.GetBytes(
					msg.ToCharArray());
			client.CurrentSocket.Send(message,message.Length,0);
		}			
				
	}
		
}