FTP文件操作

public class FtpCommon
{
    private string ftpuser = string.Empty;
    private string ftppwd = string.Empty;
    private string ftpurl = string.Empty;
    private int serverport = 21;

    public FtpCommon(string ftpUrl, int port, string ftpuser, string ftppwd)
    {
        this.ftpuser = ftpuser;
        this.ftppwd = ftppwd;
        this.ftpurl = string.Format("{0}:{1}/", ftpUrl.TrimEnd('/'), port);
        this.serverport = port;
    }

    /// <summary>
    /// 创建目录
    /// </summary>
    /// <param name="directs">相对目录名，如xxx/zz/yy</param>
    /// <returns></returns>
    public bool MakeDir(string directs)
    {
        try
        {
            Uri uri = new Uri(ftpurl + directs);
            FtpWebRequest FTP = (FtpWebRequest)FtpWebRequest.Create(uri);
            FTP.Credentials = new NetworkCredential(ftpuser, ftppwd);
            FTP.Proxy = null;
            FTP.KeepAlive = false;
            FTP.Method = WebRequestMethods.Ftp.MakeDirectory;
            FTP.UseBinary = true;
            FtpWebResponse response = FTP.GetResponse() as FtpWebResponse;
            response.Close();
            return true;
        }
        catch (Exception)
        {
            return false;
        }
    }

    /// <summary>
    /// 检查目录是否存在
    /// </summary>
    /// <param name="dir">要检查的目录xxx/xx</param>
    /// <returns>存在返回true，否则false</returns>
    public bool CheckDirectoryExist(string dir)
    {
        bool result = false;
        try
        {
            Uri uri = new Uri(this.ftpurl + dir);
            //实例化FTP连接
            FtpWebRequest request = (FtpWebRequest)FtpWebRequest.Create(uri);
            request.Credentials = new NetworkCredential(this.ftpuser, this.ftppwd);
            //指定FTP操作类型为创建目录
            request.Method = WebRequestMethods.Ftp.ListDirectoryDetails;
            //获取FTP服务器的响应
            FtpWebResponse response = (FtpWebResponse)request.GetResponse();
            StreamReader sr = new StreamReader(response.GetResponseStream(), Encoding.Default);

            string line = sr.ReadLine();

            sr.Close();
            sr.Dispose();
            response.Close();
            if (line == null)
            {
                result = false;
            }
            else
            {
                result = true;
            }
        }
        catch (Exception ex)
        {
            result = false;
            throw ex;
        }
        return result;
    }

    /// <summary>
    /// 监察所有目录是否存在
    /// </summary>
    /// <param name="url">绝对目录地址</param>
    /// <returns></returns>
    public bool CheckAndMake(string strDirectoryPath)
    {
        string strDomain = string.Empty;
        string[] dirArr = strDirectoryPath.Split(new string[] { "/" }, StringSplitOptions.RemoveEmptyEntries);
        for (int i = 0; i < dirArr.Length; i++)
        {
            if (i == 0)
            {
                strDomain = dirArr[i];
            }
            else
            {
                strDomain = strDomain + "/" + dirArr[i];
            }

            if (!CheckDirectoryExist(strDomain))
            {
                MakeDir(strDomain);
            }
        }
        return true;
    }

