急急如律令！火速搭建一个C#即时通信系统！（附源码分享——高度可移植！）

     （2016年3月更：由于后来了解到GGTalk开源即时通讯系统，因此直接采用了该资源用于项目开发，在此对作者表示由衷的感谢！）

     ——————————————————————————————————

     人在外包公司，身不由己！各种杂七杂八的项目都要做，又没有自己的技术沉淀，每次涉足新的项目都倍感吃力，常常现学现卖，却不免处处碰壁！当然，话说回来，也是自己的水平有限在先，一马配一鞍，无奈也只能留在外包公司。

      这不，就在上一周，领导下达一个任务：3天内搭建一个C#即时通讯系统，与原有的办公系统集成。

      我正心里犯嘀咕；“网络编程自己就只知道一点皮毛啊，还是大学选修课上听老师讲的那一点东西，别说即时通讯了，以前也就只照着书上的例子写过一个抓包工具当作业交过，彻头彻尾的小白啊，何况都毕业几年了，连“套接字”都快忘了！”

      领导补充说：“这个即时通讯系统要尽快完成，之后还有别的的项目。”

      我：“······好的”

      没办法，就像领导常说的“有条件要上，没有条件创造条件也要上！”，临危受命，唯有逆流而上！

      想都别想，写即时通讯总不能从socket写起啊，那样写出来的东西只能读书的时候当作业交给老师看下，然后记一个平时成绩，给领导看那就是找抽！

      所以，只能“登高而招，顺风而呼”，园子里大神多，资源也多，找找看有没有可以参考的。（这也是我一直以来的工作方法，呵呵）

      终于，看到了一篇轻量级通信引擎StriveEngine通信demo源码研究学习了一下，稍加揣摩，很快就完成了领导所交付的重任！在此要鸣谢该文的作者！

      言归正传，接下来就把自己的学习所得以及编写过程详尽的分享给大家！

 

一·C#即时通信系统界面快照

            

    

    

 

二·网络消息流与通信协议

     首先，网络中的数据是源源不断的二进制流，有如长江之水连绵不绝，那么，即时通讯系统如何从连绵不绝的数据流中准确的识别出一个消息呢？换言之，在悠远绵长的网络数据流中，一个个具体的消息应该如何被界定出来呢？

     这就需要用到通信协议。通信协议，一个大家耳熟能详的术语，什么TCP啊、UDP啊、IP啊、ICMP啊，以前学《计算机网络》时，各种协议充斥寰宇。但是，从教科书上抽象的概念中，你真的了解什么是通信协议吗？

     回到开始的问题，我想恐怕可以这样来理解：通信协议就是要让消息遵循一定的格式，而这样的格式是参与通信的各方都知晓且遵守的，依据这样的格式，消息就能从数据流中被完整的识别出来。

     通信协议的格式通常分为两类：文本消息、二进制消息。 

     文本协议相对简单，通常使用一个特殊的标记符作为一个消息的结束。这样一来，根据这个特殊的标志符，每个消息之间就有了明确的界限。 

     二进制协议，通常是由消息头（Header）和消息体（Body）构成的，消息头的长度固定，而且，通过解析消息头，可以知道消息体的长度。如此，我们便可以从网络流中解析出一个个完整的二进制消息。
     两种协议各有优劣，虽然文本协议比较简单方便，但是二进制协议更具有普适性，诸如图片啊、文件啊都可以转化为二进制数组，所以我在写即时通讯时采用的是二进制协议。

     我定义的二进制协议是：消息头固定为8个字节：前四个字节为一个int，其值表示消息类型；后四个字节也是一个int，其值表示消息体长度。

     先来看消息头的定义 

public class MsgHead
    { 
        private int messageType;
        /// <summary>
        /// 消息类型
        /// </summary>
        public int MessageType
        {
            get { return messageType; }
            set { messageType = value; }
        }

        private int bodyLength;
        /// <summary>
        /// 消息体长度
        /// </summary>
        public int BodyLength
        {
            get { return bodyLength; }
            set { bodyLength = value; }
        }

        public const int HeadLength = 8;


        public MsgHead(int msgType,int bodyLen)
        {
            this.bodyLength = bodyLen;
            this.messageType = msgType;
        }

        public byte[] ToStream()
        {
            byte[] buff = new byte[MsgHead.HeadLength];
            byte[] bodyLenBuff = BitConverter.GetBytes(this.bodyLength);
            byte[] msgTypeBuff = BitConverter.GetBytes(this.messageType);
            Buffer.BlockCopy(msgTypeBuff, 0, buff, 0, msgTypeBuff.Length);
            Buffer.BlockCopy(bodyLenBuff, 0, buff, 4, bodyLenBuff.Length);
            return buff;
        }
    }

    然后我们将识别消息的方法封装到一个协议助手类中，即收到消息的时候，明确如下两个问题：1.固定前多少位是消息头。2.如何从消息头中获取消息体长度。

 public class StreamContractHelper : IStreamContractHelper
    {
        /// <summary>
        /// 消息头长度
        /// </summary>
        public int MessageHeaderLength
        {
            get { return MsgHead.HeadLength; }
        }
        /// <summary>
        /// 从消息头中解析出消息体长度，从而可以间接取出消息体
        /// </summary>
        /// <param name="head"></param>
        /// <returns></returns>
        public int ParseMessageBodyLength(byte[] head)
        {
            return BitConverter.ToInt32(head,4);
        }
    }
   

          

