.NET程式設計實現FTP上傳檔案

1.WebClient非同步上傳
關鍵知識說明：
WebClient類提供4個非同步上傳方法,使用方法都是差不多的.
WebClient.UploadDataAsync方法
將資料緩衝區上載到指定的資源

WebClient.UploadFileAsync方法
將指定的本地檔案上載到指定的資源

WebClient.UploadStringAsync方法
將指定的字串上載到指定的資源

WebClient.UploadValuesAsync方法
將指定的名稱/值集合上載到指定的資源

其中一個方法簽名如下:
public void UploadDataAsync (
Uri address,
string method,
byte[] data,
Object userToken
)
引數
address
接收資料的資源的URI
method
用於將檔案傳送到資源的HTTP方法。如果為空，則對於http預設值為POST，對於ftp預設值為STOR
data
要傳送到資源的資料緩衝
userToken
一個使用者定義物件，此物件將被傳遞給完成非同步操作時所呼叫的方法

若要在資料的上載完成時收到通知,需要實現WebClient.UploadDataCompleted事件,此事件在每次完成非同步資料上載操作時引發

總結WebClient非同步上傳實現步驟：
第一步：定義WebClient,設定各屬性
第二步：註冊完成事件UploadDataCompleted,以便完成上傳時回撥
第三步：呼叫UploadDataAsync方法開始非同步上傳檔案
第四步：上傳檔案完成回撥完成事件UploadDataCompleted定義的方法

WebClient request = new WebClient ( );

//註冊完成事件，以便上傳完成時,收到通知request.UploadDataCompleted += new UploadDataCompletedEventHandler ( request_UploadDataCompleted );

string ftpUser = "a";
string ftpPassWord = "b";
request.Credentials = new NetworkCredential ( ftpUser , ftpPassWord );

FileStream myStream = new FileStream ( @"D:\n.txt" , FileMode.Open , FileAccess.Read );
byte [ ] dataByte = new byte [ myStream.Length ];
myStream.Read ( dataByte , 0 , dataByte.Length );        //寫到2進位制陣列中myStream.Close ( );

Uri uri = new Uri ( "ftp://ftp.dygs2b.com/n.txt" );
request.UploadDataAsync ( uri , "STOR" , dataByte , dataByte );

void request_UploadDataCompleted ( object sender , UploadDataCompletedEventArgs e )
{
    //接收UploadDataAsync傳遞過來的使用者定義物件byte [ ] dataByte = ( byte [ ] ) e.UserState;

    //AsyncCompletedEventArgs.Error屬性,獲取一個值，該值指示非同步操作期間發生的錯誤if ( e.Error == null )
     {
         MessageBox.Show ( string.Format ( "上傳成功!檔案大小{0}" , dataByte.Length ) );
     }
    else
     {
         MessageBox.Show ( e.Error.Message );
     }
}

2.FtpWebRequest非同步上傳
使用FtpWebRequest物件向伺服器上載檔案，則必須將檔案內容寫入請求流，同步請求流是通過呼叫GetRequestStream方法,而非同步對應方法是BeginGetRequestStream和EndGetRequestStream方法.

其中BeginGetRequestStream方法簽名如下：
public override IAsyncResult BeginGetRequestStream (
AsyncCallback callback,
Object state
)

引數
callback
一個 AsyncCallback 委託，它引用操作完成時要呼叫的方法
state
一個使用者定義物件，其中包含該操作的相關資訊。當操作完成時，此物件會被傳遞給callback委託

必須呼叫EndGetRequestStream方法用來完成非同步操作。通常，EndGetRequestStream由callback所引用的方法呼叫。

總結FtpWebRequest非同步上傳實現步驟：
第一步：定義FtpWebRequest,並設定相關屬性
第二步：呼叫FtpWebRequest.BeginGetRequestStream方法,定義操作完成時要呼叫的方法EndGetResponseCallback,開始以非同步方式開啟請求的內容流以便寫入.
第三步：實現EndGetResponseCallback方法,在此方法中呼叫FtpWebRequest.EndGetRequestStream方法,結束由BeginGetRequestStream啟動的掛起的非同步操作,再把本地的檔案流資料寫到請求流(RequestStream)中,再 FtpWebRequest.BeginGetResponse方法,定義操作完成時要呼叫的方法EndGetResponseCallback,開始以非同步方式向FTP伺服器傳送請求並從FTP伺服器接收響應.
第四步：實現EndGetResponseCallback方法,在此方法中呼叫FtpWebRequest.EndGetResponse方法,結束由BeginGetResponse啟動的掛起的非同步操作.

