Socket编程 (异步通讯,解决Udp丢包) - Part4

于 2024-09-08 22:07:47 发布
阅读量687 收藏 17
点赞数 5
分类专栏： Socket 文章标签： tcp/ip c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ForKnowledgeMe/article/details/141962857
版权

对于基于socket的udp协议通讯，丢包问题大家应该都见怪不怪了，但我们仍然希望在通讯方面使用Udp协议通讯，因为它即时，消耗资源少，响应迅速，灵活性强无需向Tcp那样建立连接消耗很长的时间等等很有优势的理由让我们对Udp通讯寄予了厚望。但它也存在一个不好的特点，经常丢包是时常发生的事。可能各位大侠已经有了很好的解决方案，本人在这也只是本着大家共同学习的目的，提供自己的解决方式。

解决思路：模拟tcp三次握手协议，通过使用Timer定时器监视发送请求后接受数据的时间，如果一段时间内没有接受到数据包则判定丢包，并重新发送本次请求。

下面我们将通过在客户端向服务器端发送文件以及请求下载文件…将该例子是如何解决Udp丢包的问题。

个人优化：基于上章项目的Tcp协议下通讯，模拟聊天的同时发送文件。我们开辟两个端口，一个基于Tcp协议下进行聊天通讯，一个基于Udp协议下传送文件通讯。

项目大致思路如下：

发送文件：1.tcp客户端(文件发送端)先在本端初始化Udp服务端，并绑定好相应的端口，并将Ip地址以及端口号发送到tcp服务器端(文件接收端)。

2.tcp服务端(文件接收端)接收到发送文件请求后，初始化Udp客户端，并向指定的Udp服务端发送已准备完毕信息。

3.Udp服务器端接收到Udp客户端已准备好的信息后，初始化要发送文件对象，获取文件的基本参数(文件名、文件大小、数据大小、数据包总数)。

4.Udp客户端收到文件的基本参数后想Udp服务端发送开始发送文件，以及此时接受到文件之后的偏移量，告诉Udp服务端应该从文件的哪个部分发送数据。此时启动Timer定时器。

5.Udp服务器端收到文件继续发送的请求后，设置文件的偏移量，然后发送对应的数据包。此时关闭Timer定时器。

6.循环4-5过程直到文件发送完毕后，Udp客户端向Udp服务端发送文件接受完毕消息，并与3秒后关闭Udp客户端套接字。

7.Udp接受到文件接受完毕的消息后，关闭该套接字。

8.Udp客户端一段时间没接受到消息则出发Timer的定时触发事件，重新发送本次请求。

接收文件：1.tcp客户端(文件发送端)先在本端初始化Udp服务端，并绑定好相应的端口，并将Ip地址以及端口号发送到tcp服务器端(文件接收端)。

2.tcp服务端(文件接收端)接收到发送文件请求后，初始化Udp客户端，并根据文件名初始化要发送文件对象，获取文件的基本参数(文件名、文件大小、数据大小、数据包总数)，并将此信息转成协议信息发送到Udp服务端。

后面的过程与上类似，我就不再马字了…

下面的过程主要针对发送文件进行讲解：

对于文件信息以及各种其他确认请求通过自定义协议发送后并解析的情况，在上一章都已经展示给大家看了。

Udp服务端以及Udp客户端继承UdpCommon公用抽象类，主要存放两端共同所需对象及方法：