三·通信协议类

然后我们来定义满足协议的消息基类，其中重点是要定义ToContractStream（）方法，使得消息能够序列化成满足协议的二进制流，从而通过网络进行传输。 

 [Serializable]
    public class BaseMsg
    {
        private int msgType;

        public int MsgType
        {
            get { return msgType; }
            set { msgType = value; }
        }       
        /// <summary>
        /// 序列化为本次通信协议所规范的二进制消息流
        /// </summary>
        /// <returns></returns>
        public byte[] ToContractStream()
        {
            return MsgHelper.BuildMsg(this.msgType, SerializeHelper.SerializeObject(this));
        }       
    }

然后我们来看看MsgHelper类的具体实现

public static class MsgHelper
    {
        /// <summary>
        /// 构建消息
        /// </summary>
        /// <param name="msgType">消息类型</param>
        /// <param name="msgBody">消息体</param>
        /// <returns></returns>
        public static byte[] BuildMsg(int msgType, Byte[] msgBody)
        {
            MsgHead msgHead = new MsgHead(msgType, msgBody.Length);
            //将消息头与消息体拼接起来
            byte[] msg = BufferJointer.Joint(msgHead.ToStream(), msgBody);
            return msg;
        }
      
        public static byte[] BuildMsg(int msgType, string str)
        {
            return MsgHelper.BuildMsg(msgType, Encoding.UTF8.GetBytes(str));
        }
        /// <summary>
        /// 将二进制数组还原成消息对象
        /// </summary>
        /// <typeparam name="T">所要还原成的消息类</typeparam>
        /// <param name="msg">消息数据</param>
        /// <returns></returns>
        public static T DeserializeMsg<T>(byte[] msg)
        {
            return (T)SerializeHelper.DeserializeBytes(msg, 8, msg.Length - 8);   
        }        
    }

然后我们再看一个具体的消息类ChatMsg的定义 

[Serializable]
    public class ChatMsg:BaseMsg
    {      
        private string sourceUserID;
        /// <summary>
        /// 发送该消息的用户ID
        /// </summary>
        public string SourceUserID
        {
            get { return sourceUserID; }
            set { sourceUserID = value; }
        }
        private string targetUserID;
        /// <summary>
        /// 该消息所发往的用户ID
        /// </summary>
        public string TargetUserID
        {
            get { return targetUserID; }
            set { targetUserID = value; }
        }
        private DateTime timeSent;
        /// <summary>
        /// 该消息的发送时间
        /// </summary>
        public DateTime TimeSent
        {
            get { return timeSent; }
            set { timeSent = value; }
        }
        private string msgText;
        /// <summary>
        /// 该消息的文本内容        /// 
        /// </summary>
        public string MsgText
        {
            get { return msgText; }
            set { msgText = value; }
        }
        /// <summary>
        /// 构造一个ChatMsg实例
        /// </summary>
        /// <param name="_sourceUserID">该消息源用户ID</param>
        /// <param name="_targetUserID">该消息目标用户ID</param>
        /// <param name="_MsgText">该消息的文本内容   </param>
        public ChatMsg(string _sourceUserID, string _targetUserID, string _MsgText)
        {
            base.MsgType = Core.MsgType.Chatting;
            this.sourceUserID = _sourceUserID;
            this.targetUserID = _targetUserID;
            this.timeSent = DateTime.Now;
            this.msgText = _MsgText;
        }     
    }

 

 

四·登录的通信过程 

                                    

1.客户端发送登陆消息 

 private void button_login_Click(object sender, EventArgs e)
        {
            this.selfID = this.textBox_ID.Text.Trim();
            LoginMsg loginMsg = new LoginMsg(this.selfID);
            this.tcpPassiveEngine.PostMessageToServer(loginMsg.ToContractStream());     
        }       

2.服务端回复登陆消息

 if (msgType == MsgType.Logining)
            {
                LoginMsg loginMsg = MsgHelper.DeserializeMsg<LoginMsg>(msg);
                this.ReplyLogining(loginMsg, userAddress);
                //将在线用户告知其他客户端                
                this.TellOtherUser(MsgType.NewOnlineFriend, loginMsg.SrcUserID);
            }

        /// <summary>
        /// 回复登陆消息
        /// </summary>
        /// <param name="loginMsg"></param>
        /// <param name="userAddress"></param>
        private void ReplyLogining(LoginMsg loginMsg, IPEndPoint userAddress)
        {
            if (this.onlineManager.Contains(loginMsg.SrcUserID))//重复登录
            {
                loginMsg.LogonResult = LogonResult.Repetition;
                this.tcpServerEngine.SendMessageToClient(userAddress, loginMsg.ToContractStream());
            }
            else//此demo简化处理回复成功，其他验证未处理
            {
                this.AddUser(loginMsg.SrcUserID, userAddress);
                this.ShowOnlineUserCount();
                loginMsg.LogonResult = LogonResult.Succeed;
                this.tcpServerEngine.SendMessageToClient(userAddress, loginMsg.ToContractStream());
            }
        } 

