网上找了好多，感觉还是自己这个使用起来方便点，记录一下！

using System;
using System.Collections;
using System.IO;
using System.Linq;
using System.Net;
using System.Text;

namespace FtpTest.Common
{

 public class FtpHelper  
 {  
     private readonly string \_ftpUri;  //ftp服务器地址  
     private readonly string \_ftpName;  //ftp帐户  
     private readonly string \_ftpPwd;  //ftp密码  
     private FtpWebRequest \_ftpRequest;  //请求  
     private FtpWebResponse \_ftpResponse;  //响应

     public FtpHelper(string uri, string name, string password)  
     {  
         \_ftpUri = uri;  
         \_ftpName = name;  
         \_ftpPwd = password;  
     }

     /// <summary>  
     /// 连接类  
     /// </summary>  
     /// <param name="uri">ftp地址</param>  
     private void Conn(string uri)  
     {  
         \_ftpRequest = (FtpWebRequest)WebRequest.Create(uri);  
         //登录ftp服务器，ftpName:账户名，ftpPwd:密码  
         \_ftpRequest.Credentials = new NetworkCredential(\_ftpName, \_ftpPwd);  
         \_ftpRequest.UseBinary = true;  //该值指定文件传输的数据类型。  
     }

     /// <summary>  
     /// 删除文件  
     /// </summary>  
     /// <param name="fileName">文件名</param>  
     public void DeleteFileName(string fileName)  
     {  
         string uri = \_ftpUri + "/" + fileName;  
         Conn(uri);  
         try  
         {  
             \_ftpRequest.Method = WebRequestMethods.Ftp.DeleteFile;  
             \_ftpResponse = (FtpWebResponse)\_ftpRequest.GetResponse();  
             \_ftpResponse.Close();  
         }  
         catch (Exception)  
         {  
             // ignored  
         }  
     }

     /// <summary>  
     /// 删除ftp上目录  
     /// </summary>  
     /// <param name="dirName"></param>  
     public void RemoveDir(string dirName)  
     {  
         string uri = \_ftpUri + "/" + dirName;  
         Conn(uri);  
         try  
         {  
             \_ftpRequest.Method = WebRequestMethods.Ftp.RemoveDirectory;  
             \_ftpResponse = (FtpWebResponse)\_ftpRequest.GetResponse();  
             \_ftpResponse.Close();  
         }  
         catch (Exception)  
         {  
             // ignored  
         }  
     }

     /// <summary>  
     /// 上传文件，使用FTPWebRequest、FTPWebResponse实例  
     /// </summary>  
     /// <param name="uri">ftp地址</param>  
     /// <param name="fileName">文件名</param>  
     /// <param name="fileData">文件内容</param>  
     /// <param name="msg">传出参数，返回传输结果</param>  
     public void UploadFile(string uri, string fileName, byte\[\] fileData, out string msg)  
     {  
         string ftpUri = uri.EndsWith("/") ? uri : uri + "/";  
         ftpUri += fileName;  
         //连接ftp服务器  
         Conn(ftpUri);  
         \_ftpRequest.Method = WebRequestMethods.Ftp.UploadFile;  
         \_ftpRequest.ContentLength = fileData.Length; //上传文件时通知服务器文件的大小  
         try  
         {  
             //将文件流中的数据（byte\[\] fileData）写入请求流  
             using (Stream ftpstream = \_ftpRequest.GetRequestStream())  
             {  
                 ftpstream.Write(fileData, , fileData.Length);  
             }

             \_ftpResponse = (FtpWebResponse)\_ftpRequest.GetResponse(); //响应  
             msg = \_ftpResponse.StatusDescription; //响应状态  
             \_ftpResponse.Close();  
         }  
         catch (Exception exp)  
         {  
             msg = "Failed to upload:" + exp.Message;  
         }  
     }

     /// <summary>  
     /// 上传文件，使用WebClient类  
     /// </summary>  
     /// <param name="uri">ftp地址</param>  
     /// <param name="fileName">文件名</param>  
     /// <param name="fileData">文件内容</param>  
     /// <param name="msg">传出参数，输出传输结果</param>  
     public void UploadFileByWebClient(string uri, string fileName, byte\[\] fileData, out string msg)  
     {  
         string ftpUri = uri.EndsWith("/") ? uri : uri + "/";  
         ftpUri += fileName;

         try  
         {  
             WebClient client = new WebClient { Credentials = new NetworkCredential(\_ftpName, \_ftpPwd) };  
             //登录FTP服务  
             client.UploadData(ftpUri, "STOR", fileData); //指定为ftp上传方式  
             msg = "上传成功!";  
         }  
         catch (Exception exp)  
         {  
             msg = "Failed to upload:" + exp.Message;  
         }  
     }