/// <summary>
    /// Udp异步通讯公有类
    /// 实现server与client相同方法
    /// </summary>
    public abstract class UdpCommon : IDisposable
    {
        #region 全局成员
        protected Socket worksocket;//当前套接字
        protected EndPoint sendEP;//发送端remote
        protected EndPoint reciveEP;//接受端remote
        protected int buffersize = 1024;//数据缓冲区大小

        protected RequestFile requestFile;//文件请求

        protected FileSendManager sendmanager;//文件发送管理
        protected FileReciveManager recivemanager;//文件接收管理

        protected HandlerMessage handlerMsg = new HandlerMessage();//消息协议处理类

        protected delegate void ReciveCallbackDelegate(int length, byte[] buffer);
        protected event ReciveCallbackDelegate ReciveCallbackEvent;//消息接收处理事件

        protected delegate void TimeOutHandlerDelegate(MutualMode mode, byte[] buffer);
        protected event TimeOutHandlerDelegate TimeOutHandlerEvent;//超时处理
        #endregion

        #region 构造函数
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="_requestFile">请求信息</param>
        public UdpCommon(RequestFile _requestFile)
        {
            requestFile = _requestFile;
        }
        #endregion

        #region 抽象方法
        /// <summary>
        /// 接受buffer处理
        /// </summary>
        /// <param name="length"></param>
        /// <param name="buffer"></param>
        public abstract void ReciveBufferHandler(int length, byte[] buffer);
        #endregion

        #region 异步接受/发送buffer
        /// <summary>
        /// 异步接受buffer
        /// </summary>
        protected void AsynRecive()
        {
            byte[] buffer = new byte[buffersize];
            worksocket.BeginReceiveFrom(buffer, 0, buffer.Length, SocketFlags.None, ref reciveEP,
                asyncResult =>
                {
                    if (asyncResult.IsCompleted)//信息接收完成
                    {
                        int length = worksocket.EndReceiveFrom(asyncResult, ref sendEP);
                        if (TimeOutHandlerEvent != null)
                        {
                            TimeOutHandlerEvent.Invoke(MutualMode.recive, null);
                        }
                        ReciveCallbackEvent.Invoke(length, buffer);
                    }
                }, null);
        }
        /// <summary>
        /// 异步发送buffer
        /// </summary>
        /// <param name="buffer"></param>
        protected void AsynSend(byte[] buffer)
        {
            worksocket.BeginSendTo(buffer, 0, buffer.Length, SocketFlags.None, sendEP,
                asyncResult =>
                {
                    if (asyncResult.IsCompleted)//消息发送完成
                    {
                        worksocket.EndSendTo(asyncResult);
                        if (TimeOutHandlerEvent != null)
                        {
                            TimeOutHandlerEvent.Invoke(MutualMode.send, buffer);
                        }
                    }
                }, null);
        }
        #endregion
}

Udp服务端初始化Socket套接字，并初始化相应的消息返回处理委托事件：

using System;
using System.Collections.Generic;
using System.Text;
#region 命名空间
using System.Net;
using System.Net.Sockets;
using System.IO;
using SocketCommon;
#endregion

namespace ClientConsole
{
    public class UdpServer : UdpCommon
    {
        public UdpServer(RequestFile _requestFile)
            : base(_requestFile)
        {
            //初始化套接字
            IPEndPoint ipep = new IPEndPoint(IPAddress.Parse("192.168.1.108"), 0);
            base.worksocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
            base.worksocket.Bind(ipep);
            base.reciveEP = base.sendEP = (EndPoint)(new IPEndPoint(IPAddress.Any, 0));

            //返回Ip地址及端口信息
            IPEndPoint localEP = (IPEndPoint)base.worksocket.LocalEndPoint;
            requestFile.Address = localEP.Address.ToString();
            requestFile.Port = localEP.Port;

            //根据不同的请求初始化相应的事件
            if (requestFile.Mode == RequestMode.send)//发送准备
            {
                base.ReciveCallbackEvent += new ReciveCallbackDelegate(ReadySendBuffer);
            }
            else //接受准备
            {
                base.ReciveCallbackEvent += new ReciveCallbackDelegate(ReadyReciveBuffer);
            }
            base.AsynRecive();
        }
        /// <summary>
        /// 准备发送文件信息
        /// </summary>
        /// <param name="length"></param>
        /// <param name="buffer"></param>
        public void ReadySendBuffer(int length, byte[] buffer)
        {
            MessageProtocol msgPro = handlerMsg.HandlerObject(Encoding.UTF8.GetString(buffer, 0, length));
            if (msgPro.MessageType == MessageType.text && msgPro.MessageInfo.Content == "ready")
            {
                ReciveCallbackEvent -= new ReciveCallbackDelegate(ReadySendBuffer);
                ReciveCallbackEvent += new ReciveCallbackDelegate(ReciveBufferHandler);
                if (sendmanager == null)
                {
                    sendmanager = new FileSendManager(requestFile.FileObject);
                    Console.WriteLine("发送文件：{0}", sendmanager.fileobject.FileName);
                }
                msgPro = new MessageProtocol(RequestMode.send, sendmanager.fileobject);
                AsynSend(msgPro.ToBytes());
                AsynRecive();
            }
        }
        /// <summary>
        /// 接受下一个包请求或者发送下一个数据包
        /// </summary>
        /// <param name="length"></param>
        /// <param name="buffer"></param>
        public override void ReciveBufferHandler(int length, byte[] buffer)
        {
            if (requestFile.Mode == RequestMode.send) //发送文件
            {
                SendFile(length, buffer);
            }
            else//写入文件
            {
                ReciveFile(length, buffer);
            }
        }
    }
}

