通过Windows服务进行FTP与服务器之间文件的传输

                  这几天做了一个关于FTP与服务器之间文件互相传输的Windows服务，本地开发的时候非常顺利，很快就开发完成了，可是将服务部署到服务器上的时候，却出现了许多的意外，让人防不胜防，今天就总结一下我在工作过程中遇到的问题。

                  先上我的代码吧，然后再讲解（代码主要是记录给我自己看的，可以直接跳过看问题）：

                  1.这是Program.cs文件的代码：

using System.ServiceProcess;

namespace ECI.SW.HandleStorageMessageService
{
    static class Program
    {
        /// <summary>
        /// 应用程序的主入口点。
        /// <author>Asa</author>
        /// <createDate>2019/06/20</createDate>
        /// </summary>
        static void Main()
        {
            ServiceBase[] ServicesToRun;
            ServicesToRun = new ServiceBase[]
            {
                // 实例化我的服务类
                new HandleStorageMessageService()
            };
            
            // 运行服务类
            ServiceBase.Run(ServicesToRun);

            #region test code begin

            // 控制台方式调用服务类中的方法
            // ServiceExcute.GygHandleMessage();

            #endregion test code end
        }
    }
}

            2.HandleStorageMessageService类中的代码

using ECI.SW.HandleStorageMessageService.Model;
using NPOI.HSSF.UserModel;
using NPOI.SS.UserModel;
using NPOI.XSSF.UserModel;
using PL.Base;
using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.ServiceProcess;
using System.Text;
using System.Timers;
using System.Xml;

namespace ECI.SW.HandleStorageMessageService
{
    /// <summary>
    /// 电子口岸发送企业集装箱堆场数据服务
    /// <author>Asa</author>
    /// <createDate>2019/06/13</createDate>
    /// </summary>
    public partial class HandleStorageMessageService : ServiceBase
    {
        /// <summary>
        /// 构造函数
        /// <author>Asa</author>
        /// <createDate>2019/06/20</createDate>
        /// </summary>
        public HandleStorageMessageService()
        {
            InitializeComponent();
        }

        /// <summary>
        /// 服务启动时执行
        /// <author>Asa</author>
        /// <createDate>2019/06/20</createDate>
        /// </summary>
        /// <param name="args">args</param>
        protected override void OnStart(string[] args)
        {
                // 控制台方式调试时注释掉
            //ServiceExcute.Init();
        }

        /// <summary>
        /// 服务停止时执行
        /// <author>Asa</author>
        /// <createDate>2019/06/20</createDate>
        /// </summary>
        protected override void OnStop()
        {

        }
    }

    /// <summary>
    /// 处理堆场信息
    /// <author>Asa</author>
    /// <createDate>2019/06/14</createDate>
    /// </summary>
    public class ServiceExcute
    {
        // 定义一个定时器（控制台方式调试时注释掉）
        private static Timer timer;

        /// <summary>
        /// 初始化定时器（控制台方式调试时注释掉）
        /// <author>Asa</author>
        /// <createDate>2019/06/14</createDate>
        /// </summary>
        public static void Init()
        {
            try
            {
                // 数据来源
                string DataSource = EciConfig.Read("DataSource");
                // timer执行间隔时间
                int seconds = Convert.ToInt32(EciConfig.Read("ReadFileTime")) * 60000;
                timer = new Timer(seconds);
                if (DataSource.Equals("GYG"))
                {
                    timer.Elapsed += new ElapsedEventHandler(GygHandleMessage);
                }
                // 是否使用定时器
                timer.Enabled = true;
            }
            catch (Exception ex)
            {
                Log.Write("init出错：" + ex.Message, "initCatch");
            }
        }

        /// <summary>
        /// 果园港(Gyg)堆场数据文件处理 object sender, EventArgs e
        /// <author>Asa</author>
        /// <createDate>2019/06/14</createDate>
        /// </summary>
        /// <param name="sender">sender</param>
        /// <param name="e">e</param>
        public static void GygHandleMessage(object sender, EventArgs e)
        {
            try
            {
                    // 字母转ASCII码，这里不需要 
                // AlphabetToNumber();
                
                #region 读取配置信息，声明必要的对象--BEGIN（这里因为我需要将读取的Excel转为XML保存到服务器，所以配置了很多地址，按自己需要配置）

                // 读取FTP访问地址
                string ftpPath = EciConfig.Read("ftpPath");
                // 读取ftp访问用户名
                string userName = EciConfig.Read("userName");
                // 读取ftp访问密码
                string pwd = EciConfig.Read("pwd");
                // 读取excel文件保存的路径
                string saveExcelFilePath = EciConfig.Read("saveExcelFilePath");
                // 读取xml文件保存的路径
                string saveXmlFilePath = EciConfig.Read("saveXmlFilePath");
                // 读取单一窗口服务器上回执报文保存的地址
                string readXmlFilePath = EciConfig.Read("readXmlFilePath");
                // 读取sheetname
                string sheetName = EciConfig.Read("sheetName");
                // 实例化一个Datatable对象接收Excel转换的Datatable（这里顺便可以学习npoi读取Excel并转Datatable的方法）
                DataTable excelDt = new DataTable();

                #endregion 读取配置信息，声明必要的对象--END

                #region 处理堆场数据--BEGIN

                // 连接FTP，这里使用了一个我的FTPhelper类，等会儿会贴上来
                Common.FTP.FtpHelper ftpHelper = new Common.FTP.FtpHelper(ftpPath, "", userName, pwd);
                // 获取FTP上的文件列表
                string[] fileNameArray = ftpHelper.GetFileList("");
                // 判断文件列表是否为空
                if (fileNameArray != null)
                {
                    // 遍历文件列表，从FTP服务器下载对应文件
                    foreach (string fileName in fileNameArray)
                    {
                        #region 判断是否是Excel文件

                        // 获取文件拓展名
                        string extensionName = fileName.Substring(fileName.LastIndexOf("."));
                        // 获取文件名
                        string fileNameNoExtension = fileName.Substring(0, fileName.LastIndexOf("."));
                        // 判断文件是否是Excel文件
                        if (!extensionName.Equals(".xls") && !extensionName.Equals(".xlsx"))
                        {
                            continue;
                        }

                        #endregion

                        #region 下载堆场数据Excel文件--BEGIN

                        // 判断保存Excel文件的路径是否存在，如果不存在就创建该地址
                        if (!Directory.Exists(saveExcelFilePath))
                            Directory.CreateDirectory(saveExcelFilePath);

                        // 判断文件是否已下载,如果已下载则跳过
                        if (File.Exists(saveExcelFilePath + "/" + fileName))
                            continue;

                        // 根据文件名下载文件
                        ftpHelper.Download(saveExcelFilePath, fileName);

                        #endregion 下载堆场数据Excel文件--END

                        #region 处理堆场数据Excel文件（这一块是我对读取到的FTP文件做的我自己的业务需求处理，可以不看）--BEGIN

                        #region XML头信息实体--BEGIN

                        // 当前时间
                        DateTime datetimeNow = DateTime.Now;
                        // 报文编码
                        string msgId = "01" + "CNCQI800028" + datetimeNow.ToString("yyyyMMddHHmmssfff");
                        // 实例化XML头实体对象
                        SwStorageMessageHead swStorageMessageHead = new SwStorageMessageHead();
                        // 报文编码
                        swStorageMessageHead.MSG_ID = msgId;
                        // 报文类型
                        swStorageMessageHead.MSG_TYPE = "CSA01";
                        // 关卡代码
                        swStorageMessageHead.CUSTOMS_CODE = "8007";
                        // 作业场所编号
                        swStorageMessageHead.SUPV_LOCT_CODE = "CNCQI800028";
                        // 报文发送时间
                        swStorageMessageHead.DECL_DATE = datetimeNow.ToString();
                        // 申报数据类型
                        swStorageMessageHead.DECLARE_DATE_TYPE = "0";
                        // 申报数据报文总数
                        swStorageMessageHead.TOTAL_MSG_NO = "1";
                        // 当前报文序号
                        swStorageMessageHead.CUR_MSG_NO = "1";

                        // 堆场信息XML文件头数据插入SQL语句
                        StringBuilder insertHeadBuilder = new StringBuilder();
                        BuildHeadInsertSql(insertHeadBuilder, swStorageMessageHead);

                        try
                        {
                            // 初始化connectionstring连接字符串对象
                            EciServer.InitFramework();
                            // 插入XML头数据
                            DBHelper.ExecuteNoneQuery(insertHeadBuilder.ToString());
                        }
                        catch (Exception ex)
                        {
                            Log.Write("SwStorageMessageHead插入失败：" + ex.Message, "InsertErr");
                        }

                        #endregion XML头信息实体--END

                        #region XML基础信息写入--BEGIN

                        // 实例化一个操作XML文件的对象
                        XmlDocument xmldoc = new XmlDocument();
                        // 实例化一个填写版本等信息的XML节点对象（创建具有指定值的xmldeclaration节点）
                        XmlNode versionNode = xmldoc.CreateXmlDeclaration("1.0", "UTF-8", "");
                        // 将指定的节点添加到子节点列表的末尾
                        xmldoc.AppendChild(versionNode);
                        // 创建xmldocument中的单个节点（根节点）
                        XmlNode rootNode = xmldoc.CreateElement("ContaDeclareInfo");
                        // 将根节点添加到子节点列表的末尾
                        xmldoc.AppendChild(rootNode);

                        #endregion XML基础信息写入--END

                        #region xml信息写入--BEGIN

                        // 创建XML头节点
                        CreateHeadNode(xmldoc, rootNode, swStorageMessageHead);
                        // 创建XML--Declaratioin节点
                        XmlNode declareationNode = xmldoc.CreateNode(XmlNodeType.Element, "Declaratioin", null);

                        try
                        {
                            // 调用读取Excel转换为Datatable的方法
                            excelDt = ReadExcelToDataTable(saveExcelFilePath + "\\" + fileName, sheetName);
                        }
                        catch (Exception dtEx)
                        {
                            Log.Write("Excel转换为Datatable出错：" + dtEx.Message, "ToDatatableErr");
                        }

                        if (excelDt != null && excelDt.Rows.Count > 0)
                            // 执行数据插入list表并生成对应Declaratioin--XML节点
                            InsertListDbAndCreateListXmlExecute(excelDt, msgId, xmldoc, declareationNode);

                        // 将Declaratioin节点添加到根节点
                        rootNode.AppendChild(declareationNode);

                        #endregion xml信息写入--END

                        #region 保存创建的XML文件--BEGIN

                        try
                        {
                            xmldoc.Save(saveXmlFilePath + "\\" + fileNameNoExtension + ".xml");
                        }
                        catch (Exception ex)
                        {
                            Log.Write("保存xml文件失败：" + ex.Message, "saveXmlErr");
                        }

                        #endregion 保存创建的XML文件--END

                        #endregion 处理堆场数据Excel文件--END
                    }
                }

                #endregion 处理堆场数据--END

                // 处理回执报文信息
                HandleResponseXml(readXmlFilePath, ftpHelper);
            }
            catch (Exception ex)
            {
                Log.Write("UnExpectedError：" + ex.Message, "UnExpectedError");
            }
        }