     /// <summary>  
     /// 下载文件，使用FTPWebRequest、FTPWebResponse实例  
     /// </summary>  
     /// <param name="uri">ftp地址</param>  
     /// <param name="destinationDir">目标文件存放地址</param>  
     /// <param name="msg">传出参数，返回传输结果</param>  
     public void DownloadFile(string uri, string destinationDir, out string msg)  
     {  
         string fileName = Path.GetFileName(uri);  
         // ReSharper disable once AssignNullToNotNullAttribute  
         string destinationPath = Path.Combine(destinationDir, fileName);

         try  
         {  
             //连接ftp服务器  
             Conn(uri);

             using (FileStream outputStream = new FileStream(destinationPath, FileMode.OpenOrCreate))  
             {  
                 using (\_ftpResponse = (FtpWebResponse)\_ftpRequest.GetResponse())  
                 {  
                     //将响应流中的数据写入到文件流  
                     using (Stream ftpStream = \_ftpResponse.GetResponseStream())  
                     {  
                         int bufferSize = ;  
                         byte\[\] buffer = new byte\[bufferSize\];  
                         if (ftpStream != null)  
                         {  
                             var readCount = ftpStream.Read(buffer, , bufferSize);  
                             while (readCount > )  
                             {  
                                 outputStream.Write(buffer, , readCount);  
                                 readCount = ftpStream.Read(buffer, , bufferSize);  
                             }  
                         }  
                     }  
                     msg = \_ftpResponse.StatusDescription;  
                 }  
             }  
         }  
         catch (Exception exp)  
         {  
             msg = "Failed to download:" + exp.Message;  
         }  
     }

     public byte\[\] DownloadFile()  
     {  
         try  
         {  
             WebClient client = new WebClient { Credentials = new NetworkCredential(\_ftpName, \_ftpPwd) };  
             byte\[\] responseData = client.DownloadData(\_ftpUri);  
             return responseData;  
         }  
         catch (Exception ex)  
         {  
             // ReSharper disable once PossibleIntendedRethrow  
             throw ex;  
         }  
     }

     /// <summary>  
     /// 文件下载，使用WebClient类  
     /// </summary>  
     /// <param name="uri">ftp服务地址</param>  
     /// <param name="destinationDir">存放目录</param>  
     public void DownloadFileByWebClient(string uri, string destinationDir)  
     {  
         string fileName = Path.GetFileName(uri);  
         // ReSharper disable once AssignNullToNotNullAttribute  
         string destinationPath = Path.Combine(destinationDir, fileName);

         try  
         {  
             WebClient client = new WebClient { Credentials = new NetworkCredential(\_ftpName, \_ftpPwd) };

             byte\[\] responseData = client.DownloadData(uri);

             using (FileStream fileStream = new FileStream(destinationPath, FileMode.OpenOrCreate))  
             {  
                 fileStream.Write(responseData, , responseData.Length);  
             }  
         }  
         catch (Exception)  
         {  
             // ignored  
         }  
     }

     /// <summary>  
     /// 遍历文件  
     /// </summary>  
     public ArrayList GetListDirectoryDetails()  
     {  
         ArrayList fileInfo = new ArrayList();  
         try  
         {  
             Conn(\_ftpUri);

             //获取 FTP 服务器上的文件的详细列表的 FTP LIST 协议方法  
             \_ftpRequest.Method = WebRequestMethods.Ftp.ListDirectory;  
             try  
             {  
                 \_ftpResponse = (FtpWebResponse)\_ftpRequest.GetResponse(); //响应  
             }  
             catch (WebException)  
             {  
             }  
             catch (InvalidOperationException)  
             {  
             }

             using (Stream responseStream = \_ftpResponse.GetResponseStream())  
             {  
                 // ReSharper disable once AssignNullToNotNullAttribute  
                 using (StreamReader reader = new StreamReader(responseStream))  
                 {  
                     string line = reader.ReadLine();  
                     while (line != null)  
                     {  
                         fileInfo.Add(line);  
                         line = reader.ReadLine();  
                     }  
                 }  
             }  
         }  
         catch (Exception)  
         {  
             // ignored  
         }

         return fileInfo;  
     }

