[unity3d]unity聊天功能

最新推荐文章于 2023-02-01 12:34:43 发布
最新推荐文章于 2023-02-01 12:34:43 发布
阅读量7.7k 收藏 13
点赞数 5
分类专栏： Unity3D
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dingxiaowei2013/article/details/17189393
版权

感觉之前的聊天功能可能有一些缺陷，今天收到书华兄的启发，发表一些感慨，C# .net高手跟新手的区别就是，新手仅仅满足功能上的实现，而很少去考虑性能上的问题，比如高并发怎么处理，打个比方，新手做完聊天功能之后，会沾沾自喜，而不考虑最大客户连接有多少，做个实验，如果连续有四个左右的客户端同时连接到服务器端，服务器就要消耗将近200M的内存，这时机器可怕的事情，如果不做处理的话，假设几百人去连接，估计服务器端就要崩溃了，还有一点高手喜欢写封装，将功能进行高度封装给新手用，新手用完了人家封装的类库，然后简单代码就实现功能了，也会沾沾自喜，津津乐道，这样就会止步不前！用了一下封装的类库来写unity聊天客户端果真非常快，几行代码就搞定！

unity客户端：

UI:

using UnityEngine;
using System.Collections;

public class chart : MonoBehaviour {

	string txtmsg = "";
	public string txtServer = "192.168.1.24";
	string txtLog = "";
	public string txtPort = "50000";
	ClientLibrary.Client client;
	ClientLibrary.Model model = new ClientLibrary.Model();
	// Use this for initialization
	void Start () {
	
	}

	bool flag = true;
	// Update is called once per frame
	void Update () {
		if(client.HeartDataSend()!=1)
		{
			SetTxt("请检查网络你已经掉线，可能原因服务器出错，请重新连接");
			client.KillSocket();
			flag = false;
		}
	}

	void OnGUI()
	{
		txtServer = GUI.TextField(new Rect(10f,20f,100f,20f),txtServer);
		txtLog = GUI.TextField (new Rect(50f,40f,200f,200f),txtLog);
		if(GUI.Button(new Rect(120f,20f,50f,20f),"start")&&flag)
		{
			model.TxtServer = txtServer;
			model.TxtPort = txtPort;
			bool enable;
			client = new ClientLibrary.Client(model,SetTxt,out enable);
			if(enable)
			{
				//txtLog = "123";
			}
			else
			{
				//txtLog = "no";
			}
			flag = false;
		}
	}
	void SetTxt(string msg)
	{
		txtLog+=msg+"\r\n";
	}
}

ChatClient: 

using System.Net.Sockets;
using System.Text;
using System.Threading;

namespace ClientLibrary
{
    #region 委托
    /// <summary>
    /// 信息显示委托
    /// </summary>
    /// <param name="msg">需要打印到前台的信息</param>
    public delegate void deMessageShow(string msg);
    /// <summary>
    /// 文件保存委托
    /// </summary>
    /// <param name="buffer">保存的文件数据</param>
    /// <param name="count">文件大小</param>
    /// <returns></returns>
    public delegate bool deGetFileStream(byte[] buffer,int count);
    /// <summary>
    /// 客户端震动 委托
    /// </summary>
    public delegate void deZD();
    #endregion
    /// <summary>
    /// 客户端实体类
    /// </summary>
    public class Model
    {
        private string txtMsg;

        public string TxtMsg
        {
            get { return txtMsg; }
            set { txtMsg = value; }
        }
        private string txtPort;

        public string TxtPort
        {
            get { return txtPort; }
            set { txtPort = value; }
        }
       private string txtServer;