Uri uri = new Uri ( "ftp://ftp.dygs2b.com/n.txt" );

//定義FtpWebRequest,並設定相關屬性FtpWebRequest uploadRequest = ( FtpWebRequest ) WebRequest.Create ( uri );
uploadRequest.Method = WebRequestMethods.Ftp.UploadFile;

string ftpUser = "a";
string ftpPassWord = "b";
uploadRequest.Credentials = new NetworkCredential ( ftpUser , ftpPassWord );

//開始以非同步方式開啟請求的內容流以便寫入uploadRequest.BeginGetRequestStream ( new AsyncCallback ( EndGetStreamCallback ) , uploadRequest );
private void EndGetStreamCallback ( IAsyncResult ar )
{
    //使用者定義物件，其中包含該操作的相關資訊,在這裡得到FtpWebRequest     FtpWebRequest uploadRequest = ( FtpWebRequest ) ar.AsyncState;

    //結束由BeginGetRequestStream啟動的掛起的非同步操作
    //必須呼叫EndGetRequestStream方法來完成非同步操作
    //通常EndGetRequestStream由callback所引用的方法呼叫     Stream requestStream = uploadRequest.EndGetRequestStream ( ar );

     FileStream fileStream = File.Open ( @"D:\n.txt" , FileMode.Open );

    byte [ ] buffer = new byte [ 1024 ];
    int bytesRead;
    while ( true )
     {
         bytesRead = fileStream.Read ( buffer , 0 , buffer.Length );
        if ( bytesRead == 0 )
            break;

        //本地的檔案流資料寫到請求流         requestStream.Write ( buffer , 0 , bytesRead );
     }

     requestStream.Close ( );
     fileStream.Close ( );

    //開始以非同步方式向FTP伺服器傳送請求並從FTP伺服器接收響應     uploadRequest.BeginGetResponse ( new AsyncCallback ( EndGetResponseCallback ) , uploadRequest );
} private void EndGetResponseCallback ( IAsyncResult ar )
{
     FtpWebRequest uploadRequest = ( FtpWebRequest ) ar.AsyncState;

    //結束由BeginGetResponse啟動的掛起的非同步操作     FtpWebResponse uploadResponse = ( FtpWebResponse ) uploadRequest.EndGetResponse ( ar );

     MessageBox.Show ( uploadResponse.StatusDescription );
     MessageBox.Show ( "Upload complete" );
}

C# ftp上傳ftp

/// <summary>

 /// 上傳檔案

/// </summary> /

// <param name="fileinfo">需要上傳的檔案</param>

 /// <param name="targetDir">目標路徑</param>

/// <param name="hostname">ftp地址</param> /

// <param name="username">ftp使用者名稱</param> /

// <param name="password">ftp密碼</param>