     /// <summary>  
     /// 上传图片  
     /// </summary>  
     /// <param name="mstr"></param>  
     /// <param name="ftpUri"></param>  
     /// <returns></returns>  
     public bool Upload(MemoryStream mstr, string ftpUri)  
     {  
         try  
         {  
             FtpWebRequest ftp = (FtpWebRequest)WebRequest.Create(ftpUri);  
             ftp.Credentials = new NetworkCredential(\_ftpName, \_ftpPwd);  
             ftp.Method = WebRequestMethods.Ftp.UploadFile;  
             ftp.UseBinary = true;  
             ftp.UsePassive = true;  
             using (Stream stream = ftp.GetRequestStream())  
             {  
                 byte\[\] bytes = mstr.ToArray();  
                 stream.Write(bytes, , bytes.Length);  
                 stream.Close();  
                 mstr.Close();  
             }  
             return true;  
         }  
         catch (Exception)  
         {  
             return false;  
         }  
     }

     public bool Upload(byte\[\] mstr, string ftpUri)  
     {  
         try  
         {  
             FtpWebRequest ftp = (FtpWebRequest)WebRequest.Create(ftpUri);  
             ftp.Credentials = new NetworkCredential(\_ftpName, \_ftpPwd);  
             ftp.Method = WebRequestMethods.Ftp.UploadFile;  
             ftp.UseBinary = true;  
             ftp.UsePassive = true;  
             using (Stream stream = ftp.GetRequestStream())  
             {  
                 stream.Write(mstr, , mstr.Length);  
                 stream.Close();  
             }  
             return true;  
         }  
         catch (Exception)  
         {  
             return false;  
         }  
     }

     /// <summary>  
     /// 重命名文件  
     /// </summary>  
     /// <param name="fileName">原文件名</param>  
     /// <param name="reNameFileName">新文件名</param>  
     public bool RenameFileName(string fileName, string reNameFileName)  
     {  
         bool result = true;  
         FtpWebRequest ftp = (FtpWebRequest)WebRequest.Create(reNameFileName);  
         ftp.Credentials = new NetworkCredential(\_ftpName, \_ftpPwd);  
         try  
         {  
             ftp.Method = WebRequestMethods.Ftp.Rename;  
             ftp.RenameTo = fileName;  
             ftp.UseBinary = true;  
             ftp.UsePassive = true;  
             \_ftpResponse = (FtpWebResponse)ftp.GetResponse();  
             Stream ftpStream = \_ftpResponse.GetResponseStream();  
             // ReSharper disable once PossibleNullReferenceException  
             ftpStream.Close();  
             \_ftpResponse.Close();  
         }  
         catch (Exception)  
         {  
             result = false;  
         }

         return result;  
     }

     /// <summary>  
     /// 删除文件  
     /// </summary>  
     /// <param name="fileName">文件名</param>  
     public bool DeleteFile(string fileName)  
     {  
         bool result = true;  
         FtpWebRequest ftp = (FtpWebRequest)WebRequest.Create(fileName);  
         ftp.Credentials = new NetworkCredential(\_ftpName, \_ftpPwd);  
         try  
         {  
             ftp.Method = WebRequestMethods.Ftp.DeleteFile;  
             ftp.UseBinary = true;  
             ftp.UsePassive = true;  
             \_ftpResponse = (FtpWebResponse)ftp.GetResponse();  
             Stream ftpStream = \_ftpResponse.GetResponseStream();  
             // ReSharper disable once PossibleNullReferenceException  
             ftpStream.Close();  
             \_ftpResponse.Close();  
         }  
         catch (Exception)  
         {  
             result = false;  
         }

         return result;  
     }

     /// <summary>  
     /// 创建目录  
     /// </summary>  
     /// <param name="dri"></param>  
     /// <returns></returns>  
     public bool FtpMakeDir(string dri)  
     {  
         FtpWebRequest req = (FtpWebRequest)WebRequest.Create(dri);  
         req.Credentials = new NetworkCredential(\_ftpName, \_ftpPwd);  
         req.Method = WebRequestMethods.Ftp.MakeDirectory;  
         try  
         {  
             FtpWebResponse response = (FtpWebResponse)req.GetResponse();  
             response.Close();  
         }  
         catch (Exception)  
         {  
             req.Abort();  
             return false;  
         }  
         req.Abort();  
         return true;  
     }