         // 这下面都是我的工具方法，可以不看
        // 字母转换为ASCII码数字
        public static string AlphabetToNumber()
        {
            byte[] array = new byte[1]; //定义一组数组array
            array = Encoding.ASCII.GetBytes("E"); //string转换的字母
            int asciicode = (short)(array[0]);
            string ascii = Convert.ToString(asciicode); //将转换一的ASCII码转换成string型
            return ascii;
        }

        /// <summary>
        /// 读取Excel文件并转化为Datatable
        /// <author>Asa</author>
        /// <createDate>2019/06/20</createDate>
        /// </summary>
        /// <param name="filePath">文件地址</param>
        /// <param name="sheetname">sheet名称</param>
        /// <returns></returns>
        public static DataTable ReadExcelToDataTable(string filePath, string sheetname)
        {
            #region 实例化必要的对象--BEGIN

            // 声明一个IWorkbook对象
            IWorkbook workbook = null;
            // 实例化一个ISheet对象，用来接收读取到的sheet
            ISheet sheet = null;
            // 实例化一个Datatable对象
            DataTable dt = new DataTable();
            // 判断文件是否存在，不存在返回空
            if (!File.Exists(filePath))
                return null;
            // 将读取到的文件转为文件流
            FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read);

            #endregion 实例化必要的对象--END

            #region 根据Excel文件的版本使用不同的IWorkbook对象--BEGIN

            // 判断读取到的Excel文件的版本
            if (filePath.IndexOf(".xlsx") > 0)
            {
                // 2007版本
                workbook = new XSSFWorkbook(fs);
            }
            else if (filePath.IndexOf(".xls") > 0)
            {
                // 2003版本
                workbook = new HSSFWorkbook(fs);
            }

            #endregion 根据Excel文件的版本使用不同的IWorkbook对象--END

            // 接收读取到的sheet
            sheet = workbook.GetSheet(sheetname);

            #region 对sheet表进行处理==>转换为Datatable--BEGIN

            var rows = sheet.GetRowEnumerator();
            while (rows.MoveNext())
            {
                IRow row = rows.Current as IRow;
                if (row.RowNum == 0)
                {
                    row.Cells.ForEach(cell =>
                    {
                        dt.Columns.Add(cell.StringCellValue);
                    });
                }
                else
                {
                    var dr = dt.NewRow();
                    for (int i = 0; i < row.Cells.Count; i++)
                    {
                        dr[i] = row.Cells[i].ToString();
                    }
                    dt.Rows.Add(dr);
                }
            }

            #endregion 对sheet表进行处理==>转换为Datatable--END

            return dt;
        }

