c#之向ftp服务器传文件

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using UnityEngine;

/// <summary>
/// 与 ftp 服务器通信的类
/// </summary>
public static class FtpHelper
{
    const int MaxReconnectCount = ;        // 最大的重新连接次数
    static int s_reconnectCounter;

    static void ResetReconnectCounter()
    {
        s_reconnectCounter = ;
    }

    static bool ReconnectCounterIncrease()
    {
        return ++s_reconnectCounter >= MaxReconnectCount;
    }

    /// <summary>
    /// 上传文件到 ftp 服务器
    /// </summary>
    /// <param name="srcFilePath">源文件路径</param>
    /// <param name="targetUrl">目标 url</param>
    /// <param name="credential">凭证</param>
    public static void UploadFileToFTPServer(string srcFilePath, string targetUrl, NetworkCredential credential)
    {
        if (string.IsNullOrEmpty(srcFilePath))
            throw new ArgumentException("srcFilePath");
        if (string.IsNullOrEmpty(targetUrl))
            throw new ArgumentException("targetUrl");
        if (credential == null)
            throw new ArgumentNullException("credential");

        targetUrl = FixUrl(targetUrl, false);

        try
        {
            FtpWebRequest request = (FtpWebRequest)WebRequest.Create(targetUrl);
            byte[] srcFileBuffer = File.ReadAllBytes(srcFilePath);

            request.Method = WebRequestMethods.Ftp.UploadFile;
            request.Credentials = credential;
            request.ContentLength = srcFileBuffer.Length;
            request.UseBinary = true;
            request.UsePassive = true;
            request.KeepAlive = false;

            using (Stream requestStream = request.GetRequestStream())
                requestStream.Write(srcFileBuffer, , srcFileBuffer.Length);

            Debug.Log(string.Format("Upload file succeed, source file path: {0}, target url: {1}", srcFilePath, targetUrl));

            ResetReconnectCounter();
        }
        catch (Exception ex)
        {
            string l = string.Format("Upload file failed, upload it again. source file path: {0}, target url: {1}, error message: {2}", srcFilePath, targetUrl, ex.Message);
            Debug.LogError(l);
            if (ReconnectCounterIncrease())
                throw new WebException(l);
            else
                UploadFileToFTPServer(srcFilePath, targetUrl, credential);
        }
    }

    /// <summary>
    /// 删除 ftp 服务器上的所有文件
    /// </summary>
    /// <param name="dirUrl">文件夹 url</param>
    public static void DeleteAllFilesOnFtp(string dirUrl, NetworkCredential credential)
    {
        if (string.IsNullOrEmpty(dirUrl))
            throw new ArgumentException("dirUrl");
        if (credential == null)
            throw new ArgumentNullException("credential");

        dirUrl = FixUrl(dirUrl, true);

        List<string> dirNames, fileNames;
        GetDirectoryList(dirUrl, credential, out dirNames, out fileNames);

        foreach (var dirName in dirNames)
        {
            string url = string.Format("{0}{1}/", dirUrl, dirName);
            DeleteAllFilesOnFtp(url, credential);
        }

        foreach (var fileName in fileNames)
        {
            string url = dirUrl + fileName;
            DeleteFile(url, credential);
        }
    }

    /// <summary>
    /// 获取 ftp 文件夹的列表
    /// </summary>
    public static void GetDirectoryList(string dirUrl, NetworkCredential credential, out List<string> dirNames, out List<string> fileNames)
    {
        if (string.IsNullOrEmpty(dirUrl))
            throw new ArgumentException("dirUrl");
        if (credential == null)
            throw new ArgumentNullException("credential");

        dirUrl = FixUrl(dirUrl, true);

        dirNames = new List<string>();
        fileNames = new List<string>();

        try
        {
            var request = (FtpWebRequest)WebRequest.Create(dirUrl);

            request.Method = WebRequestMethods.Ftp.ListDirectoryDetails;
            request.Credentials = credential;
            request.UseBinary = true;
            request.UsePassive = true;
            request.KeepAlive = false;

            var response = (FtpWebResponse)request.GetResponse();
            var responseStream = response.GetResponseStream();
            var responseReader = new StreamReader(responseStream);

            while (!responseReader.EndOfStream)
            {
                string line = responseReader.ReadLine();
                if (string.IsNullOrEmpty(line))
                    continue;

                string[] words = line.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                string name = words.Last();

                if (line[] == 'd')         // 表示是文件夹
                    dirNames.Add(name);
                else if (line[] == '-')    // 表示是文件
                    fileNames.Add(name);
            }

            responseReader.Dispose();
            response.Close();
            responseStream.Dispose();
        }
        catch (Exception ex)
        {
            string l = string.Format("Get directory list failed, directory url: {0}, error message: {1}", dirUrl, ex.Message);
            Debug.LogError(l);
            throw new WebException(l);
        }
    }