因为两端都存在SendFile以及ReciveFile的方法，我们在UdpCommon实现两个方法方便两端共同调用。

#region 准备发送/接收文件
        /// <summary>
        /// 准备接收
        /// </summary>
        protected void ReciveReady()
        {
            recivemanager = new FileReciveManager(requestFile.FileObject);
            Console.WriteLine("接受文件：{0}", recivemanager.fileobject.FileName);
            RequestAction();
        }
        /// <summary>
        /// 准备接收文件Buffer
        /// </summary>
        /// <param name="length"></param>
        /// <param name="buffer"></param>
        protected void ReadyReciveBuffer(int length, byte[] buffer)
        {
            MessageProtocol msgPro = handlerMsg.HandlerObject(Encoding.UTF8.GetString(buffer, 0, length));
            ReciveCallbackEvent -= new ReciveCallbackDelegate(ReadyReciveBuffer);
            ReciveCallbackEvent += new ReciveCallbackDelegate(ReciveBufferHandler);
            requestFile = msgPro.RequestFile;
            ReciveReady();
        }
        #endregion

        #region 发送/接收文件
        /// <summary>
        /// 发送文件
        /// </summary>
        /// <param name="length"></param>
        /// <param name="buffer"></param>
        protected void SendFile(int length, byte[] buffer)
        {
            string protocol = Encoding.UTF8.GetString(buffer, 0, length);
            MessageProtocol msgPro = handlerMsg.HandlerObject(protocol);
            if (msgPro.MessageType == MessageType.text)
            {
                string msg = msgPro.MessageInfo.Content;
                string[] strArr = msg.Split('|');
                Status status = (Status)Enum.Parse(typeof(Status), strArr[0]);
                if (status == Status.keepon)
                {
                    sendmanager.offset = Convert.ToInt32(strArr[1]);//文件偏移量
                    AsynSend(sendmanager.Read());//发送下一个包
                    Console.WriteLine("已发送：{0}%", sendmanager.GetPercent());
                    AsynRecive();
                }
                else Dispose();
            }
        }
        /// <summary>
        /// 接受文件
        ///     1.未接收完之前将文件保存为临时文件
        ///     2.完毕后通过moveTo重命名
        /// </summary>
        /// <param name="length"></param>
        /// <param name="buffer"></param>
        protected void ReciveFile(int length, byte[] buffer)
        {
            recivemanager.Write(buffer);
            Console.WriteLine("已接受：{0}%", recivemanager.GetPercent());
            RequestAction();
        }
        #endregion

        #region 发送请求下一个包
        /// <summary>
        /// 发送请求下一个包
        /// </summary>
        public void RequestAction()
        {
            //根据状态处理
            MessageProtocol msgPro = new MessageProtocol(
                    String.Format("{0}|{1}", (int)recivemanager.status, recivemanager.offset));
            if (recivemanager.status == Status.keepon)
            {
                AsynSend(msgPro.ToBytes());
                long tempsize = recivemanager.fileobject.FileLength - recivemanager.offset;
                if (tempsize < recivemanager.fileobject.PacketSize)
                {
                    buffersize = Convert.ToInt32(tempsize);
                }
                else buffersize = recivemanager.fileobject.PacketSize;
                AsynRecive();
            }
            else
            {
                TimeOutHandlerEvent = null;
                AsynSend(msgPro.ToBytes());
            }
        }
        #endregion

        #region 释放资源
        /// <summary>
        /// 释放资源
        /// </summary>
        public void Dispose()
        {
            if (worksocket != null)
            {
                Thread.Sleep(3);
                worksocket.Close(3);
            }
        }
        #endregion

下面我来看看Udp客户端是怎样工作的…

using System;
using System.Collections.Generic;
using System.Text;
#region 命名空间
using System.Net;
using System.Net.Sockets;
using System.IO;
using SocketCommon;
using System.Timers;
#endregion

namespace ServerConsole
{
    public class UdpClient : UdpCommon
    {
        /// <summary>
        /// 定时器辅助类
        /// </summary>
        TimerManager timermanager;//定时(用于超时重发)
        //当前发送请求数据缓存
        byte[] temp_buffer;
        public UdpClient(RequestFile _requestFile)
            : base(_requestFile)
        {
            //初始化套接字
            base.worksocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
            base.sendEP = new IPEndPoint(IPAddress.Parse(_requestFile.Address), requestFile.Port);
            base.reciveEP = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 0);

