c#制作P2P网络通讯软件

最新推荐文章于 2022-08-12 14:00:54 发布
最新推荐文章于 2022-08-12 14:00:54 发布
阅读量1.4k 收藏
点赞数
分类专栏： C# 文章标签： p2p 通讯 c# 网络 buffer byte

在网上看了很多程序（QQ、Azureus、Ants、PPStream）都实现了p2p，以前觉得技术很高深。通过这段时间的学习才发现，单纯的实现p2p在局域网通讯很容易，但是要实现外网穿透(NAT)感觉很困难。最近看了Azureus和emule源码，分别是JAVA和C++版，本人对这两门语言都不熟悉，看起来很吃力。最后只好根据VC++实现的P2PDemo程序进行了改版，根据设计思路用c#写了一个Demo出来。通过测试，多个客户端在局域网能脱离服务端实现端到端工作。外网的情况要通过路由器，看了Azureus要实现uPnp进行端口映射，在CodeProject上下载了一个uPnp源码看，测试结果没有启用uPnp路由器。结果现在郁闷了，不知道下一步怎么测试，是不是用upnp实现了端口自动映射成功就能实现象QQ那样通讯。

　　下面是程序说明：

　　1、公共类

　　公共类主要定义一些包结构

　　a、Packet.cs　

[Serializable()]
　　　 public abstract class Packet
　　　 {
　　　　　　　 /// <summary>
　　　　　　　 /// 命令类型
　　　　　　　 /// </summary>
　　　　　　　 /// <returns></returns>
　　　　　　　 public virtual int GetCommandType()
　　　　　　　 {
　　　　　　　　　　　 return -1;
　　　　　　　 }

　　　　　　　 /// <summary>
　　　　　　　 /// 用户名
　　　　　　　 /// </summary>
　　　　　　　 public string UserName
　　　　　　　 {
　　　　　　　　　　　 get;
　　　　　　　　　　　 set;
　　　　　　　 }

　　　　　　　 public Packet()
　　　　　　　 { }

　　　　　　　 public Packet(string username)
　　　　　　　 {
　　　　　　　　　　　 this.UserName = username;
　　　　　　　 }
　　　 }

　　b、MassTextPacket.cs　 --分片传输类

　[Serializable()]
　　　 public class MassTextPacket:TextPacket
　　　 {
　　　　　　　 private int seqID;
　　　　　　　 /// <summary>
　　　　　　　 /// 包序列
　　　　　　　 /// </summary>
　　　　　　　 public int SeqID
　　　　　　　 {
　　　　　　　　　　　 get { return seqID; }
　　　　　　　　　　　 set { seqID = value; }
　　　　　　　 }

　　　　　　　 private int seqCount;
　　　　　　　 /// <summary>
　　　　　　　 /// 包数量
　　　　　　　 /// </summary>
　　　　　　　 public int SeqCount
　　　　　　　 {
　　　　　　　　　　　 get { return seqCount; }
　　　　　　　　　　　 set { seqCount = value; }
　　　　　　　 }

　　　　　　　 private int _CLSD;
　　　　　　　 public int CLSD
　　　　　　　 {
　　　　　　　　　　　 get { return _CLSD; }
　　　　　　　　　　　 set { _CLSD = value; }
　　　　　　　 }

　　　 }

　　2、客户端

　　a、消息传送时进行p2p通讯