3.客户端处理登陆结果

 1         private void tcpPassiveEngine_MessageReceived(IPEndPoint userAddress, byte[] msg)
 2         {
 3             //取出消息类型
 4             int msgType = BitConverter.ToInt32(msg, 0);
 5             //验证消息类型
 6             if (msgType == MsgType.Logining)
 7             {
 8                 LoginMsg loginMsg = MsgHelper.DeserializeMsg<LoginMsg>(msg);
 9                 if (loginMsg.LogonResult == LogonResult.Succeed)
10                 {
11                     this.DialogResult = DialogResult.OK;
12                     this.tcpPassiveEngine.MessageReceived -= new StriveEngine.CbDelegate<IPEndPoint, byte[]>(tcpPassiveEngine_MessageReceived);
13                 }
14                 if (loginMsg.LogonResult == LogonResult.Repetition)
15                 {
16                     MessageBox.Show("登录失败，该账号已经登录！");
17                 }
18             }
19         } 

                     

五·即时通信客户端通信过程

                               

1.客户端A发送聊天消息给服务器

 1         /// <summary>
 2         /// 发送聊天消息
 3         /// </summary>
 4         /// <param name="sender"></param>
 5         /// <param name="e"></param>
 6         private void button_send_Click(object sender, EventArgs e)
 7         {
 8             string chatText = this.richTextBox_Write.Text;
 9             if (string.IsNullOrEmpty(chatText))
10             {
11                 MessageBox.Show("消息不能为空");
12                 return;
13             }
14             ChatMsg chatMsg = new ChatMsg(this.selfUserID, this.friendID, chatText);
15             this.tcpPassiveEngine.SendMessageToServer(chatMsg.ToContractStream());
16             this.ShowChatMsg(chatMsg);
17         }       

2.服务端转发聊天消息

1          if (msgType == MsgType.Chatting)
2          {
3              ChatMsg chatMsg = MsgHelper.DeserializeMsg<ChatMsg>(msg);
4              if (this.onlineManager.GetKeyList().Contains(chatMsg.TargetUserID))
5              {
6                  IPEndPoint targetUserAddress = this.onlineManager.Get(chatMsg.TargetUserID).Address;
7                  this.tcpServerEngine.SendMessageToClient(targetUserAddress, msg);
8              }
9          }

3.客户端B接收并显示聊天消息 

 void tcpPassiveEngine_MessageReceived(IPEndPoint userAddress, byte[] msg)
        {
            //取出消息类型
            int msgType = BitConverter.ToInt32(msg, 0);
            //验证消息类型           
            if (msgType == MsgType.Chatting)
            {
                ChatMsg chatMsg = MsgHelper.DeserializeMsg<ChatMsg>(msg);
                this.ShowChatForm(chatMsg.SourceUserID);
                this.ChatMsgReceived(chatMsg);
            }
        } 

        /// <summary>
        /// 显示聊天窗
        /// </summary>
        /// <param name="friendUserID">聊天对方用户ID</param>
        private void ShowChatForm(string friendUserID)
        {
            if (this.InvokeRequired)
            {
                this.Invoke(new CbGeneric<string>(this.ShowChatForm), friendUserID);
            }
            else
            {
                ChatForm form = this.chatFormManager.GetForm(friendUserID);
                if (form == null)
                {
                    form = new ChatForm(this.selfID, friendUserID, this, this.tcpPassiveEngine);
                    form.Text = string.Format("与{0}对话中···", friendUserID);
                    this.chatFormManager.Add(form);
                    form.Show();
                }
                form.Focus();
            }
        }


        /// <summary>
        /// 显示聊天消息
        /// </summary>
        /// <param name="chatMsg"></param>
        private void ShowChatMsg(ChatMsg chatMsg)
        {
            if (this.InvokeRequired)
            {
                this.Invoke(new CbGeneric<ChatMsg>(this.formMain_chatMsgReceived), chatMsg);
            }
            else
            {
                this.richTextBox_display.AppendText(chatMsg.SourceUserID + "   " + chatMsg.TimeSent.ToString() + "\r\n");
                this.richTextBox_display.AppendText(chatMsg.MsgText + "\r\n");
                this.richTextBox_Write.Clear();
            }
        }

 

五·C#即时通信源码下载      

    源码说明：1.客户端与服务端均含有配置文件，可配置进程的IP与端口号。
                     2.代码均含有详细注释。
                     3.调试时确保客户端的配置文件相关信息无误，先启动服务端再启动客户端。
                     4.登录账号与密码均为任意。
                     5.点击好友头像即可聊天。
    下载：Chat.Demo 

 

  附相关系列源码： 

 文本协议通信demo源码

二进制通信demo源码及说明文档

打通B/S与C/S通信demo源码与说明文档

版权声明：本文为博主原创文章，未经博主允许不得转载。