        public string TxtServer
        {
            get { return txtServer; }
            set { txtServer = value; }
        }
    }
    /// <summary>
    /// 客户端方法类
    /// </summary>
    public class Client
    {
        public Client(Model model,deMessageShow messageShowFun,out bool enable)
        {
            messageShow = messageShowFun;
            lastTimeRecive = DateTime.Now;
            if (CreateClientSocket(model)) //创建Socket
            {
                enable = true;
                return;
            }
            enable = false;     
        }
        public Client(Model model, deMessageShow message, deGetFileStream saveFileFun, out bool enable)
        {
            messageShow = message;
            getFileStream = saveFileFun;
            lastTimeRecive = DateTime.Now;
             if (CreateClientSocket(model))//创建Socket
            {
                enable = true;
                return;
            }
             enable = false;
        }
        public Client(Model model, deMessageShow message, deGetFileStream saveFileFun, deZD zdFun, out bool enable)
        {
            messageShow = message;
            getFileStream = saveFileFun;
            lastTimeRecive = DateTime.Now;
              if (!CreateClientSocket(model)) //创建Socket
            {
                enable = true;
                return;
            }
              enable = false;
        }
        Model model = new Model();
        /// <summary>
        ///  通信Scoket
        /// </summary>
        Socket connSocket;
        /// <summary>
        /// 通信线程
        /// </summary>
        Thread thmsg;
        /// <summary>
        /// 最后一次接受数据时间
        /// </summary>
        public DateTime lastTimeRecive;
        /// <summary>
        /// 最后一次发送数据时间
        /// </summary>
        public DateTime lastTimeSend;
        #region 声明委托
     public   deMessageShow messageShow;
      public  deGetFileStream getFileStream;
     public   deZD zD;
        #endregion

        /// <summary>
        /// 创建客户端Socket
        /// </summary>
        /// <param name="ModelUI"></param>
        /// <returns>创建状态</returns>
        public bool CreateClientSocket(Model ModelUI)
        {
            model = ModelUI;
            bool enabel = false; 
            //服务器IP
            IPAddress ipServer = IPAddress.Parse(model.TxtServer);
            //创建 终端地址
            IPEndPoint endPointServer = new IPEndPoint(ipServer, int.Parse(model.TxtPort));
            //创建 连接socket connSocket
           connSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            try
            {
                connSocket.Connect(endPointServer);
                messageShow("登陆成功");
                #region  创建接受信息的线程
                thmsg = new Thread(ReciveMsg);
                thmsg.IsBackground = true;
                thmsg.Start();
                #endregion
            }
            catch (Exception ex)
            {
                messageShow(ex.Message);
               enabel= true;
            }
            return enabel;
        }

        /// <summary>
        /// 信息接收
        /// </summary>
        private void ReciveMsg()
        {
            //0 文字 1 文件 2 震动
            byte[] buffer = new byte[5 * 1024 * 1024];
            while (true)
            {
                int count = connSocket.Receive(buffer);
                int flag = buffer[0];
                if (count == 0)
                {
                    connSocket.Close();
                    messageShow("你掉线或者服务器关系");
                    break;
                }
                Recive(buffer, count, flag);
            }
        }

        #region 必要方法
        #region 接收+Recive(byte[] buffer, int count,int flag)
        /// <summary>
        /// 处理接受的信息
        /// </summary>
        /// <param name="buffer"></param>
        /// <param name="count"></param>
        /// <param name="flag"></param>
        private void Recive(byte[] buffer, int count, int flag)
        {
            if (flag == 0)
            {
                #region flag=0 文字信息
                string msg = Encoding.UTF8.GetString(buffer, 1, count - 1);
                messageShow("服务器 : " + msg);
                #endregion
            }
            else if (flag == 1)
            {
                #region flag=1 传送文件
                if (getFileStream(buffer,count))
                {
                    messageShow("接受完成");
                }           
                #endregion
            }
            else if (flag == 2)
            {
                #region flag=2 震动
                zD();
                #endregion
            }
            else if (flag == 3)
            {
                string atat=Encoding.UTF8.GetString(buffer,1,count-1);
                if (atat == "ATAT")
                {
                    lastTimeRecive = DateTime.Now;
                }
            }
        }


