基于Sockets下载,支持 断点续传多线程下载

最新推荐文章于 2022-02-23 17:56:42 发布
转载 最新推荐文章于 2022-02-23 17:56:42 发布 · 1k 阅读 · 0
文章标签：

#sockets #string #http服务器 #byte #exception #system

本文介绍了一种基于C#的多线程HTTP下载技术实现方法，通过自定义类完成下载任务分配、状态管理和异常处理等功能。该方案支持断点续传、多线程并发下载及代理服务器配置。

下载程序主要类

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

namespace myIIS
{
  
    public class HttpDownload
    {
        private string linkUrl="";//链接的url
        private HttpProxy proxy = null;
        private long contentLength = 0;//下载文件长度
        private string fileName="";//下载文件名
        private string method = "GET";//HTTP方法
        private string sendMessage="";//用POST方法象HTTP服务器发送的信息
        private int itemCount = 10;//文件下载的块数量
        private HttpDownloadItem[] items;
       
        private IPAddress connectIP = null;
        private IPEndPoint connectEndPoint = null;
     
        private string modeString = "";//代理连接字符串
        private string hostString = "";//主机字符串
           
        public HttpDownload(string linkUrl)
        {
            this.linkUrl = linkUrl;
        }
        /// <summary>
        /// 获取下载文件头信息
        /// </summary>
        public void GetHttpHeadInfo()
        {
           
            string receiveString = "";//收到http服务器返回的字符串


            //获取主机字符串
            hostString = linkUrl;
            int l = hostString.IndexOf("://") + ("://").Length;
            if (l != -1)
            {
                hostString = hostString.Substring(l);
            }
            l = hostString.IndexOf("/");
            if (l != -1)
            {
                hostString = hostString.Substring(0, l);
            }


            Socket httpSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

           
            //根据是否使用代理服务器确定帮定远程计算机的IP
            if (proxy != null)
            {
                //使用代理服务器
                connectIP = proxy.IP;
                connectEndPoint = new IPEndPoint(connectIP, proxy.Port);
                modeString = "Proxy-Connection: Keep-Alive";
            }
            else
            {
                //主机中没有端口，使用默认的80端口
                if (hostString.IndexOf(":") == -1)
                {
                    connectIP = IPAddress.Parse(hostString);
                    connectEndPoint = new IPEndPoint(connectIP, 80);
                }
                else
                {
                    l = hostString.IndexOf(":");
                    connectIP = IPAddress.Parse(hostString.Substring(0,l));
                    connectEndPoint = new IPEndPoint(connectIP, int.Parse(hostString.Substring(l+1, hostString.Length-l-1)));
                }
                modeString = "Connection: Keep-Alive";
            }

 

            string formatString = "{0} {1} HTTP/1.1/r/nContent-Type: application/x-www-form-urlencoded/r/nContent-Length: {2}/r/nExpect: 100-continue/r/n{3}/r/nHost: {4}/r/n/r/n{5}";
            string sendString = string.Format(formatString, "HEAD", linkUrl, Encoding.Default.GetByteCount(sendMessage), modeString, hostString, sendMessage);
           
            byte[] sendBuffer = System.Text.Encoding.Default.GetBytes(sendString);

            try
            {
                httpSocket.Connect(connectEndPoint);
                httpSocket.Send(sendBuffer);

                int block = 10240;//定义网络缓冲区大小
                byte[] receiveBuffer = new byte[block];//定义网络缓冲区
                block = httpSocket.Receive(receiveBuffer);
                receiveString = System.Text.Encoding.Default.GetString(receiveBuffer, 0, block);
                //是否收到下载文件名和文件长度信息
                while ((receiveString.IndexOf("filename=") == -1 || receiveString.IndexOf("Content-Length: ") == -1) && block > 0)
                {
                    block = httpSocket.Receive(receiveBuffer);
                    receiveString = string.Concat(receiveString, System.Text.Encoding.Default.GetString(receiveBuffer, 0, block));
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                httpSocket.Close();
            }
            int begin = receiveString.IndexOf("filename=")+("filename=").Length;
            int end = receiveString.IndexOf("/r/n", begin);
            this.fileName = receiveString.Substring(begin, end - begin);
            begin = receiveString.IndexOf("Content-Length: ") + ("Content-Length: ").Length;
            end = receiveString.IndexOf("/r/n", begin);
            this.contentLength = int.Parse(receiveString.Substring(begin, end - begin));
            SetItems();
        }

        void SetItems()
        {
            items = new HttpDownloadItem[itemCount];
            for (int i = 0; i < itemCount; i++)
            {
                items[i] = new HttpDownloadItem(this);
                int itemLength=(int)this.contentLength / this.itemCount;

               
                items[i].BeginRange = i * itemLength;
                items[i].EndRange = (i + 1) * itemLength;
                items[i].Id = i;  
            }
            items[itemCount - 1].EndRange = (int)this.contentLength;
        }
        public void Download()
        {
            foreach (HttpDownloadItem Item in items)
            {
                Thread downlaodThread = new Thread(new ThreadStart(Item.Download));
                downlaodThread.Start();
                //Item.Download();

              
            }
        }

        public HttpDownloadItem[] Items
        {
            get
            {
                return items;
            }
        }
        public string Url
        {
            get
            {
                return linkUrl;
            }
            set
            {
                linkUrl = value;
            }
        }

        public HttpProxy Proxy
        {
            set
            {
                proxy = value;
            }
        }
        public string Method
        {
            set
            {
                method = value;
            }
        }
        public string SendMessage
        {
            set
            {
                sendMessage = value;
            }
            get
            {
                return sendMessage;
            }
        }
        public int ItemCount
        {
            set
            {
                itemCount = value;
            }
        }
        internal string ModeString
        {
            get
            {
                return modeString;
            }
        }
      
        internal string HostString
        {
            get
            {
                return hostString;
            }
        }
        internal IPEndPoint ConnectEndPoint
        {
            get
            {
                return connectEndPoint;
            }
        }
        internal string FileName
        {
            get
            {
                return this.fileName;
            }
        }
    }
}

每一个下载进程类

using System;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.IO;
namespace myIIS
{
    public class HttpDownloadItem : System.IDisposable
    {
        public delegate void StateChangeEventHandler(HttpDownloadItem sender, StateEventArgs e);
        public event StateChangeEventHandler StateChange; //状态改变事件
        private StateEventArgs eState;