        /// <summary>
        /// 处理回执报文
        /// <author>Asa</author>
        /// <createDate>2019/06/19</createDate>
        /// </summary>
        /// <param name="readXmlFilePath">读取回执报文的路径</param>
        /// <param name="fileNameArray">FTP服务器上现有的文件名列表</param>
        /// <param name="ftpHelper">FTP工具类对象</param>
        public static void HandleResponseXml(string readXmlFilePath, Common.FTP.FtpHelper ftpHelper)
        {
            // 获取文件列表
            string[] fileNameArr = ftpHelper.GetFileList("");
            // 读取所有的回执报文XML文件
            DirectoryInfo receiptXmlList = new DirectoryInfo(readXmlFilePath);
            // 遍历文件列表，获取XML文件
            foreach (FileInfo receiptXml in receiptXmlList.GetFiles("*.xml"))
            {
                // 实例化一个XML操作对象
                XmlDocument xmldoc = new XmlDocument();
                // 通过URL加载XML文件
                xmldoc.Load(receiptXml.FullName);
                // 定义一个标记判断报文是否已存在
                bool isExists = false;

                #region 上传读取的回执XML文件--BEGIN

                try
                {
                    // 遍历FTP文件列表
                    foreach (string fileName in fileNameArr)
                    {
                        // 判断回执报文是否已存在，已存在则不上传
                        if (fileName.Equals(receiptXml.Name))
                        {
                            isExists = true;
                            break;
                        }
                    }

                    // 如果回执报文不存在，则上传
                    if (!isExists)
                        ftpHelper.Upload(receiptXml.FullName);
                    else
                        continue;
                }
                catch (Exception ex)
                {
                    Log.Write("上传xml回执文件失败：" + ex.Message, "saveXmlErr");
                }

                #endregion 上传读取的回执XML文件--END

                #region 回执报文数据入库--BEGIN

                #region 获取回执报文XML节点--BEGIN

                // 报文编码
                XmlNode msgId = xmldoc.SelectSingleNode("//MsgId");
                // 报文类型
                XmlNode msgType = xmldoc.SelectSingleNode("//MsgType");
                // 关卡代码
                XmlNode customsCode = xmldoc.SelectSingleNode("//CustomsCode");
                // 作业场所编码
                XmlNode supvLoctCode = xmldoc.SelectSingleNode("//SupvLoctCode");
                // 报文发送时间
                XmlNode declDate = xmldoc.SelectSingleNode("//DeclDate");
                // 回执结果
                XmlNode result = xmldoc.SelectSingleNode("//Result");
                // 备注信息
                XmlNode remark = xmldoc.SelectSingleNode("//Remark");

                #endregion 回执报文数据入库--END

                #region 回执报文表头实体赋值--BEGIN

                // 回执报文表头实体赋值
                SwStorageResponseHead swStorageResponseHead = new SwStorageResponseHead();
                swStorageResponseHead.MSG_ID = msgId.InnerText;
                swStorageResponseHead.MSG_TYPE = msgType.InnerText;
                swStorageResponseHead.CUSTOMS_CODE = customsCode.InnerText;
                swStorageResponseHead.SUPV_LOCT_CODE = supvLoctCode.InnerText;
                swStorageResponseHead.DECL_DATE = declDate.InnerText;
                // 实例化一个stringbuilder对象用来拼接表头插入语句
                StringBuilder insertResponseHeadBuilder = new StringBuilder();
                BuildResponseHeadInserSql(insertResponseHeadBuilder, swStorageResponseHead);

                #endregion 回执报文表头实体赋值--END

                #region 执行回执报文表头数据入库--BEGIN

                try
                {
                    // 初始化connectionstring连接字符串对象
                    EciServer.InitFramework();
                    // 插入XML头数据
                    DBHelper.ExecuteNoneQuery(insertResponseHeadBuilder.ToString());
                }
                catch (Exception ex)
                {
                    Log.Write("SwStorageResponseHead插入失败：" + ex.Message, "InsertErr");
                }

                #endregion 执行回执报文表头数据入库--END

                #region 回执报文表体实体赋值--BEGIN

                // 回执报文表体赋值
                SwStorageResponseList swStorageResponseList = new SwStorageResponseList();
                swStorageResponseList.MSG_ID = msgId.InnerText;
                swStorageResponseList.RESULT = result.InnerText;
                swStorageResponseList.REMARK = remark.InnerText;
                // 实例化一个stringbuilder对象拼接表体插入语句
                StringBuilder insertResponseListBuilder = new StringBuilder();
                BuildResponseListInserSql(insertResponseListBuilder, swStorageResponseList);

                #endregion 回执报文表体实体赋值--END

                #region 执行回执报文表体数据入库--BEGIN

                try
                {
                    // 初始化connectionstring连接字符串对象
                    EciServer.InitFramework();
                    // 插入XML头数据
                    DBHelper.ExecuteNoneQuery(insertResponseListBuilder.ToString());
                }
                catch (Exception ex)
                {
                    Log.Write("SwStorageResponseList插入失败：" + ex.Message, "InsertErr");
                }

                #endregion 执行回执报文表体数据入库--END


                #endregion 回执报文数据入库--END

            }
        }

        /// <summary>
        /// 执行数据插入list表并生成对应Declaratioin--XML节点
        /// <author>Asa</author>
        /// <createDate>2019/06/18</createDate>
        /// </summary>
        /// <param name="ds">读取Excel生成的dataset</param>
        /// <param name="msgId">报文编码</param>
        /// <param name="xmldoc">xmldocument对象</param>
        /// <param name="declareationNode">Declaratioin节点</param>
        public static void InsertListDbAndCreateListXmlExecute(DataTable excelDt, string msgId, XmlDocument xmldoc, XmlNode declareationNode)
        {
            // 遍历dataset，读取Excel中的堆场数据并存入表中
            for (int i = 3; i < excelDt.Rows.Count; i++)
            {
                #region XML数据信息实体--BEGIN

                SwStorageMessageList swStorageMessageList = new SwStorageMessageList();
                // 报文编码
                swStorageMessageList.MSG_ID = msgId;
                // 集装箱号
                swStorageMessageList.CONTA_ID = excelDt.Rows[i][4].ToString();
                // 判断是否是列名，如果是列名就跳过这一行
                if (swStorageMessageList.CONTA_ID.Equals("箱号") || swStorageMessageList.CONTA_ID.NullOrEmpty())
                    continue;
                // 集装箱尺寸
                swStorageMessageList.CONTA_TYPE_CODE = excelDt.Rows[i][5].ToString();
                // 箱位代码
                swStorageMessageList.SEAT = excelDt.Rows[i][15].ToString();
                // 将箱位代码转换为正确的格式
                swStorageMessageList.SEAT = swStorageMessageList.SEAT.Replace("-", "/0");

                #region 内外贸标识--BEGIN

                swStorageMessageList.TRADE_MARK = excelDt.Rows[i][2].ToString();
                if (swStorageMessageList.TRADE_MARK.Equals("内贸"))
                    swStorageMessageList.TRADE_MARK = "D";
                else if (swStorageMessageList.TRADE_MARK.Equals("外贸"))
                    swStorageMessageList.TRADE_MARK = "I";
                else
                    swStorageMessageList.TRADE_MARK = "O";

                #endregion 内外贸标识--END

                #region 进出口标识--BEGIN

                swStorageMessageList.IE_FLAG = excelDt.Rows[i][10].ToString();
                if (swStorageMessageList.IE_FLAG.Equals("进口"))
                    swStorageMessageList.IE_FLAG = "I";
                else if (swStorageMessageList.IE_FLAG.Equals("出口"))
                    swStorageMessageList.IE_FLAG = "E";

                #endregion 进出口标识--END

                // 拼箱状态
                swStorageMessageList.CONTA_MARK = "";
                // 装载状态
                swStorageMessageList.LOAD_MARK = excelDt.Rows[i][7].ToString();
                // 危品柜状态
                swStorageMessageList.DANGER_MARK = "";
                // 进场时间
                swStorageMessageList.ENTRANCE_DATE = excelDt.Rows[i][23].ToString();
                // 出场时间
                swStorageMessageList.DEPART_TRUE_DATE = "";
                // 当前状态
                swStorageMessageList.WORK_MARK = "A";
                // 数据处理标识
                swStorageMessageList.DATA_DEAL_FLAG = "A";
                // 提单号
                swStorageMessageList.BILL_NO = excelDt.Rows[i][14].ToString();
                // 报关单号
                swStorageMessageList.ENTRY_ID = "";
                // 转关单号
                swStorageMessageList.PRE_NO = "";
                // 多式联运单号
                swStorageMessageList.MT_APPLY_NO = "";
                // 备注
                swStorageMessageList.REMARK = "备注信息";
                // 计划状态
                swStorageMessageList.PLAN_STATUS = excelDt.Rows[i][1].ToString();
                // 是否中转
                swStorageMessageList.IS_TRANSFER = excelDt.Rows[i][3].ToString();
                // 箱型
                swStorageMessageList.CONTA_TYPE = excelDt.Rows[i][6].ToString();
                // 箱货类
                swStorageMessageList.CONTA_GOODS_TYPE = excelDt.Rows[i][8].ToString();
                // 货柜
                swStorageMessageList.CONTAINER = excelDt.Rows[i][9].ToString();
                // 箱主
                swStorageMessageList.CONTA_OWNER = excelDt.Rows[i][11].ToString();
                // 船公司
                swStorageMessageList.BOAT_COMPANY = excelDt.Rows[i][12].ToString();
                // 代理公司
                swStorageMessageList.AGENT_COMPANY = excelDt.Rows[i][13].ToString();
                // 铅封
                swStorageMessageList.LEAD_SEALING = excelDt.Rows[i][16].ToString();
                // 破损说明
                swStorageMessageList.DAMAGE_DESCRIPTION = excelDt.Rows[i][17].ToString();
                // 破损代码
                swStorageMessageList.DAMAGE_CODE = excelDt.Rows[i][18].ToString();
                // 进口船名
                swStorageMessageList.I_BOAT_NAME = excelDt.Rows[i][19].ToString();
                // 进口航次
                swStorageMessageList.I_BOAT_VOYAGENO = excelDt.Rows[i][20].ToString();
                // 出口船名
                swStorageMessageList.E_BOAT_NAME = excelDt.Rows[i][21].ToString();
                // 出口航次
                swStorageMessageList.E_BOAT_VOYAGENO = excelDt.Rows[i][22].ToString();
                // 堆存天
                swStorageMessageList.STORAGE_DATE = excelDt.Rows[i][24].ToString();
                // 货名
                swStorageMessageList.GOODS_NAME = excelDt.Rows[i][25].ToString();
                // 总重
                swStorageMessageList.TOTAL_WEIGHT = excelDt.Rows[i][26].ToString();
                // 货重
                swStorageMessageList.GOODS_WEIGHT = excelDt.Rows[i][27].ToString();

                // 堆场表体数据插入SQL语句
                StringBuilder insertBodyBuilder = new StringBuilder();
                BuildListInsertSql(insertBodyBuilder, swStorageMessageList);

                try
                {
                    // 初始化connectionstring连接字符串对象
                    EciServer.InitFramework();
                    DBHelper.ExecuteNoneQuery(insertBodyBuilder.ToString());
                }
                catch (Exception ex)
                {
                    Log.Write("SwStorageMessageList插入失败：" + ex.Message, "InsertErr");
                }

                #endregion XML数据信息实体--END

                // 创建XML-->Declaration节点的子节点（Data）信息
                CreateDataNode(xmldoc, declareationNode, swStorageMessageList);
            }
        }

