閱讀571 返回首頁    go 技術社區[雲棲]

FTP上傳文件示例

 首先，你需要一個測試環境，我在自己的機器上搭建了一個FTP Server，搭建Server有一些比較優秀的軟件，例如：Crob FTP Server，不過這是一個收費軟件，雖然提供試用版，但要在公網上使用的話，還是買個注冊號吧！

    下載地址： Crob FTP Server V3.7.0 Build 196 簡體中文版 https://www.skycn.com/soft/11246.html

    中文軟件，大家都是學技術的，怎麼搭建我就不說了。

    相當傻瓜式的，上傳代碼隻有寥寥幾行：

  1. FTPClient fc = new FTPClient();
  3. fc.RemoteHost = "10.6.133.145"; // 這裏隻能用IP，而不能用機器名。當然，你可以利用工具類通過機器名獲取到IP地址
  4. fc.RemotePath = "/u01/upload";  // FTP服務器的虛擬目錄
  5. fc.RemotePort = 21;
  6. fc.RemoteUser = "admin";
  7. fc.RemotePass = "123";
  8. fc.Connect();
  10. fc.Put("c:/1.txt");
  11. fc.DisConnect();

    這裏要注意的是，虛擬目錄/u01/upload對應的路徑需要有寫文件操作的權限，你可以在屬性中配置賬號的寫權限（我直接共享了該文件夾，並允許everyone賬號完全控製）。

    這裏提供FTPClient.cs的源碼，來源一時半會兒找不到了：

  1. using System;
  2. using System.Net;
  3. using System.Net.Sockets;
  4. using System.Text;
  5. using System.IO;
  7. namespace TimerServer
  8. {
  9.     /// <summary>
  10.     /// FTPClient 的摘要說明。
  11.     /// </summary>
  12.     public class FTPClient
  13.     {
  14.         #region 構造函數
  15.         /**//// <summary>
  16.         /// 缺省構造函數
  17.         /// </summary>
  18.         public FTPClient()
  19.         {
  20.             strRemoteHost  = "";
  21.             strRemotePath  = "";
  22.             strRemoteUser  = "";
  23.             strRemotePass  = "";
  24.             strRemotePort  = 21;
  25.             bConnected
  26.                 = false;
  27.         }
  29.     /**//// <summary>
  30.     /// 構造函數
  31.     /// </summary>
  32.     /// <param name="remoteHost"></param>
  33.     /// <param name="remotePath"></param>
  34.     /// <param name="remoteUser"></param>
  35.     /// <param name="remotePass"></param>
  36.     /// <param name="remotePort"></param>
  37.     public FTPClient( string remoteHost, string remotePath, string remoteUser, string remotePass, int remotePort )
  38.     {
  39.         strRemoteHost  = remoteHost;
  40.         strRemotePath  = remotePath;
  41.         strRemoteUser  = remoteUser;
  42.         strRemotePass  = remotePass;
  43.         strRemotePort  = remotePort;
  44.         Connect();
  45.     }
  46.     #endregion
  48.     #region 登陸
  49.     /**//// <summary>
  50.     /// FTP服務器IP地址
  51.     /// </summary>
  52.     private string strRemoteHost;
  54.     public string RemoteHost
  55.     {
  56.         get
  57.         {
  58.             return strRemoteHost;
  59.         }
  60.         set
  61.         {
  62.             strRemoteHost = value;
  63.         }
  64.     }
  65.     /**//// <summary>
  66.     /// FTP服務器端口
  67.     /// </summary>
  68.     private int strRemotePort;
  69.     public int RemotePort
  70.     {
  71.         get
  72.         {
  73.             return strRemotePort;
  74.         }
  75.         set
  76.         {
  77.             strRemotePort = value;
  78.         }
  79.     }
  80.     /**//// <summary>
  81.     /// 當前服務器目錄
  82.     /// </summary>
  83.     private string strRemotePath;
  84.     public string RemotePath
  85.     {
  86.         get
  87.         {
  88.             return strRemotePath;
  89.         }
  90.         set
  91.         {
  92.             strRemotePath = value;
  93.         }
  94.     }
  95.     /**//// <summary>
  96.     /// 登錄用戶賬號
  97.     /// </summary>
  98.     private string strRemoteUser;
  99.     public string RemoteUser
  100.     {
  101.         set
  102.         {
  103.             strRemoteUser = value;
  104.         }
  105.     }
  106.     /**//// <summary>
  107.     /// 用戶登錄密碼
  108.     /// </summary>
  109.     private string strRemotePass;
  110.     public string RemotePass
  111.     {
  112.         set
  113.         {
  114.             strRemotePass = value;
  115.         }
  116.     }
  118.     /**//// <summary>
  119.     /// 是否登錄
  120.     /// </summary>
  121.     private Boolean bConnected;
  122.     public bool Connected
  123.     {
  124.         get
  125.         {
  126.             return bConnected;
  127.         }
  128.     }
  129.     #endregion
  131.     #region 鏈接
  132.     /**//// <summary>
  133.     /// 建立連接 
  134.     /// </summary>
  135.     public void Connect()
  136.     {
  137.         socketControl = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
  138.         IPEndPoint ep = new IPEndPoint(IPAddress.Parse(RemoteHost), strRemotePort);
  139.         // 鏈接
  140.         try
  141.         {
  142.             socketControl.Connect(ep);
  143.         }
  144.         catch(Exception)
  145.         {
  146.             throw new IOException("Couldn't connect to remote server");
  147.         }
  149.     // 獲取應答碼
  150.     ReadReply();
  151.     if(iReplyCode != 220)
  152.     {
  153.         DisConnect();
  154.         throw new IOException(strReply.Substring(4));
  155.     }
  157.     // 登陸
  158.     SendCommand("USER "+strRemoteUser);
  159.     if( !(iReplyCode == 331 || iReplyCode == 230) )
  160.     {
  161.         CloseSocketConnect();//關閉連接
  162.         throw new IOException(strReply.Substring(4));
  163.     }
  164.     if( iReplyCode != 230 )
  165.     {
  166.         SendCommand("PASS "+strRemotePass);
  167.         if( !(iReplyCode == 230 || iReplyCode == 202) )
  168.         {
  169.             CloseSocketConnect();//關閉連接
  170.             throw new IOException(strReply.Substring(4));
  171.         }
  172.     }
  173.     bConnected = true;
  175.     // 切換到目錄
  176.     ChDir(strRemotePath);
  177.     }
  178.     
  180.     /**//// <summary>
  181.     /// 關閉連接
  182.     /// </summary>
  183.     public void DisConnect()
  184.     {
  185.         if( socketControl != null )
  186.         {
  187.             SendCommand("QUIT");
  188.         }
  189.         CloseSocketConnect();
  190.     }
  192.     #endregion
  194.     #region 傳輸模式
  196.     /**//// <summary>
  197.     /// 傳輸模式:二進製類型、ASCII類型
  198.     /// </summary>
  199.     public enum TransferType {Binary,ASCII};
  201.     /**//// <summary>
  202.     /// 設置傳輸模式
  203.     /// </summary>
  204.     /// <param name="ttType">傳輸模式</param>
  205.     public void SetTransferType(TransferType ttType)
  206.     {
  207.         if(ttType == TransferType.Binary)
  208.         {
  209.             SendCommand("TYPE I");//binary類型傳輸
  210.         }
  211.         else
  212.         {
  213.             SendCommand("TYPE A");//ASCII類型傳輸
  214.         }
  215.         if (iReplyCode != 200)
  216.         {
  217.             throw new IOException(strReply.Substring(4));
  218.         }
  219.         else
  220.         {
  221.             trType = ttType;
  222.         }
  223.     }
  226.     /**//// <summary>
  227.     /// 獲得傳輸模式
  228.     /// </summary>
  229.     /// <returns>傳輸模式</returns>
  230.     public TransferType GetTransferType()
  231.     {
  232.         return trType;
  233.     }
  234.     
  235.         #endregion
  237.     #region 文件操作
  238.     /**//// <summary>
  239.     /// 獲得文件列表
  240.     /// </summary>
  241.     /// <param name="strMask">文件名的匹配字符串</param>
  242.     /// <returns></returns>
  243.     public string[] Dir(string strMask)
  244.     {
  245.         // 建立鏈接
  246.         if(!bConnected)
  247.         {
  248.             Connect();
  249.         }
  251.     //建立進行數據連接的socket
  252.     Socket socketData = CreateDataSocket();
  254.     //傳送命令
  255.     SendCommand("NLST " + strMask);
  257.     //分析應答代碼
  258.     if(!(iReplyCode == 150 || iReplyCode == 125 || iReplyCode == 226))
  259.     {
  260.         throw new IOException(strReply.Substring(4));
  261.     }
  263.     //獲得結果
  264.     strMsg = "";
  265.     while(true)
  266.     {
  267.         int iBytes = socketData.Receive(buffer, buffer.Length, 0);
  268.         strMsg += ASCII.GetString(buffer, 0, iBytes);
  269.         if(iBytes < buffer.Length)
  270.         {
  271.             break;
  272.         }
  273.     }
  274.     char[] seperator = {'/n'};
  275.     string[] strsFileList = strMsg.Split(seperator);
  276.     socketData.Close();//數據socket關閉時也會有返回碼
  277.     if(iReplyCode != 226)
  278.     {
  279.         ReadReply();
  280.         if(iReplyCode != 226)
  281.         {
  282.             throw new IOException(strReply.Substring(4));
  283.         }
  284.     }
  285.     return strsFileList;
  286.     }
  287.     
  289.     /**//// <summary>
  290.     /// 獲取文件大小
  291.     /// </summary>
  292.     /// <param name="strFileName">文件名</param>
  293.     /// <returns>文件大小</returns>
  294.     private long GetFileSize(string strFileName)
  295.     {
  296.         if(!bConnected)
  297.         {
  298.             Connect();
  299.         }
  300.         SendCommand("SIZE " + Path.GetFileName(strFileName));
  301.         long lSize=0;
  302.         if(iReplyCode == 213)
  303.         {
  304.             lSize = Int64.Parse(strReply.Substring(4));
  305.         }
  306.         else
  307.         {
  308.             throw new IOException(strReply.Substring(4));
  309.         }
  310.         return lSize;
  311.     }
  314.     /**//// <summary>
  315.     /// 刪除
  316.     /// </summary>
  317.     /// <param name="strFileName">待刪除文件名</param>
  318.     public void Delete(string strFileName)
  319.     {
  320.         if(!bConnected)
  321.         {
  322.             Connect();
  323.         }
  324.         SendCommand("DELE "+strFileName);
  325.         if(iReplyCode != 250)
  326.         {
  327.             throw new IOException(strReply.Substring(4));
  328.         }
  329.     }
  330.     
  332.     /**//// <summary>
  333.     /// 重命名(如果新文件名與已有文件重名,將覆蓋已有文件)
  334.     /// </summary>
  335.     /// <param name="strOldFileName">舊文件名</param>
  336.     /// <param name="strNewFileName">新文件名</param>
  337.     public void Rename(string strOldFileName,string strNewFileName)
  338.     {
  339.         if(!bConnected)
  340.         {
  341.             Connect();
  342.         }
  343.         SendCommand("RNFR "+strOldFileName);
  344.         if(iReplyCode != 350)
  345.         {
  346.             throw new IOException(strReply.Substring(4));
  347.         }
  348.         //  如果新文件名與原有文件重名,將覆蓋原有文件
  349.         SendCommand("RNTO "+strNewFileName);
  350.         if(iReplyCode != 250)
  351.         {
  352.             throw new IOException(strReply.Substring(4));
  353.         }
  354.     }
  355.     #endregion
  357.     #region 上傳和下載
  358.     /**//// <summary>
  359.     /// 下載一批文件
  360.     /// </summary>
  361.     /// <param name="strFileNameMask">文件名的匹配字符串</param>
  362.     /// <param name="strFolder">本地目錄(不得以/結束)</param>
  363.     public void Get(string strFileNameMask,string strFolder)
  364.     {
  365.         if(!bConnected)
  366.         {
  367.             Connect();
  368.         }
  369.         string[] strFiles = Dir(strFileNameMask);
  370.         foreach(string strFile in strFiles)
  371.         {
  372.             if(!strFile.Equals(""))//一般來說strFiles的最後一個元素可能是空字符串
  373.             {
  374.                 Get(strFile,strFolder,strFile);
  375.             }
  376.         }
  377.     }
  378.     
  380.     /**//// <summary>
  381.     /// 下載一個文件
  382.     /// </summary>
  383.     /// <param name="strRemoteFileName">要下載的文件名</param>
  384.     /// <param name="strFolder">本地目錄(不得以/結束)</param>
  385.     /// <param name="strLocalFileName">保存在本地時的文件名</param>
  386.     public void Get(string strRemoteFileName,string strFolder,string strLocalFileName)
  387.     {
  388.         if(!bConnected)
  389.         {
  390.             Connect();
  391.         }
  392.         SetTransferType(TransferType.Binary);
  393.         if (strLocalFileName.Equals(""))
  394.         {
  395.             strLocalFileName = strRemoteFileName;
  396.         }
  397.         if(!File.Exists(strFolder + "//" +strLocalFileName))
  398.         {
  399.             Stream st = File.Create(strFolder + "//" +strLocalFileName);
  400.             st.Close();
  401.         }
  402.         FileStream output = new 
  403.             FileStream(strFolder + "//" + strLocalFileName,FileMode.Create);
  404.         Socket socketData = CreateDataSocket();
  405.         SendCommand("RETR " + strRemoteFileName);
  406.         if(!(iReplyCode == 150 || iReplyCode == 125
  407.             || iReplyCode == 226 || iReplyCode == 250))
  408.         {
  409.             throw new IOException(strReply.Substring(4));
  410.         }
  411.         while(true)
  412.         {
  413.             int iBytes = socketData.Receive(buffer, buffer.Length, 0);
  414.             output.Write(buffer,0,iBytes);
  415.             if(iBytes <= 0)
  416.             {
  417.                 break;
  418.             }
  419.         }
  420.         output.Close();
  421.         if (socketData.Connected)
  422.         {
  423.             socketData.Close();
  424.         }
  425.         if(!(iReplyCode == 226 || iReplyCode == 250))
  426.         {
  427.             ReadReply();
  428.             if(!(iReplyCode == 226 || iReplyCode == 250))
  429.             {
  430.                 throw new IOException(strReply.Substring(4));
  431.             }
  432.         }
  433.     }
  434.     
  436.     /**//// <summary>
  437.     /// 上傳一批文件
  438.     /// </summary>
  439.     /// <param name="strFolder">本地目錄(不得以/結束)</param>
  440.     /// <param name="strFileNameMask">文件名匹配字符(可以包含*和?)</param>
  441.     public void Put(string strFolder,string strFileNameMask)
  442.     {
  443.         string[] strFiles = Directory.GetFiles(strFolder,strFileNameMask);
  444.         foreach(string strFile in strFiles)
  445.         {
  446.             //strFile是完整的文件名(包含路徑)
  447.             Put(strFile);
  448.         }
  449.     }
  450.     
  452.     /**//// <summary>
  453.     /// 上傳一個文件
  454.     /// </summary>
  455.     /// <param name="strFileName">本地文件名</param>
  456.     public void Put(string strFileName)
  457.     {
  458.         if(!bConnected)
  459.         {
  460.             Connect();
  461.         }
  462.         Socket socketData = CreateDataSocket();
  463.         SendCommand("STOR "+Path.GetFileName(strFileName));
  464.         if( !(iReplyCode == 125 || iReplyCode == 150) )
  465.         {
  466.             throw new IOException(strReply.Substring(4));
  467.         }
  468.         FileStream input = new 
  469.             FileStream(strFileName,FileMode.Open);
  470.         int iBytes = 0;
  471.         while ((iBytes = input.Read(buffer,0,buffer.Length)) > 0)
  472.         {
  473.             socketData.Send(buffer, iBytes, 0);
  474.         }
  475.         input.Close();
  476.         if (socketData.Connected)
  477.         {
  478.             socketData.Close();
  479.         }
  480.         if(!(iReplyCode == 226 || iReplyCode == 250))
  481.         {
  482.             ReadReply();
  483.             if(!(iReplyCode == 226 || iReplyCode == 250))
  484.             {
  485.                 throw new IOException(strReply.Substring(4));
  486.             }
  487.         }
  488.     }
  489.     
  490.         #endregion
  492.     #region 目錄操作
  493.     /**//// <summary>
  494.     /// 創建目錄
  495.     /// </summary>
  496.     /// <param name="strDirName">目錄名</param>
  497.     public void MkDir(string strDirName)
  498.     {
  499.         if(!bConnected)
  500.         {
  501.             Connect();
  502.         }
  503.         SendCommand("MKD "+strDirName);
  504.         if(iReplyCode != 257)
  505.         {
  506.             throw new IOException(strReply.Substring(4));
  507.         }
  508.     }
  509.     
  511.     /**//// <summary>
  512.     /// 刪除目錄
  513.     /// </summary>
  514.     /// <param name="strDirName">目錄名</param>
  515.     public void RmDir(string strDirName)
  516.     {
  517.         if(!bConnected)
  518.         {
  519.             Connect();
  520.         }
  521.         SendCommand("RMD "+strDirName);
  522.         if(iReplyCode != 250)
  523.         {
  524.             throw new IOException(strReply.Substring(4));
  525.         }
  526.     }
  527.     
  529.     /**//// <summary>
  530.     /// 改變目錄
  531.     /// </summary>
  532.     /// <param name="strDirName">新的工作目錄名</param>
  533.     public void ChDir(string strDirName)
  534.     {
  535.         if(strDirName.Equals(".") || strDirName.Equals(""))
  536.         {
  537.             return;
  538.         }
  539.         if(!bConnected)
  540.         {
  541.             Connect();
  542.         }
  543.         SendCommand("CWD "+strDirName);
  544.         if(iReplyCode != 250)
  545.         {
  546.             throw new IOException(strReply.Substring(4));
  547.         }
  548.         this.strRemotePath = strDirName;
  549.     }
  550.     
  551.         #endregion
  553.     #region 內部變量
  554.     /**//// <summary>
  555.     /// 服務器返回的應答信息(包含應答碼)
  556.     /// </summary>
  557.     private string strMsg;
  558.     /**//// <summary>
  559.     /// 服務器返回的應答信息(包含應答碼)
  560.     /// </summary>
  561.     private string strReply;
  562.     /**//// <summary>
  563.     /// 服務器返回的應答碼
  564.     /// </summary>
  565.     private int iReplyCode;
  566.     /**//// <summary>
  567.     /// 進行控製連接的socket
  568.     /// </summary>
  569.     private Socket socketControl;
  570.     /**//// <summary>
  571.     /// 傳輸模式
  572.     /// </summary>
  573.     private TransferType trType;
  574.     /**//// <summary>
  575.     /// 接收和發送數據的緩衝區
  576.     /// </summary>
  577.     private static int BLOCK_SIZE = 512;
  578.     Byte[] buffer = new Byte[BLOCK_SIZE];
  579.     /**//// <summary>
  580.     /// 編碼方式
  581.     /// </summary>
  582.     Encoding ASCII = Encoding.ASCII;
  583.     #endregion
  585.     #region 內部函數
  586.         /**//// <summary>
  587.         /// 將一行應答字符串記錄在strReply和strMsg
  588.         /// 應答碼記錄在iReplyCode
  589.         /// </summary>
  590.         private void ReadReply()
  591.         {
  592.             strMsg = "";
  593.             strReply = ReadLine();
  594.             iReplyCode = Int32.Parse(strReply.Substring(0,3));
  595.         }
  597.     /**//// <summary>
  598.     /// 建立進行數據連接的socket
  599.     /// </summary>
  600.     /// <returns>數據連接socket</returns>
  601.     private Socket CreateDataSocket()
  602.     {
  603.         SendCommand("PASV");
  604.         if(iReplyCode != 227)
  605.         {
  606.             throw new IOException(strReply.Substring(4));
  607.         }
  608.         int index1 = strReply.IndexOf('(');
  609.         int index2 = strReply.IndexOf(')');
  610.         string ipData = 
  611.             strReply.Substring(index1+1,index2-index1-1);
  612.         int[] parts = new int[6];
  613.         int len = ipData.Length;
  614.         int partCount = 0;
  615.         string buf="";
  616.         for (int i = 0; i < len && partCount <= 6; i++)
  617.         {
  618.             char ch = Char.Parse(ipData.Substring(i,1));
  619.             if (Char.IsDigit(ch))
  620.                 buf+=ch;
  621.             else if (ch != ',')
  622.             {
  623.                 throw new IOException("Malformed PASV strReply: " + 
  624.                     strReply);
  625.             }
  626.             if (ch == ',' || i+1 == len)
  627.             {
  628.                 try
  629.                 {
  630.                     parts[partCount++] = Int32.Parse(buf);
  631.                     buf="";
  632.                 }
  633.                 catch (Exception)
  634.                 {
  635.                     throw new IOException("Malformed PASV strReply: " + 
  636.                         strReply);
  637.                 }
  638.             }
  639.         }
  640.         string ipAddress = parts[0] + "."+ parts[1]+ "." +
  641.             parts[2] + "." + parts[3];
  642.         int port = (parts[4] << 8) + parts[5];
  643.         Socket s = new 
  644.             Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
  645.         IPEndPoint ep = new 
  646.             IPEndPoint(IPAddress.Parse(ipAddress), port);
  647.         try
  648.         {
  649.             s.Connect(ep);
  650.         }
  651.         catch(Exception)
  652.         {
  653.             throw new IOException("Can't connect to remote server");
  654.         }
  655.         return s;
  656.     }
  659.     /**//// <summary>
  660.     /// 關閉socket連接(用於登錄以前)
  661.     /// </summary>
  662.     private void CloseSocketConnect()
  663.     {
  664.         if(socketControl!=null)
  665.         {
  666.             socketControl.Close();
  667.             socketControl = null;
  668.         }
  669.         bConnected = false;
  670.     }
  672.     /**//// <summary>
  673.     /// 讀取Socket返回的所有字符串
  674.     /// </summary>
  675.     /// <returns>包含應答碼的字符串行</returns>
  676.     private string ReadLine()
  677.     {
  678.         while(true)
  679.         {
  680.             int iBytes = socketControl.Receive(buffer, buffer.Length, 0);
  681.             strMsg += ASCII.GetString(buffer, 0, iBytes);
  682.             if(iBytes < buffer.Length)
  683.             {
  684.                 break;
  685.             }
  686.         }
  687.         char[] seperator = {'/n'};
  688.         string[] mess = strMsg.Split(seperator);
  689.         if(strMsg.Length > 2)
  690.         {
  691.             strMsg = mess[mess.Length-2];
  692.             //seperator[0]是10,換行符是由13和0組成的,分隔後10後麵雖沒有字符串,
  693.             //但也會分配為空字符串給後麵(也是最後一個)字符串數組,
  694.             //所以最後一個mess是沒用的空字符串
  695.             //但為什麼不直接取mess[0],因為隻有最後一行字符串應答碼與信息之間有空格
  696.         }
  697.         else
  698.         {
  699.             strMsg = mess[0];
  700.         }
  701.         if(!strMsg.Substring(3,1).Equals(" "))//返回字符串正確的是以應答碼(如220開頭,後麵接一空格,再接問候字符串)
  702.         {
  703.             return ReadLine();
  704.         }
  705.         return strMsg;
  706.     }
  709.     /**//// <summary>
  710.     /// 發送命令並獲取應答碼和最後一行應答字符串
  711.     /// </summary>
  712.     /// <param name="strCommand">命令</param>
  713.     private void SendCommand(String strCommand)
  714.     {
  715.         Byte[] cmdBytes = 
  716.             Encoding.ASCII.GetBytes((strCommand+"/r/n").ToCharArray());
  717.         socketControl.Send(cmdBytes, cmdBytes.Length, 0);
  718.         ReadReply();
  719.     }
  721.     #endregion
  722.     } 
  724. }