    /// <summary>
    /// 删除 ftp 服务器上的文件
    /// </summary>
    public static void DeleteFile(string fileUrl, NetworkCredential credential)
    {
        if (string.IsNullOrEmpty(fileUrl))
            throw new ArgumentException("fileUrl");
        if (credential == null)
            throw new ArgumentNullException("credential");

        fileUrl = FixUrl(fileUrl, false);

        try
        {
            var request = (FtpWebRequest)WebRequest.Create(fileUrl);

            request.Method = WebRequestMethods.Ftp.DeleteFile;
            request.Credentials = credential;
            request.UseBinary = true;
            request.UsePassive = true;
            request.KeepAlive = false;

            var response = request.GetResponse();
            response.Close();

            Debug.Log(string.Format("Delete file succeed, url: {0}", fileUrl));

            ResetReconnectCounter();
        }
        catch (Exception ex)
        {
            string l = string.Format("Delete file failed, url: {0}, error message: {1}", fileUrl, ex.Message);
            Debug.LogError(l);
            if (ReconnectCounterIncrease())
                throw new WebException(l);
            else
                DeleteFile(fileUrl, credential);
        }
    }

    /// <summary>
    /// 在 ftp 服务器上创建文件夹
    /// </summary>
    /// <param name="dirUrl"></param>
    /// <param name="credential"></param>
    public static void CreateFolder(string dirUrl, NetworkCredential credential)
    {
        if (string.IsNullOrEmpty(dirUrl))
            throw new ArgumentException("dirUrl");
        if (credential == null)
            throw new ArgumentNullException("credential");

        dirUrl = FixUrl(dirUrl, false);

        string folderName = Path.GetFileNameWithoutExtension(dirUrl);
        string parentFolderUrl = dirUrl.Replace(folderName, "");
        List<string> dirNames, fileNames;

        GetDirectoryList(parentFolderUrl, credential, out dirNames, out fileNames);

        if (dirNames.Contains(folderName))
            return;

        try
        {
            var request = (FtpWebRequest)WebRequest.Create(dirUrl);

            request.Method = WebRequestMethods.Ftp.MakeDirectory;
            request.Credentials = credential;
            request.UseBinary = true;
            request.UsePassive = true;
            request.KeepAlive = false;

            var response = request.GetResponse();
            response.Close();

            Debug.Log(string.Format("Create folder succeed, url: {0}", dirUrl));

            ResetReconnectCounter();
        }
        catch (Exception ex)
        {
            string l = string.Format("Create folder failed, create again, url: {0}, error message: {1}", dirUrl, ex.Message);
            Debug.LogError(l);
            if (ReconnectCounterIncrease())
                throw new WebException(l);
            else
                CreateFolder(dirUrl, credential);
        }
    }

    static string FixUrl(string url, bool endWithSprit)
    {
        if (string.IsNullOrEmpty(url))
        {
            return url;
        }

        url = url.Replace("\\", "/").TrimEnd('/');
        return endWithSprit ? url + "/" : url;
    }
}

参考1