        #endregion
        /// <summary>
        /// 发送心跳包
        /// </summary>
        /// <returns>发送状态</returns>
        public int HeartDataSend()
        {
            lastTimeSend = DateTime.Now;
            if (DateTime.Now.Second - lastTimeRecive.Second > 3)
            {
                return 3;
            }
            if (connSocket != null && connSocket.Connected)
            {
                try
                {
                    byte[] buffer = Encoding.UTF8.GetBytes("NTNT");
                    connSocket.Send(buffer);
                    lastTimeRecive = DateTime.Now;
                    return 1;
                }
                catch (Exception ex)
                {
                   // messageShow(ex.Message);
                    return 2;
                }
            }
            return 1;
        }
        /// <summary>
        /// 数据发送
        /// </summary>
        /// <returns></returns>
        public bool Send()
        {
            if (connSocket != null && connSocket.Connected)
            {
                try
                {
                    byte[] buffer = new byte[1024 * 1024 * 5];
                    buffer = Encoding.UTF8.GetBytes(model.TxtMsg);
                    connSocket.Send(buffer);
                    lastTimeRecive = DateTime.Now;
                    return true;
                }
                catch (Exception ex)
                {
                    messageShow(ex.Message);
                    return false;
                }
            }
            return false;
        }

        /// <summary>
        /// 终止连接
        /// </summary>
        public void KillSocket()
        {
            if (thmsg != null)
            {
                thmsg.Abort();
            }
            if (connSocket != null && connSocket.Connected)
            {
                connSocket.Shutdown(SocketShutdown.Both);
                connSocket.Close();
            }
        }
        #endregion
    }
}

服务器端：

Server：

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;

namespace ServerChatClass
{
    #region 委托
    /// <summary>
    /// 信息显示委托
    /// </summary>
    /// <param name="msg">需要打印到前台的信息</param>
    public delegate void deMessageShow(string msg);
    /// <summary>
    /// 注册客户端ednpoing和Socket,Thread
    /// </summary>
    /// <param name="endpoing">注册地址</param>
    public delegate void deRegisterClientIP(string endpoing);
    /// <summary>
    /// 从UI上移除客户端显示
    /// </summary>
    /// <param name="endpoing">客户端地址或者名称</param>
    public delegate void deRemoveClientIPFromUI(string endpoing);
    #endregion
    /// <summary>
    /// 实体类
    /// </summary>
    public class Model
    {
        private string txtMsg;
        private string txtPath;

        private string txtLog;
        private string txtServer;
        private string txtPort;

        private string clientEndPoint;
        /// <summary>
        /// 客户端地址
        /// </summary>
        public string ClientEndPoint
        {
            get { return clientEndPoint; }
            set { clientEndPoint = value; }
        }
        /// <summary>
        /// 端口
        /// </summary>
        public string TxtPort
        {
            get { return txtPort; }
            set { txtPort = value; }
        }
        /// <summary>
        /// IP
        /// </summary>
        public string TxtServer
        {
            get { return txtServer; }
            set { txtServer = value; }
        }
        /// <summary>
        /// 日志
        /// </summary>
        public string TxtLog
        {
            get { return txtLog; }
            set { txtLog = value; }
        }
        /// <summary>
        /// 文件地址
        /// </summary>
        public string TxtPath
        {
            get { return txtPath; }
            set { txtPath = value; }
        }
        /// <summary>
        /// 消息文字发送
        /// </summary>
        public string TxtMsg
        {
            get { return txtMsg; }
            set { txtMsg = value; }
        }

    }
    public class Request
    {
        public Request(string msg)
        {
            if (msg.Length < 100)
            { return; }
            try
            {
                string[] lines = msg.Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
                string firstLine = lines[0];
                string[] array = firstLine.Split(' ');
                method = array[0];
                url = array[1];
            }
            catch (Exception)
            {

            }

        }
        private string method;
        public string Method
        {
            get { return method; }
            set { method = value; }
        }
        private string url;
        public string Url
        {
            get { return url; }
            set { url = value; }
        }
    }
    public class SeverChar
    {

