winform中DataGridView导出Excel（使用NPOI，速度最快的一种方法）
1,在网上搜索到的一般是这种通用的方法，这个方法速度太慢了，代码如下
private void ExportExcel(string fileName, DataGridView myDGV)
{
string saveFileName = "";
SaveFileDialog saveDialog = new SaveFileDialog();
saveDialog.DefaultExt = "xls";
saveDialog.Filter = "Excel文件|*.xls";
saveDialog.FileName = fileName;
saveDialog.ShowDialog();
saveFileName = saveDialog.FileName;
if (saveFileName.IndexOf(":") < 0) return; //被点了取消
Microsoft.Office.Interop.Excel.Application xlApp = new Microsoft.Office.Interop.Excel.Application();
if (xlApp == null)
{
MessageBox.Show("无法创建Excel对象，可能您的机子未安装Excel");
return;
}
Microsoft.Office.Interop.Excel.Workbooks workbooks = xlApp.Workbooks;
Microsoft.Office.Interop.Excel.Workbook workbook = workbooks.Add(Microsoft.Office.Interop.Excel.XlWBATemplate.xlWBATWorksheet);
Microsoft.Office.Interop.Excel.Worksheet worksheet = (Microsoft.Office.Interop.Excel.Worksheet)workbook.Worksheets[1];//取得sheet1
//写入标题
for (int i = 0; i < myDGV.ColumnCount; i++)
{
worksheet.Cells[1, i + 1] = myDGV.Columns[i].HeaderText;
}
//写入数值
for (int r = 0; r < myDGV.Rows.Count; r++)
{
for (int i = 0; i < myDGV.ColumnCount; i++)
{
worksheet.Cells[r + 2, i + 1] = myDGV.Rows[r].Cells[i].Value;
}
System.Windows.Forms.Application.DoEvents();
}
worksheet.Columns.EntireColumn.AutoFit();//列宽自适应
if (saveFileName != "")
{
try
{
workbook.Saved = true;
workbook.SaveCopyAs(saveFileName);
}
catch (Exception ex)
{
MessageBox.Show("导出文件时出错,文件可能正被打开！\n" + ex.Message);
}
}
xlApp.Quit();
GC.Collect();//强行销毁
MessageBox.Show("文件： " + fileName + ".xls 保存成功", "信息提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
2,最近研究了半天，使用NOPI的方法真是的太快了，秒存的感觉
【2.1】使用：
private void btn_export_Click(object sender, EventArgs e)
{
try
{
ExcelHelper.ExportToExcel(this.dgv_data);
new FrmConfirmSingle("日志导出", "日志记录导出成功") { TopMost = true }.ShowDialog();
}
catch (Exception exception)
{
new FrmConfirmSingle("日志导出", "日志记录导出失败:"+exception.Message) { TopMost = true }.ShowDialog();
}
}
【2.2】主要代码如下：
/// <summary>
/// 由DataGridView导出Excel
/// </summary>
/// <param name="grid"></param>
/// <param name="sheetName"></param>
/// <param name="filePath"></param>
/// <returns></returns>
public static string ExportToExcel(DataGridView grid, string sheetName = "result", string filePath = null)
{
if (grid.Rows.Count <= 0) return null;
if (string.IsNullOrEmpty(filePath))
{
filePath = GetSaveFilePath();
}
if (string.IsNullOrEmpty(filePath)) return null;
bool isCompatible = GetIsCompatible(filePath);
IWorkbook workbook = CreateWorkbook(isCompatible);
ICellStyle cellStyle = GetCellStyle(workbook);
ISheet sheet = workbook.CreateSheet(sheetName);
IRow headerRow = sheet.CreateRow(0);
for (int i = 0; i < grid.Columns.Count; i++)
{
ICell cell = headerRow.CreateCell(i);
cell.SetCellValue(grid.Columns[i].Name);
cell.CellStyle = cellStyle;
}
int rowIndex = 1;
foreach (DataGridViewRow row in grid.Rows)
{
IRow dataRow = sheet.CreateRow(rowIndex);
for (int n = 0; n < grid.Columns.Count; n++)
{
dataRow.CreateCell(n).SetCellValue((row.Cells[n].Value ?? "").ToString());
}
rowIndex++;
}
AutoColumnWidth(sheet, headerRow.LastCellNum - 1);
FileStream fs = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.ReadWrite);
workbook.Write(fs);
fs.Dispose();
sheet = null;
headerRow = null;
workbook = null;
MessageBox.Show("文件： " + filePath + ".xls 保存成功", "信息提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
return filePath;
}
【2.3】下面是我整理的通用EXCEL的帮助类，非常的实用
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Data;
using System.Windows.Forms;
using NPOI.SS.UserModel;
using NPOI.HSSF.UserModel;
using NPOI.XSSF.UserModel;
using System.Collections;
using System.Runtime.CompilerServices;
/*
* 须在项目中添加引用 NPOI.dll NPOI.OOXML.dll NPOI.OPenXml4Net.dll
*/
namespace AutomaticStoreMotionDal
{
public static class ExcelHelper
{
/// <summary>
/// 获取要保存的文件名称（含完整路径）
/// </summary>
/// <returns></returns>
public static string GetSaveFilePath()
{
SaveFileDialog saveFileDig = new SaveFileDialog();
saveFileDig.Filter = "Excel Office97-2003(*.xls)|*.xls|Excel Office2007及以上(*.xlsx)|*.xlsx";
saveFileDig.FileName = DateTime.Now.ToString("yyyyMMddHHmmss");
saveFileDig.FilterIndex = 0;
saveFileDig.OverwritePrompt = true;
string dir = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory);//获取当前系统桌面路径
saveFileDig.InitialDirectory = dir;
string filePath = null;
if (saveFileDig.ShowDialog() == DialogResult.OK)
{
filePath = saveFileDig.FileName;
}
return filePath;
}
/// <summary>
/// 打开文件对话框，并返回文件的路径
/// </summary>
/// <returns></returns>
public static string GetOpenFilePath()
{
//创建对话框的对象
OpenFileDialog ofd = new OpenFileDialog();
//设置对话框的标题
ofd.Title = "请选择要打开的文件";
//设置对话框可以多选
ofd.Multiselect = true;
//设置对话框的初始目录
ofd.InitialDirectory = @"C:\Users\Administrator\Desktop";
//设置对话框打开文件的类型
ofd.Filter = "Excel文件(.xls)|*.xls|Excel文件(.xlsx)|*.xlsx";
//展示对话框
ofd.ShowDialog();
//获得在打开对话框中选中的文件的路径
string filePath = ofd.FileName;//全路径
return filePath;
}
/// <summary>
/// 判断Excel文件是否为兼容模式（.xls)
/// </summary>
/// <param name="filePath"></param>
/// <returns></returns>
public static bool GetIsCompatible(string filePath)
{
return filePath.EndsWith(".xls", StringComparison.OrdinalIgnoreCase);
}
/// <summary>
/// 创建工作薄
/// </summary>
/// <param name="isCompatible">true就是.xls</param>
/// <returns></returns>
public static IWorkbook CreateWorkbook(bool isCompatible)
{
if (isCompatible)
{
return new HSSFWorkbook();
}
else
{
return new XSSFWorkbook();
}
}
/// <summary>
/// 创建工作薄(依据文件流)
/// </summary>
/// <param name="isCompatible"></param>
/// <param name="stream"></param>
/// <returns></returns>
public static IWorkbook CreateWorkbook(bool isCompatible, Stream stream)
{
if (isCompatible)
{
return new HSSFWorkbook(stream);
}
else
{
return new XSSFWorkbook(stream);
}
}
#region 传入一个文件路径，返回一个IWorkbook对象
/// <summary>
/// 传入一个文件路径，返回一个IWorkbook对象
/// </summary>
/// <param name="filepath"></param>
/// <returns></returns>
public static IWorkbook CreateWorkbook(string filepath)
{
IWorkbook workbook = null;
bool isCompatible = ExcelHelper.GetIsCompatible(filepath);
using (FileStream fs = File.Open(filepath, FileMode.Open,
FileAccess.Read, FileShare.ReadWrite))
{
//把xls文件读入workbook变量里，之后就可以关闭了
workbook = ExcelHelper.CreateWorkbook(isCompatible, fs);
fs.Close();
}
return workbook;
}
#endregion
#region 打开一个excel文件，设置单元格的值，再保存文件
/// <summary>
/// 打开一个excel文件，设置单元格的值，再保存文件
/// </summary>
/// <param name="ExcelPath"></param>
/// <param name="sheetname"></param>
/// <param name="column"></param>
/// <param name="row"></param>
/// <param name="value"></param>
/// <returns></returns>
public static bool SetCellValue(String ExcelPath, String sheetname, int column, int row, String value)
{
bool returnb = false;
try
{
IWorkbook wk = null;
bool isCompatible = ExcelHelper.GetIsCompatible(ExcelPath);
using (FileStream fs = File.Open(ExcelPath, FileMode.Open,
FileAccess.Read, FileShare.ReadWrite))
{
//把xls文件读入workbook变量里，之后就可以关闭了
wk = ExcelHelper.CreateWorkbook(isCompatible, fs);
fs.Close();
}
//把xls文件读入workbook变量里，之后就可以关闭了
//ISheet sheet = wk.GetSheet(sheetname);
ISheet sheet = wk.GetSheetAt(0);
ICell cell = sheet.GetRow(row).GetCell(column);
cell.SetCellValue(value);
using (FileStream fileStream = File.Open(ExcelPath,
FileMode.OpenOrCreate, FileAccess.ReadWrite))
{
wk.Write(fileStream);
fileStream.Close();
}
returnb = true;
}
catch (Exception)
{
returnb = false;
throw;
}
return returnb;
}
#endregion
#region 打开一个文件，读取excel文件某个单元格的值（多少行，多少列）
/// <summary>
/// 打开一个文件，读取excel文件某个单元格的值（多少行，多少列）
/// </summary>
/// <param name="ExcelPath"></param>
/// <param name="sheetname"></param>
/// <param name="column"></param>
/// <param name="row"></param>
/// <returns></returns>
public static String GetCellValue(string ExcelPath, String sheetname, int column, int row)
{
String returnStr = null;
try
{
IWorkbook wk = null;
bool isCompatible = ExcelHelper.GetIsCompatible(ExcelPath);
using (FileStream fs = File.Open(ExcelPath, FileMode.Open,
FileAccess.Read, FileShare.ReadWrite))
{
//把xls文件读入workbook变量里，之后就可以关闭了
wk = ExcelHelper.CreateWorkbook(isCompatible, fs);
fs.Close();
}
//把xls文件读入workbook变量里，之后就可以关闭了
//ISheet sheet = wk.GetSheet(sheetname);
ISheet sheet = wk.GetSheetAt(0);
ICell cell = sheet.GetRow(row).GetCell(column);
returnStr = cell.ToString();
}
catch (Exception)
{
returnStr = "Exception";
throw;
}
return returnStr;
}
#endregion
#region 打开一个文件，删除多少行以后的数据（是删除，不是清空数据）
/// <summary>
/// 打开一个文件，删除多少行以后的数据（是删除，不是清空数据）
/// </summary>
/// <param name="fileMatchPath"></param>
/// <param name="rowIndex">从多少行后开始删除</param>
public static void DelRowsData(string fileMatchPath, int startRowIndex)
{
IWorkbook wk = null;
bool isCompatible = ExcelHelper.GetIsCompatible(fileMatchPath);
using (FileStream fs = File.Open(fileMatchPath, FileMode.Open,
FileAccess.Read, FileShare.ReadWrite))
{
//把xls文件读入workbook变量里，之后就可以关闭了
wk = ExcelHelper.CreateWorkbook(isCompatible, fs);
fs.Close();
}
ISheet sheet = wk.GetSheetAt(0);
for (int i = startRowIndex; i <= sheet.LastRowNum; i++)
{
if (sheet.GetRow(i) == null)
{
i++;
continue;
}
sheet.RemoveRow(sheet.GetRow(i));
}
//转为字节数组
MemoryStream stream = new MemoryStream();
wk.Write(stream);
var buf = stream.ToArray();
//保存为Excel文件 这种方式能保存.xls和.xlsx文件
using (FileStream fs = new FileStream(fileMatchPath, FileMode.Create, FileAccess.Write))
{
fs.Write(buf, 0, buf.Length);
fs.Flush();
}
}
#endregion
/// <summary>
/// 创建表格头单元格
/// </summary>
/// <param name="sheet"></param>
/// <returns></returns>
private static ICellStyle GetCellStyle(IWorkbook workbook)
{
ICellStyle style = workbook.CreateCellStyle();
style.FillPattern = FillPattern.SolidForeground;
style.FillForegroundColor = NPOI.HSSF.Util.HSSFColor.Grey25Percent.Index;
return style;
}
/// <summary>
/// 遍历打印二维数组
/// </summary>
/// <param name="array"></param>
public static void PrintTwoArrayTest(object[,] array)
{
Console.WriteLine("============测试打印二维数组==============");
int row = array.GetLength(0);
int column = array.GetLength(1);
for (int r = 0; r < row; r++)
{
for (int c = 0; c < column; c++)
{
if (array[r, c] != null)
{
string value = array[r, c].ToString();
Console.Write($"{value} |");
}
}
Console.WriteLine();
}
}
/// <summary>
/// 传入2个二维数组，进行条件匹配替换，返回替换后的一个二维数组
/// </summary>
/// <param name="refArray">参考的数组</param>
/// <param name="matchArray">带替换的数组</param>
/// <param name="refColumn01">参考列1</param>
/// <param name="refColumn02">参考列2</param>
/// <param name="refColTarget01">被复制的值的列1</param>
/// <param name="matchColumn01">带替换的参考列1</param>
/// <param name="matchColumn02">带替换的参考列2</param>
/// <param name="matchColTarget01">带粘贴的值的列1</param>
/// <returns></returns>
public static string[,] GetMatchArray(string[,] refArray, string[,] matchArray, int refColumn01, int refColumn02, int refColTarget01, int matchColumn01, int matchColumn02, int matchColTarget01)
{
Console.WriteLine("============遍历2个二维数,匹配替换==============");
int row = refArray.GetLength(0);
int column = matchArray.GetLength(1);
int row02 = matchArray.GetLength(0);
int iMatch = 0;
for (int r = 0; r < row; r++)
{
string value01 = refArray[r, refColumn01];//第1列的数据
string value02 = refArray[r, refColumn02];//第2列的数据
if (value01 != null && value02 != null)
{
if (value01.Length > 0 | value02.Length > 0)
{
for (int r02 = 0; r02 < row02; r02++)
{
string match01 = matchArray[r02, matchColumn01];//第1列的数据
string match02 = matchArray[r02, matchColumn02];//第2列的数据
if (value01 == match01 && value02 == match02)
{
matchArray[r02, matchColTarget01] = refArray[r, refColTarget01];
iMatch++;
Console.WriteLine($"匹配了{iMatch}次");
}
}
}
}
}
return matchArray;
}
/// <summary>
/// 传入2个数组，根据相同条件匹配，吧ref的目标写入match中
/// </summary>
/// <param name="refArray">参考的数组</param>
/// <param name="matchArray">带替换的数组</param>
/// <param name="refColumn01"></param>
/// <param name="refColTarget01"></param>
/// <param name="matchColumn01"></param>
/// <param name="matchColTarget01"></param>
/// <returns></returns>
public static string[,] GetMatchArray(string[,] refArray, string[,] matchArray, int refColumn01, int refColTarget01, int matchColumn01, int matchColTarget01)
{
Console.WriteLine("============遍历2个二维数,匹配替换==============");
int row = refArray.GetLength(0);
int column = matchArray.GetLength(1);
int row02 = matchArray.GetLength(0);
int iMatch = 0;
for (int r = 0; r < row; r++)
{
string value01 = string.Empty;
value01 = refArray[r, refColumn01];//遍历第一个数组第1列的数据
//value01 = value01.Trim();
if (value01 != null)
{
if (value01.Length > 0)
{
for (int r02 = 0; r02 < row02; r02++)
{
string match01 = string.Empty;
match01 = matchArray[r02, matchColumn01];//遍历第一个数组第1列的数据
//match01 = match01.Trim();
if (value01 == match01)
{
matchArray[r02, matchColTarget01] = refArray[r, refColTarget01];
iMatch++;
Console.WriteLine($"匹配了{iMatch}次");
}
}
}
}
}
return matchArray;
}
/// <summary>
/// 遍历一个数组，如果第二列的数值大于等于第一列的数值，替换字符串
/// </summary>
/// <param name="matchArray"></param>
/// <param name="refColumn01"></param>
/// <param name="refColumn02"></param>
/// <param name="sValue"></param>
/// <returns></returns>
public static string[,] GetMatchArray(string[,] matchArray, int refColumn01, int refColumn02, string sValue)
{
Console.WriteLine("============遍历2个二维数,匹配替换==============");
int row = matchArray.GetLength(0);
int column = matchArray.GetLength(1);
int iMatch = 0;
for (int r = 0; r < row; r++)
{
string value01 = matchArray[r, refColumn01];//第1列的数据
string value02 = matchArray[r, refColumn02];//第2列的数据
try
{
int i01 = Convert.ToInt32(value01);
int i02 = Convert.ToInt32(value02);
if (i01 >= i02)
{
matchArray[r, refColumn02] = sValue + $"（数量：{value02}）";
}
}
catch
{
}
}
return matchArray;
}
#region 打开excel文件，获取某一行的数据
/// <summary>
/// 打开excel文件，获取某一行的数据
/// </summary>
/// <param name="filepath">文件全路径</param>
/// <param name="iRow">哪一行的数据</param>
/// <param name="sheet_Number">哪一个sheet表</param>
/// <returns></returns>
public static ArrayList GetRowData(string filepath, int sheet_Number, int iRow)
{
ArrayList arrayList = new ArrayList();
bool isCompatible = ExcelHelper.GetIsCompatible(filepath);
using (FileStream fsRead = File.OpenRead(filepath))
{
IWorkbook workbook = ExcelHelper.CreateWorkbook(isCompatible, fsRead);
ISheet sheet = workbook.GetSheetAt(sheet_Number - 1);
IRow currentRow = sheet.GetRow(iRow - 1);
for (int c = 0; c < currentRow.LastCellNum; c++)
{
//获取每个单元格(r行c列的数据）
ICell cell = currentRow.GetCell(c);
//获取单元格的内容
string value = string.Empty;
if (cell != null)
{
value = cell.ToString(); //如果单元格为空，这里会报错的
arrayList.Add(value);
}
}
return arrayList;
}
}
#endregion
/// <summary>
/// 打开excel文件，根据某一行的数据，根据字符串内容，返回这个字符串所在的列的索引
/// </summary>
/// <param name="filepath"></param>
/// <param name="iRow"></param>
/// <param name="sheet_Number">从1开始的</param>
/// <param name="s1">注意字符串的顺序</param>
/// <param name="s2"></param>
/// <param name="s3"></param>
/// <returns></returnss
public static ArrayList GetDataIndexs(string filepath, int sheet_Number, int iRow, string s1, string s2, string s3)
{
ArrayList arrayList = new ArrayList();
bool isCompatible = ExcelHelper.GetIsCompatible(filepath);
using (FileStream fsRead = File.OpenRead(filepath))
{
IWorkbook workbook = ExcelHelper.CreateWorkbook(isCompatible, fsRead);
ISheet sheet = workbook.GetSheetAt(sheet_Number - 1);
IRow currentRow = sheet.GetRow(iRow - 1);
for (int c = 0; c < currentRow.LastCellNum; c++)
{
//获取每个单元格(r行c列的数据）
ICell cell = currentRow.GetCell(c);
//获取单元格的内容
string value = string.Empty;
if (cell != null)
{
value = cell.ToString(); //如果单元格为空，这里会报错的
if (value == s1 | value == s2 || value == s3)
{
arrayList.Add(c);
}
}
}
Console.WriteLine("==========测试打印索引值============");
foreach (var a in arrayList)
{
Console.WriteLine($"{a} |");
}
return arrayList;
}
}
/// <summary>
/// 打开excel文件，根据某一行的字符串，然后这个字符串所在列的索引
/// </summary>
/// <param name="filepath"></param>
/// <param name="sheet_Number"></param>
/// <param name="iRow"></param>
/// <param name="sValue"></param>
/// <returns></returns>
public static int GetDataIndex(string filepath, int sheet_Number, int iRow, string sValue)
{
int i = 0;
bool isCompatible = ExcelHelper.GetIsCompatible(filepath);
using (FileStream fsRead = File.OpenRead(filepath))
{
IWorkbook workbook = ExcelHelper.CreateWorkbook(isCompatible, fsRead);
ISheet sheet = workbook.GetSheetAt(sheet_Number - 1);
IRow currentRow = sheet.GetRow(iRow - 1);
for (int c = 0; c < currentRow.LastCellNum; c++)
{
//获取每个单元格(r行c列的数据）
ICell cell = currentRow.GetCell(c);
//获取单元格的内容
string value = string.Empty;
if (cell != null)
{
value = cell.ToString(); //如果单元格为空，这里会报错的
if (value == sValue)
{
i = c;
}
}
}
}
return i;
}
/// <summary>
/// 打开一个文件，把第几行的数据取出来，返回一个字典 单元格的值：列的索引
/// </summary>
/// <param name="filepath"></param>
/// <param name="sheet_Number">第几张工作表（从1开始）</param>
/// <param name="iRow">第几行（从1开始）</param>
/// <returns></returns>
public static Dictionary<string, int> GetDataDictionary(string filepath, int sheet_Number, int iRow)
{
Dictionary<string, int> DataDict = new Dictionary<string, int>();
bool isCompatible = ExcelHelper.GetIsCompatible(filepath);
using (FileStream fsRead = File.OpenRead(filepath))
{
IWorkbook workbook = ExcelHelper.CreateWorkbook(isCompatible, fsRead);
ISheet sheet = workbook.GetSheetAt(sheet_Number - 1);
IRow currentRow = sheet.GetRow(iRow - 1);
for (int c = 0; c < currentRow.LastCellNum; c++)
{
//获取每个单元格(r行c列的数据）
ICell cell = currentRow.GetCell(c);
//获取单元格的内容
string value = string.Empty;
if (cell != null)
{
value = cell.ToString(); //如果单元格为空，这里会报错的
if (!DataDict.ContainsKey(value))
{
if (value == "*预计交货日期" | value == "预计交货日期")
{
value = "*预计交货日期";
}
DataDict.Add(value, c);
}
else
{
if (filepath.Contains("销售订单")) //销售订单模板的第二个备注填写收货地址
{
if (value == "备注") //如果有两个备注
{
//DataDict.Add("采购员", c);
DataDict.Add("收货地址", c);
}
}
}
}
}
//Console.WriteLine("================开始遍历字典===============");
//foreach (KeyValuePair<string, int> kv in DataDict)//通过KeyValuePair遍历元素
//{
// Console.WriteLine($"Key:{kv.Key},Value:{kv.Value}");
//}
return DataDict;
}
}
/// <summary>
/// 打开一个文件，根据第几张表第几行的中的两个字符，返回值：一个字典
/// </summary>
/// <param name="filepath"></param>
/// <param name="sheet_Number"></param>
/// <param name="strColumnKey"></param>
/// <param name="strColumnValue"></param>
/// <returns></returns>
public static Dictionary<string, string> GetDataDictionary(string filepath, int sheet_Number, int iRow, string strColumnKey, string strColumnValue)
{
Dictionary<string, int> dic = GetDataDictionary(filepath, 1, iRow);
int iColumnKey = dic[strColumnKey];
int iColumnValue = dic[strColumnValue];
Dictionary<string, string> DataDict = new Dictionary<string, string>();
bool isCompatible = ExcelHelper.GetIsCompatible(filepath);
using (FileStream fsRead = File.OpenRead(filepath))
{
IWorkbook workbook = ExcelHelper.CreateWorkbook(isCompatible, fsRead);
ISheet sheet = workbook.GetSheetAt(sheet_Number - 1);
for (int i = 0; i <= sheet.LastRowNum; i++)
{
IRow rowdata = sheet.GetRow(i);
if (rowdata != null)
{
ICell cellKey = rowdata.GetCell(iColumnKey);//如果rowdata是null,这里报错
ICell cellValue = rowdata.GetCell(iColumnValue);
if (cellKey != null && cellValue != null)
{
if (!DataDict.ContainsKey(cellKey.ToString()))
{
string strCellKey = cellKey.ToString();
string strCellValue = cellValue.ToString();
DataDict.Add(strCellKey, strCellValue);
}
}
}
}
return DataDict;
}
}
/// <summary>
/// 自适应列宽
/// </summary>
/// <param name="sheet"></param>
/// <param name="cols"></param>
public static void AutoColumnWidth(ISheet sheet, int cols)
{
for (int col = 0; col <= cols; col++)
{
sheet.AutoSizeColumn(col);//自适应宽度，但是其实还是比实际文本要宽
int columnWidth = sheet.GetColumnWidth(col) / 256;//获取当前列宽度
for (int rowIndex = 1; rowIndex <= sheet.LastRowNum; rowIndex++)
{
IRow row = sheet.GetRow(rowIndex);
ICell cell = row.GetCell(col);
if (cell != null)
{
int contextLength = Encoding.UTF8.GetBytes(cell.ToString()).Length;//获取当前单元格的内容宽度
columnWidth = columnWidth < contextLength ? contextLength : columnWidth;
}
}
sheet.SetColumnWidth(col, columnWidth * 200);//经过测试200比较合适。
}
}
/// <summary>
/// 自适应列宽和打印页缩放
/// </summary>
/// <param name="filePath">excel文件路径</param>
/// <param name="scale">缩放比例(77,80,100等）</param>
public static void AutoColumnWidth(string filePath,short scale=80)
{
//【1】打开excel文件的第几张表，第几行的数据，返回一个字典{列名：列的索引}
//字典的作用：可以根据列名快速找到对应的列索引
Dictionary<string, int> dicData = ExcelHelper.GetDataDictionary(filePath, 1, 1);
bool isCompatible = ExcelHelper.GetIsCompatible(filePath);
IWorkbook workbook = null;
using (FileStream fs = File.Open(filePath, FileMode.Open,
FileAccess.Read, FileShare.ReadWrite))
{
//把xls文件读入workbook变量里，之后就可以关闭了
workbook = ExcelHelper.CreateWorkbook(isCompatible, fs);
fs.Close();
}
ISheet sheet = workbook.GetSheetAt(0);
int rowCount = sheet.LastRowNum;
for (int col = 0; col < sheet.GetRow(0).LastCellNum; col++)
{
//自适应列宽
sheet.AutoSizeColumn(col);
}
//sheet.PrintSetup.FitWidth = 1;
//sheet.PrintSetup.FitHeight = 0;
//设置打印页面缩放比例
sheet.PrintSetup.Scale = scale;
#region 非常的耗时，不推荐使用
////开始遍历【遍历行操作】
//for (int r = 1; r <= rowCount; r++) //从第二行开始遍历
//{
// IRow currentRow = sheet.GetRow(r); //读取当前行数据
// if (currentRow == null) //如果为空，重新创建一行，防止null报错
// {
// sheet.CreateRow(r);
// currentRow = sheet.GetRow(r);
// }
// for (int i = 0; i < currentRow.LastCellNum; i++)
// {
// //sheet.AutoSizeColumn(i);//非常的耗时，不推荐用
// }
//}
#endregion
//转为字节数组
MemoryStream stream = new MemoryStream();
workbook.Write(stream);
var buf = stream.ToArray();
//保存为Excel文件 这种方式能保存.xls和.xlsx文件
using (FileStream fs = new FileStream(filePath, FileMode.Create, FileAccess.Write))
{
fs.Write(buf, 0, buf.Length);
fs.Flush();
}
}
#region 根据一个文件，获取一个Excel文件的最大行数和列数（不成熟不建议用）
/// <summary>
/// 根据一个文件，获取一个Excel文件的最大行数和列数（不成熟不建议用）
/// </summary>
/// <param name="filepath">excel表格保存的地址，包括"文件名.xls</param>
/// <param name="sheet_number">代表将要读取的sheet表的索引位置</param>
/// <returns>行数Array[0],列数Array[2]</returns>
public static Array GetRowCountAndColumnCount(string filepath, int sheet_number)
{
int rowMaxCount = 0;
int columnMaxCount = 0;
FileStream readStream = null;
try
{
if (!string.IsNullOrEmpty(filepath) && sheet_number > 0)
{
readStream = new FileStream(filepath, FileMode.Open, FileAccess.Read);
bool isCompatible = GetIsCompatible(filepath);
IWorkbook workbook = CreateWorkbook(isCompatible, readStream);
ISheet sheet = workbook.GetSheetAt(sheet_number - 1);
if (sheet != null)
{
rowMaxCount = sheet.LastRowNum + 1; //有效行数(NPOI读取的有效行数不包括列头，所以需要加1)
for (int c = 0; c <= sheet.LastRowNum; c++)
{
IRow row = sheet.GetRow(c);
#pragma warning disable CS1525 // 表达式项“=”无效
if (row != null && row.LastCellNum > -1)
#pragma warning restore CS1525 // 表达式项“=”无效
{
columnMaxCount = row.LastCellNum;
}
}
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
finally
{
if (readStream != null)
{
readStream.Close();
}
}
int[] array = new int[2];
array[1] = rowMaxCount;
array[2] = columnMaxCount;
return array;
}
#endregion
/// <summary>
/// Excel转化为二维数组
/// </summary>
/// <param name="filepath">文件全路径</param>
/// <param name="arrayRowNnmber">数组的行数</param>
/// <param name="arrayColumnNumber">数组的列数</param>
/// <param name="sheet_Number">要遍历的sheet索引</param>
/// <returns>返回一个二维素组</returns>
public static string[,] ToTwoArray(string filepath, int arrayRowNnmber, int arrayColumnNumber, int sheet_Number)
{
string[,] array = new string[arrayRowNnmber, arrayColumnNumber];
bool isCompatible = ExcelHelper.GetIsCompatible(filepath);
using (FileStream fsRead = File.OpenRead(filepath))
{
IWorkbook workbook = ExcelHelper.CreateWorkbook(isCompatible, fsRead);
ISheet sheet = workbook.GetSheetAt(sheet_Number - 1); //获取第一个工作表（sheet）
int rowCount = sheet.LastRowNum;
if (!isCompatible)//如果是xlsx格式的，行数要-2
{
rowCount = rowCount - 2;
}
for (int r = 0; r <= rowCount; r++)
{
IRow currentRow = sheet.GetRow(r); //读取当前行数据
Console.Write($"第{r}行有{currentRow.LastCellNum}列有数据:--->");
for (int c = 0; c < currentRow.LastCellNum; c++)
{
//获取每个单元格(r行c列的数据）
ICell cell = currentRow.GetCell(c);
//获取单元格的内容
string value = string.Empty;
if (cell != null)
{
value = cell.ToString(); //如果单元格为空，这里会报错的
}
Console.Write($"{value} |");
array[r, c] = value;
}
Console.WriteLine();
}
return array;
}
}
/// <summary>
/// 从工作表中生成DataTable
/// </summary>
/// <param name="sheet"></param>
/// <param name="headerRowIndex"></param>
/// <returns></returns>
private static DataTable GetDataTableFromSheet(ISheet sheet, int headerRowIndex)
{
DataTable table = new DataTable();
IRow headerRow = sheet.GetRow(headerRowIndex);
int cellCount = headerRow.LastCellNum;
for (int i = headerRow.FirstCellNum; i < cellCount; i++)
{
if (headerRow.GetCell(i) == null || headerRow.GetCell(i).StringCellValue.Trim() == "")
{
// 如果遇到第一个空列，则不再继续向后读取
cellCount = i + 1;
break;
}
DataColumn column = new DataColumn(headerRow.GetCell(i).StringCellValue);
table.Columns.Add(column);
}
for (int i = (headerRowIndex + 1); i <= sheet.LastRowNum; i++)
{
IRow row = sheet.GetRow(i);
if (row != null && !string.IsNullOrEmpty(row.Cells[0].StringCellValue))
{
DataRow dataRow = table.NewRow();
for (int j = row.FirstCellNum; j < cellCount; j++)
{
if (row.GetCell(j) != null)
{
dataRow[j] = row.GetCell(j).ToString();
}
}
table.Rows.Add(dataRow);
}
}
return table;
}
#region 公共导出方法
/// <summary>
/// 由DataSet导出Excel
/// </summary>
/// <param name="sourceTable">要导出数据的DataTable</param>
/// <returns>Excel工作表</returns>
public static string ExportToExcel(DataSet sourceDs, string filePath = null)
{
if (string.IsNullOrEmpty(filePath))
{
filePath = GetSaveFilePath();
}
if (string.IsNullOrEmpty(filePath)) return null;
bool isCompatible = GetIsCompatible(filePath);
IWorkbook workbook = CreateWorkbook(isCompatible);
ICellStyle cellStyle = GetCellStyle(workbook);
for (int i = 0; i < sourceDs.Tables.Count; i++)
{
DataTable table = sourceDs.Tables[i];
string sheetName = "result" + i.ToString();
ISheet sheet = workbook.CreateSheet(sheetName);
IRow headerRow = sheet.CreateRow(0);
// handling header.
foreach (DataColumn column in table.Columns)
{
ICell cell = headerRow.CreateCell(column.Ordinal);
cell.SetCellValue(column.ColumnName);
cell.CellStyle = cellStyle;
}
// handling value.
int rowIndex = 1;
foreach (DataRow row in table.Rows)
{
IRow dataRow = sheet.CreateRow(rowIndex);
foreach (DataColumn column in table.Columns)
{
dataRow.CreateCell(column.Ordinal).SetCellValue((row[column] ?? "").ToString());
}
rowIndex++;
}
}
FileStream fs = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.ReadWrite);
workbook.Write(fs);
fs.Dispose();
workbook = null;
return filePath;
}
/// <summary>
/// 获取sheet表名
/// </summary>
/// <param name="filePath"></param>
/// <returns></returns>
public static string[] GetSheetName(string filePath)
{
int sheetNumber = 0;
var file = new FileStream(filePath, FileMode.Open, FileAccess.Read);
if (filePath.IndexOf(".xlsx") > 0)
{
//2007版本
var xssfworkbook = new XSSFWorkbook(file);
sheetNumber = xssfworkbook.NumberOfSheets;
string[] sheetNames = new string[sheetNumber];
for (int i = 0; i < sheetNumber; i++)
{
sheetNames[i] = xssfworkbook.GetSheetName(i);
}
return sheetNames;
}
else if (filePath.IndexOf(".xls") > 0)
{
//2003版本
var hssfworkbook = new HSSFWorkbook(file);
sheetNumber = hssfworkbook.NumberOfSheets;
string[] sheetNames = new string[sheetNumber];
for (int i = 0; i < sheetNumber; i++)
{
sheetNames[i] = hssfworkbook.GetSheetName(i);
}
return sheetNames;
}
return null;
}
/// <summary>
/// 根据表名获取表
/// </summary>
/// <param name="filePath"></param>
/// <param name="sheetName"></param>
/// <returns></returns>
public static DataTable ExcelToDataTable(string filePath, string sheetName)
{
string outMsg = "";
var dt = new DataTable();
string fileType = Path.GetExtension(filePath).ToLower();
try
{
ISheet sheet = null;
FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read);
if (fileType == ".xlsx")
{
//2007版
XSSFWorkbook workbook = new XSSFWorkbook(fs);
sheet = workbook.GetSheet(sheetName);
if (sheet != null)
{
dt = GetSheetDataTable(sheet, out outMsg);
}
}
else if (fileType == ".xls")
{
//2003版
HSSFWorkbook workbook = new HSSFWorkbook(fs);
sheet = workbook.GetSheet(sheetName);
if (sheet != null)
{
dt = GetSheetDataTable(sheet, out outMsg);
}
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
return dt;
}
private static int sheetCellNumMax = 12;
/// <summary>
/// 获取sheet表对应的DataTable
/// </summary>
/// <param name="sheet">Excel工作表</param>
/// <param name="strMsg"></param>
/// <returns></returns>
private static DataTable GetSheetDataTable(ISheet sheet, out string strMsg)
{
strMsg = "";
DataTable dt = new DataTable();
string sheetName = sheet.SheetName;
int startIndex = 0;// sheet.FirstRowNum;
int lastIndex = sheet.LastRowNum;
//最大列数
int cellCount = 0;
IRow maxRow = sheet.GetRow(0);
for (int i = startIndex; i <= lastIndex; i++)
{
IRow row = sheet.GetRow(i);
if (row != null && cellCount < row.LastCellNum)
{
cellCount = row.LastCellNum;
maxRow = row;
}
}
//列名设置
try
{
//maxRow.LastCellNum = 12 // L
for (int i = 0; i < sheetCellNumMax; i++)//maxRow.FirstCellNum
{
dt.Columns.Add(Convert.ToChar(((int)'A') + i).ToString());
//DataColumn column = new DataColumn("Column" + (i + 1).ToString());
//dt.Columns.Add(column);
}
}
catch
{
strMsg = "工作表" + sheetName + "中无数据";
return null;
}
//数据填充
for (int i = startIndex; i <= lastIndex; i++)
{
IRow row = sheet.GetRow(i);
DataRow drNew = dt.NewRow();
if (row != null)
{
for (int j = row.FirstCellNum; j < row.LastCellNum; ++j)
{
if (row.GetCell(j) != null)
{
ICell cell = row.GetCell(j);
switch (cell.CellType)
{
case CellType.Blank:
drNew[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)
drNew[j] = cell.DateCellValue;
else
drNew[j] = cell.NumericCellValue;
if (cell.CellStyle.DataFormat == 177 || cell.CellStyle.DataFormat == 178 || cell.CellStyle.DataFormat == 188)
drNew[j] = cell.NumericCellValue.ToString("#0.00");
break;
case CellType.String:
drNew[j] = cell.StringCellValue;
break;
case CellType.Formula:
try
{
drNew[j] = cell.NumericCellValue;
if (cell.CellStyle.DataFormat == 177 || cell.CellStyle.DataFormat == 178 || cell.CellStyle.DataFormat == 188)
drNew[j] = cell.NumericCellValue.ToString("#0.00");
}
catch
{
try
{
drNew[j] = cell.StringCellValue;
}
catch { }
}
break;
default:
drNew[j] = cell.StringCellValue;
break;
}
}
}
}
dt.Rows.Add(drNew);
}
return dt;
}
/// <summary>
/// 由DataTable导出Excel
/// </summary>
/// <param name="sourceTable">要导出数据的DataTable</param>
/// <returns>Excel工作表</returns>
public static string ExportToExcel(DataTable sourceTable, string sheetName = "result", string filePath = null)
{
if (sourceTable.Rows.Count <= 0) return null;
if (string.IsNullOrEmpty(filePath))
{
filePath = GetSaveFilePath();
}
if (string.IsNullOrEmpty(filePath)) return null;
bool isCompatible = GetIsCompatible(filePath);
IWorkbook workbook = CreateWorkbook(isCompatible);
ICellStyle cellStyle = GetCellStyle(workbook);
ISheet sheet = workbook.CreateSheet(sheetName);
IRow headerRow = sheet.CreateRow(0);
// handling header.
foreach (DataColumn column in sourceTable.Columns)
{
ICell headerCell = headerRow.CreateCell(column.Ordinal);
headerCell.SetCellValue(column.ColumnName);
headerCell.CellStyle = cellStyle;
}
// handling value.
int rowIndex = 1;
foreach (DataRow row in sourceTable.Rows)
{
IRow dataRow = sheet.CreateRow(rowIndex);
foreach (DataColumn column in sourceTable.Columns)
{
dataRow.CreateCell(column.Ordinal).SetCellValue((row[column] ?? "").ToString());
}
rowIndex++;
}
FileStream fs = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.ReadWrite);
workbook.Write(fs);
fs.Dispose();
sheet = null;
headerRow = null;
workbook = null;
return filePath;
}
/// <summary>
/// 由List导出Excel
/// </summary>
/// <typeparam name="T">类型</typeparam>
/// <param name="data">在导出的List</param>
/// <param name="sheetName">sheet名称</param>
/// <returns></returns>
public static string ExportToExcel<T>(List<T> data, IList<KeyValuePair<string, string>> headerNameList, string sheetName = "result", string filePath = null) where T : class
{
if (data.Count <= 0) return null;
if (string.IsNullOrEmpty(filePath))
{
filePath = GetSaveFilePath();
}
if (string.IsNullOrEmpty(filePath)) return null;
bool isCompatible = GetIsCompatible(filePath);
IWorkbook workbook = CreateWorkbook(isCompatible);
ICellStyle cellStyle = GetCellStyle(workbook);
ISheet sheet = workbook.CreateSheet(sheetName);
IRow headerRow = sheet.CreateRow(0);
for (int i = 0; i < headerNameList.Count; i++)
{
ICell cell = headerRow.CreateCell(i);
cell.SetCellValue(headerNameList[i].Value);
cell.CellStyle = cellStyle;
}
Type t = typeof(T);
int rowIndex = 1;
foreach (T item in data)
{
IRow dataRow = sheet.CreateRow(rowIndex);
for (int n = 0; n < headerNameList.Count; n++)
{
object pValue = t.GetProperty(headerNameList[n].Key).GetValue(item, null);
dataRow.CreateCell(n).SetCellValue((pValue ?? "").ToString());
}
rowIndex++;
}
FileStream fs = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.ReadWrite);
workbook.Write(fs);
fs.Dispose();
sheet = null;
headerRow = null;
workbook = null;
return filePath;
}
/// <summary>
/// 由DataGridView导出
/// </summary>
/// <param name="grid"></param>
/// <param name="sheetName"></param>
/// <param name="filePath"></param>
/// <returns></returns>
public static string ExportToExcel(DataGridView grid, string sheetName = "result", string filePath = null)
{
if (grid.Rows.Count <= 0) return null;
if (string.IsNullOrEmpty(filePath))
{
filePath = GetSaveFilePath();
}
if (string.IsNullOrEmpty(filePath)) return null;
bool isCompatible = GetIsCompatible(filePath);
IWorkbook workbook = CreateWorkbook(isCompatible);
ICellStyle cellStyle = GetCellStyle(workbook);
ISheet sheet = workbook.CreateSheet(sheetName);
IRow headerRow = sheet.CreateRow(0);
for (int i = 0; i < grid.Columns.Count; i++)
{
ICell cell = headerRow.CreateCell(i);
cell.SetCellValue(grid.Columns[i].Name);
cell.CellStyle = cellStyle;
}
int rowIndex = 1;
foreach (DataGridViewRow row in grid.Rows)
{
IRow dataRow = sheet.CreateRow(rowIndex);
for (int n = 0; n < grid.Columns.Count; n++)
{
dataRow.CreateCell(n).SetCellValue((row.Cells[n].Value ?? "").ToString());
}
rowIndex++;
}
FileStream fs = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.ReadWrite);
workbook.Write(fs);
fs.Dispose();
sheet = null;
headerRow = null;
workbook = null;
return filePath;
}
#endregion
#region 公共导入方法
/// <summary>
/// 由Excel导入DataTable
/// </summary>
/// <param name="excelFileStream">Excel文件流</param>
/// <param name="sheetName">Excel工作表名称</param>
/// <param name="headerRowIndex">Excel表头行索引</param>
/// <param name="isCompatible">是否为兼容模式</param>
/// <returns>DataTable</returns>
public static DataTable ImportFromExcel(Stream excelFileStream, string sheetName, int headerRowIndex, bool isCompatible)
{
IWorkbook workbook = CreateWorkbook(isCompatible, excelFileStream);
ISheet sheet = null;
int sheetIndex = -1;
if (int.TryParse(sheetName, out sheetIndex))
{
sheet = workbook.GetSheetAt(sheetIndex);
}
else
{
sheet = workbook.GetSheet(sheetName);
}
DataTable table = GetDataTableFromSheet(sheet, headerRowIndex);
excelFileStream.Close();
workbook = null;
sheet = null;
return table;
}
/// <summary>
/// 由Excel导入DataTable
/// </summary>
/// <param name="excelFilePath">Excel文件路径，为物理路径。</param>
/// <param name="sheetName">Excel工作表名称</param>
/// <param name="headerRowIndex">Excel表头行索引</param>
/// <returns>DataTable</returns>
public static DataTable ImportFromExcel(string excelFilePath, string sheetName, int headerRowIndex)
{
using (FileStream stream = System.IO.File.OpenRead(excelFilePath))
{
bool isCompatible = GetIsCompatible(excelFilePath);
return ImportFromExcel(stream, sheetName, headerRowIndex, isCompatible);
}
}
/// <summary>
/// 由Excel导入DataSet，如果有多个工作表，则导入多个DataTable
/// </summary>
/// <param name="excelFileStream">Excel文件流</param>
/// <param name="headerRowIndex">Excel表头行索引</param>
/// <param name="isCompatible">是否为兼容模式</param>
/// <returns>DataSet</returns>
public static DataSet ImportFromExcel(Stream excelFileStream, int headerRowIndex, bool isCompatible)
{
DataSet ds = new DataSet();
IWorkbook workbook = CreateWorkbook(isCompatible, excelFileStream);
for (int i = 0; i < workbook.NumberOfSheets; i++)
{
ISheet sheet = workbook.GetSheetAt(i);
DataTable table = GetDataTableFromSheet(sheet, headerRowIndex);
ds.Tables.Add(table);
}
excelFileStream.Close();
workbook = null;
return ds;
}
/// <summary>
/// 由Excel导入DataSet，如果有多个工作表，则导入多个DataTable
/// </summary>
/// <param name="excelFilePath">Excel文件路径，为物理路径。</param>
/// <param name="headerRowIndex">Excel表头行索引</param>
/// <returns>DataSet</returns>
public static DataSet ImportFromExcel(string excelFilePath, int headerRowIndex)
{
using (FileStream stream = System.IO.File.OpenRead(excelFilePath))
{
bool isCompatible = GetIsCompatible(excelFilePath);
return ImportFromExcel(stream, headerRowIndex, isCompatible);
}
}
#endregion
#region 公共转换方法
/// <summary>
/// 将Excel的列索引转换为列名，列索引从0开始，列名从A开始。如第0列为A，第1列为B...
/// </summary>
/// <param name="index">列索引</param>
/// <returns>列名，如第0列为A，第1列为B...</returns>
public static string ConvertColumnIndexToColumnName(int index)
{
index = index + 1;
int system = 26;
char[] digArray = new char[100];
int i = 0;
while (index > 0)
{
int mod = index % system;
if (mod == 0) mod = system;
digArray[i++] = (char)(mod - 1 + 'A');
index = (index - 1) / 26;
}
StringBuilder sb = new StringBuilder(i);
for (int j = i - 1; j >= 0; j--)
{
sb.Append(digArray[j]);
}
return sb.ToString();
}
/// <summary>
/// 转化日期
/// </summary>
/// <param name="date">日期</param>
/// <returns></returns>
public static DateTime ConvertDate(object date)
{
string dtStr = (date ?? "").ToString();
DateTime dt = new DateTime();
if (DateTime.TryParse(dtStr, out dt))
{
return dt;
}
try
{
string spStr = "";
if (dtStr.Contains("-"))
{
spStr = "-";
}
else if (dtStr.Contains("/"))
{
spStr = "/";
}
string[] time = dtStr.Split(spStr.ToCharArray());
int year = Convert.ToInt32(time[2]);
int month = Convert.ToInt32(time[0]);
int day = Convert.ToInt32(time[1]);
string years = Convert.ToString(year);
string months = Convert.ToString(month);
string days = Convert.ToString(day);
if (months.Length == 4)
{
dt = Convert.ToDateTime(date);
}
else
{
string rq = "";
if (years.Length == 1)
{
years = "0" + years;
}
if (months.Length == 1)
{
months = "0" + months;
}
if (days.Length == 1)
{
days = "0" + days;
}
rq = "20" + years + "-" + months + "-" + days;
dt = Convert.ToDateTime(rq);
}
}
catch
{
throw new Exception("日期格式不正确，转换日期失败！");
}
return dt;
}
/// <summary>
/// 转化数字
/// </summary>
/// <param name="d">数字字符串</param>
/// <returns></returns>
public static decimal ConvertDecimal(object d)
{
string dStr = (d ?? "").ToString();
decimal result = 0;
if (decimal.TryParse(dStr, out result))
{
return result;
}
else
{
throw new Exception("数字格式不正确，转换数字失败！");
}
}
#endregion
}
}
【2.4】文件帮助类
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
/*
* 除了using System.Web;，你还须在项目中添加引用 程序集 System.Web.dll
*/
namespace AutomaticStoreMotionDal
{
/// <summary>
/// 文件操作夹
/// </summary>
public static class DirFileHelper
{
#region 打开文件对话框，并返回文件的路径，包含扩展名
/// <summary>
/// 打开文件对话框，并返回文件的路径，包含扩展名
/// </summary>
/// <returns></returns>
public static string GetOpenFilePath()
{
//创建对话框的对象
OpenFileDialog ofd = new OpenFileDialog();
//设置对话框的标题
ofd.Title = "请选择要打开的文件";
//设置对话框可以多选
ofd.Multiselect = true;
//设置对话框的初始目录
ofd.InitialDirectory = @"C:\Users\Administrator\Desktop";
//设置对话框打开文件的类型
ofd.Filter = "Excel文件(.xls和.xlsx)|*.xls;*.xlsx";
//展示对话框
ofd.ShowDialog();
//获得在打开对话框中选中的文件的路径
string filePath = ofd.FileName; //全路径
return filePath;
}
#endregion
#region 检测指定目录是否存在
/// <summary>
/// 检测指定目录是否存在
/// </summary>
/// <param name="directoryPath">目录的绝对路径</param>
/// <returns></returns>
public static bool IsExistDirectory(string directoryPath)
{
return Directory.Exists(directoryPath);
}
#endregion
#region 检测指定文件是否存在,如果存在返回true
/// <summary>
/// 检测指定文件是否存在,如果存在则返回true。
/// </summary>
/// <param name="filePath">文件的绝对路径</param>
public static bool IsExistFile(string filePath)
{
return File.Exists(filePath);
}
#endregion
#region 获取指定目录中的文件列表
/// <summary>
/// 获取指定目录中所有文件列表
/// </summary>
/// <param name="directoryPath">指定目录的绝对路径</param>
public static string[] GetFileNames(string directoryPath)
{
//如果目录不存在，则抛出异常
if (!IsExistDirectory(directoryPath))
{
throw new FileNotFoundException();
}
//获取文件列表
return Directory.GetFiles(directoryPath);
}
#endregion
#region 获取指定目录中所有子目录列表,若要搜索嵌套的子目录列表,请使用重载方法.
/// <summary>
/// 获取指定目录中所有子目录列表,若要搜索嵌套的子目录列表,请使用重载方法.
/// </summary>
/// <param name="directoryPath">指定目录的绝对路径</param>
public static string[] GetDirectories(string directoryPath)
{
try
{
return Directory.GetDirectories(directoryPath);
}
catch (IOException ex)
{
throw ex;
}
}
#endregion
#region 获取指定目录及子目录中所有文件列表
/// <summary>
/// 获取指定目录及子目录中所有文件列表
/// </summary>
/// <param name="directoryPath">指定目录的绝对路径</param>
/// <param name="searchPattern">模式字符串，"*"代表0或N个字符，"?"代表1个字符。
/// 范例："Log*.xml"表示搜索所有以Log开头的Xml文件。</param>
/// <param name="isSearchChild">是否搜索子目录</param>
public static string[] GetFileNames(string directoryPath, string searchPattern, bool isSearchChild)
{
//如果目录不存在，则抛出异常
if (!IsExistDirectory(directoryPath))
{
throw new FileNotFoundException();
}
try
{
if (isSearchChild)
{
return Directory.GetFiles(directoryPath, searchPattern, SearchOption.AllDirectories);
}
else
{
return Directory.GetFiles(directoryPath, searchPattern, SearchOption.TopDirectoryOnly);
}
}
catch (IOException ex)
{
throw ex;
}
}
#endregion
#region 检测指定目录是否为空
/// <summary>
/// 检测指定目录是否为空
/// </summary>
/// <param name="directoryPath">指定目录的绝对路径</param>
public static bool IsEmptyDirectory(string directoryPath)
{
try
{
//判断是否存在文件
string[] fileNames = GetFileNames(directoryPath);
if (fileNames.Length > 0)
{
return false;
}
//判断是否存在文件夹
string[] directoryNames = GetDirectories(directoryPath);
if (directoryNames.Length > 0)
{
return false;
}
return true;
}
catch
{
//这里记录日志
//LogHelper.WriteTraceLog(TraceLogLevel.Error, ex.Message);
return true;
}
}
#endregion
#region 检测指定目录中是否存在指定的文件
/// <summary>
/// 检测指定目录中是否存在指定的文件,若要搜索子目录请使用重载方法.
/// </summary>
/// <param name="directoryPath">指定目录的绝对路径</param>
/// <param name="searchPattern">模式字符串，"*"代表0或N个字符，"?"代表1个字符。
/// 范例："Log*.xml"表示搜索所有以Log开头的Xml文件。</param>
public static bool Contains(string directoryPath, string searchPattern)
{
try
{
//获取指定的文件列表
string[] fileNames = GetFileNames(directoryPath, searchPattern, false);
//判断指定文件是否存在
if (fileNames.Length == 0)
{
return false;
}
else
{
return true;
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
//LogHelper.WriteTraceLog(TraceLogLevel.Error, ex.Message);
}
}
/// <summary>
/// 检测指定目录中是否存在指定的文件
/// </summary>
/// <param name="directoryPath">指定目录的绝对路径</param>
/// <param name="searchPattern">模式字符串，"*"代表0或N个字符，"?"代表1个字符。
/// 范例："Log*.xml"表示搜索所有以Log开头的Xml文件。</param>
/// <param name="isSearchChild">是否搜索子目录</param>
public static bool Contains(string directoryPath, string searchPattern, bool isSearchChild)
{
try
{
//获取指定的文件列表
string[] fileNames = GetFileNames(directoryPath, searchPattern, true);
//判断指定文件是否存在
if (fileNames.Length == 0)
{
return false;
}
else
{
return true;
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
//LogHelper.WriteTraceLog(TraceLogLevel.Error, ex.Message);
}
}
#endregion
#region 创建目录
/// <summary>
/// 创建目录
/// </summary>
/// <param name="dir">要创建的目录路径包括目录名</param>
public static void CreateDir(string dir)
{
if (dir.Length == 0) return;
if (!Directory.Exists(System.Web.HttpContext.Current.Request.PhysicalApplicationPath + "\\" + dir))
Directory.CreateDirectory(System.Web.HttpContext.Current.Request.PhysicalApplicationPath + "\\" + dir);
}
#endregion
#region 删除目录
/// <summary>
/// 删除目录
/// </summary>
/// <param name="dir">要删除的目录路径和名称</param>
public static void DeleteDir(string dir)
{
if (dir.Length == 0) return;
if (Directory.Exists(System.Web.HttpContext.Current.Request.PhysicalApplicationPath + "\\" + dir))
Directory.Delete(System.Web.HttpContext.Current.Request.PhysicalApplicationPath + "\\" + dir);
}
#endregion
#region 删除文件
/// <summary>
/// 删除文件
/// </summary>
/// <param name="file">要删除的文件路径和名称</param>
public static void DeleteFile(string file)
{
if (File.Exists(System.Web.HttpContext.Current.Request.PhysicalApplicationPath + file))
File.Delete(System.Web.HttpContext.Current.Request.PhysicalApplicationPath + file);
}
#endregion
#region 创建文件
/// <summary>
/// 创建文件
/// </summary>
/// <param name="dir">带后缀的文件名</param>
/// <param name="pagestr">文件内容</param>
public static void CreateFile(string dir, string pagestr)
{
dir = dir.Replace("/", "\\");
if (dir.IndexOf("\\") > -1)
CreateDir(dir.Substring(0, dir.LastIndexOf("\\")));
System.IO.StreamWriter sw = new System.IO.StreamWriter(
System.Web.HttpContext.Current.Request.PhysicalApplicationPath + "\\" + dir, false,
System.Text.Encoding.GetEncoding("GB2312"));
sw.Write(pagestr);
sw.Close();
}
#endregion
#region 移动文件(剪贴--粘贴)
/// <summary>
/// 移动文件(剪贴--粘贴)
/// </summary>
/// <param name="dir1">要移动的文件的路径及全名(包括后缀)</param>
/// <param name="dir2">文件移动到新的位置,并指定新的文件名</param>
public static void MoveFile(string dir1, string dir2)
{
dir1 = dir1.Replace("/", "\\");
dir2 = dir2.Replace("/", "\\");
if (File.Exists(System.Web.HttpContext.Current.Request.PhysicalApplicationPath + "\\" + dir1))
File.Move(System.Web.HttpContext.Current.Request.PhysicalApplicationPath + "\\" + dir1,
System.Web.HttpContext.Current.Request.PhysicalApplicationPath + "\\" + dir2);
}
#endregion
#region 复制文件
/// <summary>
/// 复制文件
/// </summary>
/// <param name="dir1">要复制的文件的路径已经全名(包括后缀)</param>
/// <param name="dir2">目标位置,并指定新的文件名</param>
public static void CopyFile(string dir1, string dir2)
{
dir1 = dir1.Replace("/", "\\");
dir2 = dir2.Replace("/", "\\");
if (File.Exists(System.Web.HttpContext.Current.Request.PhysicalApplicationPath + "\\" + dir1))
{
File.Copy(System.Web.HttpContext.Current.Request.PhysicalApplicationPath + "\\" + dir1,
System.Web.HttpContext.Current.Request.PhysicalApplicationPath + "\\" + dir2, true);
}
}
#endregion
#region 根据时间得到目录名 / 格式:yyyyMMdd 或者 HHmmssff
/// <summary>
/// 根据时间得到目录名yyyyMMdd
/// </summary>
/// <returns></returns>
public static string GetDateDir()
{
return DateTime.Now.ToString("yyyyMMdd");
}
/// <summary>
/// 根据时间得到文件名HHmmssff
/// </summary>
/// <returns></returns>
public static string GetDateFile()
{
return DateTime.Now.ToString("HHmmssff");
}
#endregion
#region 复制文件夹
/// <summary>
/// 复制文件夹(递归)
/// </summary>
/// <param name="varFromDirectory">源文件夹路径</param>
/// <param name="varToDirectory">目标文件夹路径</param>
public static void CopyFolder(string varFromDirectory, string varToDirectory)
{
Directory.CreateDirectory(varToDirectory);
if (!Directory.Exists(varFromDirectory)) return;
string[] directories = Directory.GetDirectories(varFromDirectory);
if (directories.Length > 0)
{
foreach (string d in directories)
{
CopyFolder(d, varToDirectory + d.Substring(d.LastIndexOf("\\")));
}
}
string[] files = Directory.GetFiles(varFromDirectory);
if (files.Length > 0)
{
foreach (string s in files)
{
File.Copy(s, varToDirectory + s.Substring(s.LastIndexOf("\\")), true);
}
}
}
#endregion
#region 检查文件,如果文件不存在则创建
/// <summary>
/// 检查文件,如果文件不存在则创建
/// </summary>
/// <param name="FilePath">路径,包括文件名</param>
public static void ExistsFile(string FilePath)
{
//if(!File.Exists(FilePath))
//File.Create(FilePath);
//以上写法会报错,详细解释请看下文.........
if (!File.Exists(FilePath))
{
FileStream fs = File.Create(FilePath);
fs.Close();
}
}
#endregion
#region 删除指定文件夹对应其他文件夹里的文件
/// <summary>
/// 删除指定文件夹对应其他文件夹里的文件
/// </summary>
/// <param name="varFromDirectory">指定文件夹路径</param>
/// <param name="varToDirectory">对应其他文件夹路径</param>
public static void DeleteFolderFiles(string varFromDirectory, string varToDirectory)
{
Directory.CreateDirectory(varToDirectory);
if (!Directory.Exists(varFromDirectory)) return;
string[] directories = Directory.GetDirectories(varFromDirectory);
if (directories.Length > 0)
{
foreach (string d in directories)
{
DeleteFolderFiles(d, varToDirectory + d.Substring(d.LastIndexOf("\\")));
}
}
string[] files = Directory.GetFiles(varFromDirectory);
if (files.Length > 0)
{
foreach (string s in files)
{
File.Delete(varToDirectory + s.Substring(s.LastIndexOf("\\")));
}
}
}
#endregion
#region 从文件的绝对路径中获取文件名( 包含扩展名 )
/// <summary>
/// 从文件的绝对路径中获取文件名( 包含扩展名 )
/// </summary>
/// <param name="filePath">文件的绝对路径</param>
public static string GetFileName(string filePath)
{
if (!string.IsNullOrEmpty(filePath))
{
//获取文件的名称
FileInfo fi = new FileInfo(filePath);
return fi.Name;
}
MessageBox.Show("请选择文件");
return "";
}
#endregion
#region 从文件的绝对路径中获取文件名( 不包含扩展名 )
/// <summary>
/// 从文件的绝对路径中获取文件名( 不包含扩展名 )
/// </summary>
/// <param name="filePath">文件的绝对路径</param>
public static string GetFileNameNoExtension(string filePath)
{
//获取文件的名称
FileInfo fi = new FileInfo(filePath);
return fi.Name.Split('.')[0];
}
#endregion
#region 从文件的绝对路径中获取扩展名
/// <summary>
/// 从文件的绝对路径中获取扩展名
/// </summary>
/// <param name="filePath">文件的绝对路径</param>
public static string GetExtension(string filePath)
{
//获取文件的名称
FileInfo fi = new FileInfo(filePath);
return fi.Extension;
}
#region 从文件的绝对路径创建备份的文件路劲（包含扩展名）【另存文件用】
/// <summary>
/// 从文件的绝对路径创建备份的文件路劲（包含扩展名）【另存文件用】
/// </summary>
/// <param name="filePath">文件的绝对路径</param>
public static string GetBackUpFilePathWithFilePath(string filePath,string backUpName)
{
try
{
//获取文件所在的目录
string fileDirectory = Path.GetDirectoryName(filePath);
//获取文件的名称含有后缀
string fileName = Path.GetFileName(filePath);
return fileDirectory + "\\" + fileName.Split('.')[0] + backUpName + "." + fileName.Split('.')[1];
}
catch (Exception e)
{
MessageBox.Show("文件不存在: "+e.Message);
return null;
}
}
#endregion
#endregion
/// <summary>
/// 复制文件参考方法,页面中引用
/// </summary>
/// <param name="cDir">新路径</param>
/// <param name="TempId">模板引擎替换编号</param>
public static void CopyFiles(string cDir, string TempId)
{
//if (Directory.Exists(Request.PhysicalApplicationPath + "\\Controls"))
//{
// string TempStr = string.Empty;
// StreamWriter sw;
// if (File.Exists(Request.PhysicalApplicationPath + "\\Controls\\Default.aspx"))
// {
// TempStr = File.ReadAllText(Request.PhysicalApplicationPath + "\\Controls\\Default.aspx");
// TempStr = TempStr.Replace("{$ChannelId$}", TempId);
// sw = new StreamWriter(Request.PhysicalApplicationPath + "\\" + cDir + "\\Default.aspx", false, System.Text.Encoding.GetEncoding("GB2312"));
// sw.Write(TempStr);
// sw.Close();
// }
// if (File.Exists(Request.PhysicalApplicationPath + "\\Controls\\Column.aspx"))
// {
// TempStr = File.ReadAllText(Request.PhysicalApplicationPath + "\\Controls\\Column.aspx");
// TempStr = TempStr.Replace("{$ChannelId$}", TempId);
// sw = new StreamWriter(Request.PhysicalApplicationPath + "\\" + cDir + "\\List.aspx", false, System.Text.Encoding.GetEncoding("GB2312"));
// sw.Write(TempStr);
// sw.Close();
// }
// if (File.Exists(Request.PhysicalApplicationPath + "\\Controls\\Content.aspx"))
// {
// TempStr = File.ReadAllText(Request.PhysicalApplicationPath + "\\Controls\\Content.aspx");
// TempStr = TempStr.Replace("{$ChannelId$}", TempId);
// sw = new StreamWriter(Request.PhysicalApplicationPath + "\\" + cDir + "\\View.aspx", false, System.Text.Encoding.GetEncoding("GB2312"));
// sw.Write(TempStr);
// sw.Close();
// }
// if (File.Exists(Request.PhysicalApplicationPath + "\\Controls\\MoreDiss.aspx"))
// {
// TempStr = File.ReadAllText(Request.PhysicalApplicationPath + "\\Controls\\MoreDiss.aspx");
// TempStr = TempStr.Replace("{$ChannelId$}", TempId);
// sw = new StreamWriter(Request.PhysicalApplicationPath + "\\" + cDir + "\\DissList.aspx", false, System.Text.Encoding.GetEncoding("GB2312"));
// sw.Write(TempStr);
// sw.Close();
// }
// if (File.Exists(Request.PhysicalApplicationPath + "\\Controls\\ShowDiss.aspx"))
// {
// TempStr = File.ReadAllText(Request.PhysicalApplicationPath + "\\Controls\\ShowDiss.aspx");
// TempStr = TempStr.Replace("{$ChannelId$}", TempId);
// sw = new StreamWriter(Request.PhysicalApplicationPath + "\\" + cDir + "\\Diss.aspx", false, System.Text.Encoding.GetEncoding("GB2312"));
// sw.Write(TempStr);
// sw.Close();
// }
// if (File.Exists(Request.PhysicalApplicationPath + "\\Controls\\Review.aspx"))
// {
// TempStr = File.ReadAllText(Request.PhysicalApplicationPath + "\\Controls\\Review.aspx");
// TempStr = TempStr.Replace("{$ChannelId$}", TempId);
// sw = new StreamWriter(Request.PhysicalApplicationPath + "\\" + cDir + "\\Review.aspx", false, System.Text.Encoding.GetEncoding("GB2312"));
// sw.Write(TempStr);
// sw.Close();
// }
// if (File.Exists(Request.PhysicalApplicationPath + "\\Controls\\Search.aspx"))
// {
// TempStr = File.ReadAllText(Request.PhysicalApplicationPath + "\\Controls\\Search.aspx");
// TempStr = TempStr.Replace("{$ChannelId$}", TempId);
// sw = new StreamWriter(Request.PhysicalApplicationPath + "\\" + cDir + "\\Search.aspx", false, System.Text.Encoding.GetEncoding("GB2312"));
// sw.Write(TempStr);
// sw.Close();
// }
//}
}
#region 创建一个目录
/// <summary>
/// 创建一个目录
/// </summary>
/// <param name="directoryPath">目录的绝对路径</param>
public static void CreateDirectory(string directoryPath)
{
//如果目录不存在则创建该目录
if (!IsExistDirectory(directoryPath))
{
Directory.CreateDirectory(directoryPath);
}
}
#endregion
#region 创建一个文件
/// <summary>
/// 创建一个文件。
/// </summary>
/// <param name="filePath">文件的绝对路径</param>
public static void CreateFile(string filePath)
{
try
{
//如果文件不存在则创建该文件
if (!IsExistFile(filePath))
{
//创建一个FileInfo对象
FileInfo file = new FileInfo(filePath);
//创建文件
FileStream fs = file.Create();
//关闭文件流
fs.Close();
}
}
catch (Exception ex)
{
//LogHelper.WriteTraceLog(TraceLogLevel.Error, ex.Message);
throw ex;
}
}
/// <summary>
/// 创建一个文件,并将字节流写入文件。
/// </summary>
/// <param name="filePath">文件的绝对路径</param>
/// <param name="buffer">二进制流数据</param>
public static void CreateFile(string filePath, byte[] buffer)
{
try
{
//如果文件不存在则创建该文件
if (!IsExistFile(filePath))
{
//创建一个FileInfo对象
FileInfo file = new FileInfo(filePath);
//创建文件
FileStream fs = file.Create();
//写入二进制流
fs.Write(buffer, 0, buffer.Length);
//关闭文件流
fs.Close();
}
}
catch (Exception ex)
{
//LogHelper.WriteTraceLog(TraceLogLevel.Error, ex.Message);
throw ex;
}
}
#endregion
#region 获取文本文件的行数
/// <summary>
/// 获取文本文件的行数
/// </summary>
/// <param name="filePath">文件的绝对路径</param>
public static int GetLineCount(string filePath)
{
//将文本文件的各行读到一个字符串数组中
string[] rows = File.ReadAllLines(filePath);
//返回行数
return rows.Length;
}
#endregion
#region 获取一个文件的长度
/// <summary>
/// 获取一个文件的长度,单位为Byte
/// </summary>
/// <param name="filePath">文件的绝对路径</param>
public static int GetFileSize(string filePath)
{
//创建一个文件对象
FileInfo fi = new FileInfo(filePath);
//获取文件的大小
return (int) fi.Length;
}
#endregion
#region 获取指定目录中的子目录列表
/// <summary>
/// 获取指定目录及子目录中所有子目录列表
/// </summary>
/// <param name="directoryPath">指定目录的绝对路径</param>
/// <param name="searchPattern">模式字符串，"*"代表0或N个字符，"?"代表1个字符。
/// 范例："Log*.xml"表示搜索所有以Log开头的Xml文件。</param>
/// <param name="isSearchChild">是否搜索子目录</param>
public static string[] GetDirectories(string directoryPath, string searchPattern, bool isSearchChild)
{
try
{
if (isSearchChild)
{
return Directory.GetDirectories(directoryPath, searchPattern, SearchOption.AllDirectories);
}
else
{
return Directory.GetDirectories(directoryPath, searchPattern, SearchOption.TopDirectoryOnly);
}
}
catch (IOException ex)
{
throw ex;
}
}
#endregion
#region 向文本文件写入内容
/// <summary>
/// 向文本文件中写入内容
/// </summary>
/// <param name="filePath">文件的绝对路径</param>
/// <param name="text">写入的内容</param>
/// <param name="encoding">编码</param>
public static void WriteText(string filePath, string text, Encoding encoding)
{
//向文件写入内容
File.WriteAllText(filePath, text, encoding);
}
#endregion
#region 向文本文件的尾部追加内容
/// <summary>
/// 向文本文件的尾部追加内容
/// </summary>
/// <param name="filePath">文件的绝对路径</param>
/// <param name="content">写入的内容</param>
public static void AppendText(string filePath, string content)
{
File.AppendAllText(filePath, content);
}
#endregion
#region 将现有文件的内容复制到新文件中
/// <summary>
/// 将源文件的内容复制到目标文件中
/// </summary>
/// <param name="sourceFilePath">源文件的绝对路径</param>
/// <param name="destFilePath">目标文件的绝对路径</param>
public static void Copy(string sourceFilePath, string destFilePath)
{
File.Copy(sourceFilePath, destFilePath, true);
}
#endregion
#region 将文件移动到指定目录
/// <summary>
/// 将文件移动到指定目录
/// </summary>
/// <param name="sourceFilePath">需要移动的源文件的绝对路径</param>
/// <param name="descDirectoryPath">移动到的目录的绝对路径</param>
public static void Move(string sourceFilePath, string descDirectoryPath)
{
//获取源文件的名称
string sourceFileName = GetFileName(sourceFilePath);
if (IsExistDirectory(descDirectoryPath))
{
//如果目标中存在同名文件,则删除
if (IsExistFile(descDirectoryPath + "\\" + sourceFileName))
{
DeleteFile(descDirectoryPath + "\\" + sourceFileName);
}
//将文件移动到指定目录
File.Move(sourceFilePath, descDirectoryPath + "\\" + sourceFileName);
}
}
#endregion
#region 清空指定目录
/// <summary>
/// 清空指定目录下所有文件及子目录,但该目录依然保存.
/// </summary>
/// <param name="directoryPath">指定目录的绝对路径</param>
public static void ClearDirectory(string directoryPath)
{
if (IsExistDirectory(directoryPath))
{
//删除目录中所有的文件
string[] fileNames = GetFileNames(directoryPath);
for (int i = 0; i < fileNames.Length; i++)
{
DeleteFile(fileNames[i]);
}
//删除目录中所有的子目录
string[] directoryNames = GetDirectories(directoryPath);
for (int i = 0; i < directoryNames.Length; i++)
{
DeleteDirectory(directoryNames[i]);
}
}
}
#endregion
#region 清空文件内容
/// <summary>
/// 清空文件内容
/// </summary>
/// <param name="filePath">文件的绝对路径</param>
public static void ClearFile(string filePath)
{
//删除文件
File.Delete(filePath);
//重新创建该文件
CreateFile(filePath);
}
#endregion
#region 删除指定目录
/// <summary>
/// 删除指定目录及其所有子目录
/// </summary>
/// <param name="directoryPath">指定目录的绝对路径</param>
public static void DeleteDirectory(string directoryPath)
{
if (IsExistDirectory(directoryPath))
{
Directory.Delete(directoryPath, true);
}
}
#endregion
/*
string filePath = "C:\\JiYF\\BenXH\\BenXHCMS.xml";
Console.WriteLine("该文件的目录："+filePath);
string str = "获取文件的全路径：" + Path.GetFullPath(filePath); //-->C:\JiYF\BenXH\BenXHCMS.xml
str = "获取文件所在的目录：" + Path.GetDirectoryName(filePath); //-->C:\JiYF\BenXH
str = "获取文件的名称含有后缀：" + Path.GetFileName(filePath); //-->BenXHCMS.xml
str = "获取文件的名称没有后缀：" + Path.GetFileNameWithoutExtension(filePath); //-->BenXHCMS
str = "获取路径的后缀扩展名称：" + Path.GetExtension(filePath); //-->.xml
str = "获取路径的根目录：" + Path.GetPathRoot(filePath); //-->C:\
*/
}
}
浙公网安备 33010602011771号