public static void UploadFile(FileInfo fileinfo, string targetDir, string hostname, string username, string password)

 { //1. check target

string target;

if (targetDir.Trim() == "")

 { return; }

target = Guid.NewGuid().ToString();

//使用臨時檔名

 string URI = "FTP://" + hostname + "/" + targetDir + "/" + target;

///WebClient webcl = new WebClient();

System.Net.FtpWebRequest ftp = GetRequest(URI, username, password);

//設定FTP命令 設定所要執行的FTP命令，

//ftp.Method = System.Net.WebRequestMethods.Ftp.ListDirectoryDetails;//假設此處為顯示指定路徑下的檔案列表

 ftp.Method = System.Net.WebRequestMethods.Ftp.UploadFile;

//指定檔案傳輸的資料型別

 ftp.UseBinary = true;

ftp.UsePassive = true; //告訴ftp檔案大小

 ftp.ContentLength = fileinfo.Length;

//緩衝大小設定為2KB

const int BufferSize = 2048;

byte[] content = new byte[BufferSize - 1 + 1];

int dataRead; //開啟一個檔案流 (System.IO.FileStream) 去讀上傳的檔案

using (FileStream fs = fileinfo.OpenRead())

 {

try { //把上傳的檔案寫入流

 { do

 { //每次讀檔案流的2KB

 dataRead = fs.Read(content, 0, BufferSize); rs.Write(content, 0, dataRead); }

while (!(dataRead < BufferSize)); rs.Close(); } }

catch (Exception ex) { } finally { fs.Close(); } }

ftp = null; //設定FTP命令

ftp = GetRequest(URI, username, password);

 ftp.Method = System.Net.WebRequestMethods.Ftp.Rename; //改名

 ftp.RenameTo = fileinfo.Name; try { ftp.GetResponse(); }

catch (Exception ex)

 {

ftp = GetRequest(URI, username, password); ftp.Method = System.Net.WebRequestMethods.Ftp.DeleteFile; //刪除

 ftp.GetResponse(); throw ex; } finally

 {

//fileinfo.Delete(); } // 可以記錄一個日誌 "上傳" + fileinfo.FullName + "上傳到" + "FTP://" + hostname + "/" + targetDir + "/" + fileinfo.Name + "成功." );

ftp = null;

#region

 /***** *FtpWebResponse * ****/ //FtpWebResponse ftpWebResponse = (FtpWebResponse)ftp.GetResponse();

#endregion

}

 /// <summary>
        /// 下載檔案
        /// </summary>
        /// <param name="localDir">下載至本地路徑</param>
        /// <param name="FtpDir">ftp目標檔案路徑</param>
        /// <param name="FtpFile">從ftp要下載的檔名</param>
        /// <param name="hostname">ftp地址即IP</param>
        /// <param name="username">ftp使用者名稱</param>
        /// <param name="password">ftp密碼</param>
        public static void DownloadFile(string localDir, string FtpDir, string FtpFile, string hostname, string username, string password)
        {
            string URI = "FTP://" + hostname + "/" + FtpDir + "/" + FtpFile;
            string tmpname = Guid.NewGuid().ToString();
            string localfile = localDir + @"\" + tmpname;

            System.Net.FtpWebRequest ftp = GetRequest(URI, username, password);
            ftp.Method = System.Net.WebRequestMethods.Ftp.DownloadFile;
            ftp.UseBinary = true;
            ftp.UsePassive = false;

            using (FtpWebResponse response = (FtpWebResponse)ftp.GetResponse())
            {
                using (Stream responseStream = response.GetResponseStream())
                {
                    //loop to read & write to file
                    using (FileStream fs = new FileStream(localfile, FileMode.CreateNew))
                    {
                        try
                        {
                            byte[] buffer = new byte[2048];
                            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)
                        {
                            //catch error and delete file only partially downloaded
                            fs.Close();
                            //delete target file as it's incomplete
                            File.Delete(localfile);
                            throw;
                        }
                    }

                    responseStream.Close();
                }

                response.Close();
            }



            try
            {
                File.Delete(localDir + @"\" + FtpFile);
                File.Move(localfile, localDir + @"\" + FtpFile);


                ftp = null;
                ftp = GetRequest(URI, username, password);
                ftp.Method = System.Net.WebRequestMethods.Ftp.DeleteFile;
                ftp.GetResponse();

            }
            catch (Exception ex)
            {
                File.Delete(localfile);
                throw ex;
            }

            // 記錄日誌 "從" + URI.ToString() + "下載到" + localDir + @"\" + FtpFile + "成功." );
            ftp = null;
        }

        /// <summary>
        /// 搜尋遠端檔案
        /// </summary>
        /// <param name="targetDir"></param>
        /// <param name="hostname"></param>
        /// <param name="username"></param>
        /// <param name="password"></param>
        /// <param name="SearchPattern"></param>
        /// <returns></returns>
        public static List<string> ListDirectory(string targetDir, string hostname, string username, string password, string SearchPattern)
        {
            List<string> result = new List<string>();
            try
            {
                string URI = "FTP://" + hostname + "/" + targetDir + "/" + SearchPattern;

                System.Net.FtpWebRequest ftp = GetRequest(URI, username, password);
                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)
        {
            //Get the result, streaming to a string
            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;
        }

/// 在ftp伺服器上建立目錄
        /// </summary>
        /// <param name="dirName">建立的目錄名稱</param>
        /// <param name="ftpHostIP">ftp地址</param>
        /// <param name="username">使用者名稱</param>
        /// <param name="password">密碼</param>
        public void MakeDir(string dirName,string ftpHostIP,string username,string password)
        {
            try
            {
                string uri = "ftp://" + ftpHostIP + "/" + dirName;
                System.Net.FtpWebRequest ftp = GetRequest(uri, username, password);
                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>
        /// <param name="ftpHostIP">ftp地址</param>
        /// <param name="username">使用者名稱</param>
        /// <param name="password">密碼</param>
        public void delDir(string dirName, string ftpHostIP, string username, string password)
        {
            try
            {
                string uri = "ftp://" + ftpHostIP + "/" + dirName;
                System.Net.FtpWebRequest ftp = GetRequest(uri, username, password);
                ftp.Method = WebRequestMethods.Ftp.RemoveDirectory;
                FtpWebResponse response = (FtpWebResponse)ftp.GetResponse();
                response.Close();
            }
            catch (Exception ex)
            {

                MessageBox.Show(ex.Message);
            }
        } /// <summary>
        /// 檔案重新命名
        /// </summary>
        /// <param name="currentFilename">當前目錄名稱</param>
        /// <param name="newFilename">重新命名目錄名稱</param>
        /// <param name="ftpServerIP">ftp地址</param>
        /// <param name="username">使用者名稱</param>
        /// <param name="password">密碼</param>
        public void Rename(string currentFilename, string newFilename, string ftpServerIP, string username, string password)
        {
            try
            {

                FileInfo fileInf = new FileInfo(currentFilename);
                string uri = "ftp://" + ftpServerIP + "/" + fileInf.Name;
                System.Net.FtpWebRequest ftp = GetRequest(uri, username, password);
                ftp.Method = WebRequestMethods.Ftp.Rename;

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

                response.Close();
            }
            catch (Exception ex) { MessageBox.Show(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;
        }

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.IO;
using System.Net; /// <summary>
        /// 向Ftp伺服器上傳檔案並建立和本地相同的目錄結構
        /// 遍歷目錄和子目錄的檔案
        /// </summary>
        /// <param name="file"></param>
        private void GetFileSystemInfos(FileSystemInfo file)
        {
            string getDirecName=file.Name;
            if (!ftpIsExistsFile(getDirecName, "192.168.0.172", "Anonymous", "") && file.Name.Equals(FileName))
            {
                MakeDir(getDirecName, "192.168.0.172", "Anonymous", "");
            }
            if (!file.Exists) return;
            DirectoryInfo dire = file as DirectoryInfo;
            if (dire == null) return;
            FileSystemInfo[] files = dire.GetFileSystemInfos();

            for (int i = 0; i < files.Length; i++)
            {
                FileInfo fi = files[i] as FileInfo;
                if (fi != null)
                {
                    DirectoryInfo DirecObj=fi.Directory;
                    string DireObjName = DirecObj.Name;
                    if (FileName.Equals(DireObjName))
                    {
                        UploadFile(fi, DireObjName, "192.168.0.172", "Anonymous", "");
                    }
                    else
                    {
                        Match m = Regex.Match(files[i].FullName, FileName + "+.*" + DireObjName);
                        //UploadFile(fi, FileName+"/"+DireObjName, "192.168.0.172", "Anonymous", "");
                        UploadFile(fi, m.ToString(), "192.168.0.172", "Anonymous", "");
                    }
                }
                else
                {
                    string[] ArrayStr = files[i].FullName.Split('\\');
                    string finame=files[i].Name;
                    Match m=Regex.Match(files[i].FullName,FileName+"+.*"+finame);
                    //MakeDir(ArrayStr[ArrayStr.Length - 2].ToString() + "/" + finame, "192.168.0.172", "Anonymous", "");
                    MakeDir(m.ToString(), "192.168.0.172", "Anonymous", "");
                    GetFileSystemInfos(files[i]);
                }
            }
        }

/// <summary>
        /// 判斷ftp伺服器上該目錄是否存在
        /// </summary>
        /// <param name="dirName"></param>
        /// <param name="ftpHostIP"></param>
        /// <param name="username"></param>
        /// <param name="password"></param>
        /// <returns></returns>
        private bool ftpIsExistsFile(string dirName, string ftpHostIP, string username, string password)
        {
            bool flag = true;
            try
            {
                string uri = "ftp://" + ftpHostIP + "/" + dirName;
                System.Net.FtpWebRequest ftp = GetRequest(uri, username, password);
                ftp.Method = WebRequestMethods.Ftp.ListDirectory;

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