該工具類還提供一些文件操作，注釋也比較豐富，再次向這個類的作者致敬。

-------------------------------------------------

這個類有一種無法處理的情況，如果FTP服務器使用SSL或者SSH2安全協議搭建的Secure FTP Server，就無法鏈接上了。在網上找到一個可行的辦法，見文章：https://blog.csdn.net/venus0314/archive/2006/09/21/1262386.aspx

原理是利用psftp.exe工具來上傳文件，上傳過程和通訊協議都被隱藏了，通過流寫DOS命令來文件的複製與粘貼的操作。我寫過測試類，但沒有成功，不過應該是一個可行的辦法，正在想辦法研究，如果有結果將會在博客中放出來。

psftp.exe比較難找，但還是找的到的。google吧！

 

-------------------------------------------------

Updated On 2008-10-21

FTPClient類中沒有包含Append的功能，即將本地文件的內容追加到遠程文件上的功能。這裏，我放上來一個通過了測試的Append方法：

  1. /// <summary>
  2. /// 文件Append操作
  3. /// </summary>
  4. /// <param name="strFileName">被Append的本地文件名，要求與遠程文件名一致</param>
  5. public void Append(string strFileName)
  6. {
  7.     if(!bConnected)
  8.         Connect();
  10.     Socket socketData = CreateDataSocket();
  11.     SetTransferType(TransferType.Binary);
  12.     SendCommand("APPE " + Path.GetFileName(strFileName));       
  13.     if( !(iReplyCode == 125 || iReplyCode == 150) )
  14.     {
  15.         throw new IOException(strReply.Substring(4));
  16.     }
  17.     FileStream input = new FileStream(strFileName,FileMode.Open);
  18.     int iBytes = 0;
  19.     while ((iBytes = input.Read(buffer,0,buffer.Length)) > 0)
  20.     {
  21.         socketData.Send(buffer, iBytes, 0);
  22.     }
  23.     input.Close();
  24.     if (socketData.Connected)
  25.     {
  26.         socketData.Close();
  27.     }
  28.     if(!(iReplyCode == 226 || iReplyCode == 250))
  29.     {
  30.         ReadReply();
  31.         if(!(iReplyCode == 226 || iReplyCode == 250))
  32.         {
  33.             throw new IOException(strReply.Substring(4));
  34.         }
  35.     }
  36. }

    這裏沒有提供指定FTP遠程服務器上文件名的功能，要求你上傳的本地文件名與遠程數據庫文件名一致。事實上，我做過指定遠程文件名的嚐試，即將命令該為“APPE local-file remote-file”的格式，但我發現，結果是，它把本地文件的內容傳上去後，生成了一個文件名為local-file與remote-file拚接後的新文件，令人費解！！

最後更新：2017-04-02 00:06:45

  上一篇：go 逐行處理數據時避免死循環
  下一篇：go PMP：“拍好馬屁”，改變人生! (1)