        #region 客户机注册字典
        /// <summary>
        /// 客户端地址clientIP和对应最后一次通信时间
        /// </summary>
        public Dictionary<string, DateTime> dicListTimeConnSocket = new Dictionary<string, DateTime>();
        /// <summary>
        /// 客户端地址clinetIP和对应的通信Socket
        /// </summary>
        public Dictionary<string, Socket> dicConnSocket = new Dictionary<string, Socket>();
        /// <summary>
        /// 客户端地址clientIP和对应通信线程ThreadMsg
        /// </summary>
        public Dictionary<string, Thread> dicThreadMsg = new Dictionary<string, Thread>();
        #endregion
        #region 委托声明
        /// <summary>
        /// 消息显示
        /// </summary>
        public deMessageShow messageShow;
        /// <summary>
        /// 注册客户机
        /// </summary>
        public deRegisterClientIP registerClientIP;
        /// <summary>
        /// 从UI上移除客户端显示
        /// </summary>
        public deRemoveClientIPFromUI removeClientIPFromUI;
        #endregion
        /// <summary>
        /// 初始化程序
        /// </summary>
        /// <param name="downline">掉线信息</param>

        public SeverChar(string msg,Model model, deMessageShow messageShowFun, string downline, out bool enable)
        {
            messageShow = messageShowFun;
            if (CreateServerMonitorSorcket(model,msg)) //创建Socket
            {
                enable = true;
            }
            else
            {
                enable = false;
            }
        }
        public SeverChar(string msg,Model model, deMessageShow messageShowFun,deRegisterClientIP registerClientIPFun ,string downline, out bool enable)
        {
            registerClientIP = registerClientIPFun;
            messageShow = messageShowFun;
            if (CreateServerMonitorSorcket(model, msg))//创建Socket
            {
                enable = true;
            }
            else
            {
                enable = false;
            }
        }
        public SeverChar(string msg,Model model, deMessageShow messageShowFun, deRegisterClientIP registerClientIPFun, deRemoveClientIPFromUI removerClientIPFormUIFun,string downline, out bool enable)
        {
            removeClientIPFromUI = removerClientIPFormUIFun;
            registerClientIP = registerClientIPFun;
            messageShow = messageShowFun;
            if (CreateServerMonitorSorcket(model, msg)) //创建Socket
            {
                enable = true;
            }
            else
            {
                enable=false;
            }
        }
        public SeverChar(string downline)
        {
            downLine = downline;
        }
        /// <summary>
        /// 需要发送请求的通信Socket
        /// </summary>
        public List<Socket> listSendConnSocket = new List<Socket>();
        /// <summary>
        /// 掉线信息提示
        /// </summary>
        public string downLine;
        Socket socketServer;//监听socket
        Model modelSever = new Model();
        object o = new object();

        #region 创建监听的socket socketServer+public bool CreateServerMonitorSorcket(Model model, string msg)
        /// <summary>
        /// 服务器创建监听的socket socketServer
        /// </summary>
        /// <param name="model">监听实体，包含监听端口和IP</param>
        /// <param name="msg">监听成功后显示的信息</param>
        /// <returns></returns>
        public bool CreateServerMonitorSorcket(Model model, string msg)
        {
            modelSever = model;
            bool enable;
            Socket socketServer = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            #  region 其他测试
            //IPHostEntry host = new IPHostEntry();
            //host.
            #endregion
            //Ip地址
            IPAddress ipServer = IPAddress.Parse(model.TxtServer);
            //ip地址和端口
            IPEndPoint endPointServer = new IPEndPoint(ipServer, int.Parse(model.TxtPort));
            try
            {
                //绑定网络端点
                socketServer.Bind(endPointServer);
                //设置排队长度
                socketServer.Listen(10);
                messageShow(msg);
                #region 用连接连接线程ThreadConnSockt  创建通信Socket 防止阻塞卡死+Listen(object)
                Thread threadConnSocket = new Thread(Listen);
                threadConnSocket.Name = "conn";
                threadConnSocket.IsBackground = true;
                threadConnSocket.Start(socketServer);
                #endregion
                enable = true;
            }
            catch (Exception ex)
            {
                messageShow(ex.Message);
                enable = false;
            }
            return enable;
        }
        #endregion