　　　　　　　 private bool SendMessageTo(string toUserName, Packet packet)
　　　　　　　 {
　　　　　　　　　　　 PeerEntity toUser = userList.Single(c => c.UserName == toUserName);
　　　　　　　　　　　 if (toUser == null)
　　　　　　　　　　　 {
　　　　　　　　　　　　　　　 return false;
　　　　　　　　　　　 }
　　　　　　　　　　　 ReceivedACK = false;

　　　　　　　　　　　 for (int i=0; i<MAXRETRY; i++)　　　　　　　　　　　 
　　　　　　　　　　　 {　　　　　 
　　　　　　　　　　　　　　　 // 如果对方P2P地址不为0，就试图以它为目的地址发送数据，
　　　　　　　　　　　　　　　 // 如果发送失败，则认为此P2P地址无效
　　　　　　　　　　　　　　　 if (toUser.P2PAddress != null && toUser.P2PAddress.Port != 0)
　　　　　　　　　　　　　　　 {
　　　　　　　　　　　　　　　　　　　 if (packet.GetType() == typeof(TextPacket))
　　　　　　　　　　　　　　　　　　　 {
　　　　　　　　　　　　　　　　　　　　　　　 TextPacket msgPacket = new TextPacket(toUserName, (packet as TextPacket).Message);
　　　　　　　　　　　　　　　　　　　　　　　 byte[] buffer = UtilityHelper.Serialize(msgPacket);
　　　　　　　　　　　　　　　　　　　　　　　 if (buffer.Length > MAXBUFFERSIZE)
　　　　　　　　　　　　　　　　　　　　　　　 {
　　　　　　　　　　　　　　　　　　　　　　　　 
　　　　　　　　　　　　　　　　　　　　　　　　　　　 MassTextPacket mtp = new MassTextPacket();
　　　　　　　　　　　　　　　　　　　　　　　　　　　 mtp.SeqID = 0;
　　　　　　　　　　　　　　　　　　　　　　　　　　　 mtp.SeqCount = (int)System.Math.Ceiling(buffer.Length / (decimal)MAXBUFFERSIZE);
　　　　　　　　　　　　　　　　　　　　　　　　　　　 mtp.CLSD = mtp.GetHashCode();
　　　　　　　　　　　　　　　　　　　　　　　　　　　 
　　　　　　　　　　　　　　　　　　　　　　　　　　　 long pos = 0;
　　　　　　　　　　　　　　　　　　　　　　　　　　　 long count = buffer.Length < MAXBUFFERSIZE ? buffer.Length : MAXBUFFERSIZE;
　　　　　　　　　　　　　　　　　　　　　　　　　　　 while (pos < buffer.Length && pos > 0)
　　　　　　　　　　　　　　　　　　　　　　　　　　　 {
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 byte[] bytes = new byte[count];　　　　　　　　　　　　　　　　　　　　　　　　　 ;
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 for (int k = 0; k < count; k++)
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 bytes[k] = buffer[pos + k];
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 //数据组包
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 mtp.SeqID = mtp.SeqID + 1;
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 mtp.Message = Convert.ToBase64String(bytes);

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 //发送数据
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 byte[] buf = UtilityHelper.Serialize(mtp);
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 client.Send(buf, buf.Length, toUser.P2PAddress);
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 Thread.Sleep(100);
　　　　　　　　　　　　　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　　　　　　　　　 else
　　　　　　　　　　　　　　　　　　　　　　　　　　　 client.Send(buffer, buffer.Length, toUser.P2PAddress);
　　　　　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　　　　　 else if (packet.GetType() == typeof(FileStreamPacket))
　　　　　　　　　　　　　　　　　　　 {
　　　　　　　　　　　　　　　　　　　　　　　 FileStreamPacket fsp = packet as FileStreamPacket;
　　　　　　　　　　　　　　　　　　　　　　　 System.IO.FileStream fs = new System.IO.FileStream(fsp.FileName, System.IO.FileMode.Open, System.IO.FileAccess.Read, FileShare.Read);

　　　　　　　　　　　　　　　　　　　　　　 handle1.Reset();

　　　　　　　　　　　　　　　　　　　　　　　 fsp.SeqID = 0;
　　　　　　　　　　　　　　　　　　　　　　　 fsp.SeqCount = (int)System.Math.Ceiling(fs.Length / (decimal)MAXBUFFERSIZE);
　　　　　　　　　　　　　　　　　　　　　　　 fsp.CLSD = fsp.GetHashCode();

　　　　　　　　　　　　　　　　　　　　　　　 long pos = 0;
　　　　　　　　　　　　　　　　　　　　　　　 long count = fs.Length < MAXBUFFERSIZE ? fs.Length : MAXBUFFERSIZE;
　　　　　　　　　　　　　　　　　　　　　　　 while (pos < fs.Length && count > 0)
　　　　　　　　　　　　　　　　　　　　　　　 {
　　　　　　　　　　　　　　　　　　　　　　　　　　　 byte[] buffer = new byte[count];
　　　　　　　　　　　　　　　　　　　　　　　　　　　 fs.Seek(pos, SeekOrigin.Begin);
　　　　　　　　　　　　　　　　　　　　　　　　　　　 fs.Read(buffer, 0, (int)count);

　　　　　　　　　　　　　　　　　　　　　　　　　　　 pos += count;
　　　　　　　　　　　　　　　　　　　　　　　　　　　 count = pos + MAXBUFFERSIZE < fs.Length ? MAXBUFFERSIZE : fs.Length - pos;

　　　　　　　　　　　　　　　　　　　　　　　　　　　 //数据组包
　　　　　　　　　　　　　　　　　　　　　　　　　　　 fsp.SeqID = fsp.SeqID + 1;
　　　　　　　　　　　　　　　　　　　　　　　　　　　 fsp.Message = Convert.ToBase64String(buffer);

　　　　　　　　　　　　　　　　　　　　　　　　　　　 //发送数据
　　　　　　　　　　　　　　　　　　　　　　　　　　　 byte[] buf = UtilityHelper.Serialize(fsp);
　　　　　　　　　　　　　　　　　　　　　　　　　　　 client.Send(buf, buf.Length, toUser.P2PAddress);
　　　　　　　　　　　　　　　　　　　　　　　　　　　 Thread.Sleep(300);
　　　　　　　　　　　　　　　　　　　　　　　 }

　　　　　　　　　　　　　　　　　　　　　　　 handle1.Set();
　　　　　　　　　　　　　　　　　　　 }

　　　　　　　　　　　　　　　　　　　 // 等待接收线程将标记修改
　　　　　　　　　　　　　　　　　　　 for (int j = 0; j < 10; j++)
　　　　　　　　　　　　　　　　　　　 {
　　　　　　　　　　　　　　　　　　　　　　　 if (this.ReceivedACK)
　　　　　　　　　　　　　　　　　　　　　　　 {
　　　　　　　　　　　　　　　　　　　　　　　　　　　 this.ReceivedACK = false;
　　　　　　　　　　　　　　　　　　　　　　　　　　　 return true;
　　　　　　　　　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　　　　　　　　　 else
　　　　　　　　　　　　　　　　　　　　　　　 {
　　　　　　　　　　　　　　　　　　　　　　　　　　　 Thread.Sleep(300);
　　　　　　　　　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　 }

　　　　　　　　　　　　　　　 // 构建P2P打洞封包
　　　　　　　　　　　　　　　 // 然后通过服务器转发，请求对方向自己打洞
　　　　　　　　　　　　　　　 P2PConnectionPacket transMsg = new P2PConnectionPacket(UserName, toUserName);
　　　　　　　　　　　　　　　 byte[] msgBuffer = UtilityHelper.Serialize(transMsg);
　　　　　　　　　　　　　　　 client.Send(msgBuffer, msgBuffer.Length, hostPoint);

　　　　　　　　　　　　　　　 // 等待对方的P2PCONNECTACK消息
　　　　　　　　　　　　　　　 for(int j = 0; j < 10; ++j)
　　　　　　　　　　　　　　　 {
　　　　　　　　　　　　　　　　　　　 toUser = userList.Single(c => c.UserName == toUserName);
　　　　　　　　　　　　　　　　　　　 if ( toUser.P2PAddress != null && toUser.P2PAddress.Port != 0)
　　　　　　　　　　　　　　　　　　　　　　　 break;
　　　　　　　　　　　　　　　　　　　 Thread.Sleep(300);
　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　 
　　　　　　　　　　　 }
　　　　　　　　　　　 return false;
　　　　　　　 }

　　b、消息接受线程

/// <summary>
　　　　　　　 /// 接受线程处理
　　　　　　　 /// </summary>
　　　　　　　 private void RecvThreadProc()
　　　　　　　 {
　　　　　　　　　　　 byte[] buffer;
　　　　　　　　　　　 while (true)
　　　　　　　　　　　 {
　　　　　　　　　　　　　　　 
　　　　　　　　　　　　　　　 
　　　　　　　　　　　　　　　 buffer = client.Receive(ref remotePoint);
　　　　　　　　　　　　　　　 Packet packet = UtilityHelper.Deserialize(buffer) as Packet;　　　　　 
　　　　　　　　　　　　　　　 Type msgType = packet.GetType();
　　　　　　　　　　　　　　　 if (msgType == typeof(UserListAckPacket))
　　　　　　　　　　　　　　　 {
　　　　　　　　　　　　　　　　　　　 // 转换消息
　　　　　　　　　　　　　　　　　　　 UserListAckPacket usersMsg = (UserListAckPacket)packet;
　　　　　　　　　　　　　　　　　　　 // 更新用户列表
　　　　　　　　　　　　　　　　　　　 userList.Clear();
　　　　　　　　　　　　　　　　　　　 foreach (PeerEntity user in usersMsg.Users)
　　　　　　　　　　　　　　　　　　　 {
　　　　　　　　　　　　　　　　　　　　　　　 userList.Add(user);
　　　　　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　　　　　 bUserListComplete = true;
　　　　　　　　　　　　　　　 }　　　　　　　　　　　　　　　 
　　　　　　　　　　　　　　　 else if (msgType == typeof(UserLoginAckPacket))
　　　　　　　　　　　　　　　 {
　　　　　　　　　　　　　　　　　　　 ProcUserLogAckMsg(packet);
　　　　　　　　　　　　　　　 }　　　　　　　　 
　　　　　　　　　　　　　　　 else if (msgType == typeof(TextPacket))
　　　　　　　　　　　　　　　 {
　　　　　　　　　　　　　　　　　　　 // 转换消息
　　　　　　　　　　　　　　　　　　　 TextPacket txtPacket = (TextPacket)packet;
　　　　　　　　　　　　　　　　　　　 printf("Receive a message: {0}", txtPacket.Message);
　　　　　　　　　　　　　　　　　　　 // 发送应答消息
　　　　　　　　　　　　　　　　　　　 P2PAckPacket ackMsg = new P2PAckPacket();
　　　　　　　　　　　　　　　　　　　 buffer = UtilityHelper.Serialize(ackMsg);
　　　　　　　　　　　　　　　　　　　 client.Send(buffer, buffer.Length, remotePoint);
　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　 else if (msgType == typeof(MassTextPacket))
　　　　　　　　　　　　　　　 {
　　　　　　　　　　　　　　　　　　　 lock (this)
　　　　　　　　　　　　　　　　　　　 {
　　　　　　　　　　　　　　　　　　　　　　　 MassTextPacket fPacket = (MassTextPacket)packet;
　　　　　　　　　　　　　　　　　　　　　　　 if (packets.ContainsKey(fPacket.CLSD))
　　　　　　　　　　　　　　　　　　　　　　　　　　　 packets[fPacket.CLSD].Add(fPacket);
　　　　　　　　　　　　　　　　　　　　　　　 else
　　　　　　　　　　　　　　　　　　　　　　　　　　　 packets.Add(fPacket.CLSD, new List<MassTextPacket>() { fPacket });

　　　　　　　　　　　　　　　　　　　　　　　 printf("PacketID:{0}--SeqNo:{1}--progress:{2}%", fPacket.CLSD, fPacket.SeqID, (int)(System.Math.Round(packets[fPacket.CLSD].Count / (decimal)(fPacket as MassTextPacket).SeqCount, 2) * 100));
　　　　　　　　　　　　　　　　　　　　　　　 //组包
　　　　　　　　　　　　　　　　　　　　　　　 if ((fPacket as MassTextPacket).SeqCount == packets[fPacket.CLSD].Count)
　　　　　　　　　　　　　　　　　　　　　　　 {
　　　　　　　　　　　　　　　　　　　　　　　　　　　 List<MassTextPacket> temp = packets[fPacket.CLSD].OrderBy(c => c.SeqID).ToList();
　　　　　　　　　　　　　　　　　　　　　　　　　　　 List<byte> values = new List<byte>();
　　　　　　　　　　　　　　　　　　　　　　　　　　　 foreach (MassTextPacket mt in temp)
　　　　　　　　　　　　　　　　　　　　　　　　　　　 {
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 byte[] buf = Convert.FromBase64String(mt.Message);　　　　　　　 
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 values.AddRange(buf);
　　　　　　　　　　　　　　　　　　　　　　　　　　　 }

　　　　　　　　　　　　　　　　　　　　　　　　　　　 MassTextPacket value = UtilityHelper.Deserialize(values.ToArray()) as MassTextPacket;

　　　　　　　　　　　　　　　　　　　　　　　　　　　 printf("Receive a message: {0}", value.Message);

　　　　　　　　　　　　　　　　　　　　　　　　　　 
　　　　　　　　　　　　　　　　　　　　　　　　　　　 // 发送应答消息
　　　　　　　　　　　　　　　　　　　　　　　　　　　 P2PAckPacket ackMsg = new P2PAckPacket();
　　　　　　　　　　　　　　　　　　　　　　　　　　　 buffer = UtilityHelper.Serialize(ackMsg);
　　　　　　　　　　　　　　　　　　　　　　　　　　　 client.Send(buffer, buffer.Length, remotePoint);
　　　　　　　　　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　　　　　 }

　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　 else if (msgType == typeof(FileStreamPacket))
　　　　　　　　　　　　　　　 {　　　　　　　　　　　　　　　　 
　　　　　　　　　　　　　　　　　　　 lock (this)　　　　　　　　　　　　　　　　　　　 
　　　　　　　　　　　　　　　　　　　 {
　　　　　　　　　　　　　　　　　　　　　　　 FileStreamPacket fPacket = (FileStreamPacket)packet;
　　　　　　　　　　　　　　　　　　　　　　　 if (packets.ContainsKey(fPacket.CLSD))
　　　　　　　　　　　　　　　　　　　　　　　　　　　 packets[fPacket.CLSD].Add(fPacket);
　　　　　　　　　　　　　　　　　　　　　　　 else
　　　　　　　　　　　　　　　　　　　　　　　　　　　 packets.Add(fPacket.CLSD, new List<MassTextPacket>() { fPacket });

　　　　　　　　　　　　　　　　　　　　　　　 printf("PacketID:{0}--SeqNo:{1}--progress:{2}%", fPacket.CLSD, fPacket.SeqID, (int)(System.Math.Round(packets[fPacket.CLSD].Count / (decimal)(fPacket as FileStreamPacket).SeqCount, 2) * 100));
　　　　　　　　　　　　　　　　　　　　　　　 //组包
　　　　　　　　　　　　　　　　　　　　　　　 if ((fPacket as FileStreamPacket).SeqCount == packets[fPacket.CLSD].Count)
　　　　　　　　　　　　　　　　　　　　　　　 {
　　　　　　　　　　　　　　　　　　　　　　　　　　　 List<MassTextPacket> temp = packets[fPacket.CLSD].OrderBy(c => c.SeqID).ToList();

　　　　　　　　　　　　　　　　　　　　　　　　　　　 System.IO.FileStream fs = new System.IO.FileStream((fPacket as FileStreamPacket).FileName + ".tmp", System.IO.FileMode.Create, System.IO.FileAccess.ReadWrite);
　　　　　　　　　　　　　　　　　　　　　　　　　　　 foreach (FileStreamPacket mt in temp)
　　　　　　　　　　　　　　　　　　　　　　　　　　　 {
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 byte[] buf = Convert.FromBase64String(mt.Message);
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 fs.Write(buf, 0, buf.Length);

　　　　　　　　　　　　　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　　　　　　　　　　　　　 fs.Flush();
　　　　　　　　　　　　　　　　　　　　　　　　　　　 fs.Close();
　　　　　　　　　　　　　　　　　　　　　　　　　　 printf("Receive a file: {0}", (fPacket as FileStreamPacket).FileName);

　　　　　　　　　　　　　　　　　　　　　　　　　　 //清除数据包
　　　　　　　　　　　　　　　　　　　　　　　　　　 packets[fPacket.CLSD].Clear();

　　　　　　　　　　　　　　　　　　　　　　　　　　 // 发送应答消息
　　　　　　　　　　　　　　　　　　　　　　　　　　 P2PAckPacket ackMsg = new P2PAckPacket();
　　　　　　　　　　　　　　　　　　　　　　　　　　 buffer = UtilityHelper.Serialize(ackMsg);
　　　　　　　　　　　　　　　　　　　　　　　　　　 client.Send(buffer, buffer.Length, remotePoint);
　　　　　　　　　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　　　　　 }　　　　　　　　　　　　　 
　　　　　　　　　　　　　　　　　　 
　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　 else if (msgType == typeof(P2PAckPacket))
　　　　　　　　　　　　　　　 {
　　　　　　　　　　　　　　　　　　　 this.ReceivedACK = true;
　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　 else if (msgType == typeof(P2PPurchHolePacket))
　　　　　　　　　　　　　　　 {
　　　　　　　　　　　　　　　　　　　 ProcP2PPurchHoleMsg(packet, remotePoint);
　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　 else if (msgType == typeof(P2PPurchHoleAckPacket))
　　　　　　　　　　　　　　　 {
　　　　　　　　　　　　　　　　　　　 PeerEntity touser = userList.SingleOrDefault(c => c.UserName == (packet as P2PPurchHoleAckPacket).ToUserName);
　　　　　　　　　　　　　　　　　　　 //更改本地的P2P连接时使用的IP地址
　　　　　　　　　　　　　　　　　　　 touser.P2PAddress = touser.RemoteEndPoint;
　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　 Thread.Sleep(100);
　　　　　　　　　　　 }

　　　　　　　 }

　　c.建立p2p会话

　　　　　　　 private void ProcP2PPurchHoleMsg(Packet packet,IPEndPoint remoteEP)
　　　　　　　 {
　　　　　　　　　　　 //打洞请求消息　　　　　　　　　　 
　　　　　　　　　　　 P2PPurchHolePacket purchReqMsg = (P2PPurchHolePacket)packet;
　　　　　　　　　　　 PeerEntity toUser = userList.Single(c => c.UserName == purchReqMsg.ToUserName);
　　　　　　　　　　　 PeerEntity user = userList.Single(c => c.UserName == purchReqMsg.UserName);
　　　　　　　　　　　 toUser.P2PAddress = toUser.RemoteEndPoint;
　　　　　　　　　　　 printf("Set P2P Address for {0}->[{1}]", user.UserName, toUser.P2PAddress.ToString());　　 
　　　　　　　　 
　　　　　　　　　　　 //uPnp实现端口映射
　　　　　　　　　　　 if(NAT.AddPortMapping(toUser.P2PAddress.Port, ProtocolType.Udp, "AddPortMapping"))
　　　　　　　　　　　　　　　 printf("Port mapping successed!");

　　　　　　　　　　　 // 发送打洞消息到远程主机
　　　　　　　　　　　 P2PPurchHoleAckPacket trashMsg = new P2PPurchHoleAckPacket(purchReqMsg.UserName, purchReqMsg.ToUserName);　　　　　　　　　 
　　　　　　　　　　　 byte[] buffer = UtilityHelper.Serialize(trashMsg);
　　　　　　　　　　　 client.Send(buffer, buffer.Length, user.RemoteEndPoint);
　　　　　　　 }

　　3、服务端

　　a、消息处理线程

　 private void RecvThreadProc()
　　　　　　　 {
　　　　　　　　　　　 IPEndPoint remotePoint = null;
　　　　　　　　　　　 byte[] msgBuffer = null;
　　　　　　　　　　　 while (true)
　　　　　　　　　　　 {　　　　　　　　　　　　 
　　　　　　　　　　　　　　　 msgBuffer = server.Receive(ref remotePoint);
　　　　　　　　　　　　　　　 try
　　　　　　　　　　　　　　　 {
　　　　　　　　　　　　　　　　　　　 object msgObj = UtilityHelper.Deserialize(msgBuffer);
　　　　　　　　　　　　　　　　　　　 switch ((msgObj as Packet).GetCommandType())
　　　　　　　　　　　　　　　　　　　 {
　　　　　　　　　　　　　　　　　　　　　　　 case Command.MSG_USERLOGIN:　　　　　　　　 //用户登录　　　　　　　　　　　　　　　　　　　　　　　　　　　 
　　　　　　　　　　　　　　　　　　　　　　　　　　　 ProcUserLoginMsg(msgObj as UserLoginPacket, remotePoint);
　　　　　　　　　　　　　　　　　　　　　　　　　　　 break;
　　　　　　　　　　　　　　　　　　　　　　　 case Command.MSG_USERLOGOUT:　　　　　　　 //退出登录
　　　　　　　　　　　　　　　　　　　　　　　　　　　 ProcUserLogoutMsg(msgObj as UserLogoutPacket, remotePoint);
　　　　　　　　　　　　　　　　　　　　　　　　　　　 break;
　　　　　　　　　　　　　　　　　　　　　　　 case Command.MSG_GETUSERLIST:　　　　　　 //所有用户列表　　　　　　　　　　　　　　　　　　　　　　　　　　　 
　　　　　　　　　　　　　　　　　　　　　　　　　　　 ProcGetUserListMsg(msgObj as UserListPacket, remotePoint);
　　　　　　　　　　　　　　　　　　　　　　　　　　　 break;
　　　　　　　　　　　　　　　　　　　　　　　 case Command.MSG_P2PCONNECT:　　　　　　　 //点对点连接信息　　　　　　　　　　　　　　　　　　　　　　　　　　 
　　　　　　　　　　　　　　　　　　　　　　　　　　　 ProcP2PConnectMsg(msgObj as P2PConnectionPacket, remotePoint);
　　　　　　　　　　　　　　　　　　　　　　　　　　　 break;
　　　　　　　　　　　　　　　　　　　　　　　 case Command.MSG_USERACTIVEQUERY:　　 // 用户对服务器轮询的应答　　　　　　　　　　　　　　　　　　　　　　　　　　　 
　　　　　　　　　　　　　　　　　　　　　　　　　　　 ProcUserActiveQueryMsg(msgObj as UserActiveQueryPacket, remotePoint);
　　　　　　　　　　　　　　　　　　　　　　　　　　　 break;
　　　　　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　　　　　 Thread.Sleep(100);
　　　　　　　　　　　　　　　 }
　　　　　　　　　　　　　　　 catch { }
　　　　　　　　　　　 }
　　　　　　　 }

　　b、服务端请求客户端建立p2p连接

　　　　　　　 private void ProcP2PConnectMsg(Packet packet,IPEndPoint remoteEP)
　　　　　　　 {
　　　　　　　　　　　 // 转换接受的消息
　　　　　　　　　　　 P2PConnectionPacket transMsg = (P2PConnectionPacket)packet;
　　　　　　　　　　　 printf("{0}({1}) wants to p2p {2}", remoteEP.Address.ToString(), transMsg.UserName, transMsg.ToUserName);
　　　　　　　　　　　 // 获取目标用户
　　　　　　　　　　　 PeerEntity toUser = userList.SingleOrDefault(c => c.UserName == transMsg.ToUserName);
　　　　　　　　　　　 
　　　　　　　　　　　 // 转发Purch Hole请求消息
　　　　　　　　　　　 P2PPurchHolePacket transMsg2 = new P2PPurchHolePacket(transMsg.UserName, toUser.UserName);
　　　　　　　　　　　 //转发消息
　　　　　　　　　　　 byte[] buffer = UtilityHelper.Serialize(transMsg2);
　　　　　　　　　　　 server.Send(buffer, buffer.Length, toUser.RemoteEndPoint);
　　　　　　　　　　 
　　　　　　　 }

 

　　4、测试

　　a、服务端

　　b、客户端

　　困惑:

　　1、能不能实现外网通讯,要实现像QQ那样通讯要做哪些改进。

　　2、文件续传如何实现。

　　3、c#封装的网络操作类(像QQ.NET源码的Net实现)

　　4、远程协助的实现。

　　最后，希望大家共同讨论、共同进步！！！

Jerry_pic
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
c# 实现即时通讯工具
12-03
c#编的即时通讯工具，实现了局域网内即时通讯、文件传输、可扩展
[C# 网络编程系列：P2P编程
wangyizhi58的专栏
09-14 1417
引言： 前面的介绍专题中有朋友向我留言说介绍下关于P2P相关的内容的，首先本人对于C#网络编程也不是什么大牛，因为能力的关系，也只能把自己的一些学习过程和自己的一些学习过程中的理解和大家分享下的，下面就进入正题——P2P（Peer to Peer）编程   一、P2P的介绍  首先，现在大家熟知的BT、电驴、迅雷、QQ、MSN和PPlive等都是基于P2P方式实现的软件，并
C#通信工具
11-23
客户端服务器通信协议，进行服务器进行手机通信，进行文件的共享
可以实现即时通讯功能的C#语言编写的通信软件
12-06
在visual studio2010开发软件的C#语言的即时通信软件，使用socket套接字技术
小型即时通讯软件-C#
qq_42283621的博客
08-01 761
111
C#开源软件
深渊的水影
08-10 1393
转载 ： http://www.cnblogs.com/bsso/p/3510636.html 商业协作和项目管理平台-TeamLab 网络视频会议软件-VMukti 驰骋工作流程引擎-ccflow 【免费】正则表达式测试工具-Regex-Tester Windows-Phone-7-SDK Excel-读写组件-ExcelLibrary .NET集成开发环境-...
C#制作的网络浏览软件
05-09
摘要:C#源码,网络相关,浏览器　C#制作的网络浏览软件，使用VS2008制作的一款仿IE浏览器的软件，有地址栏有前进后退按钮，可添加网页到收藏夹中，输入指定地址可实现浏览网页的功能，源码编译后的运行截图如上所示。
C#.Net Socket 网络通讯编程
02-21
C#.Net开发Socket 知识，例程；C# Socket编程笔记，接收发送数据示例代码，适合初学者学习
C#与各种PLC通讯测试
05-10
用来测试各种品牌PLC与上位机的通讯，PLC端无需进行任何程序操作和编写
C# winform 通讯录软件
05-07
这是几个实现的比较好的通讯录软件，全部用C#实现，和大家分享。
C#视频通讯程序
12-27
一个完整的C#视频通讯程序，可以运行，代码清晰易懂
P2P远程控制C#.net二次开发源码
01-31
P2P方式连接其他电脑，穿透内网，两个在不通地方的机器之间可以直接连接。不需要对方有公网IP。 远程协助组件SDK 4.06支持剪切板文字复制粘帖。 新版简化了文件传输，可直接从远程复制粘帖到本地文件，拖动本地文件到远程指定目录。二次开发更简单。
C#编写的局域网视频会议软件，实现了音频通讯和视频通讯
04-20
学习材料 可做参考
zeromq c# .net版本 网络通讯库
02-27
c# .net版本 用 进入SRC中 clrzmq.sln用VS2012以上版本打开 clrzmq.Mono.sln 用VS2010打开 本人用 VS2012 打开 CLRZMQ.SLN编译成功
C#TCP网络通讯
11-06
TCP（Transmission Control Protocol 传输控制协议）是一种面向连接的、可靠的、基于字节流的...本程序基于TCP编程，多线程、监听服务、Socket套接字，实现网络通讯聊天。 VS2010环境测试通过，希望对你学习帮助有用。
《c# 实现p2p文件分享与传输系统》 一、 模型
weixin_33725270的博客
06-28 317
c#实现P2P文件分享与传输系统  一、模型 　　P2P的概念大家都不陌生，也就是所谓的“点对点传输”，即不直接通过服务器，在两台或多台客户端之间传输数据，实现信息交流和资源共享。P2P技术已经发展了很多年了，虽然理论上已经发展了很多的模型，但在实际的网络环境中（尤其是镇里这种环境），究竟怎样的网络结构才具有较好的稳定性和较高的传输性能，还是有很大的争议，每家做P2P的网络公司都会有不同的见解...
P2P实现远程控制
superxxd的专栏
08-12 2221
webrtc是实时音视频传输的利器，除了audio /video track的传输外还有datachannel可用于数据和信息的实时交互，在设备和浏览器间建立一个p2p通道，利用mqtt作为信令，通过对设备端rtsp服务器推流进行转换实现视频的采集，另外利用datachannel 发送浏览的监听的鼠标键盘数据给设备实现控制受控机的鼠标键盘，从而实现远程桌面控制。没事的时候自己diy一个远程控制设备，增加自己学习webrtc 和go语言的兴趣，两全其美。android系统控制。手机对Win10桌面控制。...
c#p2p五子棋对战
最新发布
12-15
1.创建一个基于P2P网络的五子棋对战程序，可以使用C#语言和.NET框架来实现。 2.在程序中实现五子棋游戏的基本规则和操作，包括放子、逼子、走子、吃子等。 3.使用P2P网络技术实现两个玩家之间的通信和数据传输，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值