            //根据不同的请求返回对应的消息
            MessageProtocol msgPro;
            if (_requestFile.Mode == RequestMode.send)//接受准备
            {
                base.ReciveCallbackEvent += new ReciveCallbackDelegate(ReadyReciveBuffer);
                msgPro = new MessageProtocol("ready");
            }
            else //发送准备
            {
                base.ReciveCallbackEvent += new ReciveCallbackDelegate(ReciveBufferHandler);
                sendmanager = new FileSendManager(requestFile.FileObject);
                msgPro = new MessageProtocol(RequestMode.recive, sendmanager.fileobject);
                Console.WriteLine("发送文件：{0}", sendmanager.fileobject.FileName);
            }
            //初始化定时器
            timermanager = new TimerManager(3000);
            timermanager.ElapsedEvent += new TimerManager.ElapsedDelegate(ElapsedEvent);
            base.TimeOutHandlerEvent += new TimeOutHandlerDelegate(TimeOutHandler);
            base.AsynSend(msgPro.ToBytes());
            base.AsynRecive();
        }
        /// <summary>
        /// 请求下一个数据包或者发送下一个数据包
        /// </summary>
        /// <param name="length"></param>
        /// <param name="buffer"></param>
        public override void ReciveBufferHandler(int length, byte[] buffer)
        {
            if (requestFile.Mode == RequestMode.send)//接受来自客户端的文件
            {
                ReciveFile(length, buffer);
            }
            else //向客户端发送文件
            {
                SendFile(length, buffer);
            }
        }

        private void TimeOutHandler(MutualMode mode, byte[] buffer)
        {
            this.temp_buffer = buffer;
            if (mode == MutualMode.send)
            {
                if (!timermanager.IsRuning)
                {
                    timermanager.Start();
                }
            }
            else
            {
                if (timermanager.IsRuning)
                {
                    timermanager.Stop();
                }
            }
        }
        /// <summary>
        /// 超时后重发当前请求
        /// </summary>
        private void ElapsedEvent()
        {
            if (temp_buffer != null)
            {
                Console.WriteLine("发生丢包，重新请求...");
                base.AsynSend(temp_buffer);
            }
        }
    }
}

我们来看看运行效果：

发送文件：在这里插入图片描述
接收文件：
在这里插入图片描述
由此对于文件使用Udp传送的过程我们完成了，上面测试过程中如果出现丢包会重新发送本次请求，并接收数据。

