文件操作—Excel，XML，txt

 

Excel

一.读取时遇到的问题

1.未在本地计算机上注册“microsoft.ACE.oledb.12.0”

 

运行环境以及代码：

本地Excel是2013，VS2010  32位的

连接代码：

//连接字符串
string connstring = "Provider=Microsoft.ACE.OLEDB.16.0;Data Source=" + filePath + ";Extended Properties='Excel 8.0;HDR=NO;IMEX=1';"; // Office 07及以上版本 不能出现多余的空格 而且分号注意

 

现状：

1.目标平台的三种模式，生成后都可以正常运行，但是用户电脑就报错：未在本地计算机上注册“microsoft.ACE.oledb.12.0”；

2.用户电脑是office2016；

 

解决方法：

1.官网上下载驱动32位：https://www.microsoft.com/en-us/download/details.aspx?id=13255，注意不要64位的；

2.安装该驱动：AccessDatabaseEngine.exe；

3.将目标平台设置为X86;

 

 二.操作Excel文件

1.OleDB

优点：读取方式简单、读取速度快

缺点：除了读取过程不太灵活之外，这种读取方式还有个弊端就是，当Excel数据量很大时。会非常占用内存，当内存不够时会抛出内存溢出的异常。

把Excel文件当作一个数据源来进行数据的读取操作；

 

连接字符串：Provider=Microsoft.Jet.OLEDB.4.0;Data Source=d:\test.xls;Extended Properties='Excel 8.0;HDR=Yes;IMEX=1;'
provider：表示提供程序名称
Data Source：这里填写Excel文件的路径
Extended Properties：设置Excel的特殊属性
Extended Properties 取值：
Excel 8.0 针对Excel2000及以上版本，Excel5.0 针对Excel97。
HDR=Yes 表示第一行包含列名,在计算行数时就不包含第一行
IMEX 0:导入模式,1:导出模式:2混合模式

 

（1）读取Excel文件