        public delegate void DataReceiveEventHandler(HttpDownloadItem sender, DataReceiveEventArgs e);
        public event DataReceiveEventHandler DataReceiveChange; //数据接受事件
        private DataReceiveEventArgs eDataReceive;

        private int beginRange = 0;
        private int endRange = 0;
        private int id = 0;
        private HttpDownload parent;


        internal HttpDownloadItem(HttpDownload parent)
        {
            eState = new StateEventArgs();
            eDataReceive = new DataReceiveEventArgs();
            this.parent = parent;
        }
       
        public int BeginRange
        {
            set
            {
                beginRange = value;
            }
            get
            {
                return beginRange;
            }
        }
        public int EndRange
        {
            set
            {
                endRange = value;
            }
            get
            {
                return endRange;
            }
        }
        protected virtual void OnStateChanged(StateEventArgs e)
        {
            if (StateChange != null)
                StateChange(this, e);
        }
        protected virtual void OnDataReceiveChange(DataReceiveEventArgs e)
        {
            if (DataReceiveChange != null)
                DataReceiveChange(this, e);
        }
        public int Id
        {
            get
            {
                return id;
            }
            set
            {
                id = value;
            }
        }
    
        public void Download()
        {
            Socket httpSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            string formatString = "{0} {1} HTTP/1.1/r/nContent-Type: application/x-www-form-urlencoded/r/nContent-Length: {2}/r/nExpect: 100-continue/r/n{3}/r/nRange:{4}-{5}/r/nHost: {6}/r/n/r/n{7}";
            string sendString = string.Format(formatString, "POST", parent.Url, Encoding.Default.GetByteCount(parent.SendMessage), parent.ModeString, this.beginRange,this.endRange, parent.HostString, parent.SendMessage);
            byte[] sendBuffer = System.Text.Encoding.Default.GetBytes(sendString);
           
            FileStream fleStm = null;
            try
            {
                eState.ItemState=DownloadItemState.Connect;
                OnStateChanged(eState);
                httpSocket.Connect(parent.ConnectEndPoint);
                httpSocket.Send(sendBuffer);

                int block = 10240;//定义网络缓冲区大小
                byte[] receiveBuffer = new byte[block];//定义网络缓冲区
               
               
               
                block = httpSocket.Receive(receiveBuffer);
                string receiveString = System.Text.Encoding.Default.GetString(receiveBuffer, 0, block);
               
               
                //获取http字头长度
                int l = receiveString.LastIndexOf("/r/n/r/n") + ("/r/n/r/n").Length;

                byte[] newBuffer = new byte[block - l];
                for (int i = 0; i < block - l; i++)
                {
                    newBuffer[i] = new byte();
                    newBuffer[i] = receiveBuffer[i + l];
                }
               
               
                //设置事件参数
                eDataReceive.FileName = parent.FileName;
                eDataReceive.Position = this.beginRange;
                eDataReceive.ReceiveBuffer = newBuffer;
                eDataReceive.Block = newBuffer.Length;

                eState.ItemState = DownloadItemState.Download;
                OnStateChanged(eState);
                OnDataReceiveChange(eDataReceive);

                eDataReceive.Position = eDataReceive.Position + eDataReceive.Block;
                while (block > 0 && eDataReceive.Position<this.endRange )
                {
                    block = httpSocket.Receive(receiveBuffer);
                   
                    eDataReceive.ReceiveBuffer = receiveBuffer;
                    eDataReceive.Block = block;
                    OnDataReceiveChange(eDataReceive);

                    eDataReceive.Position = eDataReceive.Position + block;
                }
                eState.ItemState = DownloadItemState.Complete;
                OnStateChanged(eState);
            }
            catch (ApplicationException ex)
            {
                eState.ItemState = DownloadItemState.Exception;
                eState.Message = ex.Message;
                OnStateChanged(eState);
            }
            catch (Exception ex)
            {
                eState.ItemState = DownloadItemState.Exception;
                eState.Message = ex.Message;
                OnStateChanged(eState);
            }
            finally
            {
                httpSocket.Close();
                if (fleStm != null)
                {
                    fleStm.Close();
                }
                System.Threading.Thread.CurrentThread.Abort();
            }

        }
        public virtual void Dispose()
        {
            eState = null;
        }
       
    }
}

using System;
using System.Collections.Generic;
using System.Text;

namespace myIIS
{
    public class DataReceiveEventArgs : System.EventArgs
    {
        private byte[] receiveBuffer = null;
        private int block = 0;
        private int position = 0;
        private string fileName = "";
        public byte[] ReceiveBuffer
        {
            set
            {
                receiveBuffer = value;
            }
            get
            {
                return receiveBuffer;
            }
        }
        public int Position
        {
            set
            {
                position = value;
            }
            get
            {
                return position;
            }
        }
        public string FileName
        {
            get
            {
                return this.fileName;
            }
            set
            {
                this.fileName=value;
            }
        }
        public int Block
        {
            set
            {
                this.block = value;
            }
            get
            {
                return this.block;
            }
        }
    }
}

 

using System;
using System.Collections.Generic;
using System.Text;

namespace myIIS
{
    #region 下载文件块类
    public class DownloadBlock
    {
        public DownloadBlock()
        {

        }
    }
    #endregion
}

 

using System;
using System.Collections.Generic;
using System.Text;

namespace myIIS
{
    public enum DownloadItemState
    {
        None=0,
        Stop = 1,
        Connect = 2,
        Download = 3,
        Exception = 4,
        Complete=5,
    }

}
using System;
using System.Collections.Generic;
using System.Text;
using System.Net;

namespace myIIS
{
    #region Http代理类
    public class HttpProxy
    {
        private System.Net.IPAddress ip = new IPAddress(new byte[] { 127, 0, 0, 1 });
        private int port = 0;