UDP服务端丢包-发送频率过高导致丢包
西京刀客
10-20 1825
接收方丢UDP包,发送频率过高导致丢包，主要会造成接收方自身丢包。
基于udp的网络编程socket的错误10054与SOCKET的发送与接收缓冲区的设置（udp丢包）
老衣的专栏
08-09 3882
哎！长叹一声！今天上班很鬼火，被老板骂了一顿，严重的打击了我的自信！哎，鬼火啊，到今天下班以前，才把任务完成了一点点。明天要继续努力哦！总结今天碰到的问题。 首先：今天在做一个视频转发器，用vlc播放器推视频流，通过转发器然后发送到另外一个pc，然后用vlc播放器播放，这些都是
你真的会用socket UDP吗? UDP丢包得厉害,怎么解决? 我先给你讲UDP的理论,再告诉你解决办法,省得直接告诉你答案反而说太短
12-15
你真的会用socket UDP吗? UDP丢包得厉害,怎么解决? 我先给你讲UDP的理论,再告诉你解决办法,省得直接告诉你答案反而说太短
【Socket】解决UDP丢包问题
Smartlab411
06-07 2587
UDP是一种不可靠的、无连接的、基于数据报的传输层协议。相比于TCP就比较简单，像写信一样，直接打包丢过去，就不用管了，而不用TCP这样的反复确认。所以UDP的优势就是速度快，开销小。
基于UDP SOCKET 统计丢包率
11-22
基于数据报套接字的C/S模型通信，客户端向服务器发送数据报并回射给客户端，统计丢包率。
linux网络编程-宋敬彬-part1
03-03
目 录 第1篇 Linux网络开发基础 第1章 Linux操作系统概述 2 1.1 Linux发展历史 2 1.1.1 Linux的诞生和发展 2 1.1.2 Linux名称的由来 1.2 Linux的发展要素 3 ...1.2.1 UNIX操作系统 4 ...10.1.1 UDP编程框图 267
Windows Sockets网络编程 总计4个包，part2
11-03
《Windows Sockets网络编程》是WindowsSockets网络编程领域公认的经典著作，由Windows Sockets2.0规范解释小组负责人亲自执笔，权威性毋庸置疑。它结合大量示例，对WindowsSockets规范进行了深刻地解读，系统讲解了...
Visual C++网络编程案例_part2.rar
09-17
第1篇介绍了Visual C++网络开发基础知识，包括Visual C++网络编程概述、Socket套接字编程和多线程与异步套接字编程。第2篇介绍了7大类网络开发典型应用案例的实现，包括FTP客户端实现之一、 FTP客户端实现之二、网页...
Windows Sockets网络编程 可能是最清晰版本(Windows Sockets 2规范解释小组负责人亲自执笔。)总共4个包，part1
11-03
《Windows Sockets网络编程》是WindowsSockets网络编程领域公认的经典著作，由Windows Sockets2.0规范解释小组负责人亲自执笔，权威性毋庸置疑。它结合大量示例，对WindowsSockets规范进行了深刻地解读，系统讲解了...
Visual C++网络编程案例part1
09-17
第1篇介绍了Visual C++网络开发基础知识，包括Visual C++网络编程概述、Socket套接字编程和多线程与异步套接字编程。第2篇介绍了7大类网络开发典型应用案例的实现，包括FTP客户端实现之一、 FTP客户端实现之二、网页...
Python之socket模块使用详解（附带解决丢包、粘包问题）
热门推荐
皮皮鱼哟
12-23 1万+
文章目录一、Socket简介1. Socket 一、Socket简介 1. Socket 网络上的两个程序通过一个双向的通信连接实现数据的交换，这个连接的一端称为一个socket。 Socket又称"套接字"，应用程序通常通过"套接字"向网络发出请求或者应答网络请求，使主机间或者一台计算机上的进程间可以通讯。 他工作于TCP/IP协议中应用层和传输层之间的一个抽象，如下图： ...
一个SOCKET选项导致的UDP通信问题
yourwonder的专栏
09-17 2009
场景：两台服务器，在不同路由器下，我们称之为服务器A和B，现在C向A发送UDP包，A可以收到；同样的程序，C向B发送成UDP包，B却只能收到一个包，后面全部没有到达网卡（tcpdump抓包显示）。 然后就是紧张的排查了，尝试用自己写的程序替换C的程序，结果发送到A和B都成功；这时候意识到一个问题，C原来的程序肯定有问题，于是去查看代码，最终发现唯一区别是socket选项，于是我们把那些选项一个个
为什么UDP接收或发送会丢包
vc66vcc的博客
06-01 4595
摘自海思sdk内文档 BSP FAQ.docl   用户态应用程序在接收UDP数据时（单播或组播报文），同时进行其它有延时的操作(如写码流数据到USB存储设备), 应该程序将延迟接收UDP数据包，而socket默认接收缓存只有108544Byte，这样可能会使socket接收缓存满，无法接收新的UDP数据包，出现丢包现象。可在内核下通过执行下面命令进行确认：cat /proc/net/snmp| ...
C#解决Socket丢包，段包，粘包算法
HilaryHe
03-14 8449
C#解决Socket丢包，段包，粘包算法： /// /// Socket 丢包，段包，粘包 算法 /// public class RequestHandler { private string temp = string.Empty; /// /// 处理Socket 丢包，段包，粘包 算法
C#Socket通信基础（异步Socket通信UDP）
CoffeMilk的博客
10-27 1907
一、通信原理参考https://blog.csdn.net/xiaochenXIHUA/article/details/83446031。 异步通信解决同步通信的缺点可以双向发送和接收信息；异步通信思路是引入多线程机制，在一个进程中使用两个线程，分别处理接收线程与发送线程，这种机制称为异步Socket。 二、编写异步UDP通信方法 &lt;1&gt;信息发送接收代码 using Syst...
Socket通讯的TCP和UDP
Krisiiy
12-25 1054
UDP协议和TCP协议都是传输层协议。 TCP（Transmission Control Protocol，传输控制协议）提供的是面向连接的、可靠的字节流服务，即客户和服务器交换数据前，必须先在双方之间建立一个TCP连接，才能传输数据，并提供超时重发、丢弃重复数据、检验数据、流量控制等功能，保证数据能从一端传到另一端。（对失序数据包能重新排序、应答机制） UDP（User Data Protocol，用户数据报协议）是一个面向数据报的传输层协议。他不提供可靠性，只是把应用程序传给IP层的数据包发送出去，但是
C# Socket TCP 通信
最新发布
meibianchuidi123的博客
08-09 342
Socket、TCP通信
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值