        /// <summary>
        /// 创建XML头节点的信息
        /// <author>Asa</author>
        /// <createDate>2019/06/18</createDate>
        /// </summary>
        /// <param name="xmldoc">XmlDocument对象</param>
        /// <param name="rootNode">根节点</param>
        /// <param name="swStorageMessageHead">头信息实体对象</param>
        public static void CreateHeadNode(XmlDocument xmldoc, XmlNode rootNode, SwStorageMessageHead swStorageMessageHead)
        {
            // 声明一个装载XML头信息的节点
            XmlNode headNode = xmldoc.CreateNode(XmlNodeType.Element, "Head", null);
            // 报文编码节点
            XmlNode msgIdNode = xmldoc.CreateNode(XmlNodeType.Element, "MsgId", null);
            // 报文类型节点
            XmlNode msgTypeNode = xmldoc.CreateNode(XmlNodeType.Element, "MsgType", null);
            // 关卡代码节点
            XmlNode customsCodeNode = xmldoc.CreateNode(XmlNodeType.Element, "CustomsCode", null);
            // 作业场所编号节点
            XmlNode supvLoctCodeNode = xmldoc.CreateNode(XmlNodeType.Element, "SupvLoctCode", null);
            // 报文发送时间节点
            XmlNode declDateNode = xmldoc.CreateNode(XmlNodeType.Element, "DeclDate", null);
            // 数据申报类型节点
            XmlNode declareDataTypeNode = xmldoc.CreateNode(XmlNodeType.Element, "DeclareDataType", null);
            // 申报数据报文总数节点
            XmlNode totalMsgNoNode = xmldoc.CreateNode(XmlNodeType.Element, "TotalMsgNo", null);
            // 当前报文序号节点
            XmlNode curMsgNoNode = xmldoc.CreateNode(XmlNodeType.Element, "CurMsgNo", null);
            // 给各个头信息子节点赋值
            msgIdNode.InnerText = swStorageMessageHead.MSG_ID;
            msgTypeNode.InnerText = swStorageMessageHead.MSG_TYPE;
            customsCodeNode.InnerText = swStorageMessageHead.CUSTOMS_CODE;
            supvLoctCodeNode.InnerText = swStorageMessageHead.SUPV_LOCT_CODE;
            declDateNode.InnerText = swStorageMessageHead.DECL_DATE;
            declareDataTypeNode.InnerText = swStorageMessageHead.DECLARE_DATE_TYPE;
            totalMsgNoNode.InnerText = swStorageMessageHead.TOTAL_MSG_NO;
            curMsgNoNode.InnerText = swStorageMessageHead.CUR_MSG_NO;
            // 将各个头信息子节点添加到头信息根节点
            headNode.AppendChild(msgIdNode);
            headNode.AppendChild(msgTypeNode);
            headNode.AppendChild(customsCodeNode);
            headNode.AppendChild(supvLoctCodeNode);
            headNode.AppendChild(declDateNode);
            headNode.AppendChild(declareDataTypeNode);
            headNode.AppendChild(totalMsgNoNode);
            headNode.AppendChild(curMsgNoNode);

            // 将头节点添加到根节点
            rootNode.AppendChild(headNode);
        }

