急急如律令！火速搭建一个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 = ;

         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, , buff, , msgTypeBuff.Length);
             Buffer.BlockCopy(bodyLenBuff, , buff, , 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,);
         }
     }
    

三·通信协议类

然后我们来定义满足协议的消息基类，其中重点是要定义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, , msg.Length - );
         }
     }

然后我们再看一个具体的消息类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.客户端处理登陆结果

          private void tcpPassiveEngine_MessageReceived(IPEndPoint userAddress, byte[] msg)
          {
              //取出消息类型
              int msgType = BitConverter.ToInt32(msg, );
              //验证消息类型
              if (msgType == MsgType.Logining)
              {
                  LoginMsg loginMsg = MsgHelper.DeserializeMsg<LoginMsg>(msg);
                  if (loginMsg.LogonResult == LogonResult.Succeed)
                 {
                     this.DialogResult = DialogResult.OK;
                     this.tcpPassiveEngine.MessageReceived -= new StriveEngine.CbDelegate<IPEndPoint, byte[]>(tcpPassiveEngine_MessageReceived);
                 }
                 if (loginMsg.LogonResult == LogonResult.Repetition)
                 {
                     MessageBox.Show("登录失败，该账号已经登录！");
                 }
             }
         } 

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

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

          /// <summary>
          /// 发送聊天消息
          /// </summary>
          /// <param name="sender"></param>
          /// <param name="e"></param>
          private void button_send_Click(object sender, EventArgs e)
          {
              string chatText = this.richTextBox_Write.Text;
              if (string.IsNullOrEmpty(chatText))
             {
                 MessageBox.Show("消息不能为空");
                 return;
             }
             ChatMsg chatMsg = new ChatMsg(this.selfUserID, this.friendID, chatText);
             this.tcpPassiveEngine.SendMessageToServer(chatMsg.ToContractStream());
             this.ShowChatMsg(chatMsg);
         }       

2.服务端转发聊天消息

          if (msgType == MsgType.Chatting)
          {
              ChatMsg chatMsg = MsgHelper.DeserializeMsg<ChatMsg>(msg);
              if (this.onlineManager.GetKeyList().Contains(chatMsg.TargetUserID))
              {
                  IPEndPoint targetUserAddress = this.onlineManager.Get(chatMsg.TargetUserID).Address;
                  this.tcpServerEngine.SendMessageToClient(targetUserAddress, msg);
              }
          }

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

  void tcpPassiveEngine_MessageReceived(IPEndPoint userAddress, byte[] msg)
         {
             //取出消息类型
             int msgType = BitConverter.ToInt32(msg, );
             //验证消息类型
             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源码与说明文档

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