        #region 创建服务端通信Socket  connSocket单线程会阻塞窗体运行+Listen(object)
        /// <summary>
        /// 创建通信Socket
        /// </summary>
        /// <param name="socket"></param>
        public void Listen(object socket)
        {
            socketServer = socket as Socket;
            while (true)
            {
                Socket connSocket = socketServer.Accept();//阻塞等待 客户端连接
                string clinetEndPing = connSocket.RemoteEndPoint.ToString();//获取客户端通信地址
                messageShow(clinetEndPing+"登陆");
                #region 新建通信监听线程threadMsg 接收客户端发送过来的信息
                Thread threadMsg = new Thread(ReciveMsg);             
                threadMsg.Name = "msg";
                threadMsg.IsBackground = true;
                threadMsg.Start(connSocket);
                RegisterClientAtSever(clinetEndPing, threadMsg, connSocket);
                #endregion
            }
        }
        #endregion
        #region 接收客户端发送的信息 ReciveMsg(object socket)
        /// <summary>
        /// 接收客户端发送的信息 方法
        /// </summary>
        /// <param name="socket">发送信息的socket</param>
        public void ReciveMsg(object socket)
        {
            Socket connSocket = socket as Socket;
            string clineteEndPoint = connSocket.RemoteEndPoint.ToString();
            byte[] buffer = new byte[1024 * 1024 * 5];
            while (true)
            {
                int count = connSocket.Receive(buffer);//阻塞等待输入 当count=0 说明连接关闭
                if (count == 0)
                {
                    dicConnSocket[clineteEndPoint].Close();
                    messageShow(clineteEndPoint + downLine);
                    RemoveClient(clineteEndPoint);
                }
                dicListTimeConnSocket[clineteEndPoint] = DateTime.Now;//有消息传入
                #region 协议解析
                string ntnt = Encoding.UTF8.GetString(buffer, 0, 4);
                if (ntnt != "NTNT")//不是心跳报就显示
                {
                    string msg = Encoding.UTF8.GetString(buffer, 0, count);
                    messageShow(clineteEndPoint + " : \r\n      " + msg);
                }
                #endregion
                else
                {
                    lock (o)
                    {
                        List<Socket> listSendConnSocket = new List<Socket>();
                        listSendConnSocket.Add(dicConnSocket[clineteEndPoint]);
                        SendStreamFunction(listSendConnSocket, 3, modelSever);
                        listSendConnSocket.Clear();
                    }
                }
            }
        }
        #endregion

        #region 发送方法+public void SendStreamFunction(List<Socket> listSendConnSocket, int flag, Model model)
        /// <summary>
        /// 发送方法
        /// </summary>
        /// <param name="listSendConnSocket"></param>
        /// <param name="flag"></param>
        /// <param name="model"></param>
        public void SendStreamFunction(List<Socket> listSendConnSocket, int flag, Model model, params byte[] buffersend)
        {
            if (listSendConnSocket.Count > 0)
            {
                List<byte> list = new List<byte>();
                if (flag == 0)
                {
                    byte[] buffer = new byte[5 * 1024 * 1024];
                    buffer = Encoding.UTF8.GetBytes(model.TxtMsg);
                    list.Add(0);//协议 0 文字
                    list.AddRange(buffer);
                }
                else if (flag == 1)
                {
                    if (model.TxtPath != null)
                    {
                        using (FileStream fs = new FileStream(model.TxtPath, FileMode.Open, FileAccess.Read))
                        {
                            byte[] buffer = new byte[fs.Length];
                            fs.Read(buffer, 0, buffer.Length);
                            list.Add(1);//协议 1 文件
                            list.AddRange(buffer);
                        }
                    }
                }
                else if (flag == 2)
                {
                    list.Add(2);
                }
                else if (flag == 3)//没有收到任何通信的协议 一定时间  协议3
                {
                    byte[] buffer = Encoding.UTF8.GetBytes("ATAT");//NTNT心跳报
                    list.Add(3);
                    list.AddRange(buffer);
                }
                else if (flag == 4)
                {
                    if (buffersend != null)
                    {
                        list.AddRange(buffersend);
                    }
                }
                foreach (Socket item in listSendConnSocket)
                {
                    item.Send(list.ToArray());
                }
            }

        }
        #endregion