        /// <summary>
        /// 创建XML数据节点的信息
        /// <author>Asa</author>
        /// <createDate>2091/06/18</createDate>
        /// </summary>
        /// <param name="xmldoc">XmlDocument对象</param>
        /// <param name="declareationNode">Declaration节点</param>
        /// <param name="swStorageMessageList"></param>
        public static void CreateDataNode(XmlDocument xmldoc, XmlNode declareationNode, SwStorageMessageList swStorageMessageList)
        {
            // 声明一个装载XML-->Data信息的节点
            XmlNode dataNode = xmldoc.CreateNode(XmlNodeType.Element, "Data", null);
            // 集装箱号
            XmlNode contaId = xmldoc.CreateNode(XmlNodeType.Element, "ContaId", null);
            // 集装箱尺寸
            XmlNode contaTypeCode = xmldoc.CreateNode(XmlNodeType.Element, "ContaTypeCode", null);
            // 箱位代码
            XmlNode seat = xmldoc.CreateNode(XmlNodeType.Element, "Seat", null);
            // 内外贸标识
            XmlNode tradeMark = xmldoc.CreateNode(XmlNodeType.Element, "TradeMark", null);
            // 进出口标识
            XmlNode iEFlag = xmldoc.CreateNode(XmlNodeType.Element, "IEFlag", null);
            // 拼箱状态
            XmlNode contaMark = xmldoc.CreateNode(XmlNodeType.Element, "ContaMark", null);
            // 装载状态
            XmlNode loadMark = xmldoc.CreateNode(XmlNodeType.Element, "LoadMark", null);
            // 危品柜状态
            XmlNode dangerMark = xmldoc.CreateNode(XmlNodeType.Element, "DangerMark", null);
            // 进场时间
            XmlNode entranceDate = xmldoc.CreateNode(XmlNodeType.Element, "EntranceDate", null);
            // 出场时间
            XmlNode departtureDate = xmldoc.CreateNode(XmlNodeType.Element, "DeparttureDate", null);
            // 当前状态
            XmlNode workMark = xmldoc.CreateNode(XmlNodeType.Element, "WorkMark", null);
            // 数据处理标识
            XmlNode dataDealFlag = xmldoc.CreateNode(XmlNodeType.Element, "DataDealFlag", null);
            // 提单号
            XmlNode billNo = xmldoc.CreateNode(XmlNodeType.Element, "BillNo", null);
            // 报关单号
            XmlNode entryId = xmldoc.CreateNode(XmlNodeType.Element, "EntryId", null);
            // 转关单号
            XmlNode preNo = xmldoc.CreateNode(XmlNodeType.Element, "PreNo", null);
            // 多式联运单号
            XmlNode mtApplyBlNo = xmldoc.CreateNode(XmlNodeType.Element, "MtApplyBlNo", null);
            // 备注信息
            XmlNode remark = xmldoc.CreateNode(XmlNodeType.Element, "Remark", null);
            // 给各个Data信息子节点赋值
            contaId.InnerText = swStorageMessageList.CONTA_ID;
            contaTypeCode.InnerText = swStorageMessageList.CONTA_TYPE_CODE;
            seat.InnerText = swStorageMessageList.SEAT;
            tradeMark.InnerText = swStorageMessageList.TRADE_MARK;
            iEFlag.InnerText = swStorageMessageList.IE_FLAG;
            contaMark.InnerText = swStorageMessageList.CONTA_MARK;
            loadMark.InnerText = swStorageMessageList.LOAD_MARK;
            dangerMark.InnerText = swStorageMessageList.DANGER_MARK;
            entranceDate.InnerText = swStorageMessageList.ENTRANCE_DATE;
            departtureDate.InnerText = swStorageMessageList.DEPART_TRUE_DATE;
            workMark.InnerText = swStorageMessageList.WORK_MARK;
            dataDealFlag.InnerText = swStorageMessageList.DATA_DEAL_FLAG;
            billNo.InnerText = swStorageMessageList.BILL_NO;
            entryId.InnerText = swStorageMessageList.ENTRY_ID;
            preNo.InnerText = swStorageMessageList.PRE_NO;
            mtApplyBlNo.InnerText = swStorageMessageList.MT_APPLY_NO;
            remark.InnerText = swStorageMessageList.REMARK;
            // 将各个信息节点加入Data节点
            dataNode.AppendChild(contaId);
            dataNode.AppendChild(contaTypeCode);
            dataNode.AppendChild(seat);
            dataNode.AppendChild(tradeMark);
            dataNode.AppendChild(iEFlag);
            dataNode.AppendChild(contaMark);
            dataNode.AppendChild(loadMark);
            dataNode.AppendChild(dangerMark);
            dataNode.AppendChild(entranceDate);
            dataNode.AppendChild(departtureDate);
            dataNode.AppendChild(workMark);
            dataNode.AppendChild(dataDealFlag);
            dataNode.AppendChild(billNo);
            dataNode.AppendChild(entryId);
            dataNode.AppendChild(preNo);
            dataNode.AppendChild(mtApplyBlNo);
            dataNode.AppendChild(remark);

            // 将data节点加入declareation节点
            declareationNode.AppendChild(dataNode);
        }

        /// <summary>
        /// 构建list表插入SQL语句
        /// <author>Asa</author>
        /// <createDate>2019/06/18</createDate>
        /// </summary>
        /// <param name="insertBodyBuilder">构建插入语句的对象</param>
        /// <param name="swStorageMessageList">插入信息实体</param>
        public static void BuildListInsertSql(StringBuilder insertBodyBuilder, SwStorageMessageList swStorageMessageList)
        {
            insertBodyBuilder.Append("INSERT INTO SW_STORAGE_MESSAGE_LIST(");
            insertBodyBuilder.Append("MSG_ID,CONTA_ID,CONTA_TYPE_CODE,SEAT,TRADE_MARK,IE_FLAG,CONTA_MARK,");
            insertBodyBuilder.Append("LOAD_MARK,DANGER_MARK,ENTRANCE_DATE,DEPART_TRUE_DATE,WORK_MARK,");
            insertBodyBuilder.Append("DATA_DEAL_FLAG,BILL_NO,ENTRY_ID,PRE_NO,MT_APPLY_NO,REMARK,");
            insertBodyBuilder.Append("PLAN_STATUS,IS_TRANSFER,CONTA_TYPE,CONTA_GOODS_TYPE,CONTAINER,");
            insertBodyBuilder.Append("CONTA_OWNER,BOAT_COMPANY,AGENT_COMPANY,LEAD_SEALING,DAMAGE_DESCRIPTION,");
            insertBodyBuilder.Append("DAMAGE_CODE,I_BOAT_NAME,I_BOAT_VOYAGENO,E_BOAT_NAME,E_BOAT_VOYAGENO,STORAGE_DATE,");
            insertBodyBuilder.Append("GOODS_NAME,TOTAL_WEIGHT,GOODS_WEIGHT) VALUES(");
            insertBodyBuilder.Append("'" + swStorageMessageList.MSG_ID + "',");
            insertBodyBuilder.Append("'" + swStorageMessageList.CONTA_ID + "',");
            insertBodyBuilder.Append("'" + swStorageMessageList.CONTA_TYPE_CODE + "',");
            insertBodyBuilder.Append("'" + swStorageMessageList.SEAT + "',");
            insertBodyBuilder.Append("'" + swStorageMessageList.TRADE_MARK + "',");
            insertBodyBuilder.Append("'" + swStorageMessageList.IE_FLAG + "',");
            insertBodyBuilder.Append("'" + swStorageMessageList.CONTA_MARK + "',");
            insertBodyBuilder.Append("'" + swStorageMessageList.LOAD_MARK + "',");
            insertBodyBuilder.Append("'" + swStorageMessageList.DANGER_MARK + "',");
            insertBodyBuilder.Append("to_date('" + swStorageMessageList.ENTRANCE_DATE + "', 'yyyy-MM-dd HH24:mi:ss'),"); //("'" + swStorageMessageList.ENTRANCE_DATE + "'");
            insertBodyBuilder.Append("to_date('" + swStorageMessageList.DEPART_TRUE_DATE + "', 'yyyy-MM-dd HH24:mi:ss'),"); //("'" + swStorageMessageList.DEPART_TRUE_DATE + "'");
            insertBodyBuilder.Append("'" + swStorageMessageList.WORK_MARK + "',");
            insertBodyBuilder.Append("'" + swStorageMessageList.DATA_DEAL_FLAG + "',");
            insertBodyBuilder.Append("'" + swStorageMessageList.BILL_NO + "',");
            insertBodyBuilder.Append("'" + swStorageMessageList.ENTRY_ID + "',");
            insertBodyBuilder.Append("'" + swStorageMessageList.PRE_NO + "',");
            insertBodyBuilder.Append("'" + swStorageMessageList.MT_APPLY_NO + "',");
            insertBodyBuilder.Append("'" + swStorageMessageList.REMARK + "',");
            insertBodyBuilder.Append("'" + swStorageMessageList.PLAN_STATUS + "',");
            insertBodyBuilder.Append("'" + swStorageMessageList.IS_TRANSFER + "',");
            insertBodyBuilder.Append("'" + swStorageMessageList.CONTA_TYPE + "',");
            insertBodyBuilder.Append("'" + swStorageMessageList.CONTA_GOODS_TYPE + "',");
            insertBodyBuilder.Append("'" + swStorageMessageList.CONTAINER + "',");
            insertBodyBuilder.Append("'" + swStorageMessageList.CONTA_OWNER + "',");
            insertBodyBuilder.Append("'" + swStorageMessageList.BOAT_COMPANY + "',");
            insertBodyBuilder.Append("'" + swStorageMessageList.AGENT_COMPANY + "',");
            insertBodyBuilder.Append("'" + swStorageMessageList.LEAD_SEALING + "',");
            insertBodyBuilder.Append("'" + swStorageMessageList.DAMAGE_DESCRIPTION + "',");
            insertBodyBuilder.Append("'" + swStorageMessageList.DAMAGE_CODE + "',");
            insertBodyBuilder.Append("'" + swStorageMessageList.I_BOAT_NAME + "',");
            insertBodyBuilder.Append("'" + swStorageMessageList.I_BOAT_VOYAGENO + "',");
            insertBodyBuilder.Append("'" + swStorageMessageList.E_BOAT_NAME + "',");
            insertBodyBuilder.Append("'" + swStorageMessageList.E_BOAT_VOYAGENO + "',");
            insertBodyBuilder.Append("'" + swStorageMessageList.STORAGE_DATE + "',");
            insertBodyBuilder.Append("'" + swStorageMessageList.GOODS_NAME + "',");
            insertBodyBuilder.Append("'" + swStorageMessageList.TOTAL_WEIGHT + "',");
            insertBodyBuilder.Append("'" + swStorageMessageList.GOODS_WEIGHT + "')");
        }