    /// <summary>
    /// 通过FTP上传图片、文件流到FTP服务器，注意“FileStream fs”谁创建的，谁关闭
    /// </summary>
    /// <param name="fullPath">ftp中的文件夹,格式xxx/zzz/ttt</param>
    /// <param name="fileName">ftp中存储的文件名称</param>
    /// <param name="fs">文件流</param>
    /// <param name="reqContentLength">文件大小，默认为零，此时区fs的長度</param>
    /// <returns></returns>
    public bool FtpUpload(string fullPath, string fileName, Stream fs, long reqContentLength = 0)
    {
        //配置ftp保存路徑
        if (fullPath != "")
        {
            CheckAndMake(fullPath);
        }
        string uri = fullPath + "/" + fileName;//完整的文件路徑
        try
        {
            //创建ftp请求对象
            FtpWebRequest reqFTP = CreateWebRequest(reqContentLength == 0 ? fs.Length : reqContentLength, uri);
            //创建FTP文件保存
            //获得ftp的请求流
            Stream strm = reqFTP.GetRequestStream();
            //将文件流读取到请求流中
            ReadFStream2ReqStream(fs, strm);
            strm.Close();
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message);
        }
        return true;
    }
    //客戶端文件上傳FTP
    public bool FtpUploadFile(HttpPostedFile postFile, string dirName, string filename = "")
    {
        filename = string.IsNullOrEmpty(filename) ? Path.GetFileName(postFile.FileName) : filename;
        string url = this.ftpurl + dirName + "/" + filename;
        FtpWebRequest reqFTP = (FtpWebRequest)WebRequest.Create(new Uri(url));
        reqFTP.Credentials = new NetworkCredential(this.ftpuser, this.ftppwd);
        reqFTP.KeepAlive = false;
        reqFTP.Method = "STOR";
        reqFTP.UseBinary = true;
        try
        {
            Stream fileStream = postFile.InputStream;
            Stream strm = reqFTP.GetRequestStream();
            byte[] buffer = new byte[1024];
            int bytesRead = 0;
            int totalbytes = 0;
            while (true)
            {
                bytesRead = fileStream.Read(buffer, 0, buffer.Length);
                if (bytesRead == 0)
                    break;
                strm.Write(buffer, 0, bytesRead);
                totalbytes += bytesRead;
            }
            strm.Dispose();
            strm.Close();
        }
        catch (Exception)
        {
            return false;
        }
        return true;
    }

    /// <summary>
    /// 系統生成文件直接上傳FTP
    /// </summary>
    /// <param name="localFile">本地文件详细路径D:\WEB\sendlog\ljm\123.txt</param>
    /// <param name="dirName">FTP根目录</param>
    /// <param name="fileName">远端文件名称</param>
    /// <param name="autoDelete">上传完后是否同步删除本地文件</param>
    /// <returns></returns>
    public bool ftpuploadFile2(string localFile, string dirName, string fileName, bool autoDelete)
    {
        string url = this.ftpurl + dirName + "/" + fileName;
        FtpWebRequest reqFTP = (FtpWebRequest)WebRequest.Create(new Uri(url));
        reqFTP.Credentials = new NetworkCredential(this.ftpuser, this.ftppwd);
        reqFTP.KeepAlive = false;
        reqFTP.Method = "STOR";
        reqFTP.UseBinary = true;
        try
        {
            FileStream fileStream = new FileStream(localFile, FileMode.Open);
            Stream strm = reqFTP.GetRequestStream();
            byte[] buffer = new byte[1024];
            int bytesRead = 0;
            int totalbytes = 0;
            while (true)
            {
                bytesRead = fileStream.Read(buffer, 0, buffer.Length);
                if (bytesRead == 0)
                    break;
                strm.Write(buffer, 0, bytesRead);
                totalbytes += bytesRead;
            }
            fileStream.Close();
            strm.Dispose();
            strm.Close();
            if (autoDelete)
            {
                System.IO.File.Delete(localFile);
            }
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message);
        }
        return true;
    }

    
    public void FTPUploadFile(string ftpServerIP, string FolderName, string ftpUserID, string ftpPwd, string filename)
    {
        FileInfo uploadFile = null;
        FileStream uploadFileStream = null;
        FtpWebRequest ftpRequest = null;
        Stream ftpStream = null;
        try
        {
            uploadFile = new FileInfo(filename);
            ftpRequest = (FtpWebRequest)FtpWebRequest.Create(new Uri("ftp://" + ftpServerIP + "/" + FolderName + "/" + uploadFile.Name));
            ftpRequest.Credentials = new NetworkCredential(ftpUserID, ftpPwd);
            ftpRequest.KeepAlive = false;
            ftpRequest.Method = WebRequestMethods.Ftp.UploadFile;
            ftpRequest.UseBinary = true;
            ftpRequest.ContentLength = uploadFile.Length;
            int buffLength = 2048;
            byte[] buff = new byte[buffLength];
            int contentLen;
            uploadFileStream = uploadFile.OpenRead();
            ftpStream = ftpRequest.GetRequestStream();
            contentLen = uploadFileStream.Read(buff, 0, buffLength);
            while (contentLen != 0)
            {
                ftpStream.Write(buff, 0, contentLen);
                contentLen = uploadFileStream.Read(buff, 0, buffLength);
            }
        }
        catch (Exception)
        {
        }
        finally
        {
            if (uploadFileStream != null)
            {
                uploadFileStream.Close();
            }
            if (ftpStream != null)
            {
                ftpStream.Close();
            }
        }
    }



    /// <summary>
    /// 下载FTP文件
    /// </summary>
    /// <param name="outstream">输出流</param>
    /// <param name="uri">完整的FTP文件地址 如：ftp://10.121.117.78/upload/ljm/123.pdf </param>
    /// <param name="ftpuser">FTP登陆账号</param>
    /// <param name="ftpPwd">FTP登录密码</param>
    public void DownloadFile(Stream outstream, string uri, string ftpuser, string ftpPwd)
    {
        FtpWebRequest request = (FtpWebRequest)FtpWebRequest.Create(new Uri(uri));
        request.Credentials = new NetworkCredential(ftpuser, ftpPwd);
        request.KeepAlive = false;
        request.Method = WebRequestMethods.Ftp.DownloadFile;
        FtpWebResponse response = (FtpWebResponse)request.GetResponse();
        Stream stream = response.GetResponseStream();
        int bufflength = 1024;
        byte[] buff = new byte[bufflength];
        int readedlength = 0;
        while ((readedlength = stream.Read(buff, 0, bufflength)) > 0)
        {
            outstream.Write(buff, 0, readedlength);
        }
        response.Close();
    }

    /// <summary>
    /// 下载FTP文件
    /// </summary>
    /// <param name="outstream">输入流</param>
    /// <param name="uri">FTP文件地址</param>
    public byte[] DownloadFile(string uri)
    {
        FtpWebRequest request = (FtpWebRequest)FtpWebRequest.Create(new Uri(uri));
        request.Credentials = new NetworkCredential(ftpuser, ftppwd);
        request.KeepAlive = false;
        request.Method = WebRequestMethods.Ftp.DownloadFile;
        FtpWebResponse response = (FtpWebResponse)request.GetResponse();
        Stream stream = response.GetResponseStream();
        List<byte> buffer = new List<byte>();
        int bufflength = 1024;
        byte[] buff = new byte[bufflength];
        int readedlength = 0;
        while ((readedlength = stream.Read(buff, 0, bufflength)) > 0)
        {
            for (int i = 0; i < readedlength; i++)
            {
                buffer.Add(buff[i]);
            }
        }
        return buffer.ToArray();
    }

    public string DownloadFile(string url, string fileName)
    {
        try
        {
            FtpWebRequest request = (FtpWebRequest)FtpWebRequest.Create(new Uri(url + fileName));
            request.Credentials = new NetworkCredential(ftpuser, ftppwd);
            request.KeepAlive = false;
            request.Method = WebRequestMethods.Ftp.DownloadFile;
            FtpWebResponse response = (FtpWebResponse)request.GetResponse();
            StreamReader reader = new StreamReader(response.GetResponseStream(), Encoding.Default);
            string fileStr = reader.ReadToEnd();
            reader.Close();
            response.Close();
            return fileStr;
        }
        catch (Exception ex)
        {
            throw new Exception("【" + fileName + "】" + ex.Message);
        }
    }

    public Stream DownloadFileStream(string uri, string fileName)
    {
        try
        {
            FtpWebRequest request = (FtpWebRequest)FtpWebRequest.Create(new Uri(uri + fileName));
            request.Credentials = new NetworkCredential(ftpuser, ftppwd);
            request.KeepAlive = false;
            request.Method = WebRequestMethods.Ftp.DownloadFile;
            FtpWebResponse response = (FtpWebResponse)request.GetResponse();
            return response.GetResponseStream();
        }
        catch (Exception ex)
        {
            throw new Exception("【" + fileName + "】" + ex.Message);
        }
    }
    public bool UploadFileStream(string ftpUrl, string fileName, Stream sourceStream)
    {
        try
        {
            FtpWebRequest reqFTP = (FtpWebRequest)WebRequest.Create(new Uri(ftpUrl + fileName));
            reqFTP.Credentials = new NetworkCredential(ftpuser, ftppwd);
            reqFTP.KeepAlive = false;
            reqFTP.Method = "STOR";
            reqFTP.UseBinary = true;
            using (Stream strm = reqFTP.GetRequestStream())
            {
                byte[] buffer = new byte[1024];
                int bytesRead = 0;
                int totalbytes = 0;
                while (true)
                {
                    bytesRead = sourceStream.Read(buffer, 0, buffer.Length);
                    if (bytesRead == 0)
                        break;
                    strm.Write(buffer, 0, bytesRead);
                    totalbytes += bytesRead;
                }
            }
            return true;
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message);
        }
    }

    /// <summary>
    /// 删除文件
    /// </summary>
    /// <param name="uri">FTP文件絕對地址</param>
    public bool DeleteFile(string uri)
    {
        try
        {
            FtpWebRequest reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(uri));
            reqFTP.Credentials = new NetworkCredential(ftpuser, ftppwd);
            reqFTP.KeepAlive = false;
            reqFTP.Method = WebRequestMethods.Ftp.DeleteFile;
            FtpWebResponse response = (FtpWebResponse)reqFTP.GetResponse();
            long size = response.ContentLength;
            Stream datastream = response.GetResponseStream();
            StreamReader sr = new StreamReader(datastream);
            string result = sr.ReadToEnd();
            sr.Close();
            datastream.Close();
            response.Close();
            return true;
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message);
        }
    }

    private static FtpWebRequest GetRequest(string URI, string username, string password)
    {
        //根据服务器信息FtpWebRequest创建类的对象
        FtpWebRequest result = (FtpWebRequest)FtpWebRequest.Create(URI);
        //提供身份验证信息
        result.Credentials = new System.Net.NetworkCredential(username, password);
        //设置请求完成之后是否保持到FTP服务器的控制连接，默认值为true
        result.KeepAlive = false;
        return result;
    }
    
    /// <summary>
    /// 创建WebRequest流
    /// </summary>
    /// <param name="reqContentLength"></param>
    /// <param name="uri"></param>
    /// <returns></returns>
    private FtpWebRequest CreateWebRequest(long reqContentLength, string uri)
    {
        FtpWebRequest reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(uri));
        reqFTP.Credentials = new NetworkCredential(ftpuser, ftppwd);
        reqFTP.KeepAlive = false;
        reqFTP.Method = WebRequestMethods.Ftp.UploadFile;
        reqFTP.UseBinary = true;
        reqFTP.ContentLength = reqContentLength;
        return reqFTP;
    }


    /// <summary>
    /// 将文件流读取到请求流中
    /// </summary>
    /// <param name="fs">文件流</param>
    /// <param name="strm">ftp 對應的请求流</param>
    private static void ReadFStream2ReqStream(Stream fs, Stream strm)
    {
        int buffLength = 2048;//每次寫入2KB字節
        byte[] buff = new byte[buffLength];
        int contentLen = fs.Read(buff, 0, buffLength);
        while (contentLen != 0)
        {
            strm.Write(buff, 0, contentLen);
            contentLen = fs.Read(buff, 0, buffLength);
        }
    }

    /// <summary>
    /// 讀取FTP指定目錄下面的文件清單,返回數組
    /// </summary>
    /// <param name="url"></param>
    /// <returns></returns>
    public string[] GetFileList(string url)
    {
        string[] fileList;
        try
        {
            FtpWebRequest reqFTP = (FtpWebRequest)FtpWebRequest.Create(new Uri(url));
            reqFTP.Credentials = new NetworkCredential(ftpuser, ftppwd);
            reqFTP.UseBinary = true;
            reqFTP.KeepAlive = false;
            reqFTP.Method = WebRequestMethods.Ftp.ListDirectory;
            FtpWebResponse response = (FtpWebResponse)reqFTP.GetResponse();
            StreamReader reader = new StreamReader(response.GetResponseStream());
            string line = reader.ReadToEnd();
            fileList = line.Split(new string[] { "\r\n", "\r", "\n" }, StringSplitOptions.RemoveEmptyEntries);
            //while (line != null)
            //{
            //    fileList.Add(line);//存儲文件名稱
            //    line = reader.ReadLine();//讀取下一個文件名稱
            //}
            reader.Close();
            response.Close();
            return fileList;
        }
        catch (Exception)
        {
            return null;//如果文件夾中沒有內容,FTP命令會出錯,直接返回NULL值就可以了。
        }
    }
}