        #region 定时检测方法+public  void Timer()
        /// <summary>
        /// 定时检测通信状态
        /// </summary>
        public void Timer()
        {
            int index = 0;
            Dictionary<int, string> dic = new Dictionary<int, string>();
            foreach (KeyValuePair<string, DateTime> item in dicListTimeConnSocket)
            {
                dic.Add(index, item.Key);
                index++;
            }
            DateTime timeNow = DateTime.Now;
            for (int i = 0; i < dicListTimeConnSocket.Count; i++)
            {
                if (timeNow.Second - dicListTimeConnSocket[dic[i]].Second > 3)
                {
                    RemoveClient(dic[i]);
                }
            }

        }
        #endregion

        #region 客户端在服务器注册+public void RegisterClientAtSever(string endPoint, Thread threadMsg, Socket connSocket)
        /// <summary>
        /// 客户端注册
        /// </summary>
        /// <param name="endPoint">客户端地址</param>
        /// <param name="threadMsg">通信线程</param>
        /// <param name="connSocket">通信Socket</param>
        public void RegisterClientAtSever(string endPoint, Thread threadMsg, Socket connSocket)
        {
            dicThreadMsg.Add(endPoint, threadMsg);
            dicConnSocket.Add(endPoint, connSocket);
            modelSever.ClientEndPoint = endPoint;
            if (registerClientIP != null)
            {
                registerClientIP(endPoint);//注册显示到 用户UI上 通过委托 registerClientIP
            }
        }
        #endregion
        #region 从服务器注销客户端连接+RemoveClient(string clinetEndPoint)
        /// <summary>
        /// 从服务器注销客户端连接
        /// </summary>
        /// <param name="clinetEndPoint"></param>
        public void RemoveClient(string clinetEndPoint)
        {
            KillClient(clinetEndPoint);
            dicThreadMsg.Remove(clinetEndPoint);
            dicConnSocket.Remove(clinetEndPoint);
            dicListTimeConnSocket.Remove(clinetEndPoint);
            if (removeClientIPFromUI != null)
            {
                removeClientIPFromUI(clinetEndPoint);
            }
        }
        #endregion
        #region 终止客户端通信+public void KillClient(string clinetEndPoint)
        /// <summary>
        /// 终止客户端通信
        /// </summary>
        /// <param name="clinetEndPoint"></param>
        public void KillClient(string clinetEndPoint)
        {
            if (dicConnSocket[clinetEndPoint].Connected)
            {
                dicConnSocket[clinetEndPoint].Shutdown(SocketShutdown.Both);
            }
            dicConnSocket[clinetEndPoint].Close();
            dicThreadMsg[clinetEndPoint].Abort();
        }
        #endregion
    }
}

ServerWinform： 

using System;
using System.Collections.Generic;
using System.Threading;
using System.Windows.Forms;
using ServerChatClass;

namespace ChatServer
{
    public partial class ServerChar : Form
    {
        public ServerChar()
        {
            InitializeComponent();
            Control.CheckForIllegalCrossThreadCalls = false;
        }

        //Socket connSocket;//通信socket
        //  Thread thmsg;//接收消息 线程

        ServerChatClass.SeverChar severchar;
        Model model = new Model();

        private void btnStart_Click(object sender, EventArgs e)
        {
            bool enable;
            model.TxtServer = txtServer.Text;
            model.TxtPort = txtPort.Text;
            severchar = new SeverChar("开始监听",model, ShowLog, add, RemoveControl, "掉线",out enable);
            if (enable)
            {
                btnStart.Enabled = false;
                timer1.Start();
            }
            else
            {
                btnStart.Enabled = true;
            }
        }
        void add(string clinetIP)
        {
            listIp.Items.Add(clinetIP);
            cboUsers.Items.Add(clinetIP);
        }
        public void ShowLog(string msg)
        {
            txtLog.AppendText(msg + "\r\n");
        }
        #region 发送
        private void Send(object sender, EventArgs e)
        {
            int flag = 0;
            Button btn = sender as Button;
            if (btn.Text == "发送消息")
            {
                model.TxtMsg = txtMsg.Text;
                flag = 0;
            }
            else if (btn.Text == "发送文件")
            {
                model.TxtPath = txtPath.Text;
                flag = 1;
            }
            else if (btn.Text == "震动")
            {
                flag = 2;
            }
            severchar.SendStreamFunction(severchar.listSendConnSocket, flag, model);
        }
        //private void SendMsg(object sender, EventArgs e)
        //{