     /// <summary>  
     /// 创建多级目录  
     /// </summary>  
     /// <param name="ftppath">目录,例如：/aaa/bbb/ccc </param>  
     public bool FtpMakeDirs(string ftppath)  
     {  
         string targetPath = \_ftpUri;  
         var pathArray = ftppath.Split('/');

         try  
         {  
             //遍历判断文件夹是否存在  
             foreach (var path in pathArray)  
             {  
                 if (!string.IsNullOrEmpty(path.Trim()))  
                 {  
                     //不存在此层文件夹  
                     if (!DirectoryExist(targetPath, path))  
                         FtpMakeDir(targetPath + "/" + path);

                     targetPath += "/" + path;  
                 }  
             }  
         }  
         catch (Exception)  
         {  
             return false;  
         }

         return true;  
     }

     /// <summary>  
     /// 下载  
     /// </summary>  
     /// <param name="fileName"></param>  
     public byte\[\] Download(string fileName)  
     {  
         byte\[\] buffer = null;  
         try  
         {  
             // ReSharper disable once AccessToStaticMemberViaDerivedType  
             var reqFtp = (FtpWebRequest)FtpWebRequest.Create(new Uri(\_ftpUri + "/" + fileName));  
             reqFtp.Method = WebRequestMethods.Ftp.DownloadFile;  
             reqFtp.UseBinary = true;  
             reqFtp.Credentials = new NetworkCredential(\_ftpName, \_ftpPwd);  
             FtpWebResponse response = (FtpWebResponse)reqFtp.GetResponse();  
             Stream ftpStream = response.GetResponseStream();  
             int bufferSize = ; //Convert.ToInt32(GetFileSize(fileName)) + 51200;//  
             buffer = new byte\[bufferSize\];  
             // ReSharper disable once PossibleNullReferenceException  
             var readCount = ftpStream.Read(buffer, , bufferSize);

             while (readCount > )  
             {  
                 readCount = ftpStream.Read(buffer, , bufferSize);  
             }  
             ftpStream.Close();  
             response.Close();  
         }  
         catch (Exception)  
         {  
             // ignored  
         }

         return buffer;  
     }

     /// <summary>  
     /// 获取当前目录下明细(包含文件和文件夹)  
     /// </summary>  
     /// <returns></returns>  
     public string\[\] GetFilesDetailList(string targetPath)  
     {  
         var tempftpUri = targetPath;

         try  
         {  
             StringBuilder result = new StringBuilder();

             Conn(tempftpUri);  
             //获取 FTP 服务器上的文件的详细列表的 FTP LIST 协议方法  
             \_ftpRequest.Method = WebRequestMethods.Ftp.ListDirectoryDetails;

             WebResponse response = \_ftpRequest.GetResponse();  
             // ReSharper disable once AssignNullToNotNullAttribute  
             StreamReader reader = new StreamReader(response.GetResponseStream());  
             string line = reader.ReadLine();

             while (line != null)  
             {  
                 result.Append(line);  
                 result.Append("\\n");  
                 line = reader.ReadLine();  
             }

             result.Remove(result.ToString().LastIndexOf("\\n", StringComparison.Ordinal), );  
             reader.Close();  
             response.Close();

             return result.ToString().Split('\\n');  
         }  
         catch (Exception)  
         {  
             var downloadFiles = new string\[\] { };  
             return downloadFiles;  
         }  
     }

     /// <summary>  
     /// 获取当前目录下所有的文件夹列表(仅文件夹)  
     /// </summary>  
     /// <returns></returns>  
     public string\[\] GetDirectoryList(string targetPath)  
     {  
         string\[\] drectory = GetFilesDetailList(targetPath);  
         string m = "";  
         if (drectory != null && true & drectory.Any())  
         {  
             foreach (string str in drectory)  
             {  
                 int dirPos = str.IndexOf("<DIR>", StringComparison.Ordinal);  
                 if (dirPos > )  
                 {  
                     /\*判断 Windows 风格\*/  
                     m += str.Substring(dirPos + ).Trim() + "\\n";  
                 }  
                 else if (str.Trim().Substring(, ).ToUpper() == "D")  
                 {  
                     /\*判断 Unix 风格\*/  
                     string dir = str.Substring().Trim();  
                     if (dir != "." && dir != "..")  
                     {  
                         m += dir + "\\n";  
                     }  
                 }  
             }  
         }  
         char\[\] n = new char\[\] { '\\n' };  
         return m.Split(n);  
     }