转载请注明出处：http://www.cnblogs.com/jietian331/p/4955220.html

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

 namespace FtpUploader
 {
     class FtpManager
     {
         NetworkCredential m_credential;
         string m_rootUri;
         bool m_usePassive;
         List<string> m_directories = new List<string>();
         List<string> m_files = new List<string>();

         static string FixUrl(string old)
         {
             return !string.IsNullOrEmpty(old) ?
                 old.Replace("\\", "/").TrimEnd('/') :
                 "";
         }

         static string FixRelativePath(string old)
         {
             return !string.IsNullOrEmpty(old) ?
                     old.Replace("\\", "/").TrimEnd('/').TrimStart('/') :
                     "";
         }

         public FtpManager(string userName, string password, string rootUri, bool usePassive)
         {
             if (string.IsNullOrEmpty(rootUri))
                 throw new ArgumentException("rootUri");

             m_credential = new NetworkCredential(userName, password);
             m_rootUri = FixUrl(rootUri);
             m_usePassive = usePassive;
             GetInfoRecursive("");
         }

         FtpWebRequest CreateRequest(string uri, string method)
         {
             FtpWebRequest request = (FtpWebRequest)WebRequest.Create(uri);
             request.Method = method;
             request.Credentials = m_credential;
             request.UsePassive = m_usePassive;
             request.UseBinary = true;
             request.KeepAlive = true;
             return request;
         }

         void GetInfoRecursive(string relativePath)
         {
             string fullUri = CombineUri(relativePath);
             FtpWebRequest request = CreateRequest(fullUri, WebRequestMethods.Ftp.ListDirectoryDetails);
             FtpWebResponse response = (FtpWebResponse)request.GetResponse();
             Stream stream = response.GetResponseStream();
             StreamReader reader = new StreamReader(stream);

             List<string> dirs = new List<string>();
             while (!reader.EndOfStream)
             {
                 string line = reader.ReadLine();
                 string[] words = line.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries);
                 string name = words.Last();
                 if (name != "." && name != "..")
                 {
                     char type = line[];
                     string newPath = !string.IsNullOrEmpty(relativePath) ? string.Format("{0}/{1}", relativePath, name) : name;
                     newPath = FixRelativePath(newPath);

                     if (type == 'd')
                     {
                         m_directories.Add(newPath);
                         dirs.Add(newPath);
                     }
                     else if (type == '-')
                     {
                         m_files.Add(newPath);
                     }
                 }
             }

             response.Dispose();
             stream.Dispose();
             reader.Dispose();

             foreach (var dir in dirs)
             {
                 GetInfoRecursive(dir);
             }
         }

         string CombineUri(params string[] relativePaths)
         {
             string uri = m_rootUri;
             foreach (var p in relativePaths)
             {
                 if (!string.IsNullOrEmpty(p))
                     uri = string.Format("{0}/{1}", uri, FixRelativePath(p));
             }
             return uri;
         }

         /// <summary>
         /// 将若干个文件传到 ftp 服务器
         /// </summary>
         /// <param name="files">若干文件的路径</param>
         /// <param name="ftpFolders">若干文件对应在ftp服务器上的存放文件夹路径</param>
         public void Upload(string[] files, string[] ftpFolders)
         {
             if (files == null || ftpFolders == null)
                 throw new ArgumentNullException("files == null || ftpFolders == null");
             if (files.Length != ftpFolders.Length)
                 throw new ArgumentException("files.Length != ftpFolders.Length");
             if (files.Length < )
                 return;

             // 先创建好文件夹
             List<string> targetFolders = new List<string>();
             foreach (var folder in ftpFolders)
             {
                 string fixedPath = FixRelativePath(folder);
                 string[] words = fixedPath.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries);

                 for (int i = ; i < words.Length; i++)
                 {
                     string path = words[];
                     for (int j = ; j <= i; j++)
                         path = string.Format("{0}/{1}", path, words[j]);

                     if (!targetFolders.Contains(path))
                         targetFolders.Add(path);
                 }
             }

             foreach (var f in targetFolders)
             {
                 CreateFolder(f);
             }

             // 上传
             for (int i = ; i < files.Length; i++)
                 UploadFile(files[i], ftpFolders[i]);

             Console.WriteLine("All files are uploaded succeed!");
         }

         /// <summary>
         /// 将整个文件夹的内容传到ftp服务器，目录结构保持不变
         /// </summary>
         /// <param name="folder">源文件夹路径</param>
         /// <param name="ftpFolder">ftp服务器上对应的文件夹路径</param>
         public void Upload(string folder, string ftpFolder)
         {
             if (string.IsNullOrEmpty(folder))
                 throw new ArgumentException("folder");

             folder = FixUrl(folder);
             ftpFolder = FixRelativePath(ftpFolder);

             string[] files = Directory.GetFiles(folder, "*.*", SearchOption.AllDirectories);
             string[] folders = new string[files.Length];

             for (int i = ; i < files.Length; i++)
             {
                 string file = FixUrl(files[i]);
                 string name = Path.GetFileName(file);
                 string relativeFolder = file.Substring(folder.Length, file.Length - folder.Length - name.Length);
                 folders[i] = string.Format("{0}/{1}", ftpFolder, FixRelativePath(relativeFolder));
             }

             // 上传
             Upload(files, folders);
         }

         void UploadFile(string srcPath, string relativeFolder)
         {
             string name = Path.GetFileName(srcPath);
             string uri = CombineUri(relativeFolder, name);
             byte[] srcFileBuffer = File.ReadAllBytes(srcPath);

             FtpWebRequest request = CreateRequest(uri, WebRequestMethods.Ftp.UploadFile);
             request.ContentLength = srcFileBuffer.Length;

             using (Stream requestStream = request.GetRequestStream())
                 requestStream.Write(srcFileBuffer, , srcFileBuffer.Length);

             m_files.Add(string.Format("{0}/{1}", FixRelativePath(relativeFolder), name));

             Console.WriteLine("Upload file succeed! {0} -> {1}", srcPath, uri);
         }

         public void UploadString(string src, string relativePath)
         {
             if (string.IsNullOrEmpty(src))
                 throw new ArgumentException("src");

             string uri = CombineUri(relativePath);
             byte[] buffer = Encoding.Default.GetBytes(src);

             FtpWebRequest request = CreateRequest(uri, WebRequestMethods.Ftp.UploadFile);
             request.ContentLength = buffer.Length;

             using (Stream requestStream = request.GetRequestStream())
                 requestStream.Write(buffer, , buffer.Length);

             m_files.Add(FixRelativePath(relativePath));
         }

         void CreateFolder(string relativePath)
         {
             relativePath = FixRelativePath(relativePath);
             if (string.IsNullOrEmpty(relativePath))
                 throw new ArgumentException("relativePath");

             if (m_directories.Contains(relativePath))
                 return;

             string fullUri = CombineUri(relativePath);
             FtpWebRequest request = CreateRequest(fullUri, WebRequestMethods.Ftp.MakeDirectory);
             WebResponse response = request.GetResponse();
             response.Dispose();

             m_directories.Add(relativePath);

             Console.WriteLine("Create folder succeed! {0}", fullUri);
         }

         public string DownloadFile(string relativePath)
         {
             relativePath = FixRelativePath(relativePath);
             if (string.IsNullOrEmpty(relativePath))
                 return null;

             if (!m_files.Contains(relativePath))
                 return null;

             string fullUri = CombineUri(relativePath);
             FtpWebRequest request = CreateRequest(fullUri, WebRequestMethods.Ftp.DownloadFile);
             WebResponse response = request.GetResponse();
             Stream stream = response.GetResponseStream();
             StreamReader sr = new StreamReader(stream);

             string text = sr.ReadToEnd();

             response.Dispose();
             stream.Dispose();
             sr.Dispose();

             return text;
         }

         public List<string> Directoreis
         {
             get { return m_directories; }
         }

         public List<string> Files
         {
             get { return m_files; }
         }
     }
 }