        //}
        //private void btnSendFile_Click(object sender, EventArgs e)
        //{
        //    model.TxtPath = txtPath.Text;
        //    severchar.SendStreamFunction(severchar.listSendConnSocket, 1, model);
        //}
        //private void btnZD_Click(object sender, EventArgs e)
        //{
        //    severchar.SendStreamFunction(severchar.listSendConnSocket, 2, model);
        //}
        #endregion
        private void btnSelect_Click(object sender, EventArgs e)
        {
            OpenFileDialog open = new OpenFileDialog();
            if (open.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                txtPath.Text = open.FileName;
            }
        }
        private void DownLine_Click(object sender, EventArgs e)
        {
            for (int i = 0; i < listIp.SelectedItems.Count; i++)
            {
                string clinetIP = listIp.SelectedItems[i].ToString();
                severchar.RemoveClient(clinetIP);
            }

        }
        private void RemoveControl(string clinetIP)
        {
            cboUsers.Items.Remove(clinetIP);
            listIp.Items.Remove(clinetIP);
        }
        private void listIp_SelectedIndexChanged(object sender, EventArgs e)
        {
            severchar.listSendConnSocket.Clear();
            if (listIp.SelectedItems.Count == 1)
            {
                cboUsers.SelectedIndex = listIp.SelectedIndex;
            }
            foreach (string item in listIp.SelectedItems)
            {
                severchar.listSendConnSocket.Add(severchar.dicConnSocket[item]);
            }
        }
        private void Server_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (severchar.dicThreadMsg.Count > 0)
            {
                int index = 0;
                Dictionary<int, string> dic = new Dictionary<int, string>();
                foreach (KeyValuePair<string, Thread> item in severchar.dicThreadMsg)
                {
                    dic.Add(index, item.Key);
                    index++;
                }
                DateTime timeNow = DateTime.Now;
                for (int i = 0; i < severchar.dicThreadMsg.Count; i++)
                {
                    severchar.RemoveClient(dic[i]);                
                }
            }
        }
        private void timer1_Tick(object sender, EventArgs e)
        {
        if(  severchar.dicListTimeConnSocket.Count>0)
        {
            severchar.Timer();
        }      
        }
    }
}


下载：http://download.csdn.net/detail/s10141303/6675157



==================== 迂者 丁小未 CSDN博客专栏=================

MyBlog：http://blog.csdn.net/dingxiaowei2013              MyQQ:1213250243

MyTel:13262983383 

====================== 相互学习，共同进步 ===================


丁小未
关注
  • 5
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
[Unity][UGUI]聊天气泡布局拾取物品提示击杀提示反馈
BuladeMian的博客，菜得抠脚，菜得真实
08-10 1571
  多人游戏需要用到聊天框，那么单机游戏  聊天框气泡 可以应用 在 拾取 物品提示，击杀提示上面。 本文根据参考资料6，来进行 的 图文 的 布局排列的设置。用代码实现，只说下思路。Unity 2018.1.3f1(64bit)   用按钮来触发 左边气泡，和右边气泡的效果。   using UnityEngine; public class Test...