        public System.Net.IPAddress IP
        {
            set
            {
                ip = value;
            }
            get
            {
                return ip;
            }
        }
        public int Port
        {
            set
            {
                port = value;
            }
            get
            {
                return port;
            }
        }
        public HttpProxy(IPAddress ip, int port)
        {
            this.ip = ip;
            this.port = port;
        }
    }
    #endregion
}

 

using System;
using System.Collections.Generic;
using System.Text;

namespace myIIS
{
    public class StateEventArgs:System.EventArgs
    {
        private DownloadItemState itemState = DownloadItemState.Stop;
        private string message = "";
        public DownloadItemState ItemState
        {
            get
            {
                return itemState;
            }
            set
            {
                itemState = value;
            }
        }
        public string Message
        {
            set
            {
                this.message = value;
            }
            get
            {
                return this.message;
            }
        }
    }
}
 

原文地址：http://blog.donews.com/cmic/archive/2005/05/25/398027.aspx

精选资源
C# socket TCP 大文件传输同时实现断点续传
08-21
下面，我们将深入探讨如何使用C#的Socket实现TCP大文件传输并支持断点续传。 首先，TCP协议保证了数据的有序性和无丢失性，通过三次握手建立连接，四次挥手断开连接，确保数据在传输过程中的可靠性。在C#中，我们...
c# UDP协议传送文件,支持断点续传,异步,多线程
12-15
在C#编程中，使用UDP协议进行文件传输时，需要考虑如何实现文件的断点续传、异步处理和多线程以提高效率和鲁棒性。 1. **断点续传**：断点续传是指在文件传输过程中，如果因为网络问题或其他原因中断，可以从上次...
多线程hpsocket 大文件分片传输分片,稳定,主要是简单.-易语言
06-11
源码模块动态库都有. 下载改改就可以用了,之前发过一个,是修改别人的挺复杂的乱七八糟的.用着用着就不行了,懒得找原因,自己重新写了个简单的. 多线程,服务端可以同时分片传输给客户端,挨个儿传输, 压缩和解压缩数据了一下,不然exe文件传输会有问题,可能是对齐的问题.
用 socket 编写的多线程下载工具
nhfkxbxv
08-12 281
编写本工具主要是基于两点考虑: 1. 想要一个简单点的下载工具, 曾经用了一段时间的迷你迅雷, 但是现在好像停止开发了, 后来用 chrome 自带的下载工具, 但是这个破工具下载大文件或者网络不好的时候经常出错, 下载的文件不完整.  2. 检验一下我写的 TcpServer / TcpClient 库是否正常 (主要是这个原因) 没有使用 .net 自带的 WebRequest 或 
socket多线程下载文件
HP的博客
02-11 2461
多线程下载的思路是建立多个线程，同时连接到服务器，分别从文件的不同位置开始下载，然后将各自接收到的数据合并到同一个文件中。// 服务器端代码 /************************************************************************* > File Name: server.cpp > Author: hp > Mail
Java使用Socket实现文件的下载（多线程版）
qq_33371372的博客
09-02 4514
服务器端： import java.io.*; import java.net.ServerSocket; import java.net.Socket; /** * @program: ImportantNotDelete * @Date: 2018-09-02 20:47 * @Author: 夜~星空 * @Description:服务器端：使用套接字实现文件下载功能 */ ...
在ASP.NET中支持断点续传下载大文件(ZT)
weixin_52041354的博客
02-23 210
1背景 用户本地有一份txt或者csv文件，无论是从业务数据库导出、还是其他途径获取，当需要使用蚂蚁的大数据分析工具进行数据加工、挖掘和共创应用的时候，首先要将本地文件上传至ODPS，普通的小文件通过浏览器上传至服务器，做一层中转便可以实现，但当这份文件非常大到了10GB级别，我们就需要思考另一种形式的技术方案了，也就是本文要阐述的方案。 技术要求主要有以下几方面： 支持超大数据量、10G级别以上 稳定性：除网络异常情况100%成功 准确性：数据无丢失，读写准确性100% .
Linux下的多线程下载与断点续传技术
资源摘要信息:"Linux断点续传多线程下载功能介绍" Linux系统下的多线程下载程序是网络编程中的一个重要应用，其特点在于能够在下载过程中遇到网络中断或其他错误时，不会重新开始下载整个文件，而是从上次下载停止...
VC++多线程断点续传下载器源码发布
文件名表明该压缩包内含有能够实现多线程下载、支持HTTP和FTP协议、具有断点续传功能的源代码。开发者或用户可以获取这些代码，并通过适当的编译环境进行编译和运行，以实现相应的功能。 总结来说，文件信息表明这...
支持断点续传的HTTP单线程下载工具VDown
相比之下，多线程下载工具通常会将文件分割为多个块，每个线程负责下载其中一部分，最后合并成完整文件，从而显著提升下载速度。但VDown选择单线程实现，可能是出于简化开发复杂度、便于调试和理解的目的，尤其适用...
MFC 实现FTP客户端的上传下载（断点续传）
06-21
用MFC做的FTP客户端 实现上传与下载 ，支持断点续传
支持多线程下载和断点续传的FTP客户端
02-28
一个用MFC开发的FTP客户端,特点是支持多线程下载和断点续传,没有用CSocket,用了比较底层的Socket函数,适合学习Socket的朋友,请多多支持
多线程FTP客户端
11-29
FileZilla是一个快速，实用多功能和界面直观的FTP客户端。FileZilla 是一个免费的 FTP 客户端软件，虽然它是免费软件，可功能却一点也不含糊，比起那些共享软件来有过之而无不及，在新的版本中作者改进了手动下载的界面和功能等，不过该软件暂时还是不支持断点续传功能。 总的来说是一款优秀的免费软件。
FTP客户端 MFC 计算机网络大作业
12-19
利用VS2005 MFC 实现了一个FTP Client 支持文件上传下载,目录修改,删除等基本操作, 利用MFC多线程技术实现下载进度条.
实现socket_client下载socket_server文件
weixin_34220179的博客
01-12 129
Socket模块：在网络编程中的一个基本组件就是套接字(socket)。套接字基本上是两个端点的程序之间的“信息通道”。程序分布在不通的计算机上（通过网络连接），通过套接字相互发送信息。在python中的大多数的网络编程都隐藏了socket模块的基本细节，不直接和套接字交互。套接字包括两个：服务器套接字和客户机套接字。在创建一个服务器套接字...
用swing做界面，写了个支持断点续传的ftp客户端
SavageGarden_Love的专栏
12-03 312
  最近在写一个支持多线程、断点续传方式（需要服务器支持）下载的ftp客户端，到今天总算是感觉可以放几张图出来了，欢迎指教。 目前实现的功能： 1、客户端的文件浏览、目录切换、新建文件、文件删除 2、服务端的文件浏览、目录切换、新建文件、文件删除 3、客户端的文件上传 4、服务端的文件下载、以断点续传方式下载 5、下载进度显示 6、客户端文件夹递归上传 7、服务端文件夹递归下载 ...
超大文件传输解决方案
Mr_Zang666的博客
08-19 1819
之前仿造uploadify写了一个HTML5版的文件上传插件，没看过的朋友可以点此先看一下~得到了不少朋友的好评，我自己也用在了项目中，不论是用户头像上传，还是各种媒体文件的上传，以及各种个性的业务需求，都能得到满足。小小开心了一把。 但无论插件再怎么灵活，也难以应付所有的需求，比如，你要上传一个2G的文件。以现在我们的网速，恐怕再快也得传半小时。要命的是，如果你在上传到90%的时候不小心关...
Linux安装Tomcat服务器
张天壮
07-20 675
一、环境1.Ubuntu 16.04 2.JDK1.8二、在线下载JDK1.81 .下载安装在终端上输入javac命令，根据提示安装（不同版本有不同的提示）我这里是 apt-get install openjdk-8-jdk-headless 2.配置环境变量通过查看刚才的安装过程中日志可以找到jdk的安装目录 这里是/usr/lib/jvm/java-8-openjdk-i
Ftp多线程与断点续传
gogo313的专栏
12-05 1286
其实FTP断点续传的原理很简单，可分为断点下载和断点上传。   一、下载：1、向服务器发送“REST + 本地文件长度”命令，告诉服务器，客户端要断点下载了。这时服务器还不知道客户端要下载哪个文件；2、向服务器发送“RETR + 文件名”命令，通知服务器要下载的文件名，这时服务器开始定位文件指针读文件并发送数据。3、客户端定位本地文件指针（文件末尾）；4、两端的准备工作都做完了以后，客户端
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值