public class FtpState
  {
    private ManualResetEvent wait;
    private FtpWebRequest request;
    private string fileName;
    private Exception operationException = null;
    string status;
 
    public FtpState()
    {
      wait = new ManualResetEvent(false);
    }
 
    public ManualResetEvent OperationComplete
    {
      get { return wait; }
    }
 
    public FtpWebRequest Request
    {
      get { return request; }
      set { request = value; }
    }
 
    public string FileName
    {
      get { return fileName; }
      set { fileName = value; }
    }
    public Exception OperationException
    {
      get { return operationException; }
      set { operationException = value; }
    }
    public string StatusDescription
    {
      get { return status; }
      set { status = value; }
    }
  }
 
  //包含了對(duì)FTP常用的方法
  public class FtpClient
  {
    #region 構(gòu)造函數(shù)
    /// <summary>
    /// 創(chuàng)建FTP工具
    /// <para>
    /// 默認(rèn)不使用SSL,使用二進(jìn)制傳輸方式,使用被動(dòng)模式FTP有兩種使用模式：主動(dòng)和被動(dòng)。
    /// 主動(dòng)模式要求客戶(hù)端和服務(wù)器端同時(shí)打開(kāi)并且監(jiān)聽(tīng)一個(gè)端口以建立連接。
    /// 在這種情況下，客戶(hù)端由于安裝了防火墻會(huì)產(chǎn)生一些問(wèn)題。
    /// 所以，創(chuàng)立了被動(dòng)模式。
    /// 被動(dòng)模式只要求服務(wù)器端產(chǎn)生一個(gè)監(jiān)聽(tīng)相應(yīng)端口的進(jìn)程，這樣就可以繞過(guò)客戶(hù)端安裝了防火墻的問(wèn)題。
    /// </para>
    /// </summary>
    /// <param name="host">主機(jī)名稱(chēng)</param>
    /// <param name="userId">用戶(hù)名</param>
    /// <param name="password">密碼</param>
    public FtpClient(string host, string userId, string password)
      : this(host, userId, password, 8022, null, false, true, true)
    {
        }
 
    /// <summary>
    /// 創(chuàng)建FTP工具
    /// </summary>
    /// <param name="host">主機(jī)名稱(chēng)</param>
    /// <param name="userId">用戶(hù)名</param>
    /// <param name="password">密碼</param>
    /// <param name="port">端口</param>
    /// <param name="enableSsl">允許Ssl</param>
    /// <param name="proxy">代理</param>
    /// <param name="useBinary">允許二進(jìn)制</param>
    /// <param name="usePassive">允許被動(dòng)模式</param>
    public FtpClient(string host, string userId, string password, int port, IWebProxy proxy, bool enableSsl, bool useBinary, bool usePassive)
    {
            this.userId = userId;
            this.password = password;
            MESOperate Dal = new MESOperate();
            DataTable dt = Dal.GetServer();
            string IP = "";
            foreach (IPAddress _IPAddress in Dns.GetHostEntry(Dns.GetHostName()).AddressList)
            {
                if (_IPAddress.AddressFamily.ToString() == "InterNetwork")
                {
                    IP = _IPAddress.ToString();
                }
            }
            if (IP.Substring(0, 6) == "172.30")
            {
                this.host = "ftp://" +dt.Rows[0]["SERVER_IP_NEW"].ToString();//產(chǎn)線(xiàn)
            }
            else
            {
                this.host = "ftp://" + dt.Rows[0]["SERVER_IP"].ToString();//OA
            }
 
            this.port = port;
            this.proxy = proxy;
            this.enableSsl = enableSsl;
            this.useBinary = useBinary;
            this.usePassive = usePassive;
            this.wait = new ManualResetEvent(false);
        }
    #endregion
 
    #region 變量
    #region 主機(jī)
    private string host = string.Empty;
    /// <summary>
    /// 主機(jī)
    /// </summary>
    public string Host
    {
      get
      {
        return this.host ?? string.Empty;//如果左操作數(shù)為空則返回右操作數(shù)，不為空返回左操作數(shù)
      }
    }
    #endregion
 
    #region 登錄用戶(hù)名
    private string userId = string.Empty;
    /// <summary>
    /// 登錄用戶(hù)名
    /// </summary>
    public string UserId
    {
      get
      {
        return this.userId;
      }
    }
    #endregion
 
    #region 密碼
    private string password = string.Empty;
    /// <summary>
    /// 密碼
    /// </summary>
    public string Password
    {
      get
      {
        return this.password;
      }
    }
    #endregion
 
    #region 代理
    IWebProxy proxy = null;
    /// <summary>
    /// 代理
    /// </summary>
    public IWebProxy Proxy
    {
      get
      {
        return this.proxy;
      }
      set
      {
        this.proxy = value;
      }
    }
    #endregion
 
    #region 端口
    private int port = 8022;
    /// <summary>
    /// 端口
    /// </summary>
    public int Port
    {
      get
      {
        return port;
      }
      set
      {
        this.port = value;
      }
    }
    #endregion
 
    #region 設(shè)置是否允許Ssl
    private bool enableSsl = false;
    /// <summary>
    /// EnableSsl 
    /// </summary>
    public bool EnableSsl
    {
      get
      {
        return enableSsl;
      }
    }
    #endregion
 
    #region 使用被動(dòng)模式
    private bool usePassive = true;
    /// <summary>
    /// 被動(dòng)模式
    /// </summary>
    public bool UsePassive
    {
      get
      {
        return usePassive;
      }
      set
      {
        this.usePassive = value;
      }
    }
    #endregion
 
 
    #region 二進(jìn)制方式
    private bool useBinary = true;
    /// <summary>
    /// 二進(jìn)制方式
    /// </summary>
    public bool UseBinary
    {
      get
      {
        return useBinary;
      }
      set
      {
        this.useBinary = value;
      }
    }
    #endregion
 
    #region 遠(yuǎn)端路徑
    private string remotePath = "/";
    /// <summary>
    /// 遠(yuǎn)端路徑
    /// <para>
    ///     返回FTP服務(wù)器上的當(dāng)前路徑(可以是 / 或 /a/../ 的形式)
    /// </para>
    /// </summary>
    public string RemotePath
    {
      get
      {
        return remotePath;
      }
      set
      {
        string result = "/";
        if (!string.IsNullOrEmpty(value) && value != "/")
        {
          result = "/" + value.TrimStart('/').TrimEnd('/') + "/";
        }
        this.remotePath = result;
      }
    }
    #endregion
 
    private ManualResetEvent wait;
 
    public ManualResetEvent OperationComplete
    {
      get { return wait; }
    }
    #endregion
 
    #region 創(chuàng)建一個(gè)FTP連接
    /// <summary>
    /// 創(chuàng)建一個(gè)FTP請(qǐng)求
    /// </summary>
    /// <param name="url">請(qǐng)求地址</param>
    /// <param name="method">請(qǐng)求方法</param>
    /// <returns>FTP請(qǐng)求</returns>
    private FtpWebRequest CreateRequest(string url, string method)
    {
      //建立連接
      FtpWebRequest request = (FtpWebRequest)FtpWebRequest.Create(new Uri(url));
      request.Credentials = new NetworkCredential(this.userId, this.password);
      request.Proxy = this.proxy;
      request.KeepAlive = false;//命令執(zhí)行完畢之后關(guān)閉連接
      request.UseBinary = useBinary;
      request.UsePassive = usePassive;
      request.EnableSsl = enableSsl;
      request.Method = method;
      return request;
 
    }
    #endregion
 
    #region 異步上傳
    /// <summary>
    /// 把文件上傳到FTP服務(wù)器的RemotePath下
    /// </summary>
    /// <param name="localFile">本地文件信息</param>
    /// <param name="remoteFileName">要保存到FTP文件服務(wù)器上的文件名稱(chēng)包含擴(kuò)展名</param>
    /// <param name="isReName">是否重命名</param>
    /// <returns></returns>
    public bool UploadAsync(string localFile, string remoteFileName,bool isReName,string newName)
    {
      ManualResetEvent waitObject;
      FtpState state = new FtpState();
      if (File.Exists(localFile))
      {
        string url = Host.TrimEnd('/') + RemotePath + remoteFileName;
 
        FtpWebRequest request = CreateRequest(url, WebRequestMethods.Ftp.UploadFile);
        state.Request = request;
 
        state.FileName = localFile;
 
        // Get the event to wait on.
        waitObject = state.OperationComplete;
        request.BeginGetRequestStream(
          new AsyncCallback(EndGetStreamCallback), state
      );
        waitObject.WaitOne();
 
        // The operations either completed or threw an exception.
        if (state.OperationException != null)
        {
          throw state.OperationException;
        }
        if (isReName)
        {
          if (this.CheckFileExist(remoteFileName))
          {
            if (this.Rename(remoteFileName, newName))
            {
              return true;
            }
          }
          else { throw new Exception(string.Format("遠(yuǎn)端文件不存在,{0}", remoteFileName)); }
        }
        else 
        {
          return true;
        }
        
        return false;
      }
      throw new Exception(string.Format("本地文件不存在,文件路徑:{0}", localFile));
    }
 
    private void EndGetStreamCallback(IAsyncResult ar)
    {
      FtpState state = (FtpState)ar.AsyncState;
 
      Stream requestStream = null;
      // End the asynchronous call to get the request stream.
      try
      {
        requestStream = state.Request.EndGetRequestStream(ar);
        // Copy the file contents to the request stream.
        const int bufferLength = 2048;
        byte[] buffer = new byte[bufferLength];
        int count = 0;
        int readBytes = 0;
        FileStream stream = File.OpenRead(state.FileName);
        do
        {
          readBytes = stream.Read(buffer, 0, bufferLength);
          requestStream.Write(buffer, 0, readBytes);
          count += readBytes;
        }
        while (readBytes != 0);
        //Console.WriteLine("Writing {0} bytes to the stream.", count);
        // IMPORTANT: Close the request stream before sending the request.
        requestStream.Close();
        // Asynchronously get the response to the upload request.
        state.Request.BeginGetResponse(
            new AsyncCallback(EndGetResponseCallback),
            state
        );
      }
      // Return exceptions to the main application thread.
      catch (Exception e)
      {
        
        state.OperationException = e;
        state.OperationComplete.Set();
        //throw new Exception("Could not get the request stream.");
      }
 
    }
      
 
private void EndGetResponseCallback(IAsyncResult ar)
{
  FtpState state = (FtpState)ar.AsyncState;
  FtpWebResponse response = null;
  try
  {
    response = (FtpWebResponse)state.Request.EndGetResponse(ar);
    response.Close();
    state.StatusDescription = response.StatusDescription;
    // Signal the main application thread that 
    // the operation is complete.
    state.OperationComplete.Set();
  }
  // Return exceptions to the main application thread.
  catch (Exception e)
  {
    state.OperationException = e;
    state.OperationComplete.Set();
    //throw new Exception("Error getting response.");
  }
} 
    #endregion
 
    #region 上傳一個(gè)文件到遠(yuǎn)端路徑下
    /// <summary>
    /// 把文件上傳到FTP服務(wù)器的RemotePath下
    /// </summary>
    /// <param name="localFile">本地文件信息</param>
    /// <param name="remoteFileName">要保存到FTP文件服務(wù)器上的文件名稱(chēng)包含擴(kuò)展名</param>
    public bool Upload(FileInfo localFile, string remoteFileName)
    {
      bool result = false;
      if (localFile.Exists)
      {
        string url = Host.TrimEnd('/') + RemotePath + remoteFileName;
 
        FtpWebRequest request = CreateRequest(url, WebRequestMethods.Ftp.UploadFile);
 
                //上傳數(shù)據(jù)
                using (Stream rs = request.GetRequestStream())
                {
                    using (FileStream fs = localFile.OpenRead())
                    {
                        byte[] buffer = new byte[4096];//4K
                        int count = fs.Read(buffer, 0, buffer.Length);//每次從流中讀4個(gè)字節(jié)再寫(xiě)入緩沖區(qū)
                        while (count > 0)
                        {
                            rs.Write(buffer, 0, count);
                            count = fs.Read(buffer, 0, buffer.Length);
                        }
                        fs.Close();
                        result = true;
                    }
                }
        return result;
      }
      throw new Exception(string.Format("本地文件不存在,文件路徑:{0}", localFile.FullName));
    }
    #endregion
 
 
 
    #region 從FTP服務(wù)器上下載文件
    /// <summary>
    /// 從當(dāng)前目錄下下載文件
    /// <para>
    /// 如果本地文件存在,則從本地文件結(jié)束的位置開(kāi)始下載.
    /// </para>
    /// </summary>
    /// <param name="serverName">服務(wù)器上的文件名稱(chēng)</param>
    /// <param name="localName">本地文件名稱(chēng)</param>
    /// <returns>返回一個(gè)值,指示是否下載成功</returns>
    public bool Download(string serverName, string localName)
    {
            try
            {
                bool result = false;
                //string tempfilename = Path.GetDirectoryName(localName) + @"\" + Path.GetFileNameWithoutExtension(localName) + ".tmp";
                if (File.Exists(localName)) return true;
                using (FileStream fs = new FileStream(localName, FileMode.OpenOrCreate)) //創(chuàng)建或打開(kāi)本地文件
                {
                    //建立連接
                    string url = Host.TrimEnd('/') + RemotePath + serverName;
                    FtpWebRequest request = CreateRequest(url, WebRequestMethods.Ftp.DownloadFile);
                    request.ContentOffset = fs.Length;
                    using (FtpWebResponse response = (FtpWebResponse)request.GetResponse())
                    {
                        fs.Position = fs.Length;
                        byte[] buffer = new byte[4096];//4K
                        int count = response.GetResponseStream().Read(buffer, 0, buffer.Length);
                        while (count > 0)
                        {
                            fs.Write(buffer, 0, count);
                            count = response.GetResponseStream().Read(buffer, 0, buffer.Length);
                        }
                        response.GetResponseStream().Close();
                    }
                    result = true;
                }
                return result;
            }
            catch (Exception ex) { throw ex; }
        }
    #endregion
 
    #region 重命名FTP服務(wù)器上的文件
    /// <summary>
    /// 文件更名
    /// </summary>
    /// <param name="oldFileName">原文件名</param>
    /// <param name="newFileName">新文件名</param>
    /// <returns>返回一個(gè)值,指示更名是否成功</returns>
    public bool Rename(string oldFileName, string newFileName)
    {
      bool result = false;
      //建立連接
      string url = Host.TrimEnd('/') + RemotePath + oldFileName;
      FtpWebRequest request = CreateRequest(url, WebRequestMethods.Ftp.Rename);
      request.RenameTo = newFileName;
      using (FtpWebResponse response = (FtpWebResponse)request.GetResponse())
      {
        result = true;
      }
      return result;
    }
    #endregion
 
    #region 從當(dāng)前目錄下獲取文件列表
    /// <summary>
    /// 獲取當(dāng)前目錄下文件列表
    /// </summary>
    /// <returns></returns>
    public List<string> GetFileList()
    {
            try
            {
                List<string> result = new List<string>();
                //建立連接
                string url = Host.TrimEnd('/') + RemotePath;
                FtpWebRequest request = CreateRequest(url, WebRequestMethods.Ftp.ListDirectory);
                using (FtpWebResponse response = (FtpWebResponse)request.GetResponse())
                {
                    StreamReader reader = new StreamReader(response.GetResponseStream(), System.Text.Encoding.Default);//中文文件名
                    string line = reader.ReadLine();
                    while (line != null)
                    {
                        result.Add(line);
                        line = reader.ReadLine();
                    }
                }
                return result;
            }
            catch (Exception ex) { throw ex; }
    }
    #endregion
 
    #region 從FTP服務(wù)器上獲取文件和文件夾列表
    /// <summary>
    /// 獲取詳細(xì)列表
    /// </summary>
    /// <returns></returns>
    public List<string> GetFileDetails()
    {
      List<string> result = new List<string>();
      //建立連接
      string url = Host.TrimEnd('/') + RemotePath;
      FtpWebRequest request = CreateRequest(url, WebRequestMethods.Ftp.ListDirectoryDetails);
      using (FtpWebResponse response = (FtpWebResponse)request.GetResponse())
      {
        StreamReader reader = new StreamReader(response.GetResponseStream(), System.Text.Encoding.Default);//中文文件名
        string line = reader.ReadLine();
        while (line != null)
        {
          result.Add(line);
          line = reader.ReadLine();
        }
      }
      return result;
    }
 
 
        public List<string> GetFileDetails(string remotepath)
        {
            List<string> result = new List<string>();
            //建立連接
            string url = Host.TrimEnd('/') + remotepath;
            FtpWebRequest request = CreateRequest(url, WebRequestMethods.Ftp.ListDirectoryDetails);
            using (FtpWebResponse response = (FtpWebResponse)request.GetResponse())
            {
                StreamReader reader = new StreamReader(response.GetResponseStream(), System.Text.Encoding.Default);//中文文件名
                string line = reader.ReadLine();
                while (line != null)
                {
                    result.Add(line);
                    line = reader.ReadLine();
                }
            }
            return result;
        }
        #endregion
 
        #region 從FTP服務(wù)器上刪除文件
        /// <summary>
        /// 刪除FTP服務(wù)器上的文件
        /// </summary>
        /// <param name="fileName">文件名稱(chēng)</param>
        /// <returns>返回一個(gè)值,指示是否刪除成功</returns>
        public bool DeleteFile(string fileName)
    {
      bool result = false;
      //建立連接
      string url = Host.TrimEnd('/') + RemotePath + fileName;
      FtpWebRequest request = CreateRequest(url, WebRequestMethods.Ftp.DeleteFile);
      using (FtpWebResponse response = (FtpWebResponse)request.GetResponse())
      {
        result = true;
      }
 
      return result;
    }
    #endregion
 
    #region 在FTP服務(wù)器上創(chuàng)建目錄
    /// <summary>
    /// 在當(dāng)前目錄下創(chuàng)建文件夾
    /// </summary>
    /// <param name="dirName">文件夾名稱(chēng)</param>
    /// <returns>返回一個(gè)值,指示是否創(chuàng)建成功</returns>
    public bool MakeDirectory(string dirName)
    {
      bool result = false;
      //建立連接
      string url = Host.TrimEnd('/') + RemotePath + dirName;
      FtpWebRequest request = CreateRequest(url, WebRequestMethods.Ftp.MakeDirectory);
      using (FtpWebResponse response = (FtpWebResponse)request.GetResponse())
      {
        result = true;
      }
      return result;
    }
    #endregion
 
    #region 從FTP服務(wù)器上刪除目錄
    /// <summary>
    /// 刪除文件夾
    /// </summary>
    /// <param name="dirName">文件夾名稱(chēng)</param>
    /// <returns>返回一個(gè)值,指示是否刪除成功</returns>
    public bool DeleteDirectory(string dirName)
    {
      bool result = false;
      //建立連接
      string url = Host.TrimEnd('/') + RemotePath + dirName;
      FtpWebRequest request = CreateRequest(url, WebRequestMethods.Ftp.RemoveDirectory);
      using (FtpWebResponse response = (FtpWebResponse)request.GetResponse())
      {
        result = true;
      }
      return result;
    }
    #endregion
 
    #region 從FTP服務(wù)器上獲取文件大小
    /// <summary>
    /// 獲取文件大小
    /// </summary>
    /// <param name="fileName"></param>
    /// <returns></returns>
    public long GetFileSize(string fileName)
    {
      long result = 0;
      //建立連接
      string url = Host.TrimEnd('/') + RemotePath + fileName;
      FtpWebRequest request = CreateRequest(url, WebRequestMethods.Ftp.GetFileSize);
      using (FtpWebResponse response = (FtpWebResponse)request.GetResponse())
      {
        result = response.ContentLength;
      }
 
      return result;
    }
    #endregion
 
    #region 給FTP服務(wù)器上的文件追加內(nèi)容
    /// <summary>
    /// 給FTP服務(wù)器上的文件追加內(nèi)容
    /// </summary>
    /// <param name="localFile">本地文件</param>
    /// <param name="remoteFileName">FTP服務(wù)器上的文件</param>
    /// <returns>返回一個(gè)值,指示是否追加成功</returns>
    public bool Append(FileInfo localFile, string remoteFileName)
    {
      if (localFile.Exists)
      {
        using (FileStream fs = new FileStream(localFile.FullName, FileMode.Open))
        {
          return Append(fs, remoteFileName);
        }
      }
      throw new Exception(string.Format("本地文件不存在,文件路徑:{0}", localFile.FullName));
    }
 
    /// <summary>
    /// 給FTP服務(wù)器上的文件追加內(nèi)容
    /// </summary>
    /// <param name="stream">數(shù)據(jù)流(可通過(guò)設(shè)置偏移來(lái)實(shí)現(xiàn)從特定位置開(kāi)始上傳)</param>
    /// <param name="remoteFileName">FTP服務(wù)器上的文件</param>
    /// <returns>返回一個(gè)值,指示是否追加成功</returns>
    public bool Append(Stream stream, string remoteFileName)
    {
      bool result = false;
      if (stream != null && stream.CanRead)
      {
        //建立連接
        string url = Host.TrimEnd('/') + RemotePath + remoteFileName;
        FtpWebRequest request = CreateRequest(url, WebRequestMethods.Ftp.AppendFile);
        using (Stream rs = request.GetRequestStream())
        {
          //上傳數(shù)據(jù)
          byte[] buffer = new byte[4096];//4K
          int count = stream.Read(buffer, 0, buffer.Length);
          while (count > 0)
          {
            rs.Write(buffer, 0, count);
            count = stream.Read(buffer, 0, buffer.Length);
          }
          result = true;
        }
      }
      return result;
    }
    #endregion
 
    #region 獲取FTP服務(wù)器上的當(dāng)前路徑
    /// <summary>
    /// 獲取FTP服務(wù)器上的當(dāng)前路徑
    /// </summary>
    public string CurrentDirectory
    {
      get
      {
        string result = string.Empty;
        string url = Host.TrimEnd('/') + RemotePath;
        FtpWebRequest request = CreateRequest(url, WebRequestMethods.Ftp.PrintWorkingDirectory);
        using (FtpWebResponse response = (FtpWebResponse)request.GetResponse())
        {
          string temp = response.StatusDescription;
          int start = temp.IndexOf('"') + 1;
          int end = temp.LastIndexOf('"');
          if (end >= start)
          {
            result = temp.Substring(start, end - start);
          }
        }
        return result;
 
      }
    }
    #endregion
 
    #region 檢查當(dāng)前路徑上是否存在某個(gè)文件
    /// <summary>
    /// 檢查文件是否存在
    /// </summary>
    /// <param name="fileName">要檢查的文件名</param>
    /// <returns>返回一個(gè)值,指示要檢查的文件是否存在</returns>
    public bool CheckFileExist(string fileName)
    {
      bool result = false;
      if (fileName != null && fileName.Trim().Length > 0)
      {
        fileName = fileName.Trim();
        List<string> files = GetFileList();
        if (files != null && files.Count > 0)
        {
          if (files.Count(q => q.ToLower() == fileName.ToLower()) > 0)
            result = true;
        }
      }
      return result;
    }
        #endregion
 
 
        /// <summary>
        /// 判斷當(dāng)前目錄下指定的子目錄是否存在
        /// </summary>
        /// <param name="RemoteDirectoryName">指定的目錄名</param>
        public bool CheckDirectoryExist(string rootDir, string RemoteDirectoryName)
        {
            string[] dirList = GetDirectoryList(rootDir);//獲取子目錄
            if (dirList.Length > 0)
            {
                foreach (string str in dirList)
                {
                    if (str.Trim() == RemoteDirectoryName.Trim())
                    {
                        return true;
                    }
                }
            }
            return false;
        }
 
 
        //獲取子目錄
        public string[] GetDirectoryList(string dirName)
        {
            string[] drectory = GetFileDetails(dirName).ToArray();
            List<string> strList = new List<string>();
            if (drectory.Length > 0)
            {
                foreach (string str in drectory)
                {
                    if (str.Trim().Length == 0)
                        continue;
                    //會(huì)有兩種格式的詳細(xì)信息返回
                    //一種包含<DIR>
                    //一種第一個(gè)字符串是drwxerwxx這樣的權(quán)限操作符號(hào)
                    //現(xiàn)在寫(xiě)代碼包容兩種格式的字符串
                    if (str.Trim().Contains("<DIR>"))
                    {
                        strList.Add(str.Substring(39).Trim());
                    }
                    else
                    {
                        if (str.Trim().Substring(0, 1).ToUpper() == "D")
                        {
                            strList.Add(str.Substring(55).Trim());
                        }
                    }
                }
            }
            return strList.ToArray();
        }
    }