笔记 下拉刷新 历史消息记录 unity
地球OL重生之我是程序员
11-11 357
拖动的UI像这样设置 using System; using System.Collections; using System.Collections.Generic; using UnityEngine; using UnityEngine.EventSystems; using UnityEngine.UI; /// <summary> /// @创建者: Mzi /// @创建日期: 2020/11/6 14:56:4 /// @功能描述: 通用下拉 /// @修改者： /// @修..
Unity3d C# 基于UGUI实现类似WX聊天气泡功能工程源码
03-07
Unity3d C# 基于UGUI实现类似WX聊天气泡功能， 建议先看说明：https://blog.csdn.net/qq_33789001/article/details/123331284
unity3d-学习笔记19-卡牌游戏制作（战斗胜利界面，点击菜单栏出现其他选项以及对应功能，实现能量卡消耗蓝条）
pure81的博客
03-01 1148
unity3d-学习笔记19-卡牌游戏制作战斗胜利界面思路代码实现点击菜单栏出现其他选项以及对应功能思路代码实现返回主界面按键功能思路代码 战斗胜利界面 思路 在桌面类update方法里不断判断，获取boss的血量，当≤0时，播放boss被打死消失的动画，以及出现战斗胜利的界面（没有美工所以直接用一个图来代替了） 代码 获取血量并进行判断 int bossLife = int.Parse(GameObject.Find("lifeNumber").GetComponent<Text>().tex
Unity-TCP-网络聊天功能(三): 公共/私人聊天、添加好友、好友上下线、新消息提醒、点击好友聊天、退出登录
weixin_42264818的博客
02-01 886
Unity-TCP-网络聊天功能实现
Unity3d 制作聊天框
王广帅--游戏开发技术
11-04 2935
在使用Unity3d开发一个简易的聊天程序时，需要在客户端显示聊天记录列表，做为一个初学者，开发这个功能具然快用了两天了。最后通过调一个参数解决了。这里记录一下，希望对新手有所帮助。 最终的显示效果是这样的： 项目结构如图所示： 项目中的StartPanel是用来输入昵称和连接服务器用的，这里先不用管它。ChatPanel中实现了聊天历史列表记录和聊天消息的发送。 开发步骤如下所示： 添加Ch...
unity制作聊天室界面
热门推荐
sajiazaici的博客
10-22 1万+
unity UGUI制作仿LOL客户端聊天室界面，实现按回车发送消息，带滚轮，可以查看之前的消息，发送消息后会跳到最下面。
unity3d画笔画线功能
08-01
unity3d中实现基本的铅笔，直线，画圆，画矩形和输入文字的功能，以及保存文件，打开文件的功能。其中计算直线夹角和判断鼠标是否在线上使用了NN视频聊天组件的功能（免费哦，在Assets\Plugins目录下，聊天功能参考...
Unity3D 语音聊天插件
08-14
Unity3D插件，可利用此插件进行移动平台上的语音聊天功能开发～！@
unity3d聊天
12-07
Unity聊天客户端服务器端 博客参考：http://blog.csdn.net/dingxiaowei2013/article/details/17189393
使用Unity开发的简易多人聊天室
09-06
使用Unity，基于TCP开发的一个简易的多人聊天室，可以实现聊天内容的多屏同步，正在学习Socket的初学者值得一看
Unity3D聊天室源代码
12-28
版本是Unity 5.0.2f1(64-bit),适用于Android,Win32平台。使用Richbat服务器，客户端调用动态库。
unity3d 实现多人聊天通讯
05-31
用unity3d实现的多人在线聊天通讯程序 包含服务器端（web程序）,pc端客户端，Android客户端 支持多台手机，电脑在线聊天
Unity3D使用GL实现图案解锁功能
01-21
聊天是时候看到有人问如何在Unity3D的UGUI中实现图案解锁的功能，然后便试了一下。刚开始想用LineRender来实现，但又一想是要在UGUI中，然后就用了另外一种方法，即使用GL类来实现。 GL相关介绍及官方文档 实现后在...
Unity3D从唤醒到销毁的生命周期
HerBieZProgramer
06-01 2272
从唤醒到销毁 void Rest(){} void Awake(){} void OnEnbale(){} void Main(){} void Start(){} void FixedUpdate(){} { void OnTriggerEnter(Collider other){} void OnTriggerStay(Collider other){} void OnTriggerExit...
聊天室C#服务器Unity客户端UGUI显示
kuilaurence的博客
05-30 552
服务器端脚本代码： using System; using System.Net.Sockets; using System.Threading; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace 聊天室 { cla...
unity 聊天界面
qq_32409959的博客
01-13 4338
unity，聊天气泡跟随文字的多少而变化
unity3d 脚本 实现cad cae功能
最新发布
01-11
Unity3D 是一款强大的游戏引擎，其脚本编程功能可以实现CAD（计算机辅助设计）和CAE（计算机辅助工程）功能。在 Unity3D 中，我们可以利用脚本编写程序来实现CAD和CAE功能，例如创建、编辑和展示三维几何模型，进行...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值