首页 > > 网络编程 > Asp.Net编程 >

FTP文件上传以及获取ftp配置帮助类

2018-06-22 07:49:59来源：未知 阅读 ()

新老客户大回馈,云服务器低至5折

帮助类：

using QSProjectBase;
using Reform.CommonLib;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Text;

namespace Reform.CommonLib
{
    /// <summary>
    /// ftp操作
    /// </summary>
    public class FtpHelper
    {
        /// <summary>
        /// 上传文件
        /// </summary>
        /// <param name="fileName">上传文件的全路径</param>
        /// <param name="accessory">上传类</param>
        /// <returns></returns>
        public static bool UploadFile(FileInfo fileinfo, string ftpPath)
        {
            try
            {
                if (fileinfo == null || string.IsNullOrEmpty(ftpPath))
                    return false;

                string url = ftpPath;
                if (url.Contains("/") || url.Contains("\\"))
                {
                    var str = url.Split(new Char[] { '/', '\\' });
                    var dic = url.Replace(str[str.Length - 1], "");
                    CheckAndMakeDir(dic);
                }

                System.Net.FtpWebRequest ftp = GetRequest(url);

                //设置FTP命令 设置所要执行的FTP命令，
                //ftp.Method = System.Net.WebRequestMethods.Ftp.ListDirectoryDetails;//假设此处为显示指定路径下的文件列表
                ftp.Method = System.Net.WebRequestMethods.Ftp.UploadFile;
                ftp.UseBinary = true;
                ftp.UsePassive = true;
                ftp.ContentLength = fileinfo.Length;

                const int BufferSize = 20480; //缓冲大小设置为20KB
                byte[] content = new byte[BufferSize - 1 + 1];
                int dataRead;

                using (FileStream fs = fileinfo.OpenRead())
                {
                    try
                    {
                        using (Stream rs = ftp.GetRequestStream())
                        {
                            do
                            {
                                dataRead = fs.Read(content, 0, BufferSize);
                                rs.Write(content, 0, dataRead);
                            } while (!(dataRead < BufferSize));
                            rs.Close();
                        }
                    }
                    catch (Exception) { }
                    finally
                    {
                        fs.Close();
                    }
                }
                ftp = null;
                ////设置FTP命令
                //ftp = GetRequest(URI);
                //ftp.Method = System.Net.WebRequestMethods.Ftp.Rename; //改名
                //ftp.RenameTo = fileinfo.Name;
                //try
                //{
                //    ftp.GetResponse();
                //}
                //catch (Exception ex)
                //{
                //    ftp = GetRequest(URI);
                //    ftp.Method = System.Net.WebRequestMethods.Ftp.DeleteFile; //删除
                //    ftp.GetResponse();
                //}
                //ftp = null;
                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }

        /// <summary>
        /// 上传文件
        /// </summary>
        /// <param name="fileName">上传文件的全路径</param>
        /// <param name="ftpPath">上传的目录（包括文件名）</param>
        /// <param name="progressHelper">进度帮助</param>
        /// <returns></returns>
        public static bool UploadFile(FileInfo fileinfo, string ftpPath, ProgressHelper progressHelper, MessageProgressHandler handler)
        {
            try
            {
                if (fileinfo == null || string.IsNullOrEmpty(ftpPath))
                    return false;

                string url = ftpPath;
                if (url.Contains("/") || url.Contains("\\"))
                {
                    var str = url.Split(new Char[] { '/', '\\' });
                    var dic = url.Replace(str[str.Length - 1], "");
                    CheckAndMakeDir(dic);
                }
                System.Net.FtpWebRequest ftp = GetRequest(url);

                //设置FTP命令 设置所要执行的FTP命令，
                //ftp.Method = System.Net.WebRequestMethods.Ftp.ListDirectoryDetails;//假设此处为显示指定路径下的文件列表
                ftp.Method = System.Net.WebRequestMethods.Ftp.UploadFile;
                ftp.UseBinary = true;
                ftp.UsePassive = false;
                ftp.ContentLength = fileinfo.Length;

                const int BufferSize = 20480; //缓冲大小设置为20KB
                byte[] content = new byte[BufferSize - 1 + 1];
                int dataRead;


                using (FileStream fs = fileinfo.OpenRead())
                {
                    long fileLen = fs.Length;
                    if (progressHelper != null && handler != null)
                    {
                        progressHelper.SetProgress(handler, "正在上传...", 0);
                    }
                    try
                    {
                        long proValue = 0;
                        using (Stream rs = ftp.GetRequestStream())
                        {

                            do
                            {
                                dataRead = fs.Read(content, 0, BufferSize);
                                rs.Write(content, 0, dataRead);
                                proValue += dataRead;
                                if (progressHelper != null && handler != null)
                                {
                                    progressHelper.SetProgress(handler, "正在上传...", (int)((double)proValue * 100 / fileLen));
                                }
                            } while (!(dataRead < BufferSize));
                            var aa = rs.Length;
                            rs.Close();
                        }
                    }
                    catch (Exception) { }
                    finally
                    {
                        fs.Close();
                    }
                }
                ftp = null;
                ////设置FTP命令
                //ftp = GetRequest(URI);
                //ftp.Method = System.Net.WebRequestMethods.Ftp.Rename; //改名
                //ftp.RenameTo = fileinfo.Name;
                //try
                //{
                //    ftp.GetResponse();
                //}
                //catch (Exception ex)
                //{
                //    ftp = GetRequest(URI);
                //    ftp.Method = System.Net.WebRequestMethods.Ftp.DeleteFile; //删除
                //    ftp.GetResponse();
                //}
                //ftp = null;
                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }

        /// <summary>
        /// 下载文件
        /// </summary>
        /// <param name="localDir">下载到本地（全路径）</param>
        /// <param name="accessory">要下载的附件类</param> 
        public static bool DownloadFile(string localFilePath, string ftpPath)
        {
            if (string.IsNullOrEmpty(ftpPath)) return false;
            if (string.IsNullOrEmpty(localFilePath)) return false;
            System.Net.FtpWebRequest ftp = null;
            try
            {
                string Url = ftpPath;
                string localDir = new FileInfo(localFilePath).DirectoryName;
                if (!Directory.Exists(localDir))
                {
                    Directory.CreateDirectory(localDir);
                }
                string tmpname = Guid.NewGuid().ToString();
                string tmpFilePath = localDir + @"\" + tmpname;

                ftp = GetRequest(Url);
                // MsgBoxShow.ShowInformation(Url);
                ftp.Method = System.Net.WebRequestMethods.Ftp.DownloadFile;
                ftp.UseBinary = true;
                ftp.UsePassive = false;

                using (FtpWebResponse response = (FtpWebResponse)ftp.GetResponse())
                {
                    using (Stream responseStream = response.GetResponseStream())
                    {
                        using (FileStream fs = new FileStream(tmpFilePath, FileMode.CreateNew))
                        {
                            var aa = ftp.ContentLength;
                            try
                            {
                                byte[] buffer = new byte[20480];
                                int read = 0;
                                do
                                {
                                    read = responseStream.Read(buffer, 0, buffer.Length);
                                    fs.Write(buffer, 0, read);
                                } while (!(read == 0));
                                responseStream.Close();
                                fs.Flush();
                                fs.Close();
                            }
                            catch (Exception)
                            {
                                fs.Close();
                                File.Delete(tmpFilePath);
                                return false;
                            }
                        }
                        responseStream.Close();
                    }
                    response.Close();
                }
                try
                {
                    File.Delete(localFilePath);
                    File.Move(tmpFilePath, localFilePath);
                    ftp = null;
                }
                catch (Exception)
                {
                    File.Delete(tmpFilePath);
                    return false;
                }
                ftp = null;
                return true;
            }
            catch (WebException e)
            {
                Common_LogManager.RecordLog(LogType.Error, e.Message, e);
                if (e.Status == WebExceptionStatus.ProtocolError)
                {
                    Console.WriteLine("Status Code : {0}", ((FtpWebResponse)e.Response).StatusCode);
                    Console.WriteLine("Status Description : {0}", ((FtpWebResponse)e.Response).StatusDescription);
                }
                return false;
            }
        }

        /// <summary>
        /// 下载文件,叠加
        /// </summary>
        /// <param name="localDir">下载到本地（全路径）</param>
        /// <param name="accessory">要下载的附件类</param> 
        public static bool DownloadFileEx(string localFilePath, string ftpPath)
        {
            if (string.IsNullOrEmpty(ftpPath)) return false;
            if (string.IsNullOrEmpty(localFilePath)) return false;
            try
            {
                string Url = ftpPath;

                System.Net.FtpWebRequest ftp = GetRequest(Url);
                ftp.Method = System.Net.WebRequestMethods.Ftp.DownloadFile;
                ftp.UseBinary = true;
                ftp.UsePassive = false;

                using (FtpWebResponse response = (FtpWebResponse)ftp.GetResponse())
                {
                    using (Stream responseStream = response.GetResponseStream())
                    {
                        using (FileStream fs = new FileStream(localFilePath, FileMode.Append))
                        {
                            try
                            {
                                byte[] buffer = new byte[20480];
                                int read = 0;
                                do
                                {
                                    read = responseStream.Read(buffer, 0, buffer.Length);
                                    fs.Write(buffer, 0, read);
                                } while (!(read == 0));
                                responseStream.Close();
                                fs.Flush();
                                fs.Close();
                            }
                            catch (Exception)
                            {
                                fs.Close();
                                return false;
                            }
                        }
                        responseStream.Close();
                    }
                    response.Close();
                }
                try
                {
                    ftp = null;
                }
                catch (Exception)
                {
                    return false;
                }
                ftp = null;
                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }

        /// <summary>
        /// 下载文件(包含进度)
        /// </summary>
        /// <param name="localDir">下载到本地（全路径）</param>
        /// <param name="accessory">要下载的附件类</param> 
        public static bool DownloadFile(string localFilePath, string ftpPath, ProgressHelper progressHelper, MessageProgressHandler handler)
        {
            if (string.IsNullOrEmpty(ftpPath)) return false;
            if (string.IsNullOrEmpty(localFilePath)) return false;

            try
            {
                string URI = ftpPath;
                string localDir = new FileInfo(localFilePath).DirectoryName;

                string tmpname = Guid.NewGuid().ToString();
                string tmpFilePath = localDir + @"\" + tmpname;

                System.Net.FtpWebRequest ftp = GetRequest(URI);
                ftp.Method = System.Net.WebRequestMethods.Ftp.DownloadFile;
                ftp.UseBinary = true;
                ftp.UsePassive = false;
                long fileLen = GetFileSize(ftpPath);
                using (WebResponse response = ftp.GetResponse())
                {
                    using (Stream responseStream = response.GetResponseStream())
                    {
                        if (progressHelper != null && handler != null)
                        {
                            progressHelper.SetProgress(handler, "正在下载...", 0);
                        }
                        using (FileStream fs = new FileStream(tmpFilePath, FileMode.OpenOrCreate))
                        {
                            try
                            {
                                long proValue = 0;
                                byte[] buffer = new byte[20480];
                                int read = 0;
                                do
                                {
                                    read = responseStream.Read(buffer, 0, buffer.Length);
                                    fs.Write(buffer, 0, read);
                                    proValue += read;
                                    if (progressHelper != null && handler != null)
                                    {
                                        progressHelper.SetProgress(handler, "正在下载...", (int)((double)proValue * 100 / fileLen));
                                    }
                                } while (!(read == 0));
                                responseStream.Close();
                                fs.Flush();
                                fs.Close();
                            }
                            catch (Exception)
                            {
                                fs.Close();
                                File.Delete(tmpFilePath);
                                return false;
                            }
                        }
                        responseStream.Close();
                    }
                    response.Close();
                }
                try
                {
                    File.Delete(localFilePath);
                    File.Move(tmpFilePath, localFilePath);
                    ftp = null;
                }
                catch (Exception ex)
                {
                    File.Delete(tmpFilePath);
                    return false;
                }
                ftp = null;
                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }

        /// <summary>
        /// 删除文件
        /// </summary>
        /// <param name="accessory">要删除的附件全路径</param> 
        public static bool DeleteFile(string ftpPath)
        {
            if (string.IsNullOrEmpty(ftpPath)) return false;
            try
            {
                string URI = ftpPath;
                System.Net.FtpWebRequest ftp = GetRequest(URI);
                ftp.Method = System.Net.WebRequestMethods.Ftp.DeleteFile;
                ftp.UseBinary = true;
                ftp.UsePassive = false;
                using (FtpWebResponse response = (FtpWebResponse)ftp.GetResponse())
                {
                    using (Stream responseStream = response.GetResponseStream())
                    {
                        responseStream.Close();
                    }
                    response.Close();
                }
                ftp = null;
                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }


        /// <summary>
        /// 搜索远程文件
        /// </summary>
        /// <param name="targetDir">文件夹</param>  
        /// <param name="SearchPattern">搜索模式</param>
        /// <returns></returns>
        public static List<string> ListDirectory(string targetDir, string SearchPattern)
        {
            List<string> result = new List<string>();
            try
            {
                string URI = targetDir + "/" + SearchPattern;
                System.Net.FtpWebRequest ftp = GetRequest(URI);
                ftp.Method = System.Net.WebRequestMethods.Ftp.ListDirectory;
                ftp.UsePassive = true;
                ftp.UseBinary = true;


                string str = GetStringResponse(ftp);
                str = str.Replace("\r\n", "\r").TrimEnd('\r');
                str = str.Replace("\n", "\r");
                if (str != string.Empty)
                    result.AddRange(str.Split('\r'));

                return result;
            }
            catch { }
            return null;
        }

        private static string GetStringResponse(FtpWebRequest ftp)
        {
            string result = "";
            using (FtpWebResponse response = (FtpWebResponse)ftp.GetResponse())
            {
                long size = response.ContentLength;
                using (Stream datastream = response.GetResponseStream())
                {
                    using (StreamReader sr = new StreamReader(datastream, System.Text.Encoding.Default))
                    {
                        result = sr.ReadToEnd();
                        sr.Close();
                    }

                    datastream.Close();
                }

                response.Close();
            }

            return result;
        }

        public static void CheckAndMakeDir(string dirName)
        {
            if (string.IsNullOrEmpty(dirName))
            {
                return;
            }
            if (dirName.Contains("/") || dirName.Contains("\\"))
            {
                var str = dirName.Split(new Char[] { '/', '\\' });
                if (str.Length == 0 || string.IsNullOrEmpty(str[0]))
                {
                    return;
                }
                string dir = str[0] + "/";
                if (!IsExistsFile(dir))
                    MakeDir(dir);
                for (int i = 1; i < str.Length; i++)
                {
                    if (string.IsNullOrEmpty(str[i]))
                    {
                        continue;
                    }
                    dir += (str[i] + "/");
                    if (!IsExistsFile(dir))
                        MakeDir(dir);
                }

            }
            else
            {
                if (!IsExistsFile(dirName))
                    MakeDir(dirName);
            }
        }
        ///
        /// 在ftp服务器上创建目录
        /// </summary>
        /// <param name="dirName">创建的目录名称</param> 
        public static void MakeDir(string dirName)
        {
            try
            {
                System.Net.FtpWebRequest ftp = GetRequest(dirName);
                ftp.Method = WebRequestMethods.Ftp.MakeDirectory;

                FtpWebResponse response = (FtpWebResponse)ftp.GetResponse();
                response.Close();
            }
            catch (Exception ex)
            {
                //MessageBox.Show(ex.Message);
            }
        }

        /// <summary>
        /// 删除目录
        /// </summary>
        /// <param name="dirName">删除目录名称</param> 
        public static bool delDir(string dirName)
        {
            try
            {
                System.Net.FtpWebRequest ftp = GetRequest(dirName);
                ftp.Method = WebRequestMethods.Ftp.RemoveDirectory;
                FtpWebResponse response = (FtpWebResponse)ftp.GetResponse();
                response.Close();
                return true;
            }
            catch (Exception ex)
            {
                return false;
            }
        }
        /// <summary>
        /// 文件重命名
        /// </summary>
        /// <param name="currentFilename">当前目录名称</param>
        /// <param name="newFilename">重命名目录名称</param> 
        public static bool Rename(string currentFilename, string newFilename)
        {
            try
            {
                FileInfo fileInf = new FileInfo(currentFilename);
                System.Net.FtpWebRequest ftp = GetRequest(fileInf.Name);
                ftp.Method = WebRequestMethods.Ftp.Rename;

                ftp.RenameTo = newFilename;
                FtpWebResponse response = (FtpWebResponse)ftp.GetResponse();

                response.Close();
                return true;
            }
            catch (Exception ex)
            {
                return false;
            }
        }

        private static FtpWebRequest GetRequest(string dirName)
        {
            string url = "ftp://" + ConfigHepler.FtpServer + "/" + dirName;
            //根据服务器信息FtpWebRequest创建类的对象
            FtpWebRequest result = (FtpWebRequest)FtpWebRequest.Create(url);
            //提供身份验证信息
            result.Credentials = new System.Net.NetworkCredential(ConfigHepler.FtpUser, ConfigHepler.FtpPwd);
            //设置请求完成之后是否保持到FTP服务器的控制连接，默认值为true
            result.KeepAlive = false;

            return result;
        }

        /// <summary>
        /// 判断ftp服务器上该目录是否存在
        /// </summary>
        /// <param name="dirName"></param> 
        /// <returns></returns>
        public static bool IsExistsFile(string dirName)
        {
            bool flag = true;
            try
            {
                System.Net.FtpWebRequest ftp = GetRequest(dirName);
                ftp.Method = WebRequestMethods.Ftp.ListDirectory;

                FtpWebResponse response = (FtpWebResponse)ftp.GetResponse();
                response.Close();
            }
            catch (Exception)
            {
                flag = false;
            }
            return flag;
        }

        // 获取文件大小
        public static long GetFileSize(string ftpPath)
        {
            long size = 0;
            if (string.IsNullOrEmpty(ftpPath)) return size;
            try
            {
                string URI = ftpPath;


                System.Net.FtpWebRequest ftp = GetRequest(URI);
                ftp.Method = System.Net.WebRequestMethods.Ftp.GetFileSize;
                ftp.UseBinary = true;
                ftp.UsePassive = false;

                using (FtpWebResponse response = (FtpWebResponse)ftp.GetResponse())
                {

                    size = response.ContentLength;

                }

            }
            catch (Exception)
            {

            }
            return size;
        }



    }


    /// <summary>
    /// 从配置文件获取配置信息
    /// </summary>
    public class ConfigHepler
    {
        private static string m_FtpServer;
        private static string m_FtpUser;
        private static string m_FtpPwd;
        /// <summary>
        /// ftp服务器  
        /// </summary>
        public static string FtpServer
        {
            get
            {
                if (string.IsNullOrEmpty(m_FtpServer))
                {
                    string[] ftpConfigs = GlobalVars.FtpConfig.Split(new char[] { ';' });
                    if (ftpConfigs != null && ftpConfigs.Length > 0)
                        m_FtpServer = ftpConfigs[0];
                }

                return m_FtpServer;
            }
        }

        /// <summary>
        /// ftp用户名
        /// </summary>
        public static string FtpUser
        {
            get
            {
                if (string.IsNullOrEmpty(m_FtpUser))
                {
                    string[] ftpConfigs = GlobalVars.FtpConfig.Split(new char[] { ';' });
                    if (ftpConfigs != null && ftpConfigs.Length > 1)
                        m_FtpUser = ftpConfigs[1];
                }

                return m_FtpUser;
            }
        }

        /// <summary>
        /// ftp密码
        /// </summary>
        public static string FtpPwd
        {
            get
            {
                if (string.IsNullOrEmpty(m_FtpPwd))
                {
                    string[] ftpConfigs = GlobalVars.FtpConfig.Split(new char[] { ';' });
                    if (ftpConfigs != null && ftpConfigs.Length > 2)
                        m_FtpPwd = ftpConfigs[2];
                }

                return m_FtpPwd;
            }
        }
    }


}

配置文件配置：

<!--ftp配置，以分号相隔 格式:"主机名;用户名;密码;"-->
例子：<Item key="FtpConfig" value="192.168.0.1;admin;123456" />

上传调用例子：

FileInfo fInfo = new FileInfo(txtDoc.Text);
 //上传到ftp的完整目录，FTP目录+文件格式+日期+GUID+文件名+文件后缀
ftpPath = M_FTPDIRECTORY + m_Archives.DocType.Replace(".", "") + "/" + DateTime.Now.ToString("yyyyMMdd") + "/" + Guid.NewGuid().ToString() + "/" + m_Archives.DocName + m_Archives.DocType;
 bool suc = FtpHelper.UploadFile(fInfo, ftpPath);

 

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有

上一篇：基于ABP扩展类似审计（IHasCreationTime）功能

下一篇：C#实现四部电梯的调度

相关文章

IDC资讯： 主机资讯 注册资讯 托管资讯 vps资讯 网站建设

网站运营： 建站经验 策划盈利 搜索优化 网站推广 免费资源

网站联盟： 联盟新闻 联盟介绍 联盟点评 网赚技巧

行业资讯： 搜索引擎 网络游戏 电子商务 广告传媒

网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它

服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护

软件技巧： 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷

网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash

程序设计： Java技术 C/C++ VB delphi

网络知识： 网络协议 网络安全 网络管理 组网方案 Cisco技术

操作系统： Win2000 WinXP Win2003 Mac OS Linux FreeBSD

热门词条
最新资讯
热门关注
热门标签