参考2

using System;

namespace FtpUploader
{
    class Program
    {
        static void Main(string[] args)
        {
#if true
            if (args == null || args.Length < )
                throw new ArgumentException("args == null || args.Length < 1");

            Console.WriteLine("Start uploading, args is: {0}", args[]);
            string[] lines = args[].Split(',');
#else
            string a = @"ftp://120.92.34.206,uniuftp,ryx387b1,False,True,D:/SVN/art/UnityArt/AssetBundles/PC/Products,AssetBundle/PC";
            string[] lines = a.Split(',');
#endif
            string uri = lines[];
            string userName = lines[];
            string password = lines[];
            bool usePassive;
            bool.TryParse(lines[], out usePassive);

            // 上传
            FtpManager ftp = new FtpManager(userName, password, uri, usePassive);

            bool folderStyle;
            bool.TryParse(lines[], out folderStyle);
            if (folderStyle)
            {
                string folder = lines[];
                string relativeFolder = lines[];
                ftp.Upload(folder, relativeFolder);

                // 整合版本文件
                CreateAndUploadVersionFile(ftp, relativeFolder);
            }
            else
            {
                string[] files = lines[].Split(new char['|'], StringSplitOptions.RemoveEmptyEntries);
                string[] folders = lines[].Split(new char['|'], StringSplitOptions.RemoveEmptyEntries);
                ftp.Upload(files, folders);
            }

            Console.WriteLine("按任意健结束...");
            Console.ReadKey();
        }

        static void CreateAndUploadVersionFile(FtpManager ftp, string relativeFolder)
        {
            relativeFolder = relativeFolder.Replace("\\", "/").TrimEnd('/');
            string mainVersionString = ftp.DownloadFile(relativeFolder + "/mainVersion.dat");
            string musicVersionString = ftp.DownloadFile(relativeFolder + "/musicVersion.dat");
            string artVersionString = ftp.DownloadFile(relativeFolder + "/artVersion.dat");

            int mainVersion = , musicVersion = , artVersion = ;
            int.TryParse(mainVersionString, out mainVersion);
            int.TryParse(musicVersionString, out musicVersion);
            int.TryParse(artVersionString, out artVersion);
            string versionString = string.Format("{0}.{1}.{2}\nmainList.dat,musicList.dat,artList.dat", mainVersion, musicVersion, artVersion);

            ftp.UploadString(versionString, relativeFolder + "/version.dat");

            Console.WriteLine("整合版本文件成功！版本号为： {0}", versionString);
        }
    }
}