zoukankan      html  css  js  c++  java
  • 实现断点续传的FTP下载类(支持多线程多任务下载)

    using System;
    using System.Collections.Generic;
    using System.Text;
    using System.Threading;
    using System.Windows.Forms;
    using System.IO;
    using System.Net;
    
    namespace RSGIS.FTPClient
    {
    
        public class MultiFtpService
        {
            #region variable
    
            private string _Server;//服务器地址
            private string _UserName;//用户名
            private string _Password;//密码
            private string _FileUrl;//文件地址
            private string _SavePath;//保存路经        
            Thread _Thread;
            private int _TaskIndex;
            private int _ThreadIndex;
    
            private int FileSpeed;        // 实时下载速度
    
            private FtpWebRequest ftpRequest = null;
            private FtpWebResponse ftpResponse = null;
            private Stream ftpStream = null;
            private int bufferSize = 2048;
            private int highestPercentageReached = 0;
    
            public delegate void DelegateDisplayProgress(int taskindex, int progress);
            public DelegateDisplayProgress WorkMethod;
    
            public delegate void DelegateDisplayFileSpeed(int taskindex, string speed);
            public DelegateDisplayFileSpeed FileSpeedMethod;
    
            #endregion
    
            #region Constructor
    
            public MultiFtpService(string server, string username, string password, int taskIndex, int threadIndex, string fileUrl, string savePath)
            {
                _Server = server;
                _UserName = username;
                _Password = password;
                _FileUrl = fileUrl;
                _SavePath = savePath;
                _TaskIndex = taskIndex;
                _ThreadIndex = threadIndex;
            }
    
            #endregion
    
            #region Functions
            //开始
            public void Start()
            {
                long fileSize = GetLength();
                _Thread = new Thread(() => { TheadDownload(_FileUrl, _SavePath, _TaskIndex, _ThreadIndex, fileSize); });
                _Thread.Start();
            }
            /// <summary>
            /// 暂停线程
            /// </summary>
            public void Stop()
            {
                _Thread.Suspend();
            }
            // 恢复线程
            public void continues()
            {
                _Thread.Resume();
            }
            //获取文件长度
            private long GetLength()
            {
                Ftp ftpclient = new Ftp(_Server, _UserName, _Password);
                long fileSize = ftpclient.getFileSize(_FileUrl);
                ftpclient = null;
                return fileSize;
            }
            /// <summary>
            /// 下载
            /// </summary>
            /// <param name="remoteFile"></param>
            /// <param name="localFile"></param>
            /// <param name="taskindex"></param>
            /// <param name="threadindex"></param>
            /// <param name="fileSize"></param>
            private void TheadDownload(string remoteFile, string localFile, int taskindex, int threadindex, long fileSize)
            {
                try
                {
                    //续传
                    if (File.Exists(localFile))
                    {
                        FileInfo file = new FileInfo(localFile);
                        int locSize = Convert.ToInt32(file.Length);
                        if (locSize.ToString() != fileSize.ToString())
                        {
                            Uri FTPUri = new Uri(_Server + "/" + remoteFile);
                            RestartDownloadFromServer(taskindex, localFile, FTPUri, file.Length, fileSize);
                        }
                    }
                    else
                    {
                        // Create Request
                        ftpRequest = (FtpWebRequest)FtpWebRequest.Create(_Server + "/" + remoteFile);
                        ftpRequest.Credentials = new NetworkCredential(_UserName, _Password);
                        ftpRequest.UseBinary = true;
                        ftpRequest.UsePassive = true;
                        ftpRequest.KeepAlive = true;
                        ftpRequest.Proxy = GlobalProxySelection.GetEmptyWebProxy();
                        // Request Type
                        ftpRequest.Method = WebRequestMethods.Ftp.DownloadFile;
                        // Get Response
                        ftpResponse = (FtpWebResponse)ftpRequest.GetResponse();
                        // Get server response stream 
                        ftpStream = ftpResponse.GetResponseStream();
                        FileStream localFileStream = new FileStream(localFile, FileMode.Create);
                        // Buffer for downloaded data
                        byte[] byteBuffer = new byte[bufferSize];
                        int bytesRead = ftpStream.Read(byteBuffer, 0, bufferSize);
                        // Download File
                        int fileSizes = Convert.ToInt32(fileSize);
                        try
                        {
                            while (bytesRead > 0)
                            {
                                localFileStream.Write(byteBuffer, 0, bytesRead);
                                bytesRead = ftpStream.Read(byteBuffer, 0, bufferSize);
                                int Complete = Convert.ToInt32(fileSizes) - bytesRead;
                                double Fcompletes = Convert.ToDouble(Complete) / Convert.ToDouble(fileSize);
                                double x = 1;
                                double Fcomplete = x - Fcompletes;
                                fileSizes = Complete;
                                if (Fcomplete * 100 > highestPercentageReached)
                                {
                                    WorkMethod(taskindex, Convert.ToInt32(Fcomplete * 100));
                                    string speed = SizeConversion(Convert.ToInt64(bytesRead / 0.01));
                                    FileSpeedMethod(taskindex, speed);
                                    
                                }
                            }
                            FileInfo file = new FileInfo(localFile);
                            int locSize = Convert.ToInt32(file.Length);
                            if (locSize.ToString() != fileSizes.ToString())
                            {
                                Uri FTPUri = new Uri(_Server + "/" + remoteFile);
                                RestartDownloadFromServer(taskindex, localFile, FTPUri, file.Length, fileSize);
                            }
                        }
                        catch (Exception ex)
                        {
                            throw new Exception(ex.Message);
                        }
                        localFileStream.Close();
                        ftpStream.Close();
                        ftpResponse.Close();
                        ftpRequest = null;
                        WorkComplete();
                    }
                }
                catch (Exception ex)
                {
                    throw new Exception(ex.Message);
                }
                //catch { }
            }
            //断点续传
            private bool RestartDownloadFromServer(int taskindex, string fileName, Uri serverUri, long offset, long fileSize)
            {
                if (serverUri.Scheme != Uri.UriSchemeFtp)
                {
                    return false;
                }
    
                // 获取ftp
                FtpWebRequest request = (FtpWebRequest)WebRequest.Create(serverUri);
                request.Credentials = new NetworkCredential(_UserName, _Password);
                request.UseBinary = true;
                request.UsePassive = true;
                request.KeepAlive = true;
                request.Proxy = GlobalProxySelection.GetEmptyWebProxy();
                // Request Type
                request.Method = WebRequestMethods.Ftp.DownloadFile;
                request.ContentOffset = offset;
                FtpWebResponse response = null;
                try
                {
                    response = (FtpWebResponse)request.GetResponse();
                }
                catch (WebException e)
                {
                    Console.WriteLine(e.Status);
                    Console.WriteLine(e.Message);
                    return false;
                }
                // 获取流
                ftpStream = response.GetResponseStream();
                //StreamReader reader = new StreamReader(newFile);
                //string newFileData = reader.ReadToEnd();
                FileStream localFileStream = new FileStream(fileName, FileMode.Append);
                // Buffer for downloaded data
                byte[] byteBuffer = new byte[bufferSize];
                int bytesRead = ftpStream.Read(byteBuffer, 0, bufferSize);
    
                // Download File
                int fileSizes = Convert.ToInt32(fileSize);
                try
                {
                    while (bytesRead > 0)
                    {
                        localFileStream.Write(byteBuffer, 0, bytesRead);
                        bytesRead = ftpStream.Read(byteBuffer, 0, bufferSize);
                        int Complete = Convert.ToInt32(fileSizes) - bytesRead;
                        double Fcompletes = Convert.ToDouble(Complete) / Convert.ToDouble(fileSize);
                        double x = 1;
                        double Fcomplete = x - Fcompletes;
                        fileSizes = Complete;
                        if (Fcomplete * 100 > highestPercentageReached)
                        {
                            Fcomplete = Fcomplete + offset / fileSize;
                            WorkMethod(taskindex, Convert.ToInt32(Fcomplete * 100));
                            string speed = SizeConversion(Convert.ToInt64(bytesRead / 0.01));
                            FileSpeedMethod(taskindex, speed);
                        }
                    }
                }
                catch (Exception ex)
                {
                    throw new Exception(ex.Message);
                }
                //关闭流
                localFileStream.Close();
                ftpStream.Close();
                response.Close();
                request = null;
                WorkComplete();
                return true;
            }
            //完成
            public void WorkComplete()
            {
                MessageBox.Show("文件下载成功", "Success", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }
    
            /// <summary>
            /// 文件大小换算
            /// </summary>
            /// <param name="bytes">文件长度</param>
            /// <returns></returns>
            private string SizeConversion(long bytes)
            {
                int unit = 1024;
                if (bytes < unit) return bytes + " B";
                int exp = (int)(Math.Log(bytes) / Math.Log(unit));
                return String.Format("{0:F1} {1}B", bytes / Math.Pow(unit, exp), "KMGTPE"[exp - 1]);
            }
            #endregion
        }
    }
    

      

  • 相关阅读:
    android应用程序的混淆打包
    sql 语句的limit的用法
    Android SDK开发包国内下载地址
    在android应用程序中启动其他apk程序
    docker+k8s基础篇五
    docker+k8s基础篇四
    docker+k8s基础篇三
    docker+k8s基础篇二
    docker+k8s基础篇一
    LVS的基础使用
  • 原文地址:https://www.cnblogs.com/lxc-binary/p/3461540.html
Copyright © 2011-2022 走看看