C# 的 FTP类库

Question

有谁知道比较好用的FTP的类库，要能够支持多线程！

Answer 1

有没有多线程的ftp的例子，贴上来看看！

Answer 2

http://www.codeproject.com/Articles/27245/FTP-Client-and-HttpFileDownloader-Components-Contr

Answer 3

using System;
using System.Net;
using System.IO;
using System.Text;
using System.Net.Sockets;
using System.Threading;namespace web
{
    public class c1ftp
    {
        public static object obj = new object();        #region 构造函数
        /// <summary>
        /// 缺省构造函数
        /// </summary>
        public c1ftp()
        {
            w13服务器IP = "";
            w16当前服务器目录 = "";
            w15用户 = "";
            w14密码 = "";
            w17端口 = 21;
            w18是否登录 = false;
        }        /// <summary>
        /// 构造函数
        /// </summary>
        public c1ftp(string p1服务器IP, string p2当前目录, string 用户, string 密码, int 端口)
        {
            w13服务器IP = p1服务器IP;
            w16当前服务器目录 = p2当前目录;
            w15用户 = 用户;
            w14密码 = 密码;
            w17端口 = 端口;
            f0建立连接();
        }
        #endregion        #region 字段
        private int w17端口;
        private Boolean w18是否登录;
        private string w13服务器IP;
        private string w14密码;
        private string w15用户;
        private string w16当前服务器目录;        /// <summary>
        /// 服务器返回的应答信息(包含应答码)
        /// </summary>
        private string w9返回的应答信息;
        /// <summary>
        /// 服务器返回的应答信息(包含应答码)
        /// </summary>
        private string w8返回的应答信息;
        /// <summary>
        /// 服务器返回的应答码
        /// </summary>
        private int w7返回的应答码;
        /// <summary>
        /// 进行控制连接的socket
        /// </summary>
        private Socket w9进行控制连接的socket;
        /// <summary>
        /// 传输模式
        /// </summary>
        private TransferType w10传输模式;
        /// <summary>
        /// 接收和发送数据的缓冲区
        /// </summary>
        private static int w11缓冲区大小 = 512;
        /// <summary>
        /// 编码方式
        /// </summary>
        Encoding ASCII = Encoding.ASCII;
        /// <summary>
        /// 字节数组
        /// </summary>
        Byte[] w12字节数组 = new Byte[w11缓冲区大小];
        #endregion        #region 属性
        /// <summary>
        /// FTP服务器IP地址
        /// </summary>
        public string w1服务器IP
        {
            get
            {
                return w13服务器IP;
            }
            set
            {
                w13服务器IP = value;
            }
        }        /// <summary>
        /// FTP服务器端口
        /// </summary>
        public int w2服务器端口
        {
            get
            {
                return w17端口;
            }
            set
            {
                w17端口 = value;
            }
        }        /// <summary>
        /// 当前服务器目录
        /// </summary>
        public string w3当前服务器目录
        {
            get
            {
                return w16当前服务器目录;
            }
            set
            {
                w16当前服务器目录 = value;
            }
        }        /// <summary>
        /// 登录用户账号
        /// </summary>
        public string w4账号
        {
            set
            {
                w15用户 = value;
            }
        }        /// <summary>
        /// 用户登录密码
        /// </summary>
        public string w5密码
        {
            set
            {
                w14密码 = value;
            }
        }        /// <summary>
        /// 是否登录
        /// </summary>
        public bool w6是否登录
        {
            get
            {
                return w18是否登录;
            }
        }
        #endregion        #region 链接
        /// <summary>
        /// 建立连接 
        /// </summary>
        public void f0建立连接()
        {
            lock (obj)
            {
                w9进行控制连接的socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                IPEndPoint ep = new IPEndPoint(IPAddress.Parse(w1服务器IP), w17端口);
                try
                {
                    w9进行控制连接的socket.Connect(ep);
                }
                catch (Exception)
                {
                    throw new IOException("不能连接ftp服务器");
                }
            }
            f21读应答码();
            if (w7返回的应答码 != 220)
            {
                f19关闭连接();
                throw new IOException(w8返回的应答信息.Substring(4));
            }
            f18发送命令("USER " + w15用户);
            if (!(w7返回的应答码 == 331 || w7返回的应答码 == 230))
            {
                f16关闭socket连接();
                throw new IOException(w8返回的应答信息.Substring(4));
            }
            if (w7返回的应答码 != 230)
            {
                f18发送命令("PASS " + w14密码);
                if (!(w7返回的应答码 == 230 || w7返回的应答码 == 202))
                {
                    f16关闭socket连接();
                    throw new IOException(w8返回的应答信息.Substring(4));
                }
            }
            w18是否登录 = true;
            f14改变目录(w16当前服务器目录);
        }        /// <summary>
        /// 关闭连接
        /// </summary>
        public void f19关闭连接()
        {
            if (w9进行控制连接的socket != null)
            {
                f18发送命令("QUIT");
            }
            f16关闭socket连接();
        }
        #endregion

Answer 4

        #region 传输模式
        /// <summary>
        /// 传输模式:二进制类型、ASCII类型
        /// </summary>
        public enum TransferType { Binary, ASCII };        /// <summary>
        /// 设置传输模式
        /// </summary>
        /// <param name="传输模式">传输模式</param>
        public void f22设置传输模式(TransferType 传输模式)
        {
            if (传输模式 == TransferType.Binary)
            {
                f18发送命令("TYPE I");//binary类型传输
            }
            else
            {
                f18发送命令("TYPE A");//ASCII类型传输
            }
            if (w7返回的应答码 != 200)
            {
                throw new IOException(w8返回的应答信息.Substring(4));
            }
            else
            {
                w10传输模式 = 传输模式;
            }
        }        /// <summary>
        /// 获得传输模式
        /// </summary>
        /// <returns>传输模式</returns>
        public TransferType f20获得传输模式()
        {
            return w10传输模式;
        }
        #endregion        #region 文件操作
        /// <summary>
        /// 获得文件列表
        /// </summary>
        /// <param name="文件名的匹配字符串">文件名的匹配字符串</param>
        public string[] f1获得文件列表(string 文件名的匹配字符串)
        {
            if (!w18是否登录)
            {
                f0建立连接();
            }
            Socket socketData = f15建立进行数据连接的socket();
            f18发送命令("NLST " + 文件名的匹配字符串);
            if (!(w7返回的应答码 == 150 || w7返回的应答码 == 125 || w7返回的应答码 == 226))
            {
                throw new IOException(w8返回的应答信息.Substring(4));
            }
            w9返回的应答信息 = "";
            Thread.Sleep(2000);
            while (true)
            {
                int iBytes = socketData.Receive(w12字节数组, w12字节数组.Length, 0);
                w9返回的应答信息 += ASCII.GetString(w12字节数组, 0, iBytes);
                if (iBytes < w12字节数组.Length)
                {
                    break;
                }
            }
            char[] seperator = { '\n' };
            string[] strsFileList = w9返回的应答信息.Split(seperator);
            socketData.Close(); //数据socket关闭时也会有返回码
            if (w7返回的应答码 != 226)
            {
                f21读应答码();
                if (w7返回的应答码 != 226)
                {                    throw new IOException(w8返回的应答信息.Substring(4));
                }
            }
            return strsFileList;
        }        public void newPutByGuid(string strFileName, string strGuid)
        {
            if (!w18是否登录)
            {
                f0建立连接();
            }
            string str = strFileName.Substring(0, strFileName.LastIndexOf("\\"));
            string strTypeName = strFileName.Substring(strFileName.LastIndexOf("."));
            strGuid = str + "\\" + strGuid;
            Socket socketData = f15建立进行数据连接的socket();
            f18发送命令("STOR " + Path.GetFileName(strGuid));
            if (!(w7返回的应答码 == 125 || w7返回的应答码 == 150))
            {
                throw new IOException(w8返回的应答信息.Substring(4));
            }
            FileStream input = new FileStream(strGuid, FileMode.Open);
            input.Flush();
            int iBytes = 0;
            while ((iBytes = input.Read(w12字节数组, 0, w12字节数组.Length)) > 0)
            {
                socketData.Send(w12字节数组, iBytes, 0);
            }
            input.Close();
            if (socketData.Connected)
            {
                socketData.Close();
            }
            if (!(w7返回的应答码 == 226 || w7返回的应答码 == 250))
            {
                f21读应答码();
                if (!(w7返回的应答码 == 226 || w7返回的应答码 == 250))
                {
                    throw new IOException(w8返回的应答信息.Substring(4));
                }
            }
        }        /// <summary>
        /// 获取文件大小
        /// </summary>
        /// <param name="文件名">文件名</param>
        /// <returns>文件大小</returns>
        public long f2获取文件大小(string 文件名)
        {
            if (!w18是否登录)
            {
                f0建立连接();
            }
            f18发送命令("SIZE " + Path.GetFileName(文件名));
            long lSize = 0;
            if (w7返回的应答码 == 213)
            {
                lSize = Int64.Parse(w8返回的应答信息.Substring(4));
            }
            else
            {
                throw new IOException(w8返回的应答信息.Substring(4));
            }
            return lSize;
        }
        /// <summary>
        /// 获取文件信息
        /// </summary>
        /// <param name="文件名">文件名</param>
        /// <returns>文件大小</returns>
        public string f3获取文件信息(string 文件名)
        {
            if (!w18是否登录)
            {
                f0建立连接();
            }
            Socket socketData = f15建立进行数据连接的socket();
            f18发送命令("LIST " + 文件名);
            string strResult = "";
            if (!(w7返回的应答码 == 150 || w7返回的应答码 == 125
                || w7返回的应答码 == 226 || w7返回的应答码 == 250))
            {
                throw new IOException(w8返回的应答信息.Substring(4));
            }
            byte[] b = new byte[512];
            MemoryStream ms = new MemoryStream();            while (true)
            {
                int iBytes = socketData.Receive(b, b.Length, 0);
                ms.Write(b, 0, iBytes);
                if (iBytes <= 0)
                {                    break;
                }
            }
            byte[] bt = ms.GetBuffer();
            strResult = System.Text.Encoding.ASCII.GetString(bt);
            ms.Close();
            return strResult;
        }        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="待删除文件名">待删除文件名</param>
        public void f4删除(string 待删除文件名)
        {
            if (!w18是否登录)
            {
                f0建立连接();
            }
            f18发送命令("DELE " + 待删除文件名);
            if (w7返回的应答码 != 250)
            {
                throw new IOException(w8返回的应答信息.Substring(4));
            }
        }        /// <summary>
        /// 重命名(如果新文件名与已有文件重名,将覆盖已有文件)
        /// </summary>
        /// <param name="旧文件名">旧文件名</param>
        /// <param name="新文件名">新文件名</param>
        public void f5重命名(string 旧文件名, string 新文件名)
        {
            if (!w18是否登录)
            {
                f0建立连接();
            }
            f18发送命令("RNFR " + 旧文件名);
            if (w7返回的应答码 != 350)
            {
                throw new IOException(w8返回的应答信息.Substring(4));
            }
            //  如果新文件名与原有文件重名,将覆盖原有文件
            f18发送命令("RNTO " + 新文件名);
            if (w7返回的应答码 != 250)
            {
                throw new IOException(w8返回的应答信息.Substring(4));
            }
        }
        #endregion

Answer 5

  #region 上传和下载
        /// <summary>
        /// 下载一批文件
        /// </summary>
        /// <param name="文件名的匹配字符串">文件名的匹配字符串</param>
        /// <param name="本地目录">本地目录(不得以\结束)</param>
        public void f6下载一批文件(string 文件名的匹配字符串, string 本地目录)
        {
            if (!w18是否登录)
            {
                f0建立连接();
            }
            string[] strFiles = f1获得文件列表(文件名的匹配字符串);
            foreach (string strFile in strFiles)
            {
                if (!strFile.Equals(""))//一般来说strFiles的最后一个元素可能是空字符串
                {
                    f7下载一个文件(strFile, 本地目录, strFile);
                }
            }
        }        /// <summary>
        /// 下载一个文件
        /// </summary>
        /// <param name="要下载的文件名">要下载的文件名</param>
        /// <param name="本地目录">本地目录(不得以\结束)</param>
        /// <param name="保存在本地时的文件名">保存在本地时的文件名</param>
        public void f7下载一个文件(string 要下载的文件名, string 本地目录, string 保存在本地时的文件名)
        {
            Socket socketData = f15建立进行数据连接的socket();
            try
            {
                if (!w18是否登录)
                {
                    f0建立连接();
                }
                f22设置传输模式(TransferType.Binary);
                if (保存在本地时的文件名.Equals(""))
                {
                    保存在本地时的文件名 = 要下载的文件名;
                }
                f18发送命令("RETR " + 要下载的文件名);
                if (!(w7返回的应答码 == 150 || w7返回的应答码 == 125 || w7返回的应答码 == 226 || w7返回的应答码 == 250))
                {
                    throw new IOException(w8返回的应答信息.Substring(4));
                }
                FileStream output = new FileStream(本地目录 + "\\" + 保存在本地时的文件名, FileMode.Create);
                while (true)
                {
                    int iBytes = socketData.Receive(w12字节数组, w12字节数组.Length, 0);
                    output.Write(w12字节数组, 0, iBytes);
                    if (iBytes <= 0)
                    {
                        break;
                    }
                }
                output.Close();
                if (socketData.Connected)
                {
                    socketData.Close();
                }
                if (!(w7返回的应答码 == 226 || w7返回的应答码 == 250))
                {
                    f21读应答码();
                    if (!(w7返回的应答码 == 226 || w7返回的应答码 == 250))
                    {
                        throw new IOException(w8返回的应答信息.Substring(4));
                    }
                }
            }
            catch
            {
                socketData.Close();
                socketData = null;
                w9进行控制连接的socket.Close();
                w18是否登录 = false;
                w9进行控制连接的socket = null;
            }
        }        /// <summary>
        /// 下载一个文件
        /// </summary>
        /// <param name="要下载的文件名">要下载的文件名</param>
        /// <param name="本地目录">本地目录(不得以\结束)</param>
        /// <param name="保存在本地时的文件名">保存在本地时的文件名</param>
        public void f8下载一个文件非二进制(string 要下载的文件名, string 本地目录, string 保存在本地时的文件名)
        {
            if (!w18是否登录)
            {
                f0建立连接();
            }            if (保存在本地时的文件名.Equals(""))
            {
                保存在本地时的文件名 = 要下载的文件名;
            }
            Socket socketData = f15建立进行数据连接的socket();
            f18发送命令("RETR " + 要下载的文件名);
            if (!(w7返回的应答码 == 150 || w7返回的应答码 == 125 || w7返回的应答码 == 226 || w7返回的应答码 == 250))
            {
                throw new IOException(w8返回的应答信息.Substring(4));
            }
            FileStream output = new FileStream(本地目录 + "\\" + 保存在本地时的文件名, FileMode.Create);
            while (true)
            {
                int iBytes = socketData.Receive(w12字节数组, w12字节数组.Length, 0);
                output.Write(w12字节数组, 0, iBytes);
                if (iBytes <= 0)
                {
                    break;
                }
            }
            output.Close();
            if (socketData.Connected)
            {
                socketData.Close();
            }
            if (!(w7返回的应答码 == 226 || w7返回的应答码 == 250))
            {
                f21读应答码();
                if (!(w7返回的应答码 == 226 || w7返回的应答码 == 250))
                {
                    throw new IOException(w8返回的应答信息.Substring(4));
                }
            }
        }        /// <summary>
        /// 上传一批文件
        /// </summary>
        /// <param name="本地目录">本地目录(不得以\结束)</param>
        /// <param name="文件名匹配字符">文件名匹配字符(可以包含*和?)</param>
        public void f9上传一批文件(string 本地目录, string 文件名匹配字符)
        {
            string[] strFiles = Directory.GetFiles(本地目录, 文件名匹配字符);
            foreach (string strFile in strFiles)
            {
                f10上传一个文件(strFile);
            }
        }        /// <summary>
        /// 上传一个文件
        /// </summary>
        /// <param name="p1本地文件名">本地文件名</param>
        public void f10上传一个文件(string p1本地文件名)
        {
            if (!w18是否登录)
            {
                f0建立连接();
            }
            Socket socketData = f15建立进行数据连接的socket();
            if (Path.GetExtension(p1本地文件名) == "")
                f18发送命令("STOR " + Path.GetFileNameWithoutExtension(p1本地文件名));
            else
                f18发送命令("STOR " + Path.GetFileName(p1本地文件名));            if (!(w7返回的应答码 == 125 || w7返回的应答码 == 150))
            {
                throw new IOException(w8返回的应答信息.Substring(4));
            }            FileStream input = new FileStream(p1本地文件名, FileMode.Open);
            int iBytes = 0;
            while ((iBytes = input.Read(w12字节数组, 0, w12字节数组.Length)) > 0)
            {
                socketData.Send(w12字节数组, iBytes, 0);
            }
            input.Close();
            if (socketData.Connected)
            {
                socketData.Close();
            }
            if (!(w7返回的应答码 == 226 || w7返回的应答码 == 250))
            {
                f21读应答码();
                if (!(w7返回的应答码 == 226 || w7返回的应答码 == 250))
                {
                    throw new IOException(w8返回的应答信息.Substring(4));
                }
            }
        }
        /// <summary>
        /// 上传一个文件
        /// </summary>
        /// <param name="p1本地文件名">本地文件名</param>
        public void f11上传一个文件(string p1本地文件名, string strGuid)
        {
            if (!w18是否登录)
            {
                f0建立连接();
            }
            string str = p1本地文件名.Substring(0, p1本地文件名.LastIndexOf("\\"));
            string strTypeName = p1本地文件名.Substring(p1本地文件名.LastIndexOf("."));
            strGuid = str + "\\" + strGuid;
            System.IO.File.Copy(p1本地文件名, strGuid);
            System.IO.File.SetAttributes(strGuid, System.IO.FileAttributes.Normal);
            Socket socketData = f15建立进行数据连接的socket();
            f18发送命令("STOR " + Path.GetFileName(strGuid));
            if (!(w7返回的应答码 == 125 || w7返回的应答码 == 150))
            {
                throw new IOException(w8返回的应答信息.Substring(4));
            }
            FileStream input = new FileStream(strGuid, FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.Read);
            int iBytes = 0;
            while ((iBytes = input.Read(w12字节数组, 0, w12字节数组.Length)) > 0)
            {
                socketData.Send(w12字节数组, iBytes, 0);
            }
            input.Close();
            File.Delete(strGuid);
            if (socketData.Connected)
            {
                socketData.Close();
            }
            if (!(w7返回的应答码 == 226 || w7返回的应答码 == 250))
            {
                f21读应答码();
                if (!(w7返回的应答码 == 226 || w7返回的应答码 == 250))
                {
                    throw new IOException(w8返回的应答信息.Substring(4));
                }
            }
        }
        #endregion