代码：

 public List<DataTable> ReadExcelLOBD(string filePath)
        {
            List<DataTable> list = new List<DataTable>();
            try
            {
                //连接字符串
                string connstring = "Provider=Microsoft.ACE.OLEDB.12.0;Data Source=" + filePath + ";Extended Properties='Excel 8.0;HDR=NO;IMEX=1';"; // Office 07及以上版本 不能出现多余的空格 而且分号注意
                //string connstring = Provider=Microsoft.JET.OLEDB.4.0;Data Source=" + path + ";Extended Properties='Excel 8.0;HDR=NO;IMEX=1';"; //Office 07以下版本 
                using (OleDbConnection conn = new OleDbConnection(connstring))
                {
                    conn.Open();

                    //得到所有sheet的名字
                    DataTable sheetsName = conn.GetOleDbSchemaTable(OleDbSchemaGuid.Tables, new object[] { null, null, null, "Table" }); 

                    DataTable sheetsName1 = new DataTable();
                    sheetsName1.Columns.Add("TABLE");

                    for (int i = 0; i < sheetsName.Rows.Count; i++)
                    {
                        DataRow dr = sheetsName1.NewRow();
                        dr["TABLE"] = sheetsName.Rows[i]["TABLE_NAME"].ToString();
                        sheetsName1.Rows.Add(dr);
                    }

                    for (int i = 0; i < sheetsName1.Rows.Count; i++)
                    {
                        DataSet dtSet = new DataSet();
                        string firstSheetName1 = sheetsName1.Rows[i][0].ToString(); //得到第一个sheet的名字
                        string sql1 = string.Format("SELECT * FROM [{0}]", firstSheetName1); //查询字符串
                        OleDbDataAdapter ada1 = new OleDbDataAdapter(sql1, connstring);
                        ada1.Fill(dtSet);
                        DataTable dt = dtSet.Tables[0];
                        list.Add(dt);
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
                return null;
            }
            return list;
        }

（2）.使用OleDB操作EXCEL文件

将datatable中的数据写入已存在的Excel中

/// <summary>
        /// 将数据写入Excel模板中
        /// </summary>
        /// <param name="filePath"></param>
        public void WriteExcel(string filePath)
        {
            try
            {
                //1.创建Applicaton对象
                Microsoft.Office.Interop.Excel.Application xApp = new Microsoft.Office.Interop.Excel.Application();

                //2.得到workbook对象，打开已有的文件
                Microsoft.Office.Interop.Excel.Workbook xBook = xApp.Workbooks.Open(filePath, Missing.Value, Missing.Value, Missing.Value, Missing.Value, Missing.Value, Missing.Value, Missing.Value, Missing.Value, Missing.Value, Missing.Value, Missing.Value, Missing.Value);

                //3.指定要操作的Sheet
                Microsoft.Office.Interop.Excel.Worksheet xSheet = (Microsoft.Office.Interop.Excel.Worksheet)xBook.Sheets[1];

                //料号，产品型号，版本，打印日期，机器程序名
                string[] msg = txt_message.Text.Split(',');
                //4.向相应对位置写入相应的数据
                //xSheet.Cells[Column(列)][Row(行)] = result;

                //获取所有单元格，设置列格式   
                Microsoft.Office.Interop.Excel.Range myrange = xSheet.Cells;

                //设置单元格文本格式
                myrange.NumberFormatLocal= "@";

                //自动换行
                myrange.WrapText = true;

                //获取第8行第一列到第400行第八列范围内的所有单元格
                Microsoft.Office.Interop.Excel.Range range = xSheet.Range[xSheet.Cells[8,1],xSheet.Cells[400,8]];//.Cells[8];
                //水平居中
                range.HorizontalAlignment = Microsoft.Office.Interop.Excel.XlHAlign.xlHAlignCenter;
                //垂直居中
                range.VerticalAlignment= Microsoft.Office.Interop.Excel.XlHAlign.xlHAlignCenter;

                //表头(1-7行是表头)
                xSheet.Cells[1][4] = "机器程序名:" + msg[4];
                xSheet.Cells[1][6] = "产品型号product type:" + msg[1];
                xSheet.Cells[5][5] = "半成品编号：" + msg[0];
                xSheet.Cells[5][6] = "制表日期：" + msg[3];
                xSheet.Cells[7][5] = "版本：" + msg[2];

                //定义一个集合，用于存放合并单元格的范围值
                List<string> list = new List<string>();
                int index = 8;

                #region 表身
                for (int i = 0; i < dgvTran.Rows.Count; i++)
                {
                    string machine = dgvTran.Rows[i].Cells[0].Value.ToString();//机器
                    string station = dgvTran.Rows[i].Cells[1].Value.ToString()+" "; //站位
                    string itemcode = dgvTran.Rows[i].Cells[2].Value.ToString(); //料号
                    string description = dgvTran.Rows[i].Cells[3].Value.ToString();//描述
                    string numbers = dgvTran.Rows[i].Cells[4].Value.ToString();//用量
                    string positione = dgvTran.Rows[i].Cells[5].Value.ToString();//贴装位置
                    string feidaModel = dgvTran.Rows[i].Cells[6].Value.ToString();//飞达型号

                    //从第8行开始属于表身，将machine的值赋值格Excel表的第a列，第i行单元格
                    xSheet.Cells[1][8 + i] = machine;
                    xSheet.Cells[2][8 + i] = station;
                    xSheet.Cells[3][8 + i] = itemcode;
                    xSheet.Cells[4][8 + i] = description;
                    xSheet.Cells[5][8 + i] = numbers;
                    xSheet.Cells[6][8 + i] = positione;
                    xSheet.Cells[7][8 + i] = feidaModel;

                    //获取合并的范围值
                    if (i != 0)
                    {
                        //获取每个机器号相同的范围
                        if (machine != dgvTran.Rows[i - 1].Cells[0].Value.ToString())
                        {
                            int endIndex = i - 1 + 8;
                            string scope = index + "," + endIndex;   
                            list.Add(scope);
                            index = i + 8;
                        }
                    }
                }


                #endregion
                //关闭EXCEL的提示框
                xApp.DisplayAlerts = false;

                //合并第8行第一列到第8行第三列单元格
                //range = xSheet.Range[xSheet.Cells[8, 1], xSheet.Cells[10, 1]];
                //range.Merge(Missing.Value);

                //合并单元格
                for (int i = 0; i < list.Count; i++)
                {
                    int start = int.Parse(list[i].Split(',')[0].ToString());
                    int end= int.Parse(list[i].Split(',')[1].ToString());
                    range = xSheet.Range[xSheet.Cells[start, 1], xSheet.Cells[end, 1]];
                    range.Merge(Missing.Value);
                }

                int num = 8 + dgvTran.Rows.Count;
                range = xSheet.Range[xSheet.Cells[8, 1], xSheet.Cells[num, 8]];
                //设置整个数据区边框为实线
                range.Borders.LineStyle = 1;


                //5.保存保存WorkBook
                xBook.Save();
                
                //6.从内存中关闭Excel对象
                xSheet = null;
                xBook.Close();
                xBook = null;
               
                //Excel从内存中退出
                xApp.Quit();
                xApp = null;

            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

 

2.引用的com组件：Microsoft.Office.Interop.Excel.dll   读取EXCEL文件 

优点：可以非常灵活的读取Excel中的数据 

缺点：如果是Web站点部署在IIS上时，还需要服务器机子已安装了Excel，有时候还需要为配置IIS权限。最重要的一点因为是基于单元格方式读取的，所以数据很慢（曾做过试验，直接读取千行、200多列的文件，直接读取耗时15分钟。即使采用多线程分段读取来提高CPU的利用率也需要8分钟。PS：CPU I3） 

 public static System.Data.DataTable COMImpExcel(string fileName)
        {
            System.Data.DataTable dt = new System.Data.DataTable();
            try
            {
                Microsoft.Office.Interop.Excel.Application app;
                Microsoft.Office.Interop.Excel.Workbooks wbs;
                Microsoft.Office.Interop.Excel.Worksheet ws;
                object oMissiong = System.Reflection.Missing.Value;
                app = new Microsoft.Office.Interop.Excel.Application();  //lauch excel application
                wbs = app.Workbooks;
                wbs.Open(fileName, oMissiong, oMissiong, oMissiong, oMissiong, oMissiong, oMissiong, oMissiong, oMissiong, oMissiong, oMissiong, oMissiong, oMissiong, oMissiong, oMissiong);
                ws = (Microsoft.Office.Interop.Excel.Worksheet)app.Worksheets.get_Item(1);    //取得第一个工作薄
                int rows = ws.UsedRange.Rows.Count;
                int columns = ws.UsedRange.Columns.Count;
                dt.TableName = ws.Name;

                for (int i = 1; i <= rows; i++)
                {
                    System.Data.DataRow dr = dt.NewRow();
                    for (int j = 1; j <= columns; j++)
                    {
                        Microsoft.Office.Interop.Excel.Range range = ws.Range[app.Cells[i, j], app.Cells[i, j]];
                        range.Select();
                        if (i == 1)                                  //读取列头
                        {
                            string colName = app.ActiveCell.Text.ToString();
                            if (dt.Columns.Contains(colName))                      //是否存在重复列名
                            {
                                dt.Columns.Add(colName + j);
                            }
                            else { dt.Columns.Add(colName); }
                        }
                        dr[j - 1] = app.ActiveCell.Text.ToString();
                    }
                    dt.Rows.Add(dr);
                }

                app.Quit(); app = null;
                System.Diagnostics.Process[] procs = System.Diagnostics.Process.GetProcessesByName("excel");
                foreach (System.Diagnostics.Process pro in procs)
                {
                    pro.Kill();    //没有更好的方法,只有杀掉进程
                }
                GC.Collect();
                dt.Rows.RemoveAt(0);       //上面那样写把列名也读进去了，在这里移除一下。也可以在上面把读列名单独出来
                return dt;
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }

前提是本机须安装office才能运行，且不同的office版本之间可能会有兼容问题，从Nuget下载 Microsoft.Office.Interop.Excel

或者在本地office中根目录找到这个DLL，在程序中引用；

3.使用NPOI读取

注意：

　　NPOI的版本不同，其自带的函数方法也可能不同。例如2.0.6.0获取Excel表格数量：int count = workbook.Count;  而2.5.5.0获取Excel表格数量：int count = workbook.GetAllNames().Count;

 

（1）读取Excel

Nuget下载 NPOI，并在项目中引用；

 

 

using System.IO;
using NPOI.SS.UserModel;
using NPOI.XSSF.UserModel;
using NPOI.HSSF.UserModel;

代码：

/// <summary>
        /// 将excel导入到datatable
        /// </summary>
        /// <param name="filePath">excel路径</param>
        /// <param name="isColumnName">第一行是否是列名</param>
        /// <returns>返回datatable</returns>
        public List<DataTable> ReadExcelByControl(string filePath, bool isColumnName)
        {
            //Excel文件中有多少个表，就有多少个datatable
            List<DataTable> list = new List<DataTable>();

            FileStream fs = null;
            DataColumn column = null;
            DataRow dataRow = null;
            IWorkbook workbook = null;
            ISheet sheet = null;
            IRow row = null;
            ICell cell = null;
            int startRow = 0;
            try
            {
                using (fs = File.OpenRead(filePath))
                {
                    // 2007版本
                    if (filePath.IndexOf(".xlsx") > 0)
                    {
                        workbook = new XSSFWorkbook(fs);
                    }
                    // 2003版本
                    else if (filePath.IndexOf(".xls") > 0)
                    {
                        workbook = new HSSFWorkbook(fs);
                    }

                    //Excel中表格数量
                    int count = workbook.Count;

                    if (workbook != null)
                    {
                        for (int a = 0; a < count; a++)
                        {
                            sheet = workbook.GetSheetAt(a);//读取第一个sheet，当然也可以循环读取每个sheet
                            DataTable dataTable = new DataTable();
                            if (sheet != null)
                            {
                                int rowCount = sheet.LastRowNum;//总行数
                                if (rowCount > 0)
                                {
                                    IRow firstRow = sheet.GetRow(0);//第一行
                                    int cellCount = firstRow.LastCellNum;//列数

                                    //构建datatable的列
                                    if (isColumnName)
                                    {
                                        startRow = 1;//如果第一行是列名，则从第二行开始读取
                                        for (int i = firstRow.FirstCellNum; i < cellCount; ++i)
                                        {
                                            cell = firstRow.GetCell(i);
                                            if (cell != null)
                                            {
                                                if (cell.StringCellValue != null)
                                                {
                                                    column = new DataColumn(cell.StringCellValue);
                                                    dataTable.Columns.Add(column);
                                                }
                                            }
                                        }
                                    }
                                    else
                                    {
                                        for (int i = firstRow.FirstCellNum; i < cellCount; ++i)
                                        {
                                            column = new DataColumn("column" + (i + 1));
                                            dataTable.Columns.Add(column);
                                        }
                                    }

                                    //填充行
                                    for (int i = startRow; i <= rowCount; ++i)
                                    {
                                        row = sheet.GetRow(i);
                                        if (row == null) continue;

                                        dataRow = dataTable.NewRow();
                                        for (int j = 0; j < cellCount; ++j)
                                        {
                                            cell = row.GetCell(j);
                                            if (cell == null)
                                            {
                                                dataRow[j] = "";
                                            }
                                            else
                                            {
                                                //CellType(Unknown = -1,Numeric = 0,String = 1,Formula = 2,Blank = 3,Boolean = 4,Error = 5,)
                                                switch (cell.CellType)
                                                {
                                                    case CellType.Blank:
                                                        dataRow[j] = "";
                                                        break;
                                                    case CellType.Numeric:
                                                        short format = cell.CellStyle.DataFormat;
                                                        //对时间格式（2015.12.5、2015/12/5、2015-12-5等）的处理
                                                        if (format == 14 || format == 31 || format == 57 || format == 58)
                                                            dataRow[j] = cell.DateCellValue;
                                                        else
                                                            dataRow[j] = cell.NumericCellValue;
                                                        break;
                                                    case CellType.String:
                                                        dataRow[j] = cell.StringCellValue;
                                                        break;
                                                }
                                            }
                                        }
                                        dataTable.Rows.Add(dataRow);
                                    }
                                }
                            }

                            list.Add(dataTable);
                        }
                    }
                }

                return list;
            }
            catch (Exception ex)
            {
                string str = ex.ToString();
                if (fs != null)
                {
                    fs.Close();
                }
                throw new Exception(ex.Message);
            }
        }

（2）.使用NPOI操作Excel

 1.查找行数和列数

 int lienum = sheet.GetRow(0).LastCellNum;//某一行的列数
  int rownum = sheet.LastRowNum;//所选表的行数

2.创建单元格

//sheet.CreateRow(i)//创建第i行
//sheet.GetRow(i).CreateCell(j)//创建第i行的第j个单元格

sheet.ShiftRows(0, sheet.LastRowNum, 2, true, false);
sheet.CreateRow(0); 
sheet.CreateRow(1);
IRow row1 = sheet.GetRow(0);
IRow row2 = sheet.GetRow(1);
for (int i = 0; i < lienum; i++) { row1.CreateCell(i); row2.CreateCell(i); }

3.合并单元格

先确定要合并的区域region，然后再执行AddMergedRegion函数

需要注意的是region的设置，CellRangeAddress（要合并单元格的第一行，要合并单元格的最后一行，要合并单元格的第一列，要合并单元格的最后一列）

NPOI中单元格的行数和列数均是从0开始

CellRangeAddress region1 = new CellRangeAddress(0, 0, 0, row1.LastCellNum - 1);
CellRangeAddress region2 = new CellRangeAddress(1, 1, 0, row2.LastCellNum - 1);
//合并首行
sheet.AddMergedRegion(region1);
//合并第二行注释行
sheet.AddMergedRegion(region2);

4.执行公式

sheet.GetRow(si).GetCell(j).SetCellFormula(formula_sum);

在单元格的SetCellFormula中设置要执行的公式，注意列的写法是ABCD这种的。

sheet.ForceFormulaRecalculation = true;//保证公式执行，而不是打开Excel表双击后公式才执行

string formula_sum = "SUM(" + sum_lie + 3.ToString() + ":" + sum_lie + sheet.LastRowNum.ToString() + ")";
sheet.GetRow(sheet.LastRowNum).GetCell(0).SetCellValue("合计");
sheet.GetRow(sheet.LastRowNum).GetCell(8).SetCellFormula(formula_sum);

5.设置单元格格式和列宽

ICellStyle cellstyle_title = workbook.CreateCellStyle();
// cellstyle_title.DataFormat = HSSFDataFormat.GetBuiltinFormat("0.00");
cellstyle_title.Alignment = NPOI.SS.UserModel.HorizontalAlignment.Center;
cellstyle_title.VerticalAlignment = VerticalAlignment.Center;
// cellStyle.BorderBottom =;
IFont cellfont_title = workbook.CreateFont();
cellfont_title.FontName = "等线";
cellfont_title.FontHeightInPoints = 20;//设置字号
cellfont_title.IsBold = true;
cellstyle_title.BorderTop = NPOI.SS.UserModel.BorderStyle.Thin;//上
cellstyle_title.BorderBottom = NPOI.SS.UserModel.BorderStyle.Thin;//下
cellstyle_title.BorderLeft = NPOI.SS.UserModel.BorderStyle.Thin;//左
cellstyle_title.BorderRight = NPOI.SS.UserModel.BorderStyle.Thin;//右
cellstyle_title.SetFont(cellfont_title);
sheet.GetRow(1).Height = 55 * 20; //设置行高 Height的单位是1/ 20个点。例：设置高度为50个点

6.修改Excel数据

sheet1.GetRow(1).GetCell(1).SetCellValue(200200);
sheet1.GetRow(2).GetCell(1).SetCellValue(300);
sheet1.GetRow(3).GetCell(1).SetCellValue(500050);

7.小数位数设置

sheet.GetRow(sheet.LastRowNum).GetCell(8).CellStyle.DataFormat = HSSFDataFormat.GetBuiltinFormat("0.00");

8.自动调整列宽

for (int i=0;i<lienum;i++) { sheet.AutoSizeColumn(i); }

9.修改结果保存

fs.Close();
FileStream file = new FileStream(filepath_save, FileMode.Create);
workbook.Write(file);
file.Close();

（3）将datatable数据导入Excel模板中

        /// DataTable到Excel,向Excel模板填充数据
        /// </summary>
        /// <param name="dt"></param>
        /// <param name="filePath">导出EXcel存储地方</param>
        /// <param name="templeteFile">Excel模板路径</param>
        /// <param name="titleName">sheet标题</param>
        public bool ExportExcel(DataTable dt, string filePath, string templeteFile, string titleName)
        {
            bool flag = false;
            try
            {
                using (MemoryStream ms = ExportExcelForDt(dt, filePath, templeteFile, titleName))
                {
                    using (FileStream fs = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.ReadWrite))
                    {
                        byte[] data = ms.ToArray();
                        fs.Write(data, 0, data.Length);
                        fs.Flush();

                        data = null;
                    }
                }
                flag = true;
            }
            catch
            {
            }

            return flag;
        }

        /// <summary>
        /// Excel模板填充数据
        /// </summary>
        /// <param name="dt">数据</param>
        /// <param name="filePath">导出EXcel存储地方</param>
        /// <param name="templeteFile">Excel模板路径</param>
        /// <param name="titleName">sheet标题</param>
        private MemoryStream ExportExcelForDt(DataTable dt, string filePath, string templeteFile, string titleName)
        {
            int totalIndex = 31;  //每个类别的总行数
            int rowIndex = 2;//起始行
            int dtRowIndex = dt.Rows.Count;
            //工作薄
            IWorkbook workbook = null;
            using (FileStream fs = new FileStream(templeteFile, FileMode.Open, FileAccess.Read))
            {
                //判断Excel版本
                if (System.IO.Path.GetExtension(templeteFile) == ".xls")
                {
                    workbook = new HSSFWorkbook(fs);
                }
                else if (System.IO.Path.GetExtension(templeteFile) == ".xlsx")
                {
                    workbook = new XSSFWorkbook(fs);
                }
                else
                {
                    throw new Exception("文件类型错误");
                }

                //获取sheet[0]
                ISheet sheet = workbook.GetSheetAt(0);

                //表头处理
                IRow headerRow = sheet.GetRow(0);
                ICell headerCell = headerRow.GetCell(0);
                headerCell.SetCellValue(titleName);

                //隐藏多余行，在数据填充区，对空白部分作处理
                for (int i = rowIndex + dtRowIndex; i < rowIndex + totalIndex; i++)
                {
                    IRow dataRowH = sheet.GetRow(i);
                    dataRowH.Height = 0;
                    dataRowH.ZeroHeight = true;
                }

                //填充数据
                foreach (DataRow row in dt.Rows)
                {
                    //获取sheet第rowIndex行
                    IRow dataRow = sheet.GetRow(rowIndex);

                    //开始列(0为标题列，从1开始)
                    int columnIndex = 1;

                    #region 数据填充
                    foreach (DataColumn column in dt.Columns)
                    {
                        #region 1
                        //列序号赋值：不能要等号，否则最后一项没有
                        if (columnIndex > dt.Columns.Count)
                        {
                            break;
                        }

                        //获取dataRow行第columnIndex列
                        ICell newCell = dataRow.GetCell(columnIndex);
                        if (newCell == null)
                        {
                            //创建新单元格
                            newCell = dataRow.CreateCell(columnIndex);
                        }

                        string drValue = row[column].ToString();
                        switch (column.DataType.ToString())
                        {
                            case "System.String":
                                newCell.SetCellValue(drValue);
                                break;
                            case "System.DateTime":
                                DateTime datev;
                                DateTime.TryParse(drValue, out datev);
                                newCell.SetCellValue(datev);
                                break;
                            case "System.Boolean":
                                bool boolV = false;
                                bool.TryParse(drValue, out boolV);
                                break;
                            case "System.Int16":
                            case "System.Int32":
                            case "System.Int64":
                            case "Systmen.Byte":
                                int intV = 0;
                                int.TryParse(drValue, out intV);
                                newCell.SetCellValue(intV);
                                break;
                            case "System.Decimal":
                            case "System.Double":
                                double doubV = 0;
                                double.TryParse(drValue, out doubV);
                                newCell.SetCellValue(doubV);
                                break;
                            case "System.DBNull":
                                newCell.SetCellValue("");
                                break;
                            default:
                                newCell.SetCellValue("");
                                break;
                        }
                        columnIndex++;
                        #endregion

                    }
                    #endregion

                    rowIndex++;
                }

                //格式化当前sheet,用于数据total计算
                sheet.ForceFormulaRecalculation = true;

                using (MemoryStream ms = new MemoryStream())
                {
                    workbook.Write(ms);
                    ms.Flush();
                    ms.Position = 0;
                    sheet = null;
                    workbook = null;

                    return ms;
                }
            }
        }

 

XML

1.xml文件

<?xml version="1.0" encoding="utf-8"?>
<library id="30">
  <BOOK id="20">
    <name>高等数学</name>
    <name1>大学英语</name1>
  </BOOK>
</library>

2.读取

static void Main(string[] args)
 {
     //将XML文件加载进来
     XDocument document = XDocument.Load("D:\\123.xml");
     //获取到XML的根元素进行操作
     XElement root= document.Root;
     XElement ele= root.Element("BOOK");
     //获取name标签的值
     XElement shuxing= ele.Element("name");
     Console.WriteLine(shuxing.Value);
     //获取根元素下的所有子元素
     IEnumerable<XElement> enumerable = root.Elements();
     foreach (XElement item in enumerable)
     {
         foreach (XElement item1 in item.Elements())
         {
             Console.WriteLine(item1.Name);   //输出 name  name1            
         }
         Console.WriteLine(item.Attribute("id").Value);  //输出20
     }   
     Console.ReadKey();
 }

3.写入

static void Main(string[] args)
{
     //获取根节点对象
     XDocument document = new XDocument();
     XElement root = new XElement("School");
     XElement book = new XElement("BOOK");
     book.SetElementValue("name", "高等数学");
     book.SetElementValue("name1", "大学英语");
     root.Add(book);
     root.Save("d:\\123.xml");      
     Console.ReadKey();
}

4.示例

 xml文件：

<Rows>
  <Row>
    <RowNumber>1</RowNumber>
    <贴片参考标志符 />
    <贴片机>LINE7\X4S-1</贴片机>
    <贴片头位置>4</贴片头位置>
    <拾取料槽>0</拾取料槽>
    <拾取分区>0</拾取分区>
    <段位>0</段位>
    <吸嘴>4103 C&amp;P20 P</吸嘴>
    <贴片面板 />
    <贴片头循环>0</贴片头循环>
    <降低的加速度>False</降低的加速度>
    <贴片PCB />
    <元件 />
    <拾取供料器类型 />
    <拾取料台 />
    <贴片头顺序号>1</贴片头顺序号>
  </Row>
  <Row>
    <RowNumber>2</RowNumber>
    <贴片参考标志符 />
    <贴片机>LINE7\X4S-1</贴片机>
    <贴片头位置>4</贴片头位置>
    <拾取料槽>0</拾取料槽>
    <拾取分区>0</拾取分区>
    <段位>0</段位>
    <吸嘴>4103 C&amp;P20 P</吸嘴>
    <贴片面板 />
    <贴片头循环>0</贴片头循环>
    <降低的加速度>False</降低的加速度>
    <贴片PCB />
    <元件 />
    <拾取供料器类型 />
    <拾取料台 />
    <贴片头顺序号>2</贴片头顺序号>
  </Row>
  <Row>
    <RowNumber>3</RowNumber> 
    <贴片参考标志符 />
    <贴片机>LINE7\X4S-1</贴片机>
    <贴片头位置>4</贴片头位置>
    <拾取料槽>0</拾取料槽>
    <拾取分区>0</拾取分区>
    <段位>0</段位>
    <吸嘴>4103 C&amp;P20 P</吸嘴>
    <贴片面板 />
    <贴片头循环>0</贴片头循环>
    <降低的加速度>False</降低的加速度>
    <贴片PCB />
    <元件 />
    <拾取供料器类型 />
    <拾取料台 />
    <贴片头顺序号>3</贴片头顺序号>
  </Row>

 

代码：

  public DataTable ReadXmlTag(string filePath)
        {
            try
            {
                DataTable dtTag = new DataTable();
                dtTag.Columns.Add("machine"); //机器
                dtTag.Columns.Add("Seria1NO"); //站位
                dtTag.Columns.Add("MaterialNo");//物料编码
                dtTag.Columns.Add("TagNum");//位号
                dtTag.Columns.Add("Numbers");//用量

                XmlDocument doc = new XmlDocument();
                XmlReaderSettings settings = new XmlReaderSettings();
                settings.IgnoreComments = true; //忽略文档的注释
                XmlReader reader = XmlReader.Create(filePath,settings);
                doc.Load(reader);

                XmlNode xn = doc.SelectSingleNode("Rows"); //得到根节点Rows
                XmlNodeList xnl = xn.ChildNodes; //得到根节点Rows的所有子节点

                foreach (XmlNode x in xnl)
                {
                    XmlElement xe = (XmlElement)x; //将节点转换为元素，便于得到节点的属性值

                    XmlNodeList r = xe.ChildNodes; //获取Row节点下所有的子节点

                    string _贴片参考标志符 = r.Item(1).InnerText;
                    string _贴片机 = r.Item(2).InnerText;
                    string _贴片头位置 = r.Item(3).InnerText;
                    string _拾取料槽 = r.Item(4).InnerText;
                    string _拾取分区 = r.Item(5).InnerText;
                    string _元件 = r.Item(12).InnerText;

                    if (string.IsNullOrEmpty(_元件) || string.IsNullOrEmpty(_贴片参考标志符))
                    {
                        continue;
                    }

                    string machine = string.Empty;
                    if (!_贴片机.Contains("V"))
                    {
                        machine = _贴片机.Split('\\')[1].Trim() + "-" + _贴片头位置.Trim();
                    }
                    else
                    {
                        //托盘料或者大盘料，_贴片机字段中包含V2以及空格
                        string[] str = _贴片机.Split('\\')[1].Trim().Split(' ');

                        machine = str[0] +"-"+ str[1].Split('-')[0].Replace('V',' ').Trim() + "-" + _贴片头位置.Trim();
                    }
                    string Seria1NO = _拾取料槽.Trim() + "-" + _拾取分区.Trim();
                    string MaterialNo = _元件.Split('\\')[2].Trim();
                    string TagNum = _贴片参考标志符.Trim();

                    bool flag = false;
                    for (int a = 0; a < dtTag.Rows.Count; a++)
                    {
                        if (machine == dtTag.Rows[a]["machine"].ToString() && Seria1NO == dtTag.Rows[a]["Seria1NO"].ToString() &&
                           MaterialNo == dtTag.Rows[a]["MaterialNo"].ToString())
                        {
                            //如果机台+站位+料号已经有了该位号，则不用再次添加
                            if (!dtTag.Rows[a]["TagNum"].ToString().Contains(TagNum))
                            {
                                dtTag.Rows[a]["TagNum"] = dtTag.Rows[a]["TagNum"].ToString() + "," + TagNum;
                            }
                            flag = true;
                        }
                    }

                    //如果dtTag表中没有对应的机器号站位以及料号，则新增一行数据，即flag=false；
                    if (!flag)
                    {
                        DataRow dr = dtTag.NewRow();
                        dr["machine"] = machine;
                        dr["Seria1NO"] = Seria1NO;
                        dr["MaterialNo"] = MaterialNo;
                        dr["TagNum"] = TagNum;
                        dtTag.Rows.Add(dr);
                    }
                }

                int qty = 0;
                //计算用量
                for (int i = 0; i < dtTag.Rows.Count; i++)
                {
                    int numbers = dtTag.Rows[i]["TagNum"].ToString().Split(',').Length;
                    qty = qty + numbers;
                    dtTag.Rows[i]["Numbers"] = numbers;
                }

                dtTag.DefaultView.Sort = "machine ASC";//按machine倒序

                return dtTag;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
                return null;
            }

        }

 

txt文件

1.文件读取

（1）FileStream类，转换成char数组

byte[] byData = new byte[100];
        char[] charData = new char[1000];
        public void Read()
        {
            try
            {
                FileStream file = new FileStream("E:\\test.txt", FileMode.Open);
                file.Seek(0, SeekOrigin.Begin);
                file.Read(byData, 0, 100); //byData传进来的字节数组,用以接受FileStream对象中的数据,第2个参数是字节数组中开始写入数据的位置,它通常是0,表示从数组的开端文件中向数组写数据,最后一个参数规定从文件读多少字符.
                Decoder d = Encoding.Default.GetDecoder();
                d.GetChars(byData, 0, byData.Length, charData, 0);
                Console.WriteLine(charData);
                file.Close();
            }
            catch (IOException e)
            {
                Console.WriteLine(e.ToString());
            }
        }

（2）StreamReader类

public void Read(string path)
        {
            StreamReader sr = new StreamReader(path,Encoding.Default);
            String line;
            while ((line = sr.ReadLine()) != null) 
            {
                Console.WriteLine(line.ToString());
            }
        }

2.文件写入

(1).使用FileStream类

public void Write()
        {
            FileStream fs = new FileStream("E:\\ak.txt", FileMode.Create);
            //获得字节数组
            byte[] data = System.Text.Encoding.Default.GetBytes("Hello World!"); 
            //开始写入
            fs.Write(data, 0, data.Length);
            //清空缓冲区、关闭流
            fs.Flush();
            fs.Close();
        }

（2）使用FileStream类创建文件，使用StreamWriter类，将数据写入到文件。

public void Write(string path)
        {
            FileStream fs = new FileStream(path, FileMode.Create);
            StreamWriter sw = new StreamWriter(fs);
            //开始写入
            sw.Write("Hello World!!!!");
            //清空缓冲区
            sw.Flush();
            //关闭流
            sw.Close();
            fs.Close();
        }