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 = 3;        // 最大的重新连接次数
    static int s_reconnectCounter;

    static void ResetReconnectCounter()
    {
        s_reconnectCounter = 0;
    }

    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, 0, 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[0] == 'd')         // 表示是文件夹
                    dirNames.Add(name);
                else if (line[0] == '-')    // 表示是文件
                    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;
    }
}

转载请注明出处：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[0];
                    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 < 1)
                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 = 0; i < words.Length; i++)
                {
                    string path = words[0];
                    for (int j = 1; 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 = 0; 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 = 0; 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, 0, 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, 0, 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; }
        }
    }
}

using System;

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

            Console.WriteLine("Start uploading, args is: {0}", args[0]);
            string[] lines = args[0].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[0];
            string userName = lines[1];
            string password = lines[2];
            bool usePassive;
            bool.TryParse(lines[3], out usePassive);

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

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

                // 整合版本文件
                CreateAndUploadVersionFile(ftp, relativeFolder);
            }
            else
            {
                string[] files = lines[5].Split(new char['|'], StringSplitOptions.RemoveEmptyEntries);
                string[] folders = lines[6].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 = 0, musicVersion = 0, artVersion = 0;
            int.TryParse(mainVersionString, out mainVersion);
            int.TryParse(musicVersionString, out musicVersion);
            int.TryParse(artVersionString, out artVersion);
            string versionString = string.Format("{0}.{1}.{2}
mainList.dat,musicList.dat,artList.dat", mainVersion, musicVersion, artVersion);

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

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