        /// <summary>
        /// 构建head表插入SQL语句
        /// <author>Asa</author>
        /// <createDate>2019/06/8</createDate>
        /// </summary>
        /// <param name="insertHeadBuilder">构建插入语句的对象</param>
        /// <param name="swStorageMessageHead">插入信息实体</param>
        public static void BuildHeadInsertSql(StringBuilder insertHeadBuilder, SwStorageMessageHead swStorageMessageHead)
        {
            insertHeadBuilder.Append("INSERT INTO SW_STORAGE_MESSAGE_HEAD(");
            insertHeadBuilder.Append("MSG_ID,MSG_TYPE,CUSTOMS_CODE,SUPV_LOCT_CODE,");
            insertHeadBuilder.Append("DECL_DATE,DECLARE_DATE_TYPE,TOTAL_MSG_NO,CUR_MSG_NO) ");
            insertHeadBuilder.Append("VALUES('" + swStorageMessageHead.MSG_ID + "',");
            insertHeadBuilder.Append("'" + swStorageMessageHead.MSG_TYPE + "',");
            insertHeadBuilder.Append("'" + swStorageMessageHead.CUSTOMS_CODE + "',");
            insertHeadBuilder.Append("'" + swStorageMessageHead.SUPV_LOCT_CODE + "',");
            insertHeadBuilder.Append("to_date('" + swStorageMessageHead.DECL_DATE + "', 'yyyy-MM-dd HH24:mi:ss'),");
            insertHeadBuilder.Append("'" + swStorageMessageHead.DECLARE_DATE_TYPE + "',");
            insertHeadBuilder.Append("'" + swStorageMessageHead.TOTAL_MSG_NO + "',");
            insertHeadBuilder.Append("'" + swStorageMessageHead.CUR_MSG_NO + "')");
        }

        /// <summary>
        /// 构建响应报文表头插入SQL语句
        /// <author>Asa</author>
        /// <createDate>2019/06/20</createDate>
        /// </summary>
        /// <param name="insertResponseHeadBuilder">拼接数据插入sql语句StringBuilder对象</param>
        /// <param name="swStorageResponseHead">SwStorageResponseHead实体对象</param>
        public static void BuildResponseHeadInserSql(StringBuilder insertResponseHeadBuilder, SwStorageResponseHead swStorageResponseHead)
        {
            insertResponseHeadBuilder.Append("INSERT INTO SW_STORAGE_RESPONSE_HEAD(MSG_ID,");
            insertResponseHeadBuilder.Append("MSG_TYPE,CUSTOMS_CODE,SUPV_LOCT_CODE,DECL_DATE) VALUES(");
            insertResponseHeadBuilder.Append("'" + swStorageResponseHead.MSG_ID + "',");
            insertResponseHeadBuilder.Append("'" + swStorageResponseHead.MSG_TYPE + "',");
            insertResponseHeadBuilder.Append("'" + swStorageResponseHead.CUSTOMS_CODE + "',");
            insertResponseHeadBuilder.Append("'" + swStorageResponseHead.SUPV_LOCT_CODE + "',");
            insertResponseHeadBuilder.Append("to_date('" + swStorageResponseHead.DECL_DATE + "', 'yyyy-MM-dd HH24:mi:ss'))");//("'" + swStorageResponseHead.DECL_DATE + "')");
        }

        /// <summary>
        /// 构建响应报文表体插入SQL语句
        /// <author>Asa</author>
        /// <createDate>2019/06/20</createDate>
        /// </summary>
        /// <param name="insertResponseListBuilder">拼接数据插入sql语句StringBuilder对象</param>
        /// <param name="swStorageResponseList">SwStorageResponseList实体对象</param>
        public static void BuildResponseListInserSql(StringBuilder insertResponseListBuilder, SwStorageResponseList swStorageResponseList)
        {
            insertResponseListBuilder.Append("INSERT INTO SW_STORAGE_RESPONSE_LIST(MSG_ID,");
            insertResponseListBuilder.Append("RESULT,REMARK) VALUES(");
            insertResponseListBuilder.Append("'" + swStorageResponseList.MSG_ID + "',");
            insertResponseListBuilder.Append("'" + swStorageResponseList.RESULT + "',");
            insertResponseListBuilder.Append("'" + swStorageResponseList.REMARK + "')");
        }
    }
}

                          代码主要是记录给我自己看的，现在说说我在部署过程中遇到的问题吧：

                          当我部署上去的时候，启动服务，但是我从FTP下载文件却一直没成功，下载的方法一直报出操作超时，我改了超时时间也没用

                          想了一下，会不会是FTP的数据端口--20没有开放出来，我用浏览器访问了一下FTP，却又能成功的访问到，排除了这个问题

                            后来和同事研究了很久，才想到可能是FTP的两种传输模式引起的问题，于是我试了一下，将FTP传输模式（）改为了被动式，

                            果然就能成功下载FTP上的文件了。（早先所有客户端都使用主动模式，而且工作的很好，而现在因为客户端防火墙的存在，将会关闭一些

                          端口，这样主动模式将会失败。在这种情况下就要使用被动模式，但是一些端口也可能被服务器的防火墙封掉。不过因为ftp服务器需要它的ftp服                           务连接到一定数量的客户端，所以他们总是支持被动模式的。这就是我们为什么要使用被动模式的原意，为了确保数据可以正确的传输，使用 被动                            模式要明显优于主动模式。）

                            附上我的FTP工具类，需要的小伙伴可以学习一下：