     /// <summary>  
     /// 判断当前目录下指定的子目录是否存在  
     /// modified at 2015/4/7 修改判断是否存在的方法，以前的方式过于臃肿，还有bug（竟然使用listdetail!)  
     /// </summary>  
     /// <param name="targetPath">服务器地址</param>  
     /// <param name="remoteDirectoryName">指定的目录名</param>  
     public bool DirectoryExist(string targetPath, string remoteDirectoryName)  
     {  
         try  
         {  
             var uri = Path.Combine(targetPath, remoteDirectoryName).Replace(@"\\", @"/");  
             Conn(uri);  
             \_ftpRequest.Method = WebRequestMethods.Ftp.ListDirectory;

             using (var response = (FtpWebResponse)\_ftpRequest.GetResponse())  
             // ReSharper disable once AssignNullToNotNullAttribute  
             // ReSharper disable once UnusedVariable  
             using (var stream = new StreamReader(response.GetResponseStream()))  
             {  
             }  
             return true;  
         }  
         catch (Exception)  
         {  
             // ignored  
         }

         return false;  
     }

     /// <summary>  
     /// 获取指定文件大小  
     /// </summary>  
     /// <param name="filename"></param>  
     /// <returns></returns>  
     public long GetFileSize(string filename)  
     {  
         long fileSize = ;  
         try  
         {  
             // ReSharper disable once AccessToStaticMemberViaDerivedType  
             var reqFtp = (FtpWebRequest)FtpWebRequest.Create(new Uri(\_ftpUri + "/" + filename));

             reqFtp.Method = WebRequestMethods.Ftp.GetFileSize;  
             reqFtp.UseBinary = true;  
             reqFtp.Credentials = new NetworkCredential(\_ftpName, \_ftpPwd);

             FtpWebResponse response = (FtpWebResponse)reqFtp.GetResponse();  
             Stream ftpStream = response.GetResponseStream();  
             fileSize = response.ContentLength;

             // ReSharper disable once PossibleNullReferenceException  
             ftpStream.Close();  
             response.Close();  
         }  
         catch (Exception)  
         {  
             // ignored  
         }

         return fileSize;  
     }

     /// <summary>  
     /// 获取当前目录下文件列表(仅文件)  
     /// </summary>  
     /// <returns></returns>  
     public string\[\] GetFileList(string mask)  
     {  
         StringBuilder result = new StringBuilder();  
         try  
         {  
             // ReSharper disable once AccessToStaticMemberViaDerivedType  
             var reqFtp = (FtpWebRequest)FtpWebRequest.Create(new Uri(\_ftpUri));  
             reqFtp.UseBinary = true;  
             reqFtp.Credentials = new NetworkCredential(\_ftpName, \_ftpPwd);  
             reqFtp.Method = WebRequestMethods.Ftp.ListDirectory;  
             WebResponse response = reqFtp.GetResponse();  
             // ReSharper disable once AssignNullToNotNullAttribute  
             StreamReader reader = new StreamReader(response.GetResponseStream(), Encoding.Default);

             string line = reader.ReadLine();  
             while (line != null)  
             {  
                 if (mask.Trim() != string.Empty && mask.Trim() != "\*.\*")  
                 {  
                     var masks = mask.Substring(, mask.IndexOf("\*", StringComparison.Ordinal));  
                     if (line.Substring(, masks.Length) == masks)  
                     {  
                         result.Append(line);  
                         result.Append("\\n");  
                     }  
                 }  
                 else  
                 {  
                     result.Append(line);  
                     result.Append("\\n");  
                 }  
                 line = reader.ReadLine();  
             }  
             result.Remove(result.ToString().LastIndexOf('\\n'), );  
             reader.Close();  
             response.Close();  
             return result.ToString().Split('\\n');  
         }  
         catch (Exception ex)  
         {  
             if (ex.Message.Trim() != "远程服务器返回错误: (550) 文件不可用(例如，未找到文件，无法访问文件)。")  
             {  
             }  
             return null;  
         }  
     }

     /// <summary>  
     /// 判断文件是否存在  
     /// </summary>  
     /// <param name="filename"></param>  
     /// <returns></returns>  
     public bool FileExist(string filename)  
     {  
         bool result;  
         WebResponse response = null;  
         try  
         {  
             WebRequest req = WebRequest.Create(filename);  
             response = req.GetResponse();  
             result = true;  
         }  
         catch (Exception)  
         {  
             result = false;  
         }  
         finally  
         {  
             response?.Close();  
         }

         return result;  
     }  
 }  

}

Test:

1、创建多级目录：

         string targetPath = "ftp://192.168.1.148/";  
         string ftpUserName = "ftpuser";  
         string ftpPassword = "";

         var path = "1234/1234/1234";  
         FtpHelper ftpHelper = new FtpHelper(targetPath , ftpUserName, ftpPassword);  
         try  
         {  
             ftpHelper.FtpMakeDirs(path);  
         }  
         catch (Exception ex)  
         {  
             Console.Write(ex.Message);  
         }