运用Ftp进行文件上传(一)
把文件上传到Ftp上面
首先建立配置文件
文件名称App.config:
 <?xml version="1.0" encoding="utf-8" ?>
<?xml version="1.0" encoding="utf-8" ?> <configuration>
<configuration>     <appSettings>
<appSettings> <add key="ConnStr" value="server=SERVER-DBT;database=SZHeritage;uid=szwgj;pwd=wgj;Max Pool Size=20000;"/>
<add key="ConnStr" value="server=SERVER-DBT;database=SZHeritage;uid=szwgj;pwd=wgj;Max Pool Size=20000;"/> <add key="FtpServer" value="172.17.101.89"/>
<add key="FtpServer" value="172.17.101.89"/> <add key="FtpUser" value="zaz"/>
<add key="FtpUser" value="zaz"/> <add key="FtpPwd" value="zaz"/>
<add key="FtpPwd" value="zaz"/> </appSettings>
</appSettings> </configuration>
</configuration>
 using System;
using System; using System.Net;
using System.Net; using System.IO;
using System.IO; using System.Text;
using System.Text; using System.Net.Sockets;
using System.Net.Sockets; using DevExpress.XtraEditors;
using DevExpress.XtraEditors;
 namespace WindowsApplication6
namespace WindowsApplication6

 {
{
 /**//// <summary>
    /**//// <summary> /// FTPClient 的摘要说明。
    /// FTPClient 的摘要说明。 /// </summary>
    /// </summary> public class FTPClient
    public class FTPClient
 
     {
{
 构造函数#region 构造函数
        构造函数#region 构造函数
 /**//// <summary>
        /**//// <summary> /// 缺省构造函数
        /// 缺省构造函数 /// </summary>
        /// </summary> public FTPClient()
        public FTPClient()
 
         {
{ strRemoteHost  = "";
            strRemoteHost  = ""; strRemotePath  = "";
            strRemotePath  = ""; strRemoteUser  = "";
            strRemoteUser  = ""; strRemotePass  = "";
            strRemotePass  = ""; strRemotePort  = 21;
            strRemotePort  = 21; bConnected     = false;
            bConnected     = false; }
        }

 /**//// <summary>
        /**//// <summary> /// 构造函数
        /// 构造函数 /// </summary>
        /// </summary> /// <param name="remoteHost"></param>
        /// <param name="remoteHost"></param> /// <param name="remotePath"></param>
        /// <param name="remotePath"></param> /// <param name="remoteUser"></param>
        /// <param name="remoteUser"></param> /// <param name="remotePass"></param>
        /// <param name="remotePass"></param> /// <param name="remotePort"></param>
        /// <param name="remotePort"></param> public FTPClient( string remoteHost, string remotePath, string remoteUser, string remotePass, int remotePort )
        public FTPClient( string remoteHost, string remotePath, string remoteUser, string remotePass, int remotePort )
 
         {
{ strRemoteHost  = remoteHost;
            strRemoteHost  = remoteHost; strRemotePath  = remotePath;
            strRemotePath  = remotePath; strRemoteUser  = remoteUser;
            strRemoteUser  = remoteUser; strRemotePass  = remotePass;
            strRemotePass  = remotePass; strRemotePort  = remotePort;
            strRemotePort  = remotePort; Connect();
            Connect(); }
        } #endregion
        #endregion

 登陆#region 登陆
        登陆#region 登陆
 /**//// <summary>
        /**//// <summary> /// FTP服务器IP地址
        /// FTP服务器IP地址 /// </summary>
        /// </summary> private string strRemoteHost;
        private string strRemoteHost; public string RemoteHost
        public string RemoteHost
 
         {
{ get
            get
 
             {
{ return strRemoteHost;
                return strRemoteHost; }
            } set
            set
 
             {
{ strRemoteHost = value;
                strRemoteHost = value; }
            } }
        }
 /**//// <summary>
        /**//// <summary> /// FTP服务器端口
        /// FTP服务器端口 /// </summary>
        /// </summary> private int strRemotePort;
        private int strRemotePort; public int RemotePort
        public int RemotePort
 
         {
{ get
            get
 
             {
{ return strRemotePort;
                return strRemotePort; }
            } set
            set
 
             {
{ strRemotePort = value;
                strRemotePort = value; }
            } }
        }
 /**//// <summary>
        /**//// <summary> /// 当前服务器目录
        /// 当前服务器目录 /// </summary>
        /// </summary> private string strRemotePath;
        private string strRemotePath; public string RemotePath
        public string RemotePath
 
         {
{ get
            get
 
             {
{ return strRemotePath;
                return strRemotePath; }
            } set
            set
 
             {
{ strRemotePath = value;
                strRemotePath = value; }
            } }
        }
 /**//// <summary>
        /**//// <summary> /// 登录用户账号
        /// 登录用户账号 /// </summary>
        /// </summary> private string strRemoteUser;
        private string strRemoteUser; public string RemoteUser
        public string RemoteUser
 
         {
{ set
            set
 
             {
{ strRemoteUser = value;
                strRemoteUser = value; }
            } }
        }
 /**//// <summary>
        /**//// <summary> /// 用户登录密码
        /// 用户登录密码 /// </summary>
        /// </summary> private string strRemotePass;
        private string strRemotePass; public string RemotePass
        public string RemotePass
 
         {
{ set
            set
 
             {
{ strRemotePass = value;
                strRemotePass = value; }
            } }
        }

 /**//// <summary>
        /**//// <summary> /// 是否登录
        /// 是否登录 /// </summary>
        /// </summary> private Boolean bConnected;
        private Boolean bConnected; public bool Connected
        public bool Connected
 
         {
{ get
            get
 
             {
{ return bConnected;
                return bConnected; }
            } }
        } #endregion
        #endregion

 链接#region 链接
        链接#region 链接
 /**//// <summary>
        /**//// <summary> /// 建立连接
        /// 建立连接  /// </summary>
        /// </summary> public void Connect()
        public void Connect()
 
         {
{ socketControl = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
            socketControl = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp); IPEndPoint ep = new IPEndPoint(IPAddress.Parse(RemoteHost), strRemotePort);
            IPEndPoint ep = new IPEndPoint(IPAddress.Parse(RemoteHost), strRemotePort); // 链接
            // 链接 try
            try
 
             {
{ socketControl.Connect(ep);
                socketControl.Connect(ep); }
            } catch(Exception)
            catch(Exception)
 
             {
{ throw new IOException("Couldn't connect to remote server");
                throw new IOException("Couldn't connect to remote server"); }
            }
 // 获取应答码
            // 获取应答码 ReadReply();
            ReadReply(); if(iReplyCode != 220)
            if(iReplyCode != 220)
 
             {
{ DisConnect();
                DisConnect(); throw new IOException(strReply.Substring(4));
                throw new IOException(strReply.Substring(4)); }
            }
 // 登陆
            // 登陆 SendCommand("USER "+strRemoteUser);
            SendCommand("USER "+strRemoteUser); if( !(iReplyCode == 331 || iReplyCode == 230) )
            if( !(iReplyCode == 331 || iReplyCode == 230) )
 
             {
{ CloseSocketConnect();//关闭连接
                CloseSocketConnect();//关闭连接 throw new IOException(strReply.Substring(4));
                throw new IOException(strReply.Substring(4)); }
            } if( iReplyCode != 230 )
            if( iReplyCode != 230 )
 
             {
{ SendCommand("PASS "+strRemotePass);
                SendCommand("PASS "+strRemotePass); if( !(iReplyCode == 230 || iReplyCode == 202) )
                if( !(iReplyCode == 230 || iReplyCode == 202) )
 
                 {
{ CloseSocketConnect();//关闭连接
                    CloseSocketConnect();//关闭连接 throw new IOException(strReply.Substring(4));
                    throw new IOException(strReply.Substring(4)); }
                } }
            } bConnected = true;
            bConnected = true;
 // 切换到目录
            // 切换到目录 ChDir(strRemotePath);
            ChDir(strRemotePath); }
        } 
    

 /**//// <summary>
        /**//// <summary> /// 关闭连接
        /// 关闭连接 /// </summary>
        /// </summary> public void DisConnect()
        public void DisConnect()
 
         {
{ if( socketControl != null )
            if( socketControl != null )
 
             {
{ SendCommand("QUIT");
                SendCommand("QUIT"); }
            } CloseSocketConnect();
            CloseSocketConnect(); }
        }
 #endregion
        #endregion

 传输模式#region 传输模式
        传输模式#region 传输模式

 /**//// <summary>
        /**//// <summary> /// 传输模式:二进制类型、ASCII类型
        /// 传输模式:二进制类型、ASCII类型 /// </summary>
        /// </summary>
 public enum TransferType
        public enum TransferType  {Binary,ASCII};
{Binary,ASCII};

 /**//// <summary>
        /**//// <summary> /// 设置传输模式
        /// 设置传输模式 /// </summary>
        /// </summary> /// <param name="ttType">传输模式</param>
        /// <param name="ttType">传输模式</param> public void SetTransferType(TransferType ttType)
        public void SetTransferType(TransferType ttType)
 
         {
{ if(ttType == TransferType.Binary)
            if(ttType == TransferType.Binary)
 
             {
{ SendCommand("TYPE I");//binary类型传输
                SendCommand("TYPE I");//binary类型传输 }
            } else
            else
 
             {
{ SendCommand("TYPE A");//ASCII类型传输
                SendCommand("TYPE A");//ASCII类型传输 }
            } if (iReplyCode != 200)
            if (iReplyCode != 200)
 
             {
{ throw new IOException(strReply.Substring(4));
                throw new IOException(strReply.Substring(4)); }
            } else
            else
 
             {
{ trType = ttType;
                trType = ttType; }
            } }
        }


 /**//// <summary>
        /**//// <summary> /// 获得传输模式
        /// 获得传输模式 /// </summary>
        /// </summary> /// <returns>传输模式</returns>
        /// <returns>传输模式</returns> public TransferType GetTransferType()
        public TransferType GetTransferType()
 
         {
{ return trType;
            return trType; }
        } 
     #endregion
        #endregion

 文件操作#region 文件操作
        文件操作#region 文件操作
 /**//// <summary>
        /**//// <summary> /// 获得文件列表
        /// 获得文件列表 /// </summary>
        /// </summary> /// <param name="strMask">文件名的匹配字符串</param>
        /// <param name="strMask">文件名的匹配字符串</param> /// <returns></returns>
        /// <returns></returns> public string[] Dir(string strMask)
        public string[] Dir(string strMask)
 
         {
{ // 建立链接
            // 建立链接 if(!bConnected)
            if(!bConnected)
 
             {
{ Connect();
                Connect(); }
            }
 //建立进行数据连接的socket
            //建立进行数据连接的socket Socket socketData = CreateDataSocket();
            Socket socketData = CreateDataSocket(); 
    //传送命令
            //传送命令 SendCommand("NLST " + strMask);
            SendCommand("NLST " + strMask);
 //分析应答代码
            //分析应答代码 if(!(iReplyCode == 150 || iReplyCode == 125 || iReplyCode == 226))
            if(!(iReplyCode == 150 || iReplyCode == 125 || iReplyCode == 226))
 
             {
{ throw new IOException(strReply.Substring(4));
                throw new IOException(strReply.Substring(4)); }
            }
 //获得结果
            //获得结果 strMsg = "";
            strMsg = ""; while(true)
            while(true)
 
             {
{ int iBytes = socketData.Receive(buffer, buffer.Length, 0);
                int iBytes = socketData.Receive(buffer, buffer.Length, 0); strMsg += ASCII.GetString(buffer, 0, iBytes);
                strMsg += ASCII.GetString(buffer, 0, iBytes); if(iBytes < buffer.Length)
                if(iBytes < buffer.Length)
 
                 {
{ break;
                    break; }
                } }
            }
 char[] seperator =
            char[] seperator =  {'\n'};
{'\n'}; string[] strsFileList = strMsg.Split(seperator);
            string[] strsFileList = strMsg.Split(seperator); socketData.Close();//数据socket关闭时也会有返回码
            socketData.Close();//数据socket关闭时也会有返回码 if(iReplyCode != 226)
            if(iReplyCode != 226)
 
             {
{ ReadReply();
                ReadReply(); if(iReplyCode != 226)
                if(iReplyCode != 226)
 
                 {
{ throw new IOException(strReply.Substring(4));
                    throw new IOException(strReply.Substring(4)); }
                } }
            } return strsFileList;
            return strsFileList; }
        } 
    
 public void newPutByGuid(string strFileName,string strGuid)
        public void newPutByGuid(string strFileName,string strGuid)

 
         {
{
 if(!bConnected)
            if(!bConnected)

 
             {
{
 Connect();
                Connect();
 }
            }
 string str = strFileName.Substring(0,strFileName.LastIndexOf("\\"));
            string str = strFileName.Substring(0,strFileName.LastIndexOf("\\"));
 string strTypeName = strFileName.Substring(strFileName.LastIndexOf("."));
            string strTypeName = strFileName.Substring(strFileName.LastIndexOf("."));
 strGuid = str + "\\" + strGuid ;
            strGuid = str + "\\" + strGuid ;
 //System.IO.File.Copy(strFileName,strGuid);
            //System.IO.File.Copy(strFileName,strGuid); 
 
 
 Socket socketData = CreateDataSocket();
            Socket socketData = CreateDataSocket();
 SendCommand("STOR "+Path.GetFileName(strGuid));
            SendCommand("STOR "+Path.GetFileName(strGuid));
 if( !(iReplyCode == 125 || iReplyCode == 150) )
            if( !(iReplyCode == 125 || iReplyCode == 150) )

 
             {
{
 throw new IOException(strReply.Substring(4));
                throw new IOException(strReply.Substring(4));
 }
            }
 
           
 
           
 FileStream input = new
            FileStream input = new 
 FileStream(strGuid,FileMode.Open);
                FileStream(strGuid,FileMode.Open);
 input.Flush();
            input.Flush();
 
           
 
           
 
 
 int iBytes = 0;
            int iBytes = 0;
 while ((iBytes = input.Read(buffer,0,buffer.Length)) > 0)
            while ((iBytes = input.Read(buffer,0,buffer.Length)) > 0)

 
             {
{
 socketData.Send(buffer, iBytes, 0);
                socketData.Send(buffer, iBytes, 0);
 }
            }
 input.Close();
            input.Close();
 //File.Delete(strGuid);
            //File.Delete(strGuid);
 if (socketData.Connected)
            if (socketData.Connected)

 
             {
{
 socketData.Close();
                socketData.Close();
 }
            }
 if(!(iReplyCode == 226 || iReplyCode == 250))
            if(!(iReplyCode == 226 || iReplyCode == 250))

 
             {
{
 ReadReply();
                ReadReply();
 if(!(iReplyCode == 226 || iReplyCode == 250))
                if(!(iReplyCode == 226 || iReplyCode == 250))

 
                 {
{
 throw new IOException(strReply.Substring(4));
                    throw new IOException(strReply.Substring(4));
 }
                }
 }
            }
 }
        }

 /**//// <summary>
        /**//// <summary> /// 获取文件大小
        /// 获取文件大小 /// </summary>
        /// </summary> /// <param name="strFileName">文件名</param>
        /// <param name="strFileName">文件名</param> /// <returns>文件大小</returns>
        /// <returns>文件大小</returns> private long GetFileSize(string strFileName)
        private long GetFileSize(string strFileName)
 
         {
{ if(!bConnected)
            if(!bConnected)
 
             {
{ Connect();
                Connect(); }
            } SendCommand("SIZE " + Path.GetFileName(strFileName));
            SendCommand("SIZE " + Path.GetFileName(strFileName)); long lSize=0;
            long lSize=0; if(iReplyCode == 213)
            if(iReplyCode == 213)
 
             {
{ lSize = Int64.Parse(strReply.Substring(4));
                lSize = Int64.Parse(strReply.Substring(4)); }
            } else
            else
 
             {
{ throw new IOException(strReply.Substring(4));
                throw new IOException(strReply.Substring(4)); }
            } return lSize;
            return lSize; }
        }


 /**//// <summary>
        /**//// <summary> /// 删除
        /// 删除 /// </summary>
        /// </summary> /// <param name="strFileName">待删除文件名</param>
        /// <param name="strFileName">待删除文件名</param> public void Delete(string strFileName)
        public void Delete(string strFileName)
 
         {
{ if(!bConnected)
            if(!bConnected)
 
             {
{ Connect();
                Connect(); }
            } SendCommand("DELE "+strFileName);
            SendCommand("DELE "+strFileName); if(iReplyCode != 250)
            if(iReplyCode != 250)
 
             {
{ throw new IOException(strReply.Substring(4));
                throw new IOException(strReply.Substring(4)); }
            } }
        } 
    

 /**//// <summary>
        /**//// <summary> /// 重命名(如果新文件名与已有文件重名,将覆盖已有文件)
        /// 重命名(如果新文件名与已有文件重名,将覆盖已有文件) /// </summary>
        /// </summary> /// <param name="strOldFileName">旧文件名</param>
        /// <param name="strOldFileName">旧文件名</param> /// <param name="strNewFileName">新文件名</param>
        /// <param name="strNewFileName">新文件名</param> public void Rename(string strOldFileName,string strNewFileName)
        public void Rename(string strOldFileName,string strNewFileName)
 
         {
{ if(!bConnected)
            if(!bConnected)
 
             {
{ Connect();
                Connect(); }
            } SendCommand("RNFR "+strOldFileName);
            SendCommand("RNFR "+strOldFileName); if(iReplyCode != 350)
            if(iReplyCode != 350)
 
             {
{ throw new IOException(strReply.Substring(4));
                throw new IOException(strReply.Substring(4)); }
            } //  如果新文件名与原有文件重名,将覆盖原有文件
            //  如果新文件名与原有文件重名,将覆盖原有文件 SendCommand("RNTO "+strNewFileName);
            SendCommand("RNTO "+strNewFileName); if(iReplyCode != 250)
            if(iReplyCode != 250)
 
             {
{ throw new IOException(strReply.Substring(4));
                throw new IOException(strReply.Substring(4)); }
            } }
        } #endregion
        #endregion

 上传和下载#region 上传和下载
        上传和下载#region 上传和下载
 /**//// <summary>
        /**//// <summary> /// 下载一批文件
        /// 下载一批文件 /// </summary>
        /// </summary> /// <param name="strFileNameMask">文件名的匹配字符串</param>
        /// <param name="strFileNameMask">文件名的匹配字符串</param> /// <param name="strFolder">本地目录(不得以\结束)</param>
        /// <param name="strFolder">本地目录(不得以\结束)</param> public void Get(string strFileNameMask,string strFolder)
        public void Get(string strFileNameMask,string strFolder)
 
         {
{ if(!bConnected)
            if(!bConnected)
 
             {
{ Connect();
                Connect(); }
            } string[] strFiles = Dir(strFileNameMask);
            string[] strFiles = Dir(strFileNameMask); foreach(string strFile in strFiles)
            foreach(string strFile in strFiles)
 
             {
{ if(!strFile.Equals(""))//一般来说strFiles的最后一个元素可能是空字符串
                if(!strFile.Equals(""))//一般来说strFiles的最后一个元素可能是空字符串
 
                 {
{ Get(strFile,strFolder,strFile);
                    Get(strFile,strFolder,strFile); }
                } }
            } }
        } 
    

 /**//// <summary>
        /**//// <summary> /// 下载一个文件
        /// 下载一个文件 /// </summary>
        /// </summary> /// <param name="strRemoteFileName">要下载的文件名</param>
        /// <param name="strRemoteFileName">要下载的文件名</param> /// <param name="strFolder">本地目录(不得以\结束)</param>
        /// <param name="strFolder">本地目录(不得以\结束)</param> /// <param name="strLocalFileName">保存在本地时的文件名</param>
        /// <param name="strLocalFileName">保存在本地时的文件名</param> public void Get(string strRemoteFileName,string strFolder,string strLocalFileName)
        public void Get(string strRemoteFileName,string strFolder,string strLocalFileName)
 
         {
{ if(!bConnected)
            if(!bConnected)
 
             {
{ Connect();
                Connect(); }
            } SetTransferType(TransferType.Binary);
            SetTransferType(TransferType.Binary); if (strLocalFileName.Equals(""))
            if (strLocalFileName.Equals(""))
 
             {
{ strLocalFileName = strRemoteFileName;
                strLocalFileName = strRemoteFileName; }
            } //            if(!File.Exists(strFolder + "\\" + strLocalFileName))
            //            if(!File.Exists(strFolder + "\\" + strLocalFileName)) //            {
            //            { //                Stream st = File.Create(strFolder + "\\" + strLocalFileName);
            //                Stream st = File.Create(strFolder + "\\" + strLocalFileName); //                st.Close();
            //                st.Close(); //            }
            //            } FileStream output = new
            FileStream output = new  FileStream(strFolder + "\\" + strLocalFileName,FileMode.Create);
                FileStream(strFolder + "\\" + strLocalFileName,FileMode.Create); Socket socketData = CreateDataSocket();
            Socket socketData = CreateDataSocket(); SendCommand("RETR " + strRemoteFileName);
            SendCommand("RETR " + strRemoteFileName); if(!(iReplyCode == 150 || iReplyCode == 125
            if(!(iReplyCode == 150 || iReplyCode == 125 || iReplyCode == 226 || iReplyCode == 250))
                || iReplyCode == 226 || iReplyCode == 250))
 
             {
{ throw new IOException(strReply.Substring(4));
                throw new IOException(strReply.Substring(4)); }
            } while(true)
            while(true)
 
             {
{ int iBytes = socketData.Receive(buffer, buffer.Length, 0);
                int iBytes = socketData.Receive(buffer, buffer.Length, 0); output.Write(buffer,0,iBytes);
                output.Write(buffer,0,iBytes); if(iBytes <= 0)
                if(iBytes <= 0)
 
                 {
{ break;
                    break; }
                } }
            } output.Close();
            output.Close(); if (socketData.Connected)
            if (socketData.Connected)
 
             {
{ socketData.Close();
                socketData.Close(); }
            } if(!(iReplyCode == 226 || iReplyCode == 250))
            if(!(iReplyCode == 226 || iReplyCode == 250))
 
             {
{ ReadReply();
                ReadReply(); if(!(iReplyCode == 226 || iReplyCode == 250))
                if(!(iReplyCode == 226 || iReplyCode == 250))
 
                 {
{ throw new IOException(strReply.Substring(4));
                    throw new IOException(strReply.Substring(4)); }
                } }
            } }
        }

 /**//// <summary>
        /**//// <summary> /// 下载一个文件
        /// 下载一个文件 /// </summary>
        /// </summary> /// <param name="strRemoteFileName">要下载的文件名</param>
        /// <param name="strRemoteFileName">要下载的文件名</param> /// <param name="strFolder">本地目录(不得以\结束)</param>
        /// <param name="strFolder">本地目录(不得以\结束)</param> /// <param name="strLocalFileName">保存在本地时的文件名</param>
        /// <param name="strLocalFileName">保存在本地时的文件名</param> public void Get(string strRemoteFileName,string strFolder,string strLocalFileName,ProgressBarControl p1)
        public void Get(string strRemoteFileName,string strFolder,string strLocalFileName,ProgressBarControl p1)
 
         {
{ if(!bConnected)
            if(!bConnected)
 
             {
{ Connect();
                Connect(); }
            } SetTransferType(TransferType.Binary);
            SetTransferType(TransferType.Binary); if (strLocalFileName.Equals(""))
            if (strLocalFileName.Equals(""))
 
             {
{ strLocalFileName = strRemoteFileName;
                strLocalFileName = strRemoteFileName; }
            } //            if(!File.Exists(strFolder + "\\" + strLocalFileName))
            //            if(!File.Exists(strFolder + "\\" + strLocalFileName)) //            {
            //            { //                Stream st = File.Create(strFolder + "\\" + strLocalFileName);
            //                Stream st = File.Create(strFolder + "\\" + strLocalFileName); //                st.Close();
            //                st.Close(); //            }
            //            } FileStream output = new
            FileStream output = new  FileStream(strFolder + "\\" + strLocalFileName,FileMode.Create);
                FileStream(strFolder + "\\" + strLocalFileName,FileMode.Create); Socket socketData = CreateDataSocket();
            Socket socketData = CreateDataSocket(); SendCommand("RETR " + strRemoteFileName);
            SendCommand("RETR " + strRemoteFileName); if(!(iReplyCode == 150 || iReplyCode == 125
            if(!(iReplyCode == 150 || iReplyCode == 125 || iReplyCode == 226 || iReplyCode == 250))
                || iReplyCode == 226 || iReplyCode == 250))
 
             {
{ throw new IOException(strReply.Substring(4));
                throw new IOException(strReply.Substring(4)); }
            }
 //add by jy
            //add by jy int iBytes = 0;
            int iBytes = 0; int FileSize = Convert.ToInt32(output.Length)/256000;
            int FileSize = Convert.ToInt32(output.Length)/256000; p1.Properties.Maximum = FileSize;
            p1.Properties.Maximum = FileSize; int count = 0;
            int count = 0; while(true)
            while(true)
 
             {
{ while((iBytes = socketData.Receive(buffer, buffer.Length, 0))>0)
                while((iBytes = socketData.Receive(buffer, buffer.Length, 0))>0)
 
                 {
{ count += 1;
                    count += 1; if(count == 500)
                    if(count == 500)
 
                     {
{ p1.Position +=1;
                        p1.Position +=1; count = 0;
                        count = 0; }
                    } output.Write(buffer,0,iBytes);
                    output.Write(buffer,0,iBytes); }
                } if(iBytes <= 0)
                if(iBytes <= 0)
 
                 {
{ break;
                    break; }
                } }
            } output.Close();
            output.Close(); if(p1.Position  != FileSize)
            if(p1.Position  != FileSize) p1.Position += 1;
                p1.Position += 1;
 if (socketData.Connected)
            if (socketData.Connected)
 
             {
{ socketData.Close();
                socketData.Close(); }
            } if(!(iReplyCode == 226 || iReplyCode == 250))
            if(!(iReplyCode == 226 || iReplyCode == 250))
 
             {
{ ReadReply();
                ReadReply(); if(!(iReplyCode == 226 || iReplyCode == 250))
                if(!(iReplyCode == 226 || iReplyCode == 250))
 
                 {
{ throw new IOException(strReply.Substring(4));
                    throw new IOException(strReply.Substring(4)); }
                } }
            } }
        }
 不带进度条参数的上传方法#region 不带进度条参数的上传方法
        不带进度条参数的上传方法#region 不带进度条参数的上传方法
 /**//// <summary>
        /**//// <summary> /// 上传一批文件
        /// 上传一批文件 /// </summary>
        /// </summary> /// <param name="strFolder">本地目录(不得以\结束)</param>
        /// <param name="strFolder">本地目录(不得以\结束)</param> /// <param name="strFileNameMask">文件名匹配字符(可以包含*和?)</param>
        /// <param name="strFileNameMask">文件名匹配字符(可以包含*和?)</param> public void Put(string strFolder,string strFileNameMask)
        public void Put(string strFolder,string strFileNameMask)
 
         {
{ string[] strFiles = Directory.GetFiles(strFolder,strFileNameMask);
            string[] strFiles = Directory.GetFiles(strFolder,strFileNameMask); foreach(string strFile in strFiles)
            foreach(string strFile in strFiles)
 
             {
{ //strFile是完整的文件名(包含路径)
                //strFile是完整的文件名(包含路径) Put(strFile);
                Put(strFile); }
            } }
        } 
    
 /**//// <summary>
        /**//// <summary> /// 上传一个文件
        /// 上传一个文件 /// </summary>
        /// </summary> /// <param name="strFileName">本地文件名</param>
        /// <param name="strFileName">本地文件名</param> public void Put(string strFileName)
        public void Put(string strFileName)
 
         {
{ if(!bConnected)
            if(!bConnected)
 
             {
{ Connect();
                Connect(); }
            } Socket socketData = CreateDataSocket();
            Socket socketData = CreateDataSocket(); SendCommand("STOR "+Path.GetFileName(strFileName));
            SendCommand("STOR "+Path.GetFileName(strFileName)); if( !(iReplyCode == 125 || iReplyCode == 150) )
            if( !(iReplyCode == 125 || iReplyCode == 150) )
 
             {
{ throw new IOException(strReply.Substring(4));
                throw new IOException(strReply.Substring(4)); }
            } 
             FileStream input = new
            FileStream input = new  FileStream(strFileName,FileMode.Open);
                FileStream(strFileName,FileMode.Open); int iBytes = 0;
            int iBytes = 0; while ((iBytes = input.Read(buffer,0,buffer.Length)) > 0)
            while ((iBytes = input.Read(buffer,0,buffer.Length)) > 0)
 
             {
{ socketData.Send(buffer, iBytes, 0);
                socketData.Send(buffer, iBytes, 0); }
            } input.Close();
            input.Close(); if (socketData.Connected)
            if (socketData.Connected)
 
             {
{ socketData.Close();
                socketData.Close(); }
            } if(!(iReplyCode == 226 || iReplyCode == 250))
            if(!(iReplyCode == 226 || iReplyCode == 250))
 
             {
{ ReadReply();
                ReadReply(); if(!(iReplyCode == 226 || iReplyCode == 250))
                if(!(iReplyCode == 226 || iReplyCode == 250))
 
                 {
{ throw new IOException(strReply.Substring(4));
                    throw new IOException(strReply.Substring(4)); }
                } }
            } }
        } 
         #endregion
        #endregion
 /**//// <summary>
        /**//// <summary> /// 上传一个文件
        /// 上传一个文件 /// </summary>
        /// </summary> /// <param name="strFileName">本地文件名</param>
        /// <param name="strFileName">本地文件名</param> public void PutByGuid(string strFileName,string strGuid,ProgressBarControl p1)
        public void PutByGuid(string strFileName,string strGuid,ProgressBarControl p1)
 
         {
{ if(!bConnected)
            if(!bConnected)
 
             {
{ Connect();
                Connect(); }
            } string str = strFileName.Substring(0,strFileName.LastIndexOf("\\"));
            string str = strFileName.Substring(0,strFileName.LastIndexOf("\\")); string strTypeName = strFileName.Substring(strFileName.LastIndexOf("."));
            string strTypeName = strFileName.Substring(strFileName.LastIndexOf(".")); strGuid = str + "\\" + strGuid ;
            strGuid = str + "\\" + strGuid ; 
             System.IO.File.Move(strFileName,strGuid);
            System.IO.File.Move(strFileName,strGuid);
 //add by wzy
            //add by wzy System.IO.File.SetAttributes(strGuid,System.IO.FileAttributes.Normal);
            System.IO.File.SetAttributes(strGuid,System.IO.FileAttributes.Normal); Socket socketData = CreateDataSocket();
            Socket socketData = CreateDataSocket(); SendCommand("STOR "+Path.GetFileName(strGuid));
            SendCommand("STOR "+Path.GetFileName(strGuid)); if( !(iReplyCode == 125 || iReplyCode == 150) )
            if( !(iReplyCode == 125 || iReplyCode == 150) )
 
             {
{ throw new IOException(strReply.Substring(4));
                throw new IOException(strReply.Substring(4)); }
            } //change by wzy
            //change by wzy FileStream input = new FileStream(strGuid,FileMode.Open,System.IO.FileAccess.Read,System.IO.FileShare.Read);
            FileStream input = new FileStream(strGuid,FileMode.Open,System.IO.FileAccess.Read,System.IO.FileShare.Read); 
             int iBytes = 0;
            int iBytes = 0; int FileSize = Convert.ToInt32(input.Length)/256000;
            int FileSize = Convert.ToInt32(input.Length)/256000; p1.Properties.Maximum = FileSize;
            p1.Properties.Maximum = FileSize; int count = 0;
            int count = 0; while ((iBytes = input.Read(buffer,0,buffer.Length)) > 0)
            while ((iBytes = input.Read(buffer,0,buffer.Length)) > 0)
 
             {
{ count += 1;
                count += 1; if(count == 500)
                if(count == 500)
 
                 {
{ p1.Position +=1;
                    p1.Position +=1; count = 0;
                    count = 0; }
                } socketData.Send(buffer, iBytes, 0);
                socketData.Send(buffer, iBytes, 0); }
            } input.Close();
            input.Close(); if(p1.Position  != FileSize)
            if(p1.Position  != FileSize) p1.Position += 1;
                p1.Position += 1; 
             System.IO.File.Move(strGuid,strFileName);
            System.IO.File.Move(strGuid,strFileName); if (socketData.Connected)
            if (socketData.Connected)
 
             {
{ socketData.Close();
                socketData.Close(); }
            } if(!(iReplyCode == 226 || iReplyCode == 250))
            if(!(iReplyCode == 226 || iReplyCode == 250))
 
             {
{ ReadReply();
                ReadReply(); if(!(iReplyCode == 226 || iReplyCode == 250))
                if(!(iReplyCode == 226 || iReplyCode == 250))
 
                 {
{ throw new IOException(strReply.Substring(4));
                    throw new IOException(strReply.Substring(4)); }
                } }
            } }
        } #endregion
        #endregion

 目录操作#region 目录操作
        目录操作#region 目录操作
 /**//// <summary>
        /**//// <summary> /// 创建目录
        /// 创建目录 /// </summary>
        /// </summary> /// <param name="strDirName">目录名</param>
        /// <param name="strDirName">目录名</param> public void MkDir(string strDirName)
        public void MkDir(string strDirName)
 
         {
{ if(!bConnected)
            if(!bConnected)
 
             {
{ Connect();
                Connect(); }
            } SendCommand("MKD "+strDirName);
            SendCommand("MKD "+strDirName); if(iReplyCode != 257)
            if(iReplyCode != 257)
 
             {
{ throw new IOException(strReply.Substring(4));
                throw new IOException(strReply.Substring(4)); }
            } }
        } 
     
 
 /**//// <summary>
        /**//// <summary> /// 删除目录
        /// 删除目录 /// </summary>
        /// </summary> /// <param name="strDirName">目录名</param>
        /// <param name="strDirName">目录名</param> public void RmDir(string strDirName)
        public void RmDir(string strDirName)
 
         {
{ if(!bConnected)
            if(!bConnected)
 
             {
{ Connect();
                Connect(); }
            } SendCommand("RMD "+strDirName);
            SendCommand("RMD "+strDirName); if(iReplyCode != 250)
            if(iReplyCode != 250)
 
             {
{ throw new IOException(strReply.Substring(4));
                throw new IOException(strReply.Substring(4)); }
            } }
        } 
     
 
 /**//// <summary>
        /**//// <summary> /// 改变目录
        /// 改变目录 /// </summary>
        /// </summary> /// <param name="strDirName">新的工作目录名</param>
        /// <param name="strDirName">新的工作目录名</param> public void ChDir(string strDirName)
        public void ChDir(string strDirName)
 
         {
{ if(strDirName.Equals(".") || strDirName.Equals(""))
            if(strDirName.Equals(".") || strDirName.Equals(""))
 
             {
{ return;
                return; }
            } if(!bConnected)
            if(!bConnected)
 
             {
{ Connect();
                Connect(); }
            } SendCommand("CWD "+strDirName);
            SendCommand("CWD "+strDirName); if(iReplyCode != 250)
            if(iReplyCode != 250)
 
             {
{ throw new IOException(strReply.Substring(4));
                throw new IOException(strReply.Substring(4)); }
            } this.strRemotePath = strDirName;
            this.strRemotePath = strDirName; }
        } 
     #endregion
        #endregion

 内部变量#region 内部变量
        内部变量#region 内部变量
 /**//// <summary>
        /**//// <summary> /// 服务器返回的应答信息(包含应答码)
        /// 服务器返回的应答信息(包含应答码) /// </summary>
        /// </summary> private string strMsg;
        private string strMsg;
 /**//// <summary>
        /**//// <summary> /// 服务器返回的应答信息(包含应答码)
        /// 服务器返回的应答信息(包含应答码) /// </summary>
        /// </summary> private string strReply;
        private string strReply;
 /**//// <summary>
        /**//// <summary> /// 服务器返回的应答码
        /// 服务器返回的应答码 /// </summary>
        /// </summary> private int iReplyCode;
        private int iReplyCode;
 /**//// <summary>
        /**//// <summary> /// 进行控制连接的socket
        /// 进行控制连接的socket /// </summary>
        /// </summary> private Socket socketControl;
        private Socket socketControl;
 /**//// <summary>
        /**//// <summary> /// 传输模式
        /// 传输模式 /// </summary>
        /// </summary> private TransferType trType;
        private TransferType trType;
 /**//// <summary>
        /**//// <summary> /// 接收和发送数据的缓冲区
        /// 接收和发送数据的缓冲区 /// </summary>
        /// </summary> private static int BLOCK_SIZE = 512;
        private static int BLOCK_SIZE = 512; Byte[] buffer = new Byte[BLOCK_SIZE];
        Byte[] buffer = new Byte[BLOCK_SIZE];
 /**//// <summary>
        /**//// <summary> /// 编码方式
        /// 编码方式 /// </summary>
        /// </summary> Encoding ASCII = Encoding.ASCII;
        Encoding ASCII = Encoding.ASCII; #endregion
        #endregion

 内部函数#region 内部函数
        内部函数#region 内部函数
 /**//// <summary>
        /**//// <summary> /// 将一行应答字符串记录在strReply和strMsg
        /// 将一行应答字符串记录在strReply和strMsg /// 应答码记录在iReplyCode
        /// 应答码记录在iReplyCode /// </summary>
        /// </summary> private void ReadReply()
        private void ReadReply()
 
         {
{ strMsg = "";
            strMsg = ""; strReply = ReadLine();
            strReply = ReadLine(); iReplyCode = Int32.Parse(strReply.Substring(0,3));
            iReplyCode = Int32.Parse(strReply.Substring(0,3)); }
        }

 /**//// <summary>
        /**//// <summary> /// 建立进行数据连接的socket
        /// 建立进行数据连接的socket /// </summary>
        /// </summary> /// <returns>数据连接socket</returns>
        /// <returns>数据连接socket</returns> private Socket CreateDataSocket()
        private Socket CreateDataSocket()
 
         {
{ SendCommand("PASV");
            SendCommand("PASV"); if(iReplyCode != 227)
            if(iReplyCode != 227)
 
             {
{ throw new IOException(strReply.Substring(4));
                throw new IOException(strReply.Substring(4)); }
            } int index1 = strReply.IndexOf('(');
            int index1 = strReply.IndexOf('('); int index2 = strReply.IndexOf(')');
            int index2 = strReply.IndexOf(')'); string ipData =
            string ipData =  strReply.Substring(index1+1,index2-index1-1);
                strReply.Substring(index1+1,index2-index1-1); int[] parts = new int[6];
            int[] parts = new int[6]; int len = ipData.Length;
            int len = ipData.Length; int partCount = 0;
            int partCount = 0; string buf="";
            string buf=""; for (int i = 0; i < len && partCount <= 6; i++)
            for (int i = 0; i < len && partCount <= 6; i++)
 
             {
{ char ch = Char.Parse(ipData.Substring(i,1));
                char ch = Char.Parse(ipData.Substring(i,1)); if (Char.IsDigit(ch))
                if (Char.IsDigit(ch)) buf+=ch;
                    buf+=ch; else if (ch != ',')
                else if (ch != ',')
 
                 {
{ throw new IOException("Malformed PASV strReply: " +
                    throw new IOException("Malformed PASV strReply: " +  strReply);
                        strReply); }
                } if (ch == ',' || i+1 == len)
                if (ch == ',' || i+1 == len)
 
                 {
{ try
                    try
 
                     {
{ parts[partCount++] = Int32.Parse(buf);
                        parts[partCount++] = Int32.Parse(buf); buf="";
                        buf=""; }
                    } catch (Exception)
                    catch (Exception)
 
                     {
{ throw new IOException("Malformed PASV strReply: " +
                        throw new IOException("Malformed PASV strReply: " +  strReply);
                            strReply); }
                    } }
                } }
            } string ipAddress = parts[0] + "."+ parts[1]+ "." +
            string ipAddress = parts[0] + "."+ parts[1]+ "." + parts[2] + "." + parts[3];
                parts[2] + "." + parts[3]; int port = (parts[4] << 8) + parts[5];
            int port = (parts[4] << 8) + parts[5]; Socket s = new
            Socket s = new  Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
                Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp); IPEndPoint ep = new
            IPEndPoint ep = new  IPEndPoint(IPAddress.Parse(ipAddress), port);
                IPEndPoint(IPAddress.Parse(ipAddress), port); try
            try
 
             {
{ s.Connect(ep);
                s.Connect(ep); }
            } catch(Exception)
            catch(Exception)
 
             {
{ throw new IOException("Can't connect to remote server");
                throw new IOException("Can't connect to remote server"); }
            } return s;
            return s; }
        }
 
 
 /**//// <summary>
        /**//// <summary> /// 关闭socket连接(用于登录以前)
        /// 关闭socket连接(用于登录以前) /// </summary>
        /// </summary> private void CloseSocketConnect()
        private void CloseSocketConnect()
 
         {
{ if(socketControl!=null)
            if(socketControl!=null)
 
             {
{ socketControl.Close();
                socketControl.Close(); socketControl = null;
                socketControl = null; }
            } bConnected = false;
            bConnected = false; }
        } 
 
 /**//// <summary>
        /**//// <summary> /// 读取Socket返回的所有字符串
        /// 读取Socket返回的所有字符串 /// </summary>
        /// </summary> /// <returns>包含应答码的字符串行</returns>
        /// <returns>包含应答码的字符串行</returns> private string ReadLine()
        private string ReadLine()
 
         {
{ while(true)
            while(true)
 
             {
{ int iBytes = socketControl.Receive(buffer, buffer.Length, 0);
                int iBytes = socketControl.Receive(buffer, buffer.Length, 0); strMsg += ASCII.GetString(buffer, 0, iBytes);
                strMsg += ASCII.GetString(buffer, 0, iBytes); if(iBytes < buffer.Length)
                if(iBytes < buffer.Length)
 
                 {
{ break;
                    break; }
                } }
            }
 char[] seperator =
            char[] seperator =  {'\n'};
{'\n'}; string[] mess = strMsg.Split(seperator);
            string[] mess = strMsg.Split(seperator); if(strMsg.Length > 2)
            if(strMsg.Length > 2)
 
             {
{ strMsg = mess[mess.Length-2];
                strMsg = mess[mess.Length-2]; //seperator[0]是10,换行符是由13和0组成的,分隔后10后面虽没有字符串,
                //seperator[0]是10,换行符是由13和0组成的,分隔后10后面虽没有字符串, //但也会分配为空字符串给后面(也是最后一个)字符串数组,
                //但也会分配为空字符串给后面(也是最后一个)字符串数组, //所以最后一个mess是没用的空字符串
                //所以最后一个mess是没用的空字符串 //但为什么不直接取mess[0],因为只有最后一行字符串应答码与信息之间有空格
                //但为什么不直接取mess[0],因为只有最后一行字符串应答码与信息之间有空格 }
            } else
            else
 
             {
{ strMsg = mess[0];
                strMsg = mess[0]; }
            } if(!strMsg.Substring(3,1).Equals(" "))//返回字符串正确的是以应答码(如220开头,后面接一空格,再接问候字符串)
            if(!strMsg.Substring(3,1).Equals(" "))//返回字符串正确的是以应答码(如220开头,后面接一空格,再接问候字符串)
 
             {
{ return ReadLine();
                return ReadLine(); }
            } return strMsg;
            return strMsg; }
        }


 /**//// <summary>
        /**//// <summary> /// 发送命令并获取应答码和最后一行应答字符串
        /// 发送命令并获取应答码和最后一行应答字符串 /// </summary>
        /// </summary> /// <param name="strCommand">命令</param>
        /// <param name="strCommand">命令</param> private void SendCommand(String strCommand)
        private void SendCommand(String strCommand)
 
         {
{ try
            try
 
             {
{ Byte[] cmdBytes =
                Byte[] cmdBytes =  Encoding.ASCII.GetBytes((strCommand+"\r\n").ToCharArray());
                    Encoding.ASCII.GetBytes((strCommand+"\r\n").ToCharArray()); socketControl.Send(cmdBytes, cmdBytes.Length, 0);
                socketControl.Send(cmdBytes, cmdBytes.Length, 0); ReadReply();
                ReadReply(); }
            } catch
            catch
 
             {
{
 }
            } 
             }
        }
 #endregion
        #endregion }
    } }
}
建立附件操作基类FileOperator.cs
 using System;
using System; using System.Drawing;
using System.Drawing; using System.Collections;
using System.Collections; using System.ComponentModel;
using System.ComponentModel; using System.Windows.Forms;
using System.Windows.Forms; using System.Data;
using System.Data; using DevExpress.XtraEditors;
using DevExpress.XtraEditors; using System.IO;
using System.IO;

 namespace WindowsApplication6
namespace WindowsApplication6

 {
{
 /**//// <summary>
    /**//// <summary> /// 文件操作集合类
    /// 文件操作集合类 /// 为其他模块提供文件操作方法
    /// 为其他模块提供文件操作方法 /// </summary>
    /// </summary> public class FileOperator
    public class FileOperator
 
     {
{ public FileOperator()
        public FileOperator()
 
         {
{ //
            // // TODO: 在此处添加构造函数逻辑
            // TODO: 在此处添加构造函数逻辑 //
            // }
        } 
         
         private bool b_sign;
        private bool b_sign;
 /**//// <summary>
        /**//// <summary> /// 文件集合操作标志 true 操作成功 false 操作失败
        /// 文件集合操作标志 true 操作成功 false 操作失败 /// </summary>
        /// </summary> public bool b_OperatorSign
        public bool b_OperatorSign
 
         {
{ get
            get
 
             {
{ return b_sign;
                return b_sign; }
            } }
        }
 附件操作方法集合#region 附件操作方法集合
        附件操作方法集合#region 附件操作方法集合
 /**//// <summary>
        /**//// <summary> /// 写附件至服务器
        /// 写附件至服务器 /// </summary>
        /// </summary> /// <param name="fileName">原文件路径("c:\tt\a.txt")</param>
        /// <param name="fileName">原文件路径("c:\tt\a.txt")</param> /// <param name="guidname">服务器文件名("asdf-wer-46wer.doc")</param>
        /// <param name="guidname">服务器文件名("asdf-wer-46wer.doc")</param> public bool writeAttach(string fileName,string guidname,ProgressBarControl p1)
        public bool writeAttach(string fileName,string guidname,ProgressBarControl p1)
 
         {
{ FTPClient ftp = new FTPClient();
            FTPClient ftp = new FTPClient(); try
            try
 
             {
{ ftp = this.getFtpClient();
                ftp = this.getFtpClient(); ftp.PutByGuid(fileName,guidname,p1);
                ftp.PutByGuid(fileName,guidname,p1); }
            } catch(Exception ft)
            catch(Exception ft)
 
             {
{ string s = ft.Message;
                string s = ft.Message; ftp.DisConnect();
                ftp.DisConnect(); XtraMessageBox.Show("传输失败!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
                XtraMessageBox.Show("传输失败!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Asterisk); return false;
                return false; }
            } ftp.DisConnect();
            ftp.DisConnect(); return true;
            return true; }
        } public bool newwriteAttach(string fileName,string guidname)
        public bool newwriteAttach(string fileName,string guidname)
 
         {
{ FTPClient ftp = new FTPClient();
            FTPClient ftp = new FTPClient(); try
            try
 
             {
{ 
                 ftp = this.getFtpClient();
                ftp = this.getFtpClient(); ftp.newPutByGuid(fileName,guidname);
                ftp.newPutByGuid(fileName,guidname); }
            } catch(Exception ft)
            catch(Exception ft)
 
             {
{ ftp.DisConnect();
                ftp.DisConnect(); XtraMessageBox.Show("传输失败!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
                XtraMessageBox.Show("传输失败!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Asterisk); return false;
                return false; }
            } ftp.DisConnect();
            ftp.DisConnect(); return true;
            return true; }
        }
 /**//// <summary>
        /**//// <summary> /// 删除附件
        /// 删除附件 /// </summary>
        /// </summary> /// <param name="fileName">删除服务器的文件名("a.txt")</param>
        /// <param name="fileName">删除服务器的文件名("a.txt")</param> 
     public bool delAttach(string fileName)
        public bool delAttach(string fileName)
 
         {
{ FTPClient ftp = new FTPClient();
            FTPClient ftp = new FTPClient(); try
            try
 
             {
{ 
                 ftp = this.getFtpClient();
                ftp = this.getFtpClient(); ftp.Delete(fileName);
                ftp.Delete(fileName); }
            } catch(Exception ft)
            catch(Exception ft)
 
             {
{ XtraMessageBox.Show("删除失败!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
                XtraMessageBox.Show("删除失败!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Asterisk); ftp.DisConnect();
                ftp.DisConnect(); return false;
                return false; }
            } ftp.DisConnect();
            ftp.DisConnect(); return true;
            return true; }
        }
 /**//// <summary>
        /**//// <summary> /// 打开附件
        /// 打开附件 /// </summary>
        /// </summary> /// <param name="fileName"></param>
        /// <param name="fileName"></param> public void openAttach(string fileName)
        public void openAttach(string fileName)
 
         {
{ 
             string path =Path.GetTempPath();
            string path =Path.GetTempPath(); FTPClient ftp = new FTPClient();
            FTPClient ftp = new FTPClient(); if(!System.IO.Directory.Exists(path))
            if(!System.IO.Directory.Exists(path)) System.IO.Directory.CreateDirectory(path);
                System.IO.Directory.CreateDirectory(path); try
            try
 
             {
{ 
                 ftp = this.getFtpClient();
                ftp = this.getFtpClient(); ftp.Get(fileName,path,fileName);
                ftp.Get(fileName,path,fileName); }
            } catch(Exception ft)
            catch(Exception ft)
 
             {
{ string s = ft.Message;
                string s = ft.Message; XtraMessageBox.Show("网络传输错误!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
                XtraMessageBox.Show("网络传输错误!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Asterisk); ftp.DisConnect();
                ftp.DisConnect(); }
            } System.Diagnostics.Process p =  new System.Diagnostics.Process();
            System.Diagnostics.Process p =  new System.Diagnostics.Process(); p.StartInfo.FileName = path + "\\" + fileName;
            p.StartInfo.FileName = path + "\\" + fileName; p.StartInfo.UseShellExecute = true;
            p.StartInfo.UseShellExecute = true;
 try
            try
 
             {
{ p.Start();
                p.Start(); }
            } catch
            catch
 
             {
{ XtraMessageBox.Show("无法打开文件,系统无关联后缀名 !", "提示", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
                XtraMessageBox.Show("无法打开文件,系统无关联后缀名 !", "提示", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
 }
            } ftp.DisConnect();
            ftp.DisConnect();
 }
        }
 /**//// <summary>
        /**//// <summary> /// 下载附件
        /// 下载附件 /// </summary>
        /// </summary> /// <param name="fileName"></param>
        /// <param name="fileName"></param> public void getAttach(string fileName,string path,ProgressBarControl p1)
        public void getAttach(string fileName,string path,ProgressBarControl p1)
 
         {
{ FTPClient ftp = new FTPClient();
            FTPClient ftp = new FTPClient(); if(!System.IO.Directory.Exists(path))
            if(!System.IO.Directory.Exists(path)) System.IO.Directory.CreateDirectory(path);
                System.IO.Directory.CreateDirectory(path); try
            try
 
             {
{ ftp = this.getFtpClient();
                ftp = this.getFtpClient(); //fileName:要下载的文件名 path:本地目录 fileName:保存在本地时的文件名 p1 滚动条
                //fileName:要下载的文件名 path:本地目录 fileName:保存在本地时的文件名 p1 滚动条 ftp.Get(fileName,path,fileName,p1);
                ftp.Get(fileName,path,fileName,p1); }
            } catch(Exception ft)
            catch(Exception ft)
 
             {
{ string s = ft.Message;
                string s = ft.Message; XtraMessageBox.Show("网络传输错误!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
                XtraMessageBox.Show("网络传输错误!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Asterisk); ftp.DisConnect();
                ftp.DisConnect(); }
            } ftp.DisConnect();
            ftp.DisConnect();
 }
        }

 /**//// <summary>
        /**//// <summary> /// 下载附件
        /// 下载附件 /// </summary>
        /// </summary> /// <param name="ftpfileName">要下载的文件名</param>
        /// <param name="ftpfileName">要下载的文件名</param> /// <param name="path">本地目录</param>
        /// <param name="path">本地目录</param> /// <param name="localfileName">保存在本地时的文件名</param>
        /// <param name="localfileName">保存在本地时的文件名</param> /// <param name="p1">滚动条</param>
        /// <param name="p1">滚动条</param> public void getAttach(string ftpfileName,string path,string localfileName,ProgressBarControl p1)
        public void getAttach(string ftpfileName,string path,string localfileName,ProgressBarControl p1)
 
         {
{ FTPClient ftp = new FTPClient();
            FTPClient ftp = new FTPClient(); if(!System.IO.Directory.Exists(path))
            if(!System.IO.Directory.Exists(path)) System.IO.Directory.CreateDirectory(path);
                System.IO.Directory.CreateDirectory(path); try
            try
 
             {
{ ftp = this.getFtpClient();
                ftp = this.getFtpClient(); //fileName:要下载的文件名 path:本地目录 localfileName:保存在本地时的文件名 p1 滚动条
                //fileName:要下载的文件名 path:本地目录 localfileName:保存在本地时的文件名 p1 滚动条 ftp.Get(ftpfileName,path,localfileName,p1);
                ftp.Get(ftpfileName,path,localfileName,p1); b_sign=true;
                b_sign=true; }
            } catch(Exception ft)
            catch(Exception ft)
 
             {
{ string s = ft.Message;
                string s = ft.Message; XtraMessageBox.Show("网络传输错误!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
                XtraMessageBox.Show("网络传输错误!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Asterisk); ftp.DisConnect();
                ftp.DisConnect(); b_sign=false;
                b_sign=false; }
            } ftp.DisConnect();
            ftp.DisConnect(); }
        }
 public void newgetAttach(string fileName,string path)
        public void newgetAttach(string fileName,string path)
 
         {
{ FTPClient ftp = new FTPClient();
            FTPClient ftp = new FTPClient(); if(!System.IO.Directory.Exists(path))
            if(!System.IO.Directory.Exists(path)) System.IO.Directory.CreateDirectory(path);
                System.IO.Directory.CreateDirectory(path); try
            try
 
             {
{ ftp = this.getFtpClient();
                ftp = this.getFtpClient(); ftp.Get(fileName,path,fileName);
                ftp.Get(fileName,path,fileName); }
            } catch(Exception ft)
            catch(Exception ft)
 
             {
{ string s = ft.Message;
                string s = ft.Message; XtraMessageBox.Show("网络传输错误!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
                XtraMessageBox.Show("网络传输错误!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Asterisk); ftp.DisConnect();
                ftp.DisConnect(); }
            } ftp.DisConnect();
            ftp.DisConnect(); }
        }

 /**//// <summary>
        /**//// <summary> ///得到ftp传输对象
        ///得到ftp传输对象 /// </summary>
        /// </summary> public FTPClient  getFtpClient()
        public FTPClient  getFtpClient()
 
         {
{ string strHost = System.Configuration.ConfigurationSettings.AppSettings["FtpServer"].ToString();
            string strHost = System.Configuration.ConfigurationSettings.AppSettings["FtpServer"].ToString(); string strUser = System.Configuration.ConfigurationSettings.AppSettings["FtpUser"].ToString();
            string strUser = System.Configuration.ConfigurationSettings.AppSettings["FtpUser"].ToString(); string strPwd = System.Configuration.ConfigurationSettings.AppSettings["FtpPwd"].ToString();
            string strPwd = System.Configuration.ConfigurationSettings.AppSettings["FtpPwd"].ToString(); 
             FTPClient ft = new FTPClient();
            FTPClient ft = new FTPClient(); ft.RemoteHost = strHost;
            ft.RemoteHost = strHost; ft.RemotePort = 21;
            ft.RemotePort = 21; ft.RemoteUser = strUser;
            ft.RemoteUser = strUser; ft.RemotePass = strPwd;
            ft.RemotePass = strPwd; 
             return ft ;
            return ft ; }
        } #endregion
        #endregion }
    } }
}
 
                    
                 
                
            
         
         浙公网安备 33010602011771号
浙公网安备 33010602011771号