using System;
using System.IO;
using System.Net;
using System.Text;
using System.Web;

namespace ECI.SW.Common.FTP
{
    /// <summary>
    /// <author>Asa</author>
    /// <createDate>2017-03-07</createDate>
    /// <description>FTP工具类</description>
    /// </summary>
    public class FtpHelper
    {
        private readonly string _ftpPassword;
        private readonly string _ftpServerIp;
        private readonly string _ftpUserId;
        private string _ftpRemotePath;
        private string _ftpUri;

        /// <summary>
        /// 连接FTP
        /// </summary>
        /// <param name="ftpServerIp">FTP连接地址</param>
        /// <param name="ftpRemotePath">指定FTP连接成功后的当前目录, 如果不指定即默认为根目录</param>
        /// <param name="ftpUserId">用户名</param>
        /// <param name="ftpPassword">密码</param>
        public FtpHelper(string ftpServerIp, string ftpRemotePath, string ftpUserId, string ftpPassword)
        {
            _ftpServerIp = ftpServerIp;
            _ftpRemotePath = ftpRemotePath;
            _ftpUserId = ftpUserId;
            _ftpPassword = ftpPassword;
            _ftpUri = "ftp://" + _ftpServerIp + "/" + _ftpRemotePath + "/";
        }

        /// <summary>
        /// 上传
        /// </summary>
        /// <param name="filename">文件名称（含路径）</param>
        public void Upload(string filename)
        {
            var fileInf = new FileInfo(filename);
            var uri = _ftpUri + fileInf.Name;

            var reqFtp = (FtpWebRequest)WebRequest.Create(new Uri(uri));
            reqFtp.Credentials = new NetworkCredential(_ftpUserId, _ftpPassword);
            reqFtp.KeepAlive = false;
            reqFtp.Method = WebRequestMethods.Ftp.UploadFile;
            reqFtp.UseBinary = true;
            reqFtp.KeepAlive = true;
            reqFtp.UsePassive = true;
            reqFtp.ContentLength = fileInf.Length;
            reqFtp.ReadWriteTimeout = 60000;
            reqFtp.Timeout = 60000;
            var buffLength = 2048;
            var buff = new byte[buffLength];
            var fs = fileInf.OpenRead();
            try
            {
                var strm = reqFtp.GetRequestStream();
                var contentLen = fs.Read(buff, 0, buffLength);
                while (contentLen != 0)
                {
                    strm.Write(buff, 0, contentLen);
                    contentLen = fs.Read(buff, 0, buffLength);
                }
                strm.Close();
                fs.Close();
            }
            catch (Exception ex)
            {
                throw new Exception("Ftphelper Upload Error --> " + ex.Message);
            }
        }

        /// <summary>
        /// 上传
        /// </summary>
        /// <param name="fileInf">提供对客户端已上载的单独文件的访问</param>
        public void Upload(HttpPostedFile fileInf)
        {
            var uri = _ftpUri + fileInf.FileName;

            var reqFtp = (FtpWebRequest)WebRequest.Create(new Uri(uri));
            reqFtp.Credentials = new NetworkCredential(_ftpUserId, _ftpPassword);
            reqFtp.KeepAlive = false;
            reqFtp.Method = WebRequestMethods.Ftp.UploadFile;
            reqFtp.UseBinary = true;
            reqFtp.UsePassive = false;
            reqFtp.ContentLength = fileInf.ContentLength;
            var buffLength = 2048;
            var buff = new byte[buffLength];
            var fs = fileInf.InputStream;
            try
            {
                var strm = reqFtp.GetRequestStream();
                var contentLen = fs.Read(buff, 0, buffLength);
                while (contentLen != 0)
                {
                    strm.Write(buff, 0, contentLen);
                    contentLen = fs.Read(buff, 0, buffLength);
                }
                strm.Close();
                fs.Close();
            }
            catch (Exception ex)
            {
                throw new Exception("Ftphelper Upload Error --> " + ex.Message);
            }
        }

        /// <summary>
        /// 下载
        /// </summary>
        /// <param name="filePath">保存文件的本地路径</param>
        /// <param name="fileName">要下载的文件名</param>
        public void Download(string filePath, string fileName)
        {
            try
            {
                var outputStream = new FileStream(filePath + "\\" + fileName, FileMode.Create);

                var reqFtp = (FtpWebRequest)WebRequest.Create(new Uri(_ftpUri + fileName));
                reqFtp.Method = WebRequestMethods.Ftp.DownloadFile;
                reqFtp.UseBinary = true;
                reqFtp.KeepAlive = true;
                reqFtp.UsePassive = true;
                reqFtp.Timeout = 60000;
                reqFtp.ReadWriteTimeout = 60000;
                reqFtp.Credentials = new NetworkCredential(_ftpUserId, _ftpPassword);
                var response = (FtpWebResponse)reqFtp.GetResponse();
                var ftpStream = response.GetResponseStream();
                var cl = response.ContentLength;
                var bufferSize = 2048;
                var buffer = new byte[bufferSize];

                if (ftpStream != null)
                {
                    var readCount = ftpStream.Read(buffer, 0, bufferSize);
                    while (readCount > 0)
                    {
                        outputStream.Write(buffer, 0, readCount);
                        readCount = ftpStream.Read(buffer, 0, bufferSize);
                    }
                }
                if (ftpStream != null) ftpStream.Close();
                outputStream.Close();
                response.Close();
            }
            catch (Exception ex)
            {
                throw new Exception("FtpHelper Download Error --> " + ex.Message);
            }
        }

        /// <summary>
        /// 删除文件
        /// </summary>
        /// <param name="fileName">文件名</param>
        public void Delete(string fileName)
        {
            try
            {
                var uri = _ftpUri + fileName;
                var reqFtp = (FtpWebRequest)WebRequest.Create(new Uri(uri));

                reqFtp.Credentials = new NetworkCredential(_ftpUserId, _ftpPassword);
                reqFtp.KeepAlive = false;
                reqFtp.Method = WebRequestMethods.Ftp.DeleteFile;
                reqFtp.UsePassive = false;

                var result = string.Empty;
                var response = (FtpWebResponse)reqFtp.GetResponse();
                var size = response.ContentLength;
                var datastream = response.GetResponseStream();
                if (datastream != null)
                {
                    var sr = new StreamReader(datastream);
                    result = sr.ReadToEnd();
                    sr.Close();
                }
                if (datastream != null) datastream.Close();
                response.Close();
            }
            catch (Exception ex)
            {
                throw new Exception("FtpHelper Delete Error --> " + ex.Message + "  文件名:" + fileName);
            }
        }

        /// <summary>
        /// 删除文件夹
        /// </summary>
        /// <param name="folderName">文件夹名称</param>
        public void RemoveDirectory(string folderName)
        {
            try
            {
                var uri = _ftpUri + folderName;
                var reqFtp = (FtpWebRequest)WebRequest.Create(new Uri(uri));

                reqFtp.Credentials = new NetworkCredential(_ftpUserId, _ftpPassword);
                reqFtp.KeepAlive = false;
                reqFtp.Method = WebRequestMethods.Ftp.RemoveDirectory;
                reqFtp.UsePassive = false;

                var result = string.Empty;
                var response = (FtpWebResponse)reqFtp.GetResponse();
                var size = response.ContentLength;
                var datastream = response.GetResponseStream();
                if (datastream != null)
                {
                    var sr = new StreamReader(datastream);
                    result = sr.ReadToEnd();
                    sr.Close();
                }
                if (datastream != null) datastream.Close();
                response.Close();
            }
            catch (Exception ex)
            {
                throw new Exception("FtpHelper Delete Error --> " + ex.Message + "  文件名:" + folderName);
            }
        }

