zoukankan      html  css  js  c++  java
  • C#FTP操作类:上传下载、断点续传等

    只下载FTP文件更新的部分

     1         /// <summary>
     2         /// 下载
     3         /// </summary>
     4         /// <param name="filePath">下载后文件存放位置</param>
     5         /// <param name="fileName">文件名称</param>
     6         public bool Download(string filePath, string fileName)
     7         {
     8             bool judge = false;
     9             FtpWebRequest reqFTP = null;
    10             Stream ftpStream = null;
    11             FtpWebResponse response = null;
    12             FileStream outputStream = null;
    13 
    14             try
    15             {
    16                 var path = filePath + "\" + fileName;
    17                 //获取本地文件
    18                 //Append决定outputStream.Write写入时,是从头开始覆盖,还是从末尾追加。 
    19                 outputStream = new FileStream(path, FileMode.Append);
    20                 //本地文件字节数
    21                 long outputStreamLength = outputStream.Length;
    22                 //创建FTP请求
    23                 reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(ftpURI + fileName));        
    24                 //reqFTP.UsePassive = false;//会导致 操作超时
    25                 //reqFTP.KeepAlive = false; 
    26                 reqFTP.UseBinary = true;
    27                 //配置FTP下载的开始位置:outputStreamLength
    28                 reqFTP.ContentOffset = outputStreamLength;
    29                 reqFTP.Method = WebRequestMethods.Ftp.DownloadFile;
    30                 reqFTP.Credentials = new NetworkCredential(ftpUserID, ftpPassword);
    31                 //FTP服务器响应(或返回)结果
    32                 response = (FtpWebResponse)reqFTP.GetResponse();
    33                 //获取FTP发送的响应数据流
    34                 ftpStream = response.GetResponseStream();
    35                 int bufferSize = 2048;
    36                 int readCount;
    37                 byte[] buffer = new byte[bufferSize];
    38                /*
    39                 Stream 表示“流”(这个bai概念在计算机中非常常见,题主可以自行搜索相关资料),本质上是一种字节序列。说穿了,计算机只认识0和1,那么这么丰富多彩的文本、音乐、视频,归根结底都是转换成字节存储在内存与硬盘中的。
    40                 Stream 对象有一个属性 Length,表示这个流的长度;还有一个属性 Position,表示这个流当前的位置。
    41                 Stream.Read(byte[] array, int offset, int count);
    42                 array 表示缓冲区;offset 表示从流的当前位置(也就上面说的 Position)偏移多少个字节开始读;count 表示读取多少个字节。
    43                 该方法返回的是实际上读取了多少个字节(永远小于等于 count),如果该值等于 0,说明已经到流的末尾了。读取之后,这个流的 Position 就会发生变化。
    44                 为什么要缓冲区?因为一个流很可能非常大,一次性的加载是不现实的,所以需要分块来读取,存储每个分块的这个字节数组就叫做“缓冲区”。
    45               */   
    46                readCount = ftpStream.Read(buffer, 0, bufferSize);
    47       
    48                 while (readCount > 0)
    49                 {
    50                     //将读取的字节数组buffer写入outputStream文件流
    51                     outputStream.Write(buffer, 0, readCount);
    52                     //再次读取,再次位置提升。不断重复直到readCount为0;
    53                     readCount = ftpStream.Read(buffer, 0, bufferSize);
    54                 }
    55                 judge = true;
    56                 ftpStream.Close();
    57                 outputStream.Close();
    58                 response.Close();
    59                 
    60             }
    61             catch (Exception ex)
    62             {
    63 
    64                 LogManage.Info(fileName);
    65                 LogManage.Error(ex);
    66 
    67                 try
    68                 {
    69                     if (ftpStream != null)
    70                     {
    71                         ftpStream.Close();
    72                     }
    73                     if (outputStream != null)
    74                     {
    75                         outputStream.Close();
    76                     }
    77                     if (response != null)
    78                     {
    79                         response.Close();
    80                     }
    81                 }
    82                 catch (Exception ex2)
    83                 {
    84 
    85                 }
    86             }
    87  
    88 
    89             return judge;
    90         }
    View Code

    转载来源一: https://www.cnblogs.com/swtseaman/archive/2011/03/29/1998611.html

     
    using System;
    using System.Collections.Generic;
    using System.Text;
    using System.IO;
    using System.Net;
    //using System.Windows.Forms;
    using System.Globalization;
    
    namespace FTPLib
    {
    
        public class FtpWeb
        {
            string ftpServerIP;
            string ftpRemotePath;
            string ftpUserID;
            string ftpPassword;
            string ftpURI;
    
            /// <summary>
            /// 连接FTP
            /// </summary>
            /// <param name="FtpServerIP">FTP连接地址</param>
            /// <param name="FtpRemotePath">指定FTP连接成功后的当前目录, 如果不指定即默认为根目录</param>
            /// <param name="FtpUserID">用户名</param>
            /// <param name="FtpPassword">密码</param>
            public FtpWeb(string FtpServerIP, string FtpRemotePath, string FtpUserID, string FtpPassword)
            {
                ftpServerIP = FtpServerIP;
                ftpRemotePath = FtpRemotePath;
                ftpUserID = FtpUserID;
                ftpPassword = FtpPassword;
                if (ftpRemotePath != "")
                {
                    ftpURI = "ftp://" + ftpServerIP + "/" + ftpRemotePath + "/";
    
                }
                else
                {
                    ftpURI = "ftp://" + ftpServerIP + "/";
                }
    
            }
    
    
            /// <summary>
            /// 下载
            /// </summary>
            /// <param name="filePath">下载后文件存放位置</param>
            /// <param name="fileName">文件名称</param>
            public bool Download(string filePath, string fileName)
            {
                FtpWebRequest reqFTP;
                bool judge = false;
                //try
                //{
                    FileStream outputStream = new FileStream(filePath+"\" + fileName, FileMode.Create);
    
                    reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(ftpURI + fileName));
                    reqFTP.Method = WebRequestMethods.Ftp.DownloadFile;
                    reqFTP.UseBinary = true;
                    reqFTP.KeepAlive = false;
                    reqFTP.Credentials = new NetworkCredential(ftpUserID, ftpPassword);
                    FtpWebResponse response = (FtpWebResponse)reqFTP.GetResponse();
                    Stream ftpStream = response.GetResponseStream();
                    long cl = response.ContentLength;
                    int bufferSize = 2048;
                    int readCount;
                    byte[] buffer = new byte[bufferSize];
    
                    readCount = ftpStream.Read(buffer, 0, bufferSize);
                    while (readCount > 0)
                    {
                        outputStream.Write(buffer, 0, readCount);
                        readCount = ftpStream.Read(buffer, 0, bufferSize);
                    }
    
                    ftpStream.Close();
                    outputStream.Close();
                    response.Close();
    
                    judge = true;
                //}
                //catch (Exception ex)
                //{
                //    Insert_Standard_ErrorLog.Insert("FtpWeb", "Download Error --> " + ex.Message);
                //}
    
                return judge;
            }
    
            #region 没用上的方法,使用时注释try catch,把异常抛给上一级处理
            /// <summary>
            /// 上传
            /// </summary>
            /// <param name="filename"></param>
            public void Upload(string filename)
            {
                FileInfo fileInf = new FileInfo(filename);
                string uri = ftpURI + fileInf.Name;
                FtpWebRequest reqFTP;
    
                reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(uri));
                reqFTP.Credentials = new NetworkCredential(ftpUserID, ftpPassword);
                reqFTP.KeepAlive = false;
                reqFTP.Method = WebRequestMethods.Ftp.UploadFile;
                reqFTP.UseBinary = true;
                reqFTP.ContentLength = fileInf.Length;
                int buffLength = 2048;
                byte[] buff = new byte[buffLength];
                int contentLen;
                FileStream fs = fileInf.OpenRead();
                //try
                //{
                    Stream strm = reqFTP.GetRequestStream();
                    contentLen = fs.Read(buff, 0, buffLength);
                    while (contentLen != 0)
                    {
                        strm.Write(buff, 0, contentLen);
                        contentLen = fs.Read(buff, 0, buffLength);
                    }
                    strm.Close();
                    fs.Close();
                //}
                //catch (Exception ex)
                //{
                //    Insert_Standard_ErrorLog.Insert("FtpWeb", "Upload Error --> " + ex.Message);
                //}
            }
    
    
            /// <summary>
            /// 删除文件
            /// </summary>
            /// <param name="fileName"></param>
            public void Delete(string fileName)
            {
                //try
                //{
                    string uri = ftpURI + fileName;
                    FtpWebRequest reqFTP;
                    reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(uri));
    
                    reqFTP.Credentials = new NetworkCredential(ftpUserID, ftpPassword);
                    reqFTP.KeepAlive = false;
                    reqFTP.Method = WebRequestMethods.Ftp.DeleteFile;
    
                    string result = String.Empty;
                    FtpWebResponse response = (FtpWebResponse)reqFTP.GetResponse();
                    long size = response.ContentLength;
                    Stream datastream = response.GetResponseStream();
                    StreamReader sr = new StreamReader(datastream);
                    result = sr.ReadToEnd();
                    sr.Close();
                    datastream.Close();
                    response.Close();
                //}
                //catch (Exception ex)
                //{
                //    Insert_Standard_ErrorLog.Insert("FtpWeb", "Delete Error --> " + ex.Message + "  文件名:" + fileName);
                //}
            }
    
            /// <summary>
            /// 删除文件夹
            /// </summary>
            /// <param name="folderName"></param>
            public void RemoveDirectory(string folderName)
            {
                //try
                //{
                    string uri = ftpURI + folderName;
                    FtpWebRequest reqFTP;
                    reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(uri));
    
                    reqFTP.Credentials = new NetworkCredential(ftpUserID, ftpPassword);
                    reqFTP.KeepAlive = false;
                    reqFTP.Method = WebRequestMethods.Ftp.RemoveDirectory;
    
                    string result = String.Empty;
                    FtpWebResponse response = (FtpWebResponse)reqFTP.GetResponse();
                    long size = response.ContentLength;
                    Stream datastream = response.GetResponseStream();
                    StreamReader sr = new StreamReader(datastream);
                    result = sr.ReadToEnd();
                    sr.Close();
                    datastream.Close();
                    response.Close();
                //}
                //catch (Exception ex)
                //{
                //    Insert_Standard_ErrorLog.Insert("FtpWeb", "Delete Error --> " + ex.Message + "  文件名:" + folderName);
                //}
            }
    
            /// <summary>
            /// 获取当前目录下明细(包含文件和文件夹)
            /// </summary>
            /// <returns></returns>
            public string[] GetFilesDetailList()
            {
                string[] downloadFiles;
                //try
                //{
                    StringBuilder result = new StringBuilder();
                    FtpWebRequest ftp;
                    ftp = (FtpWebRequest)FtpWebRequest.Create(new Uri(ftpURI));
                    ftp.Credentials = new NetworkCredential(ftpUserID, ftpPassword);
                    ftp.Method = WebRequestMethods.Ftp.ListDirectoryDetails;
                    WebResponse response = ftp.GetResponse();
                    StreamReader reader = new StreamReader(response.GetResponseStream(), Encoding.Default);
    
                    //while (reader.Read() > 0)
                    //{
    
                    //}
                    string line = reader.ReadLine();
                    //line = reader.ReadLine();
                    //line = reader.ReadLine();
    
                    while (line != null)
                    {
                        result.Append(line);
                        result.Append("
    ");
                        line = reader.ReadLine();
                    }
                    result.Remove(result.ToString().LastIndexOf("
    "), 1);
                    reader.Close();
                    response.Close();
                    return result.ToString().Split('
    ');
                //}
                //catch (Exception ex)
                //{
                //    downloadFiles = null;
                //    Insert_Standard_ErrorLog.Insert("FtpWeb", "GetFilesDetailList Error --> " + ex.Message);
                //    return downloadFiles;
                //}
            }
    
            /// <summary>
            /// 获取当前目录下文件列表(仅文件)
            /// </summary>
            /// <returns></returns>
            public string[] GetFileList(string mask)
            {
                string[] downloadFiles;
                StringBuilder result = new StringBuilder();
                FtpWebRequest reqFTP;
                //try
                //{
                    reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(ftpURI));
                    reqFTP.UseBinary = true;
                    reqFTP.Credentials = new NetworkCredential(ftpUserID, ftpPassword);
                    reqFTP.Method = WebRequestMethods.Ftp.ListDirectory;
                    WebResponse response = reqFTP.GetResponse();
                    StreamReader reader = new StreamReader(response.GetResponseStream(), Encoding.Default);
    
                    string line = reader.ReadLine();
                    while (line != null)
                    {
                        if (mask.Trim() != string.Empty && mask.Trim() != "*.*")
                        {
    
                            string mask_ = mask.Substring(0, mask.IndexOf("*"));
                            if (line.Substring(0, mask_.Length) == mask_)
                            {
                                result.Append(line);
                                result.Append("
    ");
                            }
                        }
                        else
                        {
                            result.Append(line);
                            result.Append("
    ");
                        }
                        line = reader.ReadLine();
                    }
                    result.Remove(result.ToString().LastIndexOf('
    '), 1);
                    reader.Close();
                    response.Close();
                    return result.ToString().Split('
    ');
                //}
                //catch (Exception ex)
                //{
                //    downloadFiles = null;
                //    if (ex.Message.Trim() != "远程服务器返回错误: (550) 文件不可用(例如,未找到文件,无法访问文件)。")
                //    {
                //        Insert_Standard_ErrorLog.Insert("FtpWeb", "GetFileList Error --> " + ex.Message.ToString());
                //    }
                //    return downloadFiles;
                //}
            }
    
            /// <summary>
            /// 获取当前目录下所有的文件夹列表(仅文件夹)
            /// </summary>
            /// <returns></returns>
            public string[] GetDirectoryList()
            {
                string[] drectory = GetFilesDetailList();
                string m = string.Empty;
                foreach (string str in drectory)
                {
                    int dirPos = str.IndexOf("<DIR>");
                    if (dirPos > 0)
                    {
                        /*判断 Windows 风格*/
                        m += str.Substring(dirPos + 5).Trim() + "
    ";
                    }
                    else if (str.Trim().Substring(0, 1).ToUpper() == "D")
                    {
                        /*判断 Unix 风格*/
                        string dir = str.Substring(54).Trim();
                        if (dir != "." && dir != "..")
                        {
                            m += dir + "
    ";
                        }
                    }
                }
    
                char[] n = new char[] { '
    ' };
                return m.Split(n);
            }
    
            /// <summary>
            /// 判断当前目录下指定的子目录是否存在
            /// </summary>
            /// <param name="RemoteDirectoryName">指定的目录名</param>
            public bool DirectoryExist(string RemoteDirectoryName)
            {
                string[] dirList = GetDirectoryList();
                foreach (string str in dirList)
                {
                    if (str.Trim() == RemoteDirectoryName.Trim())
                    {
                        return true;
                    }
                }
                return false;
            }
    
            /// <summary>
            /// 判断当前目录下指定的文件是否存在
            /// </summary>
            /// <param name="RemoteFileName">远程文件名</param>
            public bool FileExist(string RemoteFileName)
            {
                string[] fileList = GetFileList("*.*");
                foreach (string str in fileList)
                {
                    if (str.Trim() == RemoteFileName.Trim())
                    {
                        return true;
                    }
                }
                return false;
            }
    
            /// <summary>
            /// 创建文件夹
            /// </summary>
            /// <param name="dirName"></param>
            public void MakeDir(string dirName)
            {
                FtpWebRequest reqFTP;
                //try
                //{
                    // dirName = name of the directory to create.
                    reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(ftpURI + dirName));
                    reqFTP.Method = WebRequestMethods.Ftp.MakeDirectory;
                    reqFTP.UseBinary = true;
                    reqFTP.Credentials = new NetworkCredential(ftpUserID, ftpPassword);
                    FtpWebResponse response = (FtpWebResponse)reqFTP.GetResponse();
                    Stream ftpStream = response.GetResponseStream();
    
                    ftpStream.Close();
                    response.Close();
                //}
                //catch (Exception ex)
                //{
                //    Insert_Standard_ErrorLog.Insert("FtpWeb", "MakeDir Error --> " + ex.Message);
                //}
            }
    
            /// <summary>
            /// 获取指定文件大小
            /// </summary>
            /// <param name="filename"></param>
            /// <returns></returns>
            public long GetFileSize(string filename)
            {
                FtpWebRequest reqFTP;
                long fileSize = 0;
                //try
                //{
                    reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(ftpURI + filename));
                    reqFTP.Method = WebRequestMethods.Ftp.GetFileSize;
                    reqFTP.UseBinary = true;
                    reqFTP.Credentials = new NetworkCredential(ftpUserID, ftpPassword);
                    FtpWebResponse response = (FtpWebResponse)reqFTP.GetResponse();
                    Stream ftpStream = response.GetResponseStream();
                    fileSize = response.ContentLength;
    
                    ftpStream.Close();
                    response.Close();
                //}
                //catch (Exception ex)
                //{
                //    Insert_Standard_ErrorLog.Insert("FtpWeb", "GetFileSize Error --> " + ex.Message);
                //}
                return fileSize;
            }
    
            /// <summary>
            /// 改名
            /// </summary>
            /// <param name="currentFilename"></param>
            /// <param name="newFilename"></param>
            public void ReName(string currentFilename, string newFilename)
            {
                FtpWebRequest reqFTP;
                //try
                //{
                    reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(ftpURI + currentFilename));
                    reqFTP.Method = WebRequestMethods.Ftp.Rename;
                    reqFTP.RenameTo = newFilename;
                    reqFTP.UseBinary = true;
                    reqFTP.Credentials = new NetworkCredential(ftpUserID, ftpPassword);
                    FtpWebResponse response = (FtpWebResponse)reqFTP.GetResponse();
                    Stream ftpStream = response.GetResponseStream();
    
                    ftpStream.Close();
                    response.Close();
                //}
                //catch (Exception ex)
                //{
                //    Insert_Standard_ErrorLog.Insert("FtpWeb", "ReName Error --> " + ex.Message);
                //}
            }
    
            /// <summary>
            /// 移动文件
            /// </summary>
            /// <param name="currentFilename"></param>
            /// <param name="newFilename"></param>
            public void MovieFile(string currentFilename, string newDirectory)
            {
                ReName(currentFilename, newDirectory);
            }
    
            /// <summary>
            /// 切换当前目录
            /// </summary>
            /// <param name="DirectoryName"></param>
            /// <param name="IsRoot">true 绝对路径   false 相对路径</param>
            public void GotoDirectory(string DirectoryName, bool IsRoot)
            {
                if (IsRoot)
                {
                    ftpRemotePath = DirectoryName;
                }
                else
                {
                    ftpRemotePath += DirectoryName + "/";
                }
                ftpURI = "ftp://" + ftpServerIP + "/" + ftpRemotePath + "/";
            }
    
            /// <summary>
            /// 删除订单目录
            /// </summary>
            /// <param name="ftpServerIP">FTP 主机地址</param>
            /// <param name="folderToDelete">FTP 用户名</param>
            /// <param name="ftpUserID">FTP 用户名</param>
            /// <param name="ftpPassword">FTP 密码</param>
            public static void DeleteOrderDirectory(string ftpServerIP, string folderToDelete, string ftpUserID, string ftpPassword)
            {
                //try
                //{
                    if (!string.IsNullOrEmpty(ftpServerIP) && !string.IsNullOrEmpty(folderToDelete) && !string.IsNullOrEmpty(ftpUserID) && !string.IsNullOrEmpty(ftpPassword))
                    {
                        FtpWeb fw = new FtpWeb(ftpServerIP, folderToDelete, ftpUserID, ftpPassword);
                        //进入订单目录
                        fw.GotoDirectory(folderToDelete, true);
                        //获取规格目录
                        string[] folders = fw.GetDirectoryList();
                        foreach (string folder in folders)
                        {
                            if (!string.IsNullOrEmpty(folder) || folder != "")
                            {
                                //进入订单目录
                                string subFolder = folderToDelete + "/" + folder;
                                fw.GotoDirectory(subFolder, true);
                                //获取文件列表
                                string[] files = fw.GetFileList("*.*");
                                if (files != null)
                                {
                                    //删除文件
                                    foreach (string file in files)
                                    {
                                        fw.Delete(file);
                                    }
                                }
                                //删除冲印规格文件夹
                                fw.GotoDirectory(folderToDelete, true);
                                fw.RemoveDirectory(folder);
                            }
                        }
    
                        //删除订单文件夹
                        string parentFolder = folderToDelete.Remove(folderToDelete.LastIndexOf('/'));
                        string orderFolder = folderToDelete.Substring(folderToDelete.LastIndexOf('/') + 1);
                        fw.GotoDirectory(parentFolder, true);
                        fw.RemoveDirectory(orderFolder);
                    }
                    else
                    {
                        throw new Exception("FTP 及路径不能为空!");
                    }
                //}
                //catch (Exception ex)
                //{
                //    throw new Exception("删除订单时发生错误,错误信息为:" + ex.Message);
                //}
            }
            #endregion
        }
    
    
        public class Insert_Standard_ErrorLog
        {
            public static void Insert(string x, string y)
            {
              
            }
        }
    
    
    }
     
    
     
    

      

    来源二:C# FTP 上传下载(支持断点续传)

    https://www.cnblogs.com/lvdongjie/p/5570355.html

     
    
    using System;  
    using System.Collections.Generic;  
    using System.Linq;  
    using System.Text;  
    using System.Net;  
    using System.IO;  
      
    namespace JianKunKing.Common.Ftp  
    {  
        /// <summary>  
        /// ftp方式文件下载上传  
        /// </summary>  
        public static class FileUpDownload  
        {  
            #region 变量属性  
            /// <summary>  
            /// Ftp服务器ip  
            /// </summary>  
            public static string FtpServerIP = string.Empty;  
            /// <summary>  
            /// Ftp 指定用户名  
            /// </summary>  
            public static string FtpUserID = string.Empty;  
            /// <summary>  
            /// Ftp 指定用户密码  
            /// </summary>  
            public static string FtpPassword = string.Empty;  
     
            #endregion  
     
            #region 从FTP服务器下载文件,指定本地路径和本地文件名  
            /// <summary>  
            /// 从FTP服务器下载文件,指定本地路径和本地文件名  
            /// </summary>  
            /// <param name="remoteFileName">远程文件名</param>  
            /// <param name="localFileName">保存本地的文件名(包含路径)</param>  
            /// <param name="ifCredential">是否启用身份验证(false:表示允许用户匿名下载)</param>  
            /// <param name="updateProgress">报告进度的处理(第一个参数:总大小,第二个参数:当前进度)</param>  
            /// <returns>是否下载成功</returns>  
            public static bool FtpDownload(string remoteFileName, string localFileName, bool ifCredential, Action<int, int> updateProgress = null)  
            {  
                FtpWebRequest reqFTP, ftpsize;  
                Stream ftpStream = null;  
                FtpWebResponse response = null;  
                FileStream outputStream = null;  
                try  
                {  
      
                    outputStream = new FileStream(localFileName, FileMode.Create);  
                    if (FtpServerIP == null || FtpServerIP.Trim().Length == 0)  
                    {  
                        throw new Exception("ftp下载目标服务器地址未设置!");  
                    }  
                    Uri uri = new Uri("ftp://" + FtpServerIP + "/" + remoteFileName);  
                    ftpsize = (FtpWebRequest)FtpWebRequest.Create(uri);  
                    ftpsize.UseBinary = true;  
      
                    reqFTP = (FtpWebRequest)FtpWebRequest.Create(uri);  
                    reqFTP.UseBinary = true;  
                    reqFTP.KeepAlive = false;  
                    if (ifCredential)//使用用户身份认证  
                    {  
                        ftpsize.Credentials = new NetworkCredential(FtpUserID, FtpPassword);  
                        reqFTP.Credentials = new NetworkCredential(FtpUserID, FtpPassword);  
                    }  
                    ftpsize.Method = WebRequestMethods.Ftp.GetFileSize;  
                    FtpWebResponse re = (FtpWebResponse)ftpsize.GetResponse();  
                    long totalBytes = re.ContentLength;  
                    re.Close();  
      
                    reqFTP.Method = WebRequestMethods.Ftp.DownloadFile;  
                    response = (FtpWebResponse)reqFTP.GetResponse();  
                    ftpStream = response.GetResponseStream();  
      
                    //更新进度    
                    if (updateProgress != null)  
                    {  
                        updateProgress((int)totalBytes, 0);//更新进度条     
                    }  
                    long totalDownloadedByte = 0;  
                    int bufferSize = 2048;  
                    int readCount;  
                    byte[] buffer = new byte[bufferSize];  
                    readCount = ftpStream.Read(buffer, 0, bufferSize);  
                    while (readCount > 0)  
                    {  
                        totalDownloadedByte = readCount + totalDownloadedByte;  
                        outputStream.Write(buffer, 0, readCount);  
                        //更新进度    
                        if (updateProgress != null)  
                        {  
                            updateProgress((int)totalBytes, (int)totalDownloadedByte);//更新进度条     
                        }  
                        readCount = ftpStream.Read(buffer, 0, bufferSize);  
                    }  
                    ftpStream.Close();  
                    outputStream.Close();  
                    response.Close();  
                    return true;  
                }  
                catch (Exception)  
                {  
                    return false;  
                    throw;  
                }  
                finally  
                {  
                    if (ftpStream != null)  
                    {  
                        ftpStream.Close();  
                    }  
                    if (outputStream != null)  
                    {  
                        outputStream.Close();  
                    }  
                    if (response != null)  
                    {  
                        response.Close();  
                    }  
                }  
            }  
            /// <summary>  
            /// 从FTP服务器下载文件,指定本地路径和本地文件名(支持断点下载)  
            /// </summary>  
            /// <param name="remoteFileName">远程文件名</param>  
            /// <param name="localFileName">保存本地的文件名(包含路径)</param>  
            /// <param name="ifCredential">是否启用身份验证(false:表示允许用户匿名下载)</param>  
            /// <param name="size">已下载文件流大小</param>  
            /// <param name="updateProgress">报告进度的处理(第一个参数:总大小,第二个参数:当前进度)</param>  
            /// <returns>是否下载成功</returns>  
            public static bool FtpBrokenDownload(string remoteFileName, string localFileName, bool ifCredential, long size, Action<int, int> updateProgress = null)  
            {  
                FtpWebRequest reqFTP, ftpsize;  
                Stream ftpStream = null;  
                FtpWebResponse response = null;  
                FileStream outputStream = null;  
                try  
                {  
      
                    outputStream = new FileStream(localFileName, FileMode.Append);  
                    if (FtpServerIP == null || FtpServerIP.Trim().Length == 0)  
                    {  
                        throw new Exception("ftp下载目标服务器地址未设置!");  
                    }  
                    Uri uri = new Uri("ftp://" + FtpServerIP + "/" + remoteFileName);  
                    ftpsize = (FtpWebRequest)FtpWebRequest.Create(uri);  
                    ftpsize.UseBinary = true;  
                    ftpsize.ContentOffset = size;  
      
                    reqFTP = (FtpWebRequest)FtpWebRequest.Create(uri);  
                    reqFTP.UseBinary = true;  
                    reqFTP.KeepAlive = false;  
                    reqFTP.ContentOffset = size;  
                    if (ifCredential)//使用用户身份认证  
                    {  
                        ftpsize.Credentials = new NetworkCredential(FtpUserID, FtpPassword);  
                        reqFTP.Credentials = new NetworkCredential(FtpUserID, FtpPassword);  
                    }  
                    ftpsize.Method = WebRequestMethods.Ftp.GetFileSize;  
                    FtpWebResponse re = (FtpWebResponse)ftpsize.GetResponse();  
                    long totalBytes = re.ContentLength;  
                    re.Close();  
      
                    reqFTP.Method = WebRequestMethods.Ftp.DownloadFile;  
                    response = (FtpWebResponse)reqFTP.GetResponse();  
                    ftpStream = response.GetResponseStream();  
      
                    //更新进度    
                    if (updateProgress != null)  
                    {  
                        updateProgress((int)totalBytes, 0);//更新进度条     
                    }  
                    long totalDownloadedByte = 0;  
                    int bufferSize = 2048;  
                    int readCount;  
                    byte[] buffer = new byte[bufferSize];  
                    readCount = ftpStream.Read(buffer, 0, bufferSize);  
                    while (readCount > 0)  
                    {  
                        totalDownloadedByte = readCount + totalDownloadedByte;  
                        outputStream.Write(buffer, 0, readCount);  
                        //更新进度    
                        if (updateProgress != null)  
                        {  
                            updateProgress((int)totalBytes, (int)totalDownloadedByte);//更新进度条     
                        }  
                        readCount = ftpStream.Read(buffer, 0, bufferSize);  
                    }  
                    ftpStream.Close();  
                    outputStream.Close();  
                    response.Close();  
                    return true;  
                }  
                catch (Exception)  
                {  
                    return false;  
                    throw;  
                }  
                finally  
                {  
                    if (ftpStream != null)  
                    {  
                        ftpStream.Close();  
                    }  
                    if (outputStream != null)  
                    {  
                        outputStream.Close();  
                    }  
                    if (response != null)  
                    {  
                        response.Close();  
                    }  
                }  
            }  
      
            /// <summary>  
            /// 从FTP服务器下载文件,指定本地路径和本地文件名  
            /// </summary>  
            /// <param name="remoteFileName">远程文件名</param>  
            /// <param name="localFileName">保存本地的文件名(包含路径)</param>  
            /// <param name="ifCredential">是否启用身份验证(false:表示允许用户匿名下载)</param>  
            /// <param name="updateProgress">报告进度的处理(第一个参数:总大小,第二个参数:当前进度)</param>  
            /// <param name="brokenOpen">是否断点下载:true 会在localFileName 找是否存在已经下载的文件,并计算文件流大小</param>  
            /// <returns>是否下载成功</returns>  
            public static bool FtpDownload(string remoteFileName, string localFileName, bool ifCredential, bool brokenOpen, Action<int, int> updateProgress = null)  
            {  
                if (brokenOpen)  
                {  
                    try  
                    {  
                        long size = 0;  
                        if (File.Exists(localFileName))  
                        {  
                            using (FileStream outputStream = new FileStream(localFileName, FileMode.Open))  
                            {  
                                size = outputStream.Length;  
                            }  
                        }  
                        return FtpBrokenDownload(remoteFileName, localFileName, ifCredential, size, updateProgress);  
                    }  
                    catch  
                    {  
                        throw;  
                    }  
                }  
                else  
                {  
                    return FtpDownload(remoteFileName, localFileName, ifCredential, updateProgress);  
                }  
            }  
            #endregion  
     
            #region 上传文件到FTP服务器  
            /// <summary>  
            /// 上传文件到FTP服务器  
            /// </summary>  
            /// <param name="localFullPath">本地带有完整路径的文件名</param>  
            /// <param name="updateProgress">报告进度的处理(第一个参数:总大小,第二个参数:当前进度)</param>  
            /// <returns>是否下载成功</returns>  
            public static bool FtpUploadFile(string localFullPathName, Action<int, int> updateProgress = null)  
            {  
                FtpWebRequest reqFTP;  
                Stream stream = null;  
                FtpWebResponse response = null;  
                FileStream fs = null;  
                try  
                {  
                    FileInfo finfo = new FileInfo(localFullPathName);  
                    if (FtpServerIP == null || FtpServerIP.Trim().Length == 0)  
                    {  
                        throw new Exception("ftp上传目标服务器地址未设置!");  
                    }  
                    Uri uri = new Uri("ftp://" + FtpServerIP + "/" + finfo.Name);  
                    reqFTP = (FtpWebRequest)FtpWebRequest.Create(uri);  
                    reqFTP.KeepAlive = false;  
                    reqFTP.UseBinary = true;  
                    reqFTP.Credentials = new NetworkCredential(FtpUserID, FtpPassword);//用户,密码  
                    reqFTP.Method = WebRequestMethods.Ftp.UploadFile;//向服务器发出下载请求命令  
                    reqFTP.ContentLength = finfo.Length;//为request指定上传文件的大小  
                    response = reqFTP.GetResponse() as FtpWebResponse;  
                    reqFTP.ContentLength = finfo.Length;  
                    int buffLength = 1024;  
                    byte[] buff = new byte[buffLength];  
                    int contentLen;  
                    fs = finfo.OpenRead();  
                    stream = reqFTP.GetRequestStream();  
                    contentLen = fs.Read(buff, 0, buffLength);  
                    int allbye = (int)finfo.Length;  
                    //更新进度    
                    if (updateProgress != null)  
                    {  
                        updateProgress((int)allbye, 0);//更新进度条     
                    }  
                    int startbye = 0;  
                    while (contentLen != 0)  
                    {  
                        startbye = contentLen + startbye;  
                        stream.Write(buff, 0, contentLen);  
                        //更新进度    
                        if (updateProgress != null)  
                        {  
                            updateProgress((int)allbye, (int)startbye);//更新进度条     
                        }  
                        contentLen = fs.Read(buff, 0, buffLength);  
                    }  
                    stream.Close();  
                    fs.Close();  
                    response.Close();  
                    return true;  
      
                }  
                catch (Exception)  
                {  
                    return false;  
                    throw;  
                }  
                finally  
                {  
                    if (fs != null)  
                    {  
                        fs.Close();  
                    }  
                    if (stream != null)  
                    {  
                        stream.Close();  
                    }  
                    if (response != null)  
                    {  
                        response.Close();  
                    }  
                }  
            }  
      
            /// <summary>  
            /// 上传文件到FTP服务器(断点续传)  
            /// </summary>  
            /// <param name="localFullPath">本地文件全路径名称:C:UsersJianKunKingDesktopIronPython脚本测试工具</param>  
            /// <param name="remoteFilepath">远程文件所在文件夹路径</param>  
            /// <param name="updateProgress">报告进度的处理(第一个参数:总大小,第二个参数:当前进度)</param>  
            /// <returns></returns>         
            public static bool FtpUploadBroken(string localFullPath, string remoteFilepath, Action<int, int> updateProgress = null)  
            {  
                if (remoteFilepath == null)  
                {  
                    remoteFilepath = "";  
                }  
                string newFileName = string.Empty;  
                bool success = true;  
                FileInfo fileInf = new FileInfo(localFullPath);  
                long allbye = (long)fileInf.Length;  
                if (fileInf.Name.IndexOf("#") == -1)  
                {  
                    newFileName = RemoveSpaces(fileInf.Name);  
                }  
                else  
                {  
                    newFileName = fileInf.Name.Replace("#", "");  
                    newFileName = RemoveSpaces(newFileName);  
                }  
                long startfilesize = GetFileSize(newFileName, remoteFilepath);  
                if (startfilesize >= allbye)  
                {  
                    return false;  
                }  
                long startbye = startfilesize;  
                //更新进度    
                if (updateProgress != null)  
                {  
                    updateProgress((int)allbye, (int)startfilesize);//更新进度条     
                }  
      
                string uri;  
                if (remoteFilepath.Length == 0)  
                {  
                    uri = "ftp://" + FtpServerIP + "/" + newFileName;  
                }  
                else  
                {  
                    uri = "ftp://" + FtpServerIP + "/" + remoteFilepath + "/" + newFileName;  
                }  
                FtpWebRequest reqFTP;  
                // 根据uri创建FtpWebRequest对象   
                reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(uri));  
                // ftp用户名和密码   
                reqFTP.Credentials = new NetworkCredential(FtpUserID, FtpPassword);  
                // 默认为true,连接不会被关闭   
                // 在一个命令之后被执行   
                reqFTP.KeepAlive = false;  
                // 指定执行什么命令   
                reqFTP.Method = WebRequestMethods.Ftp.AppendFile;  
                // 指定数据传输类型   
                reqFTP.UseBinary = true;  
                // 上传文件时通知服务器文件的大小   
                reqFTP.ContentLength = fileInf.Length;  
                int buffLength = 2048;// 缓冲大小设置为2kb   
                byte[] buff = new byte[buffLength];  
                // 打开一个文件流 (System.IO.FileStream) 去读上传的文件   
                FileStream fs = fileInf.OpenRead();  
                Stream strm = null;  
                try  
                {  
                    // 把上传的文件写入流   
                    strm = reqFTP.GetRequestStream();  
                    // 每次读文件流的2kb     
                    fs.Seek(startfilesize, 0);  
                    int contentLen = fs.Read(buff, 0, buffLength);  
                    // 流内容没有结束   
                    while (contentLen != 0)  
                    {  
                        // 把内容从file stream 写入 upload stream   
                        strm.Write(buff, 0, contentLen);  
                        contentLen = fs.Read(buff, 0, buffLength);  
                        startbye += contentLen;  
                        //更新进度    
                        if (updateProgress != null)  
                        {  
                            updateProgress((int)allbye, (int)startbye);//更新进度条     
                        }  
                    }  
                    // 关闭两个流   
                    strm.Close();  
                    fs.Close();  
                }  
                catch  
                {  
                    success = false;  
                    throw;  
                }  
                finally  
                {  
                    if (fs != null)  
                    {  
                        fs.Close();  
                    }  
                    if (strm != null)  
                    {  
                        strm.Close();  
                    }  
                }  
                return success;  
            }  
      
            /// <summary>  
            /// 去除空格  
            /// </summary>  
            /// <param name="str"></param>  
            /// <returns></returns>  
            private static string RemoveSpaces(string str)  
            {  
                string a = "";  
                CharEnumerator CEnumerator = str.GetEnumerator();  
                while (CEnumerator.MoveNext())  
                {  
                    byte[] array = new byte[1];  
                    array = System.Text.Encoding.ASCII.GetBytes(CEnumerator.Current.ToString());  
                    int asciicode = (short)(array[0]);  
                    if (asciicode != 32)  
                    {  
                        a += CEnumerator.Current.ToString();  
                    }  
                }  
                string sdate = System.DateTime.Now.Year.ToString() + System.DateTime.Now.Month.ToString() + System.DateTime.Now.Day.ToString() + System.DateTime.Now.Hour.ToString()  
                    + System.DateTime.Now.Minute.ToString() + System.DateTime.Now.Second.ToString() + System.DateTime.Now.Millisecond.ToString();  
                return a.Split('.')[a.Split('.').Length - 2] + "." + a.Split('.')[a.Split('.').Length - 1];  
            }  
            /// <summary>  
            /// 获取已上传文件大小  
            /// </summary>  
            /// <param name="filename">文件名称</param>  
            /// <param name="path">服务器文件路径</param>  
            /// <returns></returns>  
            public static long GetFileSize(string filename, string remoteFilepath)  
            {  
                long filesize = 0;  
                try  
                {  
                    FtpWebRequest reqFTP;  
                    FileInfo fi = new FileInfo(filename);  
                    string uri;  
                    if (remoteFilepath.Length == 0)  
                    {  
                        uri = "ftp://" + FtpServerIP + "/" + fi.Name;  
                    }  
                    else  
                    {  
                        uri = "ftp://" + FtpServerIP + "/" + remoteFilepath + "/" + fi.Name;  
                    }  
                    reqFTP = (FtpWebRequest)FtpWebRequest.Create(uri);  
                    reqFTP.KeepAlive = false;  
                    reqFTP.UseBinary = true;  
                    reqFTP.Credentials = new NetworkCredential(FtpUserID, FtpPassword);//用户,密码  
                    reqFTP.Method = WebRequestMethods.Ftp.GetFileSize;  
                    FtpWebResponse response = (FtpWebResponse)reqFTP.GetResponse();  
                    filesize = response.ContentLength;  
                    return filesize;  
                }  
                catch  
                {  
                    return 0;  
                }  
            }  
      
            //public void Connect(String path, string ftpUserID, string ftpPassword)//连接ftp  
            //{  
            //    // 根据uri创建FtpWebRequest对象  
            //    reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(path));  
            //    // 指定数据传输类型  
            //    reqFTP.UseBinary = true;  
            //    // ftp用户名和密码  
            //    reqFTP.Credentials = new NetworkCredential(ftpUserID, ftpPassword);  
            //}  
     
            #endregion  
      
      
      
        }  
    }</pre><br></pre>  
    [csharp] view plain copy
     
    print?
    <pre class="csharp" name="code">using System;  
    using System.Collections.Generic;  
    using System.Linq;  
    using System.Text;  
    using System.Net;  
    using System.IO;  
      
    namespace JianKunKing.Common.Ftp  
    {  
        /// <summary>  
        /// ftp方式文件下载上传  
        /// </summary>  
        public static class FileUpDownload  
        {  
            #region 变量属性  
            /// <summary>  
            /// Ftp服务器ip  
            /// </summary>  
            public static string FtpServerIP = string.Empty;  
            /// <summary>  
            /// Ftp 指定用户名  
            /// </summary>  
            public static string FtpUserID = string.Empty;  
            /// <summary>  
            /// Ftp 指定用户密码  
            /// </summary>  
            public static string FtpPassword = string.Empty;  
     
            #endregion  
     
            #region 从FTP服务器下载文件,指定本地路径和本地文件名  
            /// <summary>  
            /// 从FTP服务器下载文件,指定本地路径和本地文件名  
            /// </summary>  
            /// <param name="remoteFileName">远程文件名</param>  
            /// <param name="localFileName">保存本地的文件名(包含路径)</param>  
            /// <param name="ifCredential">是否启用身份验证(false:表示允许用户匿名下载)</param>  
            /// <param name="updateProgress">报告进度的处理(第一个参数:总大小,第二个参数:当前进度)</param>  
            /// <returns>是否下载成功</returns>  
            public static bool FtpDownload(string remoteFileName, string localFileName, bool ifCredential, Action<int, int> updateProgress = null)  
            {  
                FtpWebRequest reqFTP, ftpsize;  
                Stream ftpStream = null;  
                FtpWebResponse response = null;  
                FileStream outputStream = null;  
                try  
                {  
      
                    outputStream = new FileStream(localFileName, FileMode.Create);  
                    if (FtpServerIP == null || FtpServerIP.Trim().Length == 0)  
                    {  
                        throw new Exception("ftp下载目标服务器地址未设置!");  
                    }  
                    Uri uri = new Uri("ftp://" + FtpServerIP + "/" + remoteFileName);  
                    ftpsize = (FtpWebRequest)FtpWebRequest.Create(uri);  
                    ftpsize.UseBinary = true;  
      
                    reqFTP = (FtpWebRequest)FtpWebRequest.Create(uri);  
                    reqFTP.UseBinary = true;  
                    reqFTP.KeepAlive = false;  
                    if (ifCredential)//使用用户身份认证  
                    {  
                        ftpsize.Credentials = new NetworkCredential(FtpUserID, FtpPassword);  
                        reqFTP.Credentials = new NetworkCredential(FtpUserID, FtpPassword);  
                    }  
                    ftpsize.Method = WebRequestMethods.Ftp.GetFileSize;  
                    FtpWebResponse re = (FtpWebResponse)ftpsize.GetResponse();  
                    long totalBytes = re.ContentLength;  
                    re.Close();  
      
                    reqFTP.Method = WebRequestMethods.Ftp.DownloadFile;  
                    response = (FtpWebResponse)reqFTP.GetResponse();  
                    ftpStream = response.GetResponseStream();  
      
                    //更新进度    
                    if (updateProgress != null)  
                    {  
                        updateProgress((int)totalBytes, 0);//更新进度条     
                    }  
                    long totalDownloadedByte = 0;  
                    int bufferSize = 2048;  
                    int readCount;  
                    byte[] buffer = new byte[bufferSize];  
                    readCount = ftpStream.Read(buffer, 0, bufferSize);  
                    while (readCount > 0)  
                    {  
                        totalDownloadedByte = readCount + totalDownloadedByte;  
                        outputStream.Write(buffer, 0, readCount);  
                        //更新进度    
                        if (updateProgress != null)  
                        {  
                            updateProgress((int)totalBytes, (int)totalDownloadedByte);//更新进度条     
                        }  
                        readCount = ftpStream.Read(buffer, 0, bufferSize);  
                    }  
                    ftpStream.Close();  
                    outputStream.Close();  
                    response.Close();  
                    return true;  
                }  
                catch (Exception)  
                {  
                    return false;  
                    throw;  
                }  
                finally  
                {  
                    if (ftpStream != null)  
                    {  
                        ftpStream.Close();  
                    }  
                    if (outputStream != null)  
                    {  
                        outputStream.Close();  
                    }  
                    if (response != null)  
                    {  
                        response.Close();  
                    }  
                }  
            }  
            /// <summary>  
            /// 从FTP服务器下载文件,指定本地路径和本地文件名(支持断点下载)  
            /// </summary>  
            /// <param name="remoteFileName">远程文件名</param>  
            /// <param name="localFileName">保存本地的文件名(包含路径)</param>  
            /// <param name="ifCredential">是否启用身份验证(false:表示允许用户匿名下载)</param>  
            /// <param name="size">已下载文件流大小</param>  
            /// <param name="updateProgress">报告进度的处理(第一个参数:总大小,第二个参数:当前进度)</param>  
            /// <returns>是否下载成功</returns>  
            public static bool FtpBrokenDownload(string remoteFileName, string localFileName, bool ifCredential, long size, Action<int, int> updateProgress = null)  
            {  
                FtpWebRequest reqFTP, ftpsize;  
                Stream ftpStream = null;  
                FtpWebResponse response = null;  
                FileStream outputStream = null;  
                try  
                {  
      
                    outputStream = new FileStream(localFileName, FileMode.Append);  
                    if (FtpServerIP == null || FtpServerIP.Trim().Length == 0)  
                    {  
                        throw new Exception("ftp下载目标服务器地址未设置!");  
                    }  
                    Uri uri = new Uri("ftp://" + FtpServerIP + "/" + remoteFileName);  
                    ftpsize = (FtpWebRequest)FtpWebRequest.Create(uri);  
                    ftpsize.UseBinary = true;  
                    ftpsize.ContentOffset = size;  
      
                    reqFTP = (FtpWebRequest)FtpWebRequest.Create(uri);  
                    reqFTP.UseBinary = true;  
                    reqFTP.KeepAlive = false;  
                    reqFTP.ContentOffset = size;  
                    if (ifCredential)//使用用户身份认证  
                    {  
                        ftpsize.Credentials = new NetworkCredential(FtpUserID, FtpPassword);  
                        reqFTP.Credentials = new NetworkCredential(FtpUserID, FtpPassword);  
                    }  
                    ftpsize.Method = WebRequestMethods.Ftp.GetFileSize;  
                    FtpWebResponse re = (FtpWebResponse)ftpsize.GetResponse();  
                    long totalBytes = re.ContentLength;  
                    re.Close();  
      
                    reqFTP.Method = WebRequestMethods.Ftp.DownloadFile;  
                    response = (FtpWebResponse)reqFTP.GetResponse();  
                    ftpStream = response.GetResponseStream();  
      
                    //更新进度    
                    if (updateProgress != null)  
                    {  
                        updateProgress((int)totalBytes, 0);//更新进度条     
                    }  
                    long totalDownloadedByte = 0;  
                    int bufferSize = 2048;  
                    int readCount;  
                    byte[] buffer = new byte[bufferSize];  
                    readCount = ftpStream.Read(buffer, 0, bufferSize);  
                    while (readCount > 0)  
                    {  
                        totalDownloadedByte = readCount + totalDownloadedByte;  
                        outputStream.Write(buffer, 0, readCount);  
                        //更新进度    
                        if (updateProgress != null)  
                        {  
                            updateProgress((int)totalBytes, (int)totalDownloadedByte);//更新进度条     
                        }  
                        readCount = ftpStream.Read(buffer, 0, bufferSize);  
                    }  
                    ftpStream.Close();  
                    outputStream.Close();  
                    response.Close();  
                    return true;  
                }  
                catch (Exception)  
                {  
                    return false;  
                    throw;  
                }  
                finally  
                {  
                    if (ftpStream != null)  
                    {  
                        ftpStream.Close();  
                    }  
                    if (outputStream != null)  
                    {  
                        outputStream.Close();  
                    }  
                    if (response != null)  
                    {  
                        response.Close();  
                    }  
                }  
            }  
      
            /// <summary>  
            /// 从FTP服务器下载文件,指定本地路径和本地文件名  
            /// </summary>  
            /// <param name="remoteFileName">远程文件名</param>  
            /// <param name="localFileName">保存本地的文件名(包含路径)</param>  
            /// <param name="ifCredential">是否启用身份验证(false:表示允许用户匿名下载)</param>  
            /// <param name="updateProgress">报告进度的处理(第一个参数:总大小,第二个参数:当前进度)</param>  
            /// <param name="brokenOpen">是否断点下载:true 会在localFileName 找是否存在已经下载的文件,并计算文件流大小</param>  
            /// <returns>是否下载成功</returns>  
            public static bool FtpDownload(string remoteFileName, string localFileName, bool ifCredential, bool brokenOpen, Action<int, int> updateProgress = null)  
            {  
                if (brokenOpen)  
                {  
                    try  
                    {  
                        long size = 0;  
                        if (File.Exists(localFileName))  
                        {  
                            using (FileStream outputStream = new FileStream(localFileName, FileMode.Open))  
                            {  
                                size = outputStream.Length;  
                            }  
                        }  
                        return FtpBrokenDownload(remoteFileName, localFileName, ifCredential, size, updateProgress);  
                    }  
                    catch  
                    {  
                        throw;  
                    }  
                }  
                else  
                {  
                    return FtpDownload(remoteFileName, localFileName, ifCredential, updateProgress);  
                }  
            }  
            #endregion  
     
            #region 上传文件到FTP服务器  
            /// <summary>  
            /// 上传文件到FTP服务器  
            /// </summary>  
            /// <param name="localFullPath">本地带有完整路径的文件名</param>  
            /// <param name="updateProgress">报告进度的处理(第一个参数:总大小,第二个参数:当前进度)</param>  
            /// <returns>是否下载成功</returns>  
            public static bool FtpUploadFile(string localFullPathName, Action<int, int> updateProgress = null)  
            {  
                FtpWebRequest reqFTP;  
                Stream stream = null;  
                FtpWebResponse response = null;  
                FileStream fs = null;  
                try  
                {  
                    FileInfo finfo = new FileInfo(localFullPathName);  
                    if (FtpServerIP == null || FtpServerIP.Trim().Length == 0)  
                    {  
                        throw new Exception("ftp上传目标服务器地址未设置!");  
                    }  
                    Uri uri = new Uri("ftp://" + FtpServerIP + "/" + finfo.Name);  
                    reqFTP = (FtpWebRequest)FtpWebRequest.Create(uri);  
                    reqFTP.KeepAlive = false;  
                    reqFTP.UseBinary = true;  
                    reqFTP.Credentials = new NetworkCredential(FtpUserID, FtpPassword);//用户,密码  
                    reqFTP.Method = WebRequestMethods.Ftp.UploadFile;//向服务器发出下载请求命令  
                    reqFTP.ContentLength = finfo.Length;//为request指定上传文件的大小  
                    response = reqFTP.GetResponse() as FtpWebResponse;  
                    reqFTP.ContentLength = finfo.Length;  
                    int buffLength = 1024;  
                    byte[] buff = new byte[buffLength];  
                    int contentLen;  
                    fs = finfo.OpenRead();  
                    stream = reqFTP.GetRequestStream();  
                    contentLen = fs.Read(buff, 0, buffLength);  
                    int allbye = (int)finfo.Length;  
                    //更新进度    
                    if (updateProgress != null)  
                    {  
                        updateProgress((int)allbye, 0);//更新进度条     
                    }  
                    int startbye = 0;  
                    while (contentLen != 0)  
                    {  
                        startbye = contentLen + startbye;  
                        stream.Write(buff, 0, contentLen);  
                        //更新进度    
                        if (updateProgress != null)  
                        {  
                            updateProgress((int)allbye, (int)startbye);//更新进度条     
                        }  
                        contentLen = fs.Read(buff, 0, buffLength);  
                    }  
                    stream.Close();  
                    fs.Close();  
                    response.Close();  
                    return true;  
      
                }  
                catch (Exception)  
                {  
                    return false;  
                    throw;  
                }  
                finally  
                {  
                    if (fs != null)  
                    {  
                        fs.Close();  
                    }  
                    if (stream != null)  
                    {  
                        stream.Close();  
                    }  
                    if (response != null)  
                    {  
                        response.Close();  
                    }  
                }  
            }  
      
            /// <summary>  
            /// 上传文件到FTP服务器(断点续传)  
            /// </summary>  
            /// <param name="localFullPath">本地文件全路径名称:C:UsersJianKunKingDesktopIronPython脚本测试工具</param>  
            /// <param name="remoteFilepath">远程文件所在文件夹路径</param>  
            /// <param name="updateProgress">报告进度的处理(第一个参数:总大小,第二个参数:当前进度)</param>  
            /// <returns></returns>         
            public static bool FtpUploadBroken(string localFullPath, string remoteFilepath, Action<int, int> updateProgress = null)  
            {  
                if (remoteFilepath == null)  
                {  
                    remoteFilepath = "";  
                }  
                string newFileName = string.Empty;  
                bool success = true;  
                FileInfo fileInf = new FileInfo(localFullPath);  
                long allbye = (long)fileInf.Length;  
                if (fileInf.Name.IndexOf("#") == -1)  
                {  
                    newFileName = RemoveSpaces(fileInf.Name);  
                }  
                else  
                {  
                    newFileName = fileInf.Name.Replace("#", "");  
                    newFileName = RemoveSpaces(newFileName);  
                }  
                long startfilesize = GetFileSize(newFileName, remoteFilepath);  
                if (startfilesize >= allbye)  
                {  
                    return false;  
                }  
                long startbye = startfilesize;  
                //更新进度    
                if (updateProgress != null)  
                {  
                    updateProgress((int)allbye, (int)startfilesize);//更新进度条     
                }  
      
                string uri;  
                if (remoteFilepath.Length == 0)  
                {  
                    uri = "ftp://" + FtpServerIP + "/" + newFileName;  
                }  
                else  
                {  
                    uri = "ftp://" + FtpServerIP + "/" + remoteFilepath + "/" + newFileName;  
                }  
                FtpWebRequest reqFTP;  
                // 根据uri创建FtpWebRequest对象   
                reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(uri));  
                // ftp用户名和密码   
                reqFTP.Credentials = new NetworkCredential(FtpUserID, FtpPassword);  
                // 默认为true,连接不会被关闭   
                // 在一个命令之后被执行   
                reqFTP.KeepAlive = false;  
                // 指定执行什么命令   
                reqFTP.Method = WebRequestMethods.Ftp.AppendFile;  
                // 指定数据传输类型   
                reqFTP.UseBinary = true;  
                // 上传文件时通知服务器文件的大小   
                reqFTP.ContentLength = fileInf.Length;  
                int buffLength = 2048;// 缓冲大小设置为2kb   
                byte[] buff = new byte[buffLength];  
                // 打开一个文件流 (System.IO.FileStream) 去读上传的文件   
                FileStream fs = fileInf.OpenRead();  
                Stream strm = null;  
                try  
                {  
                    // 把上传的文件写入流   
                    strm = reqFTP.GetRequestStream();  
                    // 每次读文件流的2kb     
                    fs.Seek(startfilesize, 0);  
                    int contentLen = fs.Read(buff, 0, buffLength);  
                    // 流内容没有结束   
                    while (contentLen != 0)  
                    {  
                        // 把内容从file stream 写入 upload stream   
                        strm.Write(buff, 0, contentLen);  
                        contentLen = fs.Read(buff, 0, buffLength);  
                        startbye += contentLen;  
                        //更新进度    
                        if (updateProgress != null)  
                        {  
                            updateProgress((int)allbye, (int)startbye);//更新进度条     
                        }  
                    }  
                    // 关闭两个流   
                    strm.Close();  
                    fs.Close();  
                }  
                catch  
                {  
                    success = false;  
                    throw;  
                }  
                finally  
                {  
                    if (fs != null)  
                    {  
                        fs.Close();  
                    }  
                    if (strm != null)  
                    {  
                        strm.Close();  
                    }  
                }  
                return success;  
            }  
      
            /// <summary>  
            /// 去除空格  
            /// </summary>  
            /// <param name="str"></param>  
            /// <returns></returns>  
            private static string RemoveSpaces(string str)  
            {  
                string a = "";  
                CharEnumerator CEnumerator = str.GetEnumerator();  
                while (CEnumerator.MoveNext())  
                {  
                    byte[] array = new byte[1];  
                    array = System.Text.Encoding.ASCII.GetBytes(CEnumerator.Current.ToString());  
                    int asciicode = (short)(array[0]);  
                    if (asciicode != 32)  
                    {  
                        a += CEnumerator.Current.ToString();  
                    }  
                }  
                string sdate = System.DateTime.Now.Year.ToString() + System.DateTime.Now.Month.ToString() + System.DateTime.Now.Day.ToString() + System.DateTime.Now.Hour.ToString()  
                    + System.DateTime.Now.Minute.ToString() + System.DateTime.Now.Second.ToString() + System.DateTime.Now.Millisecond.ToString();  
                return a.Split('.')[a.Split('.').Length - 2] + "." + a.Split('.')[a.Split('.').Length - 1];  
            }  
            /// <summary>  
            /// 获取已上传文件大小  
            /// </summary>  
            /// <param name="filename">文件名称</param>  
            /// <param name="path">服务器文件路径</param>  
            /// <returns></returns>  
            public static long GetFileSize(string filename, string remoteFilepath)  
            {  
                long filesize = 0;  
                try  
                {  
                    FtpWebRequest reqFTP;  
                    FileInfo fi = new FileInfo(filename);  
                    string uri;  
                    if (remoteFilepath.Length == 0)  
                    {  
                        uri = "ftp://" + FtpServerIP + "/" + fi.Name;  
                    }  
                    else  
                    {  
                        uri = "ftp://" + FtpServerIP + "/" + remoteFilepath + "/" + fi.Name;  
                    }  
                    reqFTP = (FtpWebRequest)FtpWebRequest.Create(uri);  
                    reqFTP.KeepAlive = false;  
                    reqFTP.UseBinary = true;  
                    reqFTP.Credentials = new NetworkCredential(FtpUserID, FtpPassword);//用户,密码  
                    reqFTP.Method = WebRequestMethods.Ftp.GetFileSize;  
                    FtpWebResponse response = (FtpWebResponse)reqFTP.GetResponse();  
                    filesize = response.ContentLength;  
                    return filesize;  
                }  
                catch  
                {  
                    return 0;  
                }  
            }  
      
            //public void Connect(String path, string ftpUserID, string ftpPassword)//连接ftp  
            //{  
            //    // 根据uri创建FtpWebRequest对象  
            //    reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(path));  
            //    // 指定数据传输类型  
            //    reqFTP.UseBinary = true;  
            //    // ftp用户名和密码  
            //    reqFTP.Credentials = new NetworkCredential(ftpUserID, ftpPassword);  
            //}  
     
            #endregion  
      
      
      
        }  
    }</pre><br>  
    [csharp] view plain copy
     
    print?
    using System;  
    using System.Collections.Generic;  
    using System.Linq;  
    using System.Text;  
    using System.Net;  
    using System.IO;  
      
    namespace JianKunKing.Common.Ftp  
    {  
        /// <summary>  
        /// ftp方式文件下载上传  
        /// </summary>  
        public static class FileUpDownload  
        {  
            #region 变量属性  
            /// <summary>  
            /// Ftp服务器ip  
            /// </summary>  
            public static string FtpServerIP = string.Empty;  
            /// <summary>  
            /// Ftp 指定用户名  
            /// </summary>  
            public static string FtpUserID = string.Empty;  
            /// <summary>  
            /// Ftp 指定用户密码  
            /// </summary>  
            public static string FtpPassword = string.Empty;  
     
            #endregion  
     
            #region 从FTP服务器下载文件,指定本地路径和本地文件名  
            /// <summary>  
            /// 从FTP服务器下载文件,指定本地路径和本地文件名  
            /// </summary>  
            /// <param name="remoteFileName">远程文件名</param>  
            /// <param name="localFileName">保存本地的文件名(包含路径)</param>  
            /// <param name="ifCredential">是否启用身份验证(false:表示允许用户匿名下载)</param>  
            /// <param name="updateProgress">报告进度的处理(第一个参数:总大小,第二个参数:当前进度)</param>  
            /// <returns>是否下载成功</returns>  
            public static bool FtpDownload(string remoteFileName, string localFileName, bool ifCredential, Action<int, int> updateProgress = null)  
            {  
                FtpWebRequest reqFTP, ftpsize;  
                Stream ftpStream = null;  
                FtpWebResponse response = null;  
                FileStream outputStream = null;  
                try  
                {  
      
                    outputStream = new FileStream(localFileName, FileMode.Create);  
                    if (FtpServerIP == null || FtpServerIP.Trim().Length == 0)  
                    {  
                        throw new Exception("ftp下载目标服务器地址未设置!");  
                    }  
                    Uri uri = new Uri("ftp://" + FtpServerIP + "/" + remoteFileName);  
                    ftpsize = (FtpWebRequest)FtpWebRequest.Create(uri);  
                    ftpsize.UseBinary = true;  
      
                    reqFTP = (FtpWebRequest)FtpWebRequest.Create(uri);  
                    reqFTP.UseBinary = true;  
                    reqFTP.KeepAlive = false;  
                    if (ifCredential)//使用用户身份认证  
                    {  
                        ftpsize.Credentials = new NetworkCredential(FtpUserID, FtpPassword);  
                        reqFTP.Credentials = new NetworkCredential(FtpUserID, FtpPassword);  
                    }  
                    ftpsize.Method = WebRequestMethods.Ftp.GetFileSize;  
                    FtpWebResponse re = (FtpWebResponse)ftpsize.GetResponse();  
                    long totalBytes = re.ContentLength;  
                    re.Close();  
      
                    reqFTP.Method = WebRequestMethods.Ftp.DownloadFile;  
                    response = (FtpWebResponse)reqFTP.GetResponse();  
                    ftpStream = response.GetResponseStream();  
      
                    //更新进度    
                    if (updateProgress != null)  
                    {  
                        updateProgress((int)totalBytes, 0);//更新进度条     
                    }  
                    long totalDownloadedByte = 0;  
                    int bufferSize = 2048;  
                    int readCount;  
                    byte[] buffer = new byte[bufferSize];  
                    readCount = ftpStream.Read(buffer, 0, bufferSize);  
                    while (readCount > 0)  
                    {  
                        totalDownloadedByte = readCount + totalDownloadedByte;  
                        outputStream.Write(buffer, 0, readCount);  
                        //更新进度    
                        if (updateProgress != null)  
                        {  
                            updateProgress((int)totalBytes, (int)totalDownloadedByte);//更新进度条     
                        }  
                        readCount = ftpStream.Read(buffer, 0, bufferSize);  
                    }  
                    ftpStream.Close();  
                    outputStream.Close();  
                    response.Close();  
                    return true;  
                }  
                catch (Exception)  
                {  
                    return false;  
                    throw;  
                }  
                finally  
                {  
                    if (ftpStream != null)  
                    {  
                        ftpStream.Close();  
                    }  
                    if (outputStream != null)  
                    {  
                        outputStream.Close();  
                    }  
                    if (response != null)  
                    {  
                        response.Close();  
                    }  
                }  
            }  
            /// <summary>  
            /// 从FTP服务器下载文件,指定本地路径和本地文件名(支持断点下载)  
            /// </summary>  
            /// <param name="remoteFileName">远程文件名</param>  
            /// <param name="localFileName">保存本地的文件名(包含路径)</param>  
            /// <param name="ifCredential">是否启用身份验证(false:表示允许用户匿名下载)</param>  
            /// <param name="size">已下载文件流大小</param>  
            /// <param name="updateProgress">报告进度的处理(第一个参数:总大小,第二个参数:当前进度)</param>  
            /// <returns>是否下载成功</returns>  
            public static bool FtpBrokenDownload(string remoteFileName, string localFileName, bool ifCredential, long size, Action<int, int> updateProgress = null)  
            {  
                FtpWebRequest reqFTP, ftpsize;  
                Stream ftpStream = null;  
                FtpWebResponse response = null;  
                FileStream outputStream = null;  
                try  
                {  
      
                    outputStream = new FileStream(localFileName, FileMode.Append);  
                    if (FtpServerIP == null || FtpServerIP.Trim().Length == 0)  
                    {  
                        throw new Exception("ftp下载目标服务器地址未设置!");  
                    }  
                    Uri uri = new Uri("ftp://" + FtpServerIP + "/" + remoteFileName);  
                    ftpsize = (FtpWebRequest)FtpWebRequest.Create(uri);  
                    ftpsize.UseBinary = true;  
                    ftpsize.ContentOffset = size;  
      
                    reqFTP = (FtpWebRequest)FtpWebRequest.Create(uri);  
                    reqFTP.UseBinary = true;  
                    reqFTP.KeepAlive = false;  
                    reqFTP.ContentOffset = size;  
                    if (ifCredential)//使用用户身份认证  
                    {  
                        ftpsize.Credentials = new NetworkCredential(FtpUserID, FtpPassword);  
                        reqFTP.Credentials = new NetworkCredential(FtpUserID, FtpPassword);  
                    }  
                    ftpsize.Method = WebRequestMethods.Ftp.GetFileSize;  
                    FtpWebResponse re = (FtpWebResponse)ftpsize.GetResponse();  
                    long totalBytes = re.ContentLength;  
                    re.Close();  
      
                    reqFTP.Method = WebRequestMethods.Ftp.DownloadFile;  
                    response = (FtpWebResponse)reqFTP.GetResponse();  
                    ftpStream = response.GetResponseStream();  
      
                    //更新进度    
                    if (updateProgress != null)  
                    {  
                        updateProgress((int)totalBytes, 0);//更新进度条     
                    }  
                    long totalDownloadedByte = 0;  
                    int bufferSize = 2048;  
                    int readCount;  
                    byte[] buffer = new byte[bufferSize];  
                    readCount = ftpStream.Read(buffer, 0, bufferSize);  
                    while (readCount > 0)  
                    {  
                        totalDownloadedByte = readCount + totalDownloadedByte;  
                        outputStream.Write(buffer, 0, readCount);  
                        //更新进度    
                        if (updateProgress != null)  
                        {  
                            updateProgress((int)totalBytes, (int)totalDownloadedByte);//更新进度条     
                        }  
                        readCount = ftpStream.Read(buffer, 0, bufferSize);  
                    }  
                    ftpStream.Close();  
                    outputStream.Close();  
                    response.Close();  
                    return true;  
                }  
                catch (Exception)  
                {  
                    return false;  
                    throw;  
                }  
                finally  
                {  
                    if (ftpStream != null)  
                    {  
                        ftpStream.Close();  
                    }  
                    if (outputStream != null)  
                    {  
                        outputStream.Close();  
                    }  
                    if (response != null)  
                    {  
                        response.Close();  
                    }  
                }  
            }  
      
            /// <summary>  
            /// 从FTP服务器下载文件,指定本地路径和本地文件名  
            /// </summary>  
            /// <param name="remoteFileName">远程文件名</param>  
            /// <param name="localFileName">保存本地的文件名(包含路径)</param>  
            /// <param name="ifCredential">是否启用身份验证(false:表示允许用户匿名下载)</param>  
            /// <param name="updateProgress">报告进度的处理(第一个参数:总大小,第二个参数:当前进度)</param>  
            /// <param name="brokenOpen">是否断点下载:true 会在localFileName 找是否存在已经下载的文件,并计算文件流大小</param>  
            /// <returns>是否下载成功</returns>  
            public static bool FtpDownload(string remoteFileName, string localFileName, bool ifCredential, bool brokenOpen, Action<int, int> updateProgress = null)  
            {  
                if (brokenOpen)  
                {  
                    try  
                    {  
                        long size = 0;  
                        if (File.Exists(localFileName))  
                        {  
                            using (FileStream outputStream = new FileStream(localFileName, FileMode.Open))  
                            {  
                                size = outputStream.Length;  
                            }  
                        }  
                        return FtpBrokenDownload(remoteFileName, localFileName, ifCredential, size, updateProgress);  
                    }  
                    catch  
                    {  
                        throw;  
                    }  
                }  
                else  
                {  
                    return FtpDownload(remoteFileName, localFileName, ifCredential, updateProgress);  
                }  
            }  
            #endregion  
     
            #region 上传文件到FTP服务器  
            /// <summary>  
            /// 上传文件到FTP服务器  
            /// </summary>  
            /// <param name="localFullPath">本地带有完整路径的文件名</param>  
            /// <param name="updateProgress">报告进度的处理(第一个参数:总大小,第二个参数:当前进度)</param>  
            /// <returns>是否下载成功</returns>  
            public static bool FtpUploadFile(string localFullPathName, Action<int, int> updateProgress = null)  
            {  
                FtpWebRequest reqFTP;  
                Stream stream = null;  
                FtpWebResponse response = null;  
                FileStream fs = null;  
                try  
                {  
                    FileInfo finfo = new FileInfo(localFullPathName);  
                    if (FtpServerIP == null || FtpServerIP.Trim().Length == 0)  
                    {  
                        throw new Exception("ftp上传目标服务器地址未设置!");  
                    }  
                    Uri uri = new Uri("ftp://" + FtpServerIP + "/" + finfo.Name);  
                    reqFTP = (FtpWebRequest)FtpWebRequest.Create(uri);  
                    reqFTP.KeepAlive = false;  
                    reqFTP.UseBinary = true;  
                    reqFTP.Credentials = new NetworkCredential(FtpUserID, FtpPassword);//用户,密码  
                    reqFTP.Method = WebRequestMethods.Ftp.UploadFile;//向服务器发出下载请求命令  
                    reqFTP.ContentLength = finfo.Length;//为request指定上传文件的大小  
                    response = reqFTP.GetResponse() as FtpWebResponse;  
                    reqFTP.ContentLength = finfo.Length;  
                    int buffLength = 1024;  
                    byte[] buff = new byte[buffLength];  
                    int contentLen;  
                    fs = finfo.OpenRead();  
                    stream = reqFTP.GetRequestStream();  
                    contentLen = fs.Read(buff, 0, buffLength);  
                    int allbye = (int)finfo.Length;  
                    //更新进度    
                    if (updateProgress != null)  
                    {  
                        updateProgress((int)allbye, 0);//更新进度条     
                    }  
                    int startbye = 0;  
                    while (contentLen != 0)  
                    {  
                        startbye = contentLen + startbye;  
                        stream.Write(buff, 0, contentLen);  
                        //更新进度    
                        if (updateProgress != null)  
                        {  
                            updateProgress((int)allbye, (int)startbye);//更新进度条     
                        }  
                        contentLen = fs.Read(buff, 0, buffLength);  
                    }  
                    stream.Close();  
                    fs.Close();  
                    response.Close();  
                    return true;  
      
                }  
                catch (Exception)  
                {  
                    return false;  
                    throw;  
                }  
                finally  
                {  
                    if (fs != null)  
                    {  
                        fs.Close();  
                    }  
                    if (stream != null)  
                    {  
                        stream.Close();  
                    }  
                    if (response != null)  
                    {  
                        response.Close();  
                    }  
                }  
            }  
      
            /// <summary>  
            /// 上传文件到FTP服务器(断点续传)  
            /// </summary>  
            /// <param name="localFullPath">本地文件全路径名称:C:UsersJianKunKingDesktopIronPython脚本测试工具</param>  
            /// <param name="remoteFilepath">远程文件所在文件夹路径</param>  
            /// <param name="updateProgress">报告进度的处理(第一个参数:总大小,第二个参数:当前进度)</param>  
            /// <returns></returns>         
            public static bool FtpUploadBroken(string localFullPath, string remoteFilepath, Action<int, int> updateProgress = null)  
            {  
                if (remoteFilepath == null)  
                {  
                    remoteFilepath = "";  
                }  
                string newFileName = string.Empty;  
                bool success = true;  
                FileInfo fileInf = new FileInfo(localFullPath);  
                long allbye = (long)fileInf.Length;  
                if (fileInf.Name.IndexOf("#") == -1)  
                {  
                    newFileName = RemoveSpaces(fileInf.Name);  
                }  
                else  
                {  
                    newFileName = fileInf.Name.Replace("#", "");  
                    newFileName = RemoveSpaces(newFileName);  
                }  
                long startfilesize = GetFileSize(newFileName, remoteFilepath);  
                if (startfilesize >= allbye)  
                {  
                    return false;  
                }  
                long startbye = startfilesize;  
                //更新进度    
                if (updateProgress != null)  
                {  
                    updateProgress((int)allbye, (int)startfilesize);//更新进度条     
                }  
      
                string uri;  
                if (remoteFilepath.Length == 0)  
                {  
                    uri = "ftp://" + FtpServerIP + "/" + newFileName;  
                }  
                else  
                {  
                    uri = "ftp://" + FtpServerIP + "/" + remoteFilepath + "/" + newFileName;  
                }  
                FtpWebRequest reqFTP;  
                // 根据uri创建FtpWebRequest对象   
                reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(uri));  
                // ftp用户名和密码   
                reqFTP.Credentials = new NetworkCredential(FtpUserID, FtpPassword);  
                // 默认为true,连接不会被关闭   
                // 在一个命令之后被执行   
                reqFTP.KeepAlive = false;  
                // 指定执行什么命令   
                reqFTP.Method = WebRequestMethods.Ftp.AppendFile;  
                // 指定数据传输类型   
                reqFTP.UseBinary = true;  
                // 上传文件时通知服务器文件的大小   
                reqFTP.ContentLength = fileInf.Length;  
                int buffLength = 2048;// 缓冲大小设置为2kb   
                byte[] buff = new byte[buffLength];  
                // 打开一个文件流 (System.IO.FileStream) 去读上传的文件   
                FileStream fs = fileInf.OpenRead();  
                Stream strm = null;  
                try  
                {  
                    // 把上传的文件写入流   
                    strm = reqFTP.GetRequestStream();  
                    // 每次读文件流的2kb     
                    fs.Seek(startfilesize, 0);  
                    int contentLen = fs.Read(buff, 0, buffLength);  
                    // 流内容没有结束   
                    while (contentLen != 0)  
                    {  
                        // 把内容从file stream 写入 upload stream   
                        strm.Write(buff, 0, contentLen);  
                        contentLen = fs.Read(buff, 0, buffLength);  
                        startbye += contentLen;  
                        //更新进度    
                        if (updateProgress != null)  
                        {  
                            updateProgress((int)allbye, (int)startbye);//更新进度条     
                        }  
                    }  
                    // 关闭两个流   
                    strm.Close();  
                    fs.Close();  
                }  
                catch  
                {  
                    success = false;  
                    throw;  
                }  
                finally  
                {  
                    if (fs != null)  
                    {  
                        fs.Close();  
                    }  
                    if (strm != null)  
                    {  
                        strm.Close();  
                    }  
                }  
                return success;  
            }  
      
            /// <summary>  
            /// 去除空格  
            /// </summary>  
            /// <param name="str"></param>  
            /// <returns></returns>  
            private static string RemoveSpaces(string str)  
            {  
                string a = "";  
                CharEnumerator CEnumerator = str.GetEnumerator();  
                while (CEnumerator.MoveNext())  
                {  
                    byte[] array = new byte[1];  
                    array = System.Text.Encoding.ASCII.GetBytes(CEnumerator.Current.ToString());  
                    int asciicode = (short)(array[0]);  
                    if (asciicode != 32)  
                    {  
                        a += CEnumerator.Current.ToString();  
                    }  
                }  
                string sdate = System.DateTime.Now.Year.ToString() + System.DateTime.Now.Month.ToString() + System.DateTime.Now.Day.ToString() + System.DateTime.Now.Hour.ToString()  
                    + System.DateTime.Now.Minute.ToString() + System.DateTime.Now.Second.ToString() + System.DateTime.Now.Millisecond.ToString();  
                return a.Split('.')[a.Split('.').Length - 2] + "." + a.Split('.')[a.Split('.').Length - 1];  
            }  
            /// <summary>  
            /// 获取已上传文件大小  
            /// </summary>  
            /// <param name="filename">文件名称</param>  
            /// <param name="path">服务器文件路径</param>  
            /// <returns></returns>  
            public static long GetFileSize(string filename, string remoteFilepath)  
            {  
                long filesize = 0;  
                try  
                {  
                    FtpWebRequest reqFTP;  
                    FileInfo fi = new FileInfo(filename);  
                    string uri;  
                    if (remoteFilepath.Length == 0)  
                    {  
                        uri = "ftp://" + FtpServerIP + "/" + fi.Name;  
                    }  
                    else  
                    {  
                        uri = "ftp://" + FtpServerIP + "/" + remoteFilepath + "/" + fi.Name;  
                    }  
                    reqFTP = (FtpWebRequest)FtpWebRequest.Create(uri);  
                    reqFTP.KeepAlive = false;  
                    reqFTP.UseBinary = true;  
                    reqFTP.Credentials = new NetworkCredential(FtpUserID, FtpPassword);//用户,密码  
                    reqFTP.Method = WebRequestMethods.Ftp.GetFileSize;  
                    FtpWebResponse response = (FtpWebResponse)reqFTP.GetResponse();  
                    filesize = response.ContentLength;  
                    return filesize;  
                }  
                catch  
                {  
                    return 0;  
                }  
            }  
      
            //public void Connect(String path, string ftpUserID, string ftpPassword)//连接ftp  
            //{  
            //    // 根据uri创建FtpWebRequest对象  
            //    reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(path));  
            //    // 指定数据传输类型  
            //    reqFTP.UseBinary = true;  
            //    // ftp用户名和密码  
            //    reqFTP.Credentials = new NetworkCredential(ftpUserID, ftpPassword);  
            //}  
     
            #endregion  
      
      
      
        }  
    }  
    View Code

    IIS下搭建FTP服务器

    https://blog.csdn.net/jiankunking/article/details/50016043

    树立目标,保持活力,gogogo!
  • 相关阅读:
    关于==和equals的区别和联系,面试这么回答就可以
    (附运行结果和截图)关于try{return}finally中都有return 运行结果测试之旅
    [已解决]踩过的坑之mysql连接报“Communications link failure”错误
    JVM虚拟机----运行时数据区-------方法区
    JVM虚拟机------运行时数据区------堆
    JVM虚拟机-----运行时数据区-----本地方法栈
    JVM虚拟机栈------运行时数据区------方法的调用
    JVM虚拟机-----运行时数据区------动态链接
    JVM虚拟机栈------运行时数据区-------栈顶缓存技术
    JVM虚拟机-----运行时数据区-----JVM虚拟机栈-----操作数栈
  • 原文地址:https://www.cnblogs.com/hao-1234-1234/p/14237141.html
Copyright © 2011-2022 走看看