        /// <summary>
        /// 获取当前目录下明细(包含文件和文件夹)
        /// </summary>
        /// <returns></returns>
        public string[] GetFilesDetailList()
        {
            try
            {
                var result = new StringBuilder();
                var ftp = (FtpWebRequest)WebRequest.Create(new Uri(_ftpUri));
                ftp.Credentials = new NetworkCredential(_ftpUserId, _ftpPassword);
                ftp.Method = WebRequestMethods.Ftp.ListDirectoryDetails;
                ftp.UsePassive = false;
                var response = ftp.GetResponse();
                var reader = new StreamReader(response.GetResponseStream(), Encoding.Default);

                var line = reader.ReadLine();

                while (line != null)
                {
                    result.Append(line);
                    result.Append("\n");
                    line = reader.ReadLine();
                }
                result.Remove(result.ToString().LastIndexOf("\n"), 1);
                reader.Close();
                response.Close();
                return result.ToString().Split('\n');
            }
            catch (Exception ex)
            {
                //downloadFiles = null;
                throw new Exception("FtpHelper  Error --> " + ex.Message);
            }
        }

        /// <summary>
        /// 获取当前目录下文件列表(仅文件)
        /// </summary>
        /// <returns></returns>
        public string[] GetFileList(string mask)
        {
            var result = new StringBuilder();
            try
            {
                var reqFtp = (FtpWebRequest)WebRequest.Create(new Uri(_ftpUri));
                reqFtp.UseBinary = true;
                reqFtp.Credentials = new NetworkCredential(_ftpUserId, _ftpPassword);
                reqFtp.Method = WebRequestMethods.Ftp.ListDirectory;
                reqFtp.KeepAlive = true;
                reqFtp.UsePassive = true;
                reqFtp.Timeout = 60000;
                var response = reqFtp.GetResponse();
                var reader = new StreamReader(response.GetResponseStream(), Encoding.UTF8);

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

        /// <summary>
        /// 获取当前目录下所有的文件夹列表(仅文件夹)
        /// </summary>
        /// <returns></returns>
        public string[] GetDirectoryList()
        {
            var drectory = GetFilesDetailList();
            var m = string.Empty;
            foreach (var str in drectory)
            {
                var dirPos = str.IndexOf("<DIR>");
                if (dirPos > 0)
                {
                    /*判断 Windows 风格*/
                    m += str.Substring(dirPos + 5).Trim() + "\n";
                }
                else if (str.Trim().Substring(0, 1).ToUpper() == "D")
                {
                    /*判断 Unix 风格*/
                    var dir = str.Substring(54).Trim();
                    if ((dir != ".") && (dir != ".."))
                        m += dir + "\n";
                }
            }

            char[] n = { '\n' };
            return m.Split(n);
        }

        /// <summary>
        /// 判断当前目录下指定的子目录是否存在
        /// </summary>
        /// <param name="remoteDirectoryName">指定的目录名</param>
        public bool DirectoryExist(string remoteDirectoryName)
        {
            var dirList = GetDirectoryList();
            foreach (var str in dirList)
                if (str.Trim() == remoteDirectoryName.Trim())
                    return true;
            return false;
        }

        /// <summary>
        /// 判断当前目录下指定的文件是否存在
        /// </summary>
        /// <param name="remoteFileName">远程文件名</param>
        public bool FileExist(string remoteFileName)
        {
            var fileList = GetFileList("*.*");
            foreach (var str in fileList)
                if (str.Trim() == remoteFileName.Trim())
                    return true;
            return false;
        }

        /// <summary>
        /// 创建文件夹
        /// </summary>
        /// <param name="dirName"></param>
        public void MakeDir(string dirName)
        {
            try
            {
                // dirName = name of the directory to create.
                var reqFtp = (FtpWebRequest)WebRequest.Create(new Uri(_ftpUri + dirName));
                reqFtp.Method = WebRequestMethods.Ftp.MakeDirectory;
                reqFtp.UseBinary = true;
                reqFtp.UsePassive = false;
                reqFtp.Credentials = new NetworkCredential(_ftpUserId, _ftpPassword);
                var response = (FtpWebResponse)reqFtp.GetResponse();
                var ftpStream = response.GetResponseStream();

                if (ftpStream != null) ftpStream.Close();
                response.Close();
            }
            catch (Exception ex)
            {
                throw new Exception("FtpHelper MakeDir Error --> " + ex.Message);
            }
        }

        /// <summary>
        /// 获取指定文件大小
        /// </summary>
        /// <param name="filename">文件名称</param>
        /// <returns></returns>
        public long GetFileSize(string filename)
        {
            long fileSize = 0;
            try
            {
                var reqFtp = (FtpWebRequest)WebRequest.Create(new Uri(_ftpUri + filename));
                reqFtp.Method = WebRequestMethods.Ftp.GetFileSize;
                reqFtp.UseBinary = true;
                reqFtp.UsePassive = false;
                reqFtp.Credentials = new NetworkCredential(_ftpUserId, _ftpPassword);
                var response = (FtpWebResponse)reqFtp.GetResponse();
                var ftpStream = response.GetResponseStream();
                fileSize = response.ContentLength;

                ftpStream.Close();
                response.Close();
            }
            catch (Exception ex)
            {
                throw new Exception("FtpHelper GetFileSize Error --> " + ex.Message);
            }
            return fileSize;
        }

        /// <summary>
        /// 改名
        /// </summary>
        /// <param name="currentFilename">当前文件名</param>
        /// <param name="newFilename">新文件名</param>
        public void ReName(string currentFilename, string newFilename)
        {
            try
            {
                var reqFtp = (FtpWebRequest)WebRequest.Create(new Uri(_ftpUri + currentFilename));
                reqFtp.Method = WebRequestMethods.Ftp.Rename;
                reqFtp.RenameTo = newFilename;
                reqFtp.UseBinary = true;
                reqFtp.UsePassive = false;
                reqFtp.Credentials = new NetworkCredential(_ftpUserId, _ftpPassword);
                var response = (FtpWebResponse)reqFtp.GetResponse();
                var ftpStream = response.GetResponseStream();

                if (ftpStream != null) ftpStream.Close();
                response.Close();
            }
            catch (Exception ex)
            {
                throw new Exception("FtpHelper ReName Error --> " + ex.Message);
            }
        }

        /// <summary>
        /// 移动文件
        /// </summary>
        /// <param name="currentFilename">当前文件名</param>
        /// <param name="newDirectory">新文件夹</param>
        public void MovieFile(string currentFilename, string newDirectory)
        {
            ReName(currentFilename, newDirectory);
        }

        /// <summary>
        /// 切换当前目录
        /// </summary>
        /// <param name="directoryName">文件夹名称</param>
        /// <param name="isRoot">true 绝对路径   false 相对路径</param>
        public void GotoDirectory(string directoryName, bool isRoot)
        {
            if (isRoot)
                _ftpRemotePath = directoryName;
            else
                _ftpRemotePath += directoryName + "/";
            _ftpUri = "ftp://" + _ftpServerIp + "/" + _ftpRemotePath + "/";
        }
    }
}