1.FileHeper
代码
csharp
复制代码
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Threading.Tasks;
namespace ToolsLib
{
public class FileHelper
{
#region 1.文本文件读写
public static void WriteToTxt(string path, string content, bool isAppend = false)
{
//【1】创建文件流
FileStream fileStream = new FileStream(path, isAppend ? FileMode.Append : FileMode.Create);
//【2】创建写入器
StreamWriter streamWriter = new StreamWriter(fileStream);
//【3】以流的形式写入数据
streamWriter.Write(content);
//【4】关闭写入器
streamWriter.Close();
//【5】关闭文件流
fileStream.Close();
}
public static string ReadFromTxt(string path)
{
//判断文件是否存在
if (!File.Exists(path))
{
return string.Empty;
}
//【1】创建文件流
FileStream fileStream = new FileStream(path, FileMode.Open);
//【2】创建读取器
StreamReader streamReader = new StreamReader(fileStream);
//【3】以流的方式读取
string content = streamReader.ReadToEnd();
//【4】关闭读取器
streamReader.Close();
//【5】关闭文件流
fileStream.Close();
return content;
}
#endregion
#region 2.对象序列化文件
// BinaryFormatter 序列化与反序列化，不稳定，不安全，已经被微软抛弃了
/// <summary>
/// 序列化一个对象到一个文件中
/// </summary>
/// <param name="obj"></param>
/// <param name="path"></param>
public static void SerializeObject(object obj, string path)
{
FileStream fileStream = null;
try
{
fileStream = new FileStream(path, FileMode.Create);
BinaryFormatter binaryFormatter = new BinaryFormatter();
binaryFormatter.Serialize(fileStream, obj);
}
catch (Exception ex)
{
throw new Exception("序列化对象出错：" + ex.Message);
}
finally
{
fileStream.Close();
}
}
public static T DeSerializeObject<T>(string path)
{
FileStream fileStream = null;
try
{
fileStream = new FileStream(path, FileMode.Open);
BinaryFormatter binaryFormatter = new BinaryFormatter();
return (T)binaryFormatter.Deserialize(fileStream);
}
catch (Exception ex)
{
throw new Exception("反序列化对象出错：" + ex.Message);
}
finally
{
fileStream.Close();
}
}
#endregion
#region 3.对象序列化字符串
/// <summary>
/// 将对象序列化成字符串
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public static string SerializeObjToString(object obj)
{
IFormatter formatter = new BinaryFormatter();
string result = string.Empty;
using (MemoryStream stream = new MemoryStream())
{
formatter.Serialize(stream, obj);
byte[] bytes = stream.ToArray();
result = Convert.ToBase64String(bytes);
stream.Flush();
}
return result;
}
/// <summary>
/// 将字符串反序列化成对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="str"></param>
/// <returns></returns>
public static T DeSerializeObjFromString<T>(string str) where T : class
{
IFormatter formatter = new BinaryFormatter();
byte[] bytes = Convert.FromBase64String(str);
T obj = null;
using (MemoryStream stream = new MemoryStream(bytes, 0, bytes.Length))
{
obj = (T)formatter.Deserialize(stream);
}
return obj;
}
#endregion
#region 4.文件的基本操作
/// <summary>
/// 文件复制
/// </summary>
/// <param name="srcFileName"></param>
/// <param name="desFileName"></param>
public static void CopyFile(string srcFileName, string desFileName)
{
if (File.Exists(desFileName))
{
File.Delete(desFileName);
}
File.Copy(srcFileName, desFileName);
}
/// <summary>
/// 文件移动
/// </summary>
/// <param name="srcFileName"></param>
/// <param name="desFileName"></param>
public static void MoveFile(string srcFileName, string desFileName)
{
if (File.Exists(srcFileName))
{
if (File.Exists(desFileName))
{
File.Delete(desFileName);
}
File.Move(srcFileName, desFileName);
}
}
/// <summary>
/// 文件删除
/// </summary>
/// <param name="fileName"></param>
public static void DeleteFile(string fileName)
{
if (File.Exists(fileName))
{
File.Delete(fileName);
}
}
#endregion
#region 5.文件夹的相关操作
/// <summary>
/// 获取指定目录下的所有文件
/// </summary>
/// <param name="path"></param>
/// <returns></returns>
public static string[] GetFiles(string path)
{
return Directory.GetFiles(path);
}
/// <summary>
/// 获取指定目录下的所有子目录
/// </summary>
/// <param name="path"></param>
/// <returns></returns>
public static string[] GetDirectories(string path)
{
return Directory.GetDirectories(path);
}
/// <summary>
/// 创建文件夹
/// </summary>
/// <param name="path"></param>
public static void CreateDirectory(string path)
{
Directory.CreateDirectory(path);
}
/// <summary>
/// 删除指定目录下的所有子目录和文件
/// </summary>
/// <param name="path"></param>
public static void DeleteFiles(string path)
{
DirectoryInfo directory = new DirectoryInfo(path);
directory.Delete(true);
}
#endregion
}
}
2.Ini帮助类 IniConfigHelper
代码
csharp
复制代码
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
namespace ToolsLib
{
public class IniConfigHelper
{
/// <summary>
/// 文件路径
/// </summary>
public static string IniPath = string.Empty;
#region API函数声明
[DllImport("kernel32")]
private static extern long WritePrivateProfileString(string section, string key,
string val, string filePath);
//需要调用GetPrivateProfileString的重载
[DllImport("kernel32", EntryPoint = "GetPrivateProfileString")]
private static extern long GetPrivateProfileString(string section, string key,
string def, StringBuilder retVal, int size, string filePath);
[DllImport("kernel32", EntryPoint = "GetPrivateProfileString")]
private static extern uint GetPrivateProfileStringA(string section, string key,
string def, Byte[] retVal, int size, string filePath);
#endregion
#region 读取INI文件
/// <summary>
/// 根据节点及Key的值返回数据
/// </summary>
/// <param name="Section">节点</param>
/// <param name="Key">键</param>
/// <param name="defaultValue">默认值</param>
/// <param name="path">路径</param>
/// <returns>返回值</returns>
public static string ReadIniData(string Section, string Key, string defaultValue, string path)
{
if (File.Exists(path))
{
StringBuilder stringBuilder = new StringBuilder();
GetPrivateProfileString(Section, Key, defaultValue, stringBuilder, 1024, path);
return stringBuilder.ToString();
}
else
{
return string.Empty;
}
}
/// <summary>
/// 根据节点及Key的值返回数据
/// </summary>
/// <param name="Section">节点</param>
/// <param name="Key">键</param>
/// <param name="defaultValue">默认值</param>
/// <returns>返回值</returns>
public static string ReadIniData(string Section, string Key, string defaultValue)
{
return ReadIniData(Section, Key, defaultValue, IniPath);
}
#endregion
#region 写入Ini文件
/// <summary>
/// 根据节点及Key的值写入数据
/// </summary>
/// <param name="Section">节点</param>
/// <param name="Key">键</param>
/// <param name="Value">值</param>
/// <param name="path">路径</param>
/// <returns>操作结果</returns>
public static bool WriteIniData(string Section, string Key, string Value, string path)
{
long result = WritePrivateProfileString(Section, Key, Value, path);
if (result == 0)
{
return false;
}
else
{
return true;
}
}
/// <summary>
/// 根据节点及Key的值写入数据
/// </summary>
/// <param name="Section">节点</param>
/// <param name="Key">键</param>
/// <param name="Value">值</param>
/// <returns>操作结果</returns>
public static bool WriteIniData(string Section, string Key, string Value)
{
return WriteIniData(Section, Key, Value, IniPath);
}
#endregion
#region 读取所有的Sections
/// <summary>
/// 读取所有的Section
/// </summary>
/// <param name="path">路径</param>
/// <returns>Section集合</returns>
public static List<string> ReadSections(string path)
{
byte[] buffer = new byte[65536];
uint length = GetPrivateProfileStringA(null, null, null, buffer, buffer.Length, path);
int startIndex = 0;
List<string> sections = new List<string>();
for (int i = 0; i < length; i++)
{
if (buffer[i] == 0)
{
sections.Add(Encoding.Default.GetString(buffer, startIndex, i - startIndex));
startIndex = i + 1;
}
}
return sections;
}
/// <summary>
/// 读取所有的Section
/// </summary>
/// <param name="path">路径</param>
/// <returns>Section集合</returns>
public static List<string> ReadSections()
{
byte[] buffer = new byte[65536];
uint length = GetPrivateProfileStringA(null, null, null, buffer, buffer.Length, IniPath);
int startIndex = 0;
List<string> sections = new List<string>();
for (int i = 0; i < length; i++)
{
if (buffer[i] == 0)
{
sections.Add(Encoding.Default.GetString(buffer, startIndex, i - startIndex));
startIndex = i + 1;
}
}
return sections;
}
#endregion
#region 根据某个Section读取所有的Keys
/// <summary>
/// 根据某个Section读取所有的Keys
/// </summary>
/// <param name="section">某个section</param>
/// <param name="path">路径</param>
/// <returns>key的集合</returns>
public static List<string> ReadKeys(string section, string path)
{
byte[] buffer = new byte[65536];
uint length = GetPrivateProfileStringA(section, null, null, buffer, buffer.Length, path);
int startIndex = 0;
List<string> keys = new List<string>();
for (int i = 0; i < length; i++)
{
if (buffer[i] == 0)
{
keys.Add(Encoding.Default.GetString(buffer, startIndex, i - startIndex));
startIndex = i + 1;
}
}
return keys;
}
/// <summary>
/// 根据某个Section读取所有的Keys
/// </summary>
/// <param name="section">某个section</param>
/// <param name="path">路径</param>
/// <returns>key的集合</returns>
public static List<string> ReadKeys(string section)
{
byte[] buffer = new byte[65536];
uint length = GetPrivateProfileStringA(section, null, null, buffer, buffer.Length, IniPath);
int startIndex = 0;
List<string> keys = new List<string>();
for (int i = 0; i < length; i++)
{
if (buffer[i] == 0)
{
keys.Add(Encoding.Default.GetString(buffer, startIndex, i - startIndex));
startIndex = i + 1;
}
}
return keys;
}
#endregion
}
}
3.JSON
介绍
复制代码
JSON 是一个轻量级描述数据信息的特殊格式的文件
1：以key:value 键值对形式描述数据信息
2: json中类型：数组，对象，string 数字 bool
3: [] ------ 数组或者集合
{} ------ 对象
安装 ：Newtonsoft.Json;
代码
csharp
复制代码
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.Serialization.Json;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
namespace ToolsLib
{
public class JsonHelper
{
/// <summary>
/// 使用Newtonsoft.json.dll对象序列化成Json字符串
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="t"></param>
/// <returns></returns>
public static string EntityToJson<T>(T t)
{
try
{
return JsonConvert.SerializeObject(t);
}
catch (Exception)
{
return string.Empty;
}
}
/// <summary>
/// 使用Newtonsoft.json.dll 将Json字符串反序列化成对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="json"></param>
/// <returns></returns>
public static T JsonToEntity<T>(string json)
{
try
{
return (T)JsonConvert.DeserializeObject(json,typeof(T));
}
catch (Exception)
{
return default(T);
}
}
/// <summary>
/// 实体类转换成JSON字符串
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="obj"></param>
/// <returns></returns>
public static string EntityToJson2<T>(T obj)
{
//序列化
DataContractJsonSerializer js = new DataContractJsonSerializer(typeof(T));
MemoryStream msObj = new MemoryStream();
//将序列化之后的Json格式数据写入流中
js.WriteObject(msObj, obj);
msObj.Position = 0;
//从0这个位置开始读取流中的数据
StreamReader sr = new StreamReader(msObj, Encoding.Default);
string json = sr.ReadToEnd();
sr.Close();
msObj.Close();
return json;
}
/// <summary>
/// JSON字符串转换成实体类
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="json"></param>
/// <returns></returns>
public static T JsonToEntity2<T>(string json) where T : class
{
//反序列化
using (var ms = new MemoryStream(Encoding.Default.GetBytes(json)))
{
DataContractJsonSerializer deseralizer = new DataContractJsonSerializer(typeof(T));
T model = (T)deseralizer.ReadObject(ms);// //反序列化ReadObject
return model;
}
}
}
}
4.xml
代码
csharp
复制代码
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using System.Xml.Serialization;
namespace ToolsLib
{
public class XmlHelper
{
#region 1.Xml序列化反序列化相关的方法
/// <summary>
/// 使用XmlSerializer序列化对象
/// </summary>
/// <typeparam name="T">需要序列化的对象类型，必须声明[Serializable]特征</typeparam>
/// <param name="obj">需要序列化的对象</param>
/// <param name="omitXmlDeclaration">true:省略XML声明;否则为false.默认false，即编写 XML 声明。</param>
/// <returns>序列化后的字符串</returns>
public static string EntityToXml<T>(T obj, bool omitXmlDeclaration = false)
{
/* This property only applies to XmlWriter instances that output text content to a stream; otherwise, this setting is ignored.
可能很多朋友遇见过 不能转换成Xml不能反序列化成为UTF8XML声明的情况，就是这个原因。
*/
XmlWriterSettings xmlSettings = new XmlWriterSettings();
xmlSettings.OmitXmlDeclaration = omitXmlDeclaration;
xmlSettings.Encoding = new System.Text.UTF8Encoding(false);
MemoryStream stream = new MemoryStream();
XmlWriter xmlwriter = XmlWriter.Create(stream, xmlSettings); //这里如果直接写成：Encoding = Encoding.UTF8 会在生成的xml中加入BOM(Byte-order Mark) 信息(Unicode 字节顺序标记) ， 所以new System.Text.UTF8Encoding(false)是最佳方式，省得再做替换的麻烦
XmlSerializerNamespaces xmlns = new XmlSerializerNamespaces();
xmlns.Add(String.Empty, String.Empty); //在XML序列化时去除默认命名空间xmlns:xsd和xmlns:xsi
XmlSerializer ser = new XmlSerializer(typeof(T));
ser.Serialize(xmlwriter, obj, xmlns);
return Encoding.UTF8.GetString(stream.ToArray());//writer.ToString();
}
/// <summary>
/// 使用XmlSerializer序列化对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="path">文件路径</param>
/// <param name="obj">需要序列化的对象</param>
/// <param name="omitXmlDeclaration">true:省略XML声明;否则为false.默认false，即编写 XML 声明。</param>
/// <param name="removeDefaultNamespace">是否移除默认名称空间(如果对象定义时指定了:XmlRoot(Namespace = "http://www.xxx.com/xsd")则需要传false值进来)</param>
/// <returns>序列化后的字符串</returns>
public static void EntityToXmlFile<T>(string path, T obj, bool omitXmlDeclaration = false, bool removeDefaultNamespace = true)
{
XmlWriterSettings xmlSetings = new XmlWriterSettings();
xmlSetings.OmitXmlDeclaration = omitXmlDeclaration;
using (XmlWriter xmlwriter = XmlWriter.Create(path, xmlSetings))
{
XmlSerializerNamespaces xmlns = new XmlSerializerNamespaces();
if (removeDefaultNamespace)
xmlns.Add(String.Empty, String.Empty); //在XML序列化时去除默认命名空间xmlns:xsd和xmlns:xsi
XmlSerializer ser = new XmlSerializer(typeof(T));
ser.Serialize(xmlwriter, obj, xmlns);
}
}
private static byte[] ReadFile(string filePath)
{
byte[] bytes;
//避免"正由另一进程使用,因此该进程无法访问此文件"造成异常 共享锁 flieShare必须为ReadWrite，但是如果文件不存在的话，还是会出现异常，所以这里不能吃掉任何异常，但是需要考虑到这些问题
using (FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
bytes = new byte[fs.Length];
int numBytesToRead = (int)fs.Length;
int numBytesRead = 0;
while (numBytesToRead > 0)
{
int n = fs.Read(bytes, numBytesRead, numBytesToRead);
if (n == 0)
break;
numBytesRead += n;
numBytesToRead -= n;
}
}
return bytes;
}
/// <summary>
/// 使用XmlSerializer反序列化对象
/// </summary>
/// <param name="xmlOfObject">需要反序列化的xml字符串</param>
/// <returns>反序列化后的对象</returns>
public static T XmlToEntity<T>(string xmlOfObject) where T : class
{
XmlReader xmlReader = XmlReader.Create(new StringReader(xmlOfObject), new XmlReaderSettings());
return (T)new XmlSerializer(typeof(T)).Deserialize(xmlReader);
}
/// <summary>
/// 从文件读取并反序列化为对象 （解决: 多线程或多进程下读写并发问题）
/// </summary>
/// <typeparam name="T">返回的对象类型</typeparam>
/// <param name="path">文件地址</param>
/// <returns></returns>
public static T XmlFileToEntity<T>(string path)
{
byte[] bytes = ReadFile(path);
if (bytes.Length < 1)//当文件正在被写入数据时，可能读出为0
for (int i = 0; i < 5; i++)
{
//5次机会
bytes = ReadFile(path); // 采用这样诡异的做法避免独占文件和文件正在被写入时读出来的数据为0字节的问题。
if (bytes.Length > 0) break;
System.Threading.Thread.Sleep(50); //悲观情况下总共最多消耗1/4秒，读取文件
}
XmlDocument doc = new XmlDocument();
doc.Load(new MemoryStream(bytes));
if (doc.DocumentElement != null)
return (T)new XmlSerializer(typeof(T)).Deserialize(new XmlNodeReader(doc.DocumentElement));
return default(T);
}
#endregion
#region 2.Xml文件读写操作的方法
/// <summary>
/// 创建XML文档
/// </summary>
/// <param name="name">根节点名称</param>
/// <param name="type">根节点的一个属性值</param>
/// <returns></returns>
/// .net中调用方法：写入文件中,则：
/// document = XmlOperate.CreateXmlDocument("sex", "sexy");
/// document.Save("c:/bookstore.xml");
public static XmlDocument CreateXmlDocument(string name, string type)
{
XmlDocument doc = null;
XmlElement rootEle = null;
try
{
doc = new XmlDocument();
doc.LoadXml("<" + name + "/>");
rootEle = doc.DocumentElement;
rootEle.SetAttribute("type", type);
}
catch (Exception ex)
{
throw ex;
}
return doc;
}
/// <summary>
/// 读取数据
/// </summary>
/// <param name="path">路径</param>
/// <param name="node">节点</param>
/// <param name="attribute">属性名，非空时返回该属性值，否则返回串联值</param>
/// <returns>string</returns>
/**************************************************
* 使用示列:
* XmlHelper.Read(path, "/Node", "")
* XmlHelper.Read(path, "/Node/Element[@Attribute='Name']", "Attribute")
************************************************/
public static string Read(string path, string node, string attribute)
{
string value = "";
try
{
XmlDocument doc = new XmlDocument();
doc.Load(path);
XmlNode xn = doc.SelectSingleNode(node);
value = (attribute.Equals("") ? xn.InnerText : xn.Attributes[attribute].Value);
}
catch (Exception ex)
{
throw ex;
}
return value;
}
/// <summary>
/// 插入数据
/// </summary>
/// <param name="path">路径</param>
/// <param name="node">节点</param>
/// <param name="element">元素名，非空时插入新元素，否则在该元素中插入属性</param>
/// <param name="attribute">属性名，非空时插入该元素属性值，否则插入元素值</param>
/// <param name="value">值</param>
/// <returns></returns>
/**************************************************
* 使用示列:
* XmlHelper.Insert(path, "/Node", "Element", "", "Value")
* XmlHelper.Insert(path, "/Node", "Element", "Attribute", "Value")
* XmlHelper.Insert(path, "/Node", "", "Attribute", "Value")
************************************************/
public static void Insert(string path, string node, string element, string attribute, string value)
{
try
{
XmlDocument doc = new XmlDocument();
doc.Load(path);
XmlNode xn = doc.SelectSingleNode(node);
if (element.Equals(""))
{
if (!attribute.Equals(""))
{
XmlElement xe = (XmlElement)xn;
xe.SetAttribute(attribute, value);
}
}
else
{
XmlElement xe = doc.CreateElement(element);
if (attribute.Equals(""))
xe.InnerText = value;
else
xe.SetAttribute(attribute, value);
xn.AppendChild(xe);
}
doc.Save(path);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 修改数据
/// </summary>
/// <param name="path">路径</param>
/// <param name="node">节点</param>
/// <param name="attribute">属性名，非空时修改该节点属性值，否则修改节点值</param>
/// <param name="value">值</param>
/// <returns></returns>
/**************************************************
* 使用示列:
* XmlHelper.Insert(path, "/Node", "", "Value")
* XmlHelper.Insert(path, "/Node", "Attribute", "Value")
************************************************/
public static void Update(string path, string node, string attribute, string value)
{
try
{
XmlDocument doc = new XmlDocument();
doc.Load(path);
XmlNode xn = doc.SelectSingleNode(node);
XmlElement xe = (XmlElement)xn;
if (attribute.Equals(""))
xe.InnerText = value;
else
xe.SetAttribute(attribute, value);
doc.Save(path);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 删除数据
/// </summary>
/// <param name="path">路径</param>
/// <param name="node">节点</param>
/// <param name="attribute">属性名，非空时删除该节点属性值，否则删除节点值</param>
/// <param name="value">值</param>
/// <returns></returns>
/**************************************************
* 使用示列:
* XmlHelper.Delete(path, "/Node", "")
* XmlHelper.Delete(path, "/Node", "Attribute")
************************************************/
public static void Delete(string path, string node, string attribute)
{
try
{
XmlDocument doc = new XmlDocument();
doc.Load(path);
XmlNode xn = doc.SelectSingleNode(node);
XmlElement xe = (XmlElement)xn;
if (attribute.Equals(""))
xn.ParentNode.RemoveChild(xn);
else
xe.RemoveAttribute(attribute);
doc.Save(path);
}
catch (Exception ex)
{
throw ex;
}
}
#endregion
}
}
5.CSV
代码
csharp
复制代码
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
namespace ToolsLib
{
public class CsvHelper
{
/// <summary>
/// 将CSV文件中内容读取到DataTable中
/// </summary>
/// <param name="path">CSV文件路径</param>
/// <param name="hasTitle">是否将CSV文件的第一行读取为DataTable的列名</param>
/// <returns></returns>
public static DataTable CsvToDataTable(string path, bool hasTitle = false)
{
DataTable dt = new DataTable(); //要输出的数据表
StreamReader sr = new StreamReader(path, Encoding.Default); //文件读入流
bool bFirst = true; //指示是否第一次读取数据
//逐行读取
string line;
while ((line = sr.ReadLine()) != null)
{
string[] elements = line.Split(',');
//第一次读取数据时，要创建数据列
if (bFirst)
{
for (int i = 0; i < elements.Length; i++)
{
dt.Columns.Add();
}
bFirst = false;
}
//有标题行时，第一行当做标题行处理
if (hasTitle)
{
for (int i = 0; i < dt.Columns.Count && i < elements.Length; i++)
{
dt.Columns[i].ColumnName = elements[i];
}
hasTitle = false;
}
else //读取一行数据
{
if (elements.Length == dt.Columns.Count)
{
dt.Rows.Add(elements);
}
else
{
throw new Exception("CSV格式错误：表格各行列数不一致");
}
}
}
sr.Close();
return dt;
}
/// <summary>
/// 将CSV文件中的内容读取转换成List<T>
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="path"></param>
/// <param name="hasTitle"></param>
/// <returns></returns>
public static List<T> CsvToList<T>(string path, bool hasTitle = false)
{
DataTable dataTable = CsvToDataTable(path, hasTitle);
return DataTableToList<T>(dataTable);
}
/// <summary>
/// 将DataTable内容保存到CSV文件中
/// </summary>
/// <param name="dt">数据表</param>
/// <param name="path">CSV文件地址</param>
/// <param name="hasTitle">是否要输出数据表各列列名作为CSV文件第一行</param>
public static void DataTableToCsv(DataTable dt, string path, bool hasTitle = false)
{
StreamWriter sw = new StreamWriter(path, false, Encoding.Default);
//输出标题行（如果有）
if (hasTitle)
{
for (int i = 0; i < dt.Columns.Count; i++)
{
sw.Write(dt.Columns[i].ColumnName);
if (i != dt.Columns.Count - 1)
{
sw.Write(",");
}
}
sw.WriteLine();
}
//输出文件内容
for (int i = 0; i < dt.Rows.Count; i++)
{
for (int j = 0; j < dt.Columns.Count; j++)
{
sw.Write(dt.Rows[i][j].ToString());
if (j != dt.Columns.Count - 1)
{
sw.Write(",");
}
}
sw.WriteLine();
}
sw.Close();
}
/// <summary>
/// 将List集合转换CSV文件
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="list"></param>
/// <param name="path"></param>
/// <param name="hasTitle"></param>
public static void ListToCsv<T>(List<T> list, string path, bool hasTitle = false)
{
DataTable dataTable = ListToDataTable<T>(list);
DataTableToCsv(dataTable, path, hasTitle);
}
#region DataTableToList
public static List<T> DataTableToList<T>(DataTable table)
{
if (table == null)
{
return null;
}
List<DataRow> rows = new List<DataRow>();
foreach (DataRow row in table.Rows)
{
rows.Add(row);
}
return ConvertTo<T>(rows);
}
private static List<T> ConvertTo<T>(IList<DataRow> rows)
{
List<T> list = null;
if (rows != null)
{
list = new List<T>();
foreach (DataRow row in rows)
{
T item = CreateItem<T>(row);
list.Add(item);
}
}
return list;
}
private static T CreateItem<T>(DataRow row)
{
T obj = default(T);
if (row != null)
{
obj = Activator.CreateInstance<T>();
foreach (DataColumn column in row.Table.Columns)
{
PropertyInfo prop = obj.GetType().GetProperty(column.ColumnName);
try
{
object value = row[column.ColumnName];
SetObjectPropertyValue(obj, column.ColumnName, value.ToString());
}
catch (Exception ex)
{
throw ex;
}
}
}
return obj;
}
/// <summary>
/// 通过属性名称设置值
/// </summary>
/// <typeparam name="T">对象类型</typeparam>
/// <param name="obj">对象</param>
/// <param name="propertyName">属性名称</param>
/// <param name="value">值</param>
/// <returns>是否成功</returns>
private static bool SetObjectPropertyValue<T>(T obj, string propertyName, string value)
{
try
{
Type type = typeof(T);
object t = Convert.ChangeType(value, type.GetProperty(propertyName).PropertyType);
type.GetProperty(propertyName).SetValue(obj, t, null);
return true;
}
catch (Exception ex)
{
return false;
}
}
#endregion
#region ListToDataTable
public static DataTable ListToDataTable<T>(IEnumerable<T> collection)
{
var props = typeof(T).GetProperties();
var dt = new DataTable();
dt.Columns.AddRange(props.Select(p => new DataColumn(p.Name, p.PropertyType)).ToArray());
if (collection.Count() > 0)
{
for (int i = 0; i < collection.Count(); i++)
{
ArrayList tempList = new ArrayList();
foreach (PropertyInfo pi in props)
{
object obj = pi.GetValue(collection.ElementAt(i), null);
tempList.Add(obj);
}
object[] array = tempList.ToArray();
dt.LoadDataRow(array, true);
}
}
return dt;
}
#endregion
#region 写入到CSV
/// <summary>
/// 写入到CSV
/// </summary>
/// <param name="path">路径</param>
/// <param name="dataList">数据集合</param>
/// <param name="title">标题集合</param>
public static void WriteToCsv(string path, List<string> dataList, List<string> title = null, string remark = null)
{
StreamWriter streamWriter = null;
try
{
//说明是第一次，因为第一次需要写入title
if (!File.Exists(path))
{
streamWriter = new StreamWriter(path, false, Encoding.Default);
if (remark != null)
{
//写入一些备注信息
streamWriter.WriteLine(remark, Encoding.Default);
}
if (title != null)
{
//写入标题
streamWriter.WriteLine(string.Join(",", title), Encoding.Default);
}
}
else
{
//写入数据
streamWriter = new StreamWriter(path, true, Encoding.Default);
}
streamWriter.WriteLine(string.Join(",", dataList), Encoding.Default);
streamWriter.Flush();
streamWriter.Close();
}
catch (Exception ex)
{
throw new Exception("Csv写入失败：" + ex.Message);
}
}
#endregion
}
}
6.excel
介绍
是基于 NPOI 对 xls xlsx 文件进行处理的帮助类，使用本类之前，需要先下载安装NPOI 。看下面的API文档
代码
csharp
复制代码
using NPOI.HSSF.UserModel;
using NPOI.SS.Formula.Eval;
using NPOI.SS.UserModel;
using NPOI.SS.Util;
using NPOI.XSSF.UserModel;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Windows.Forms;
using HorizontalAlignment = NPOI.SS.UserModel.HorizontalAlignment;
namespace ToolsLib
{
public class ExcelHelper
{
#region 1.从DataTable/List导出到excel文件中，支持xls和xlsx格式
/// <summary>
/// DataTable导出到Excel文件
/// </summary>
/// <param name="dtSource">数据源</param>
/// <param name="strHeaderText">表名</param>
/// <param name="strFileName">excel文件名</param>
/// <param name="dir">datatable和excel列名对应字典</param>
/// <param name="sheetRow">每个sheet存放的行数</param>
public static void DataTableToExcel(DataTable dtSource, string strHeaderText, string strFileName, Dictionary<string, string> dir, bool isNew, int sheetRow = 50000)
{
int currentSheetCount = GetSheetNumber(strFileName);//现有的页数sheetnum
if (sheetRow <= 0)
{
sheetRow = dtSource.Rows.Count;
}
string[] temp = strFileName.Split('.');
string fileExtens = temp[temp.Length - 1];
int sheetCount = (int)Math.Ceiling((double)dtSource.Rows.Count / sheetRow);//sheet数目
if (temp[temp.Length - 1] == "xls" && dtSource.Columns.Count < 256 && sheetRow < 65536)
{
if (isNew)
{
currentSheetCount = 0;
}
for (int i = currentSheetCount; i < currentSheetCount + sheetCount; i++)
{
DataTable pageDataTable = dtSource.Clone();
int hasRowCount = dtSource.Rows.Count - sheetRow * (i - currentSheetCount) < sheetRow ? dtSource.Rows.Count - sheetRow * (i - currentSheetCount) : sheetRow;
for (int j = 0; j < hasRowCount; j++)
{
pageDataTable.ImportRow(dtSource.Rows[(i - currentSheetCount) * sheetRow + j]);
}
using (MemoryStream ms = ExportDataTable(strFileName, pageDataTable, strHeaderText, dir, i))
{
using (FileStream fs = new FileStream(strFileName, FileMode.Create, FileAccess.Write))
{
byte[] data = ms.ToArray();
fs.Write(data, 0, data.Length);
fs.Flush();
}
}
}
}
else
{
if (temp[temp.Length - 1] == "xls")
strFileName = strFileName + "x";
if (isNew)
{
currentSheetCount = 0;
}
for (int i = currentSheetCount; i < currentSheetCount + sheetCount; i++)
{
DataTable pageDataTable = dtSource.Clone();
int hasRowCount = dtSource.Rows.Count - sheetRow * (i - currentSheetCount) < sheetRow ? dtSource.Rows.Count - sheetRow * (i - currentSheetCount) : sheetRow;
for (int j = 0; j < hasRowCount; j++)
{
pageDataTable.ImportRow(dtSource.Rows[(i - currentSheetCount) * sheetRow + j]);
}
FileStream readfs = new FileStream(strFileName, FileMode.OpenOrCreate, FileAccess.Read);
MemoryStream readfsm = new MemoryStream();
readfs.CopyTo(readfsm);
readfs.Close();
using (FileStream writefs = new FileStream(strFileName, FileMode.Create, FileAccess.Write))
{
ExportDataTable(pageDataTable, strHeaderText, writefs, readfsm, dir, i);
}
readfsm.Close();
}
}
}
/// <summary>
/// 将List集合导出到Excel文件
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="list"></param>
/// <param name="strHeaderText"></param>
/// <param name="strFileName"></param>
/// <param name="dir"></param>
/// <param name="isNew"></param>
/// <param name="sheetRow"></param>
public static void ListToExcel<T>(List<T> list, string strHeaderText, string strFileName, Dictionary<string, string> dir, bool isNew, int sheetRow = 50000)
{
DataTable dataTable = ListToDataTable<T>(list);
DataTableToExcel(dataTable, strHeaderText, strFileName, dir, isNew, sheetRow);
}
/// <summary>
/// 导出为xls文件内部方法
/// </summary>
/// <param name="strFileName">excel文件名</param>
/// <param name="dtSource">datatabe源数据</param>
/// <param name="strHeaderText">表名</param>
/// <param name="sheetnum">sheet的编号</param>
/// <returns></returns>
private static MemoryStream ExportDataTable(string strFileName, DataTable dtSource, string strHeaderText, Dictionary<string, string> dir, int sheetnum)
{
//创建工作簿和sheet
IWorkbook workbook = new HSSFWorkbook();
using (Stream writefile = new FileStream(strFileName, FileMode.OpenOrCreate, FileAccess.Read))
{
if (writefile.Length > 0 && sheetnum > 0)
{
workbook = WorkbookFactory.Create(writefile);
}
}
ISheet sheet = null;
ICellStyle dateStyle = workbook.CreateCellStyle();
IDataFormat format = workbook.CreateDataFormat();
dateStyle.DataFormat = format.GetFormat("yyyy-mm-dd");
int[] arrColWidth = new int[dtSource.Columns.Count];
foreach (DataColumn item in dtSource.Columns)
{
arrColWidth[item.Ordinal] = Encoding.GetEncoding(936).GetBytes(item.ColumnName.ToString()).Length;
}
for (int i = 0; i < dtSource.Rows.Count; i++)
{
for (int j = 0; j < dtSource.Columns.Count; j++)
{
int intTemp = Encoding.GetEncoding(936).GetBytes(dtSource.Rows[i][j].ToString()).Length;
if (intTemp > arrColWidth[j])
{
arrColWidth[j] = intTemp;
}
}
}
int rowIndex = 0;
foreach (DataRow row in dtSource.Rows)
{
#region 新建表，填充表头，填充列头，样式
if (rowIndex == 0)
{
string sheetName = strHeaderText + (sheetnum == 0 ? "" : sheetnum.ToString());
if (workbook.GetSheetIndex(sheetName) >= 0)
{
workbook.RemoveSheetAt(workbook.GetSheetIndex(sheetName));
}
sheet = workbook.CreateSheet(sheetName);
#region 表头及样式
{
sheet.AddMergedRegion(new CellRangeAddress(0, 0, 0, dtSource.Columns.Count - 1));
IRow headerRow = sheet.CreateRow(0);
headerRow.HeightInPoints = 25;
headerRow.CreateCell(0).SetCellValue(strHeaderText);
ICellStyle headStyle = workbook.CreateCellStyle();
headStyle.Alignment = HorizontalAlignment.Center;
IFont font = workbook.CreateFont();
font.FontHeightInPoints = 20;
font.IsBold = true;
headStyle.SetFont(font);
headerRow.GetCell(0).CellStyle = headStyle;
rowIndex = 1;
}
#endregion
#region 列头及样式
if (rowIndex == 1)
{
IRow headerRow = sheet.CreateRow(1);//第二行设置列名
ICellStyle headStyle = workbook.CreateCellStyle();
headStyle.Alignment = HorizontalAlignment.Center;
IFont font = workbook.CreateFont();
font.FontHeightInPoints = 10;
font.IsBold = true;
headStyle.SetFont(font);
//写入列标题
foreach (DataColumn column in dtSource.Columns)
{
headerRow.CreateCell(column.Ordinal).SetCellValue(dir[column.ColumnName]);
headerRow.GetCell(column.Ordinal).CellStyle = headStyle;
//设置列宽
sheet.SetColumnWidth(column.Ordinal, (arrColWidth[column.Ordinal] + 1) * 256 * 2);
}
rowIndex = 2;
}
#endregion
}
#endregion
#region 填充内容
IRow dataRow = sheet.CreateRow(rowIndex);
foreach (DataColumn column in dtSource.Columns)
{
ICell newCell = dataRow.CreateCell(column.Ordinal);
string drValue = row[column].ToString();
switch (column.DataType.ToString())
{
case "System.String": //字符串类型
double result;
if (isNumeric(drValue, out result))
{
//数字字符串
double.TryParse(drValue, out result);
newCell.SetCellValue(result);
break;
}
else
{
newCell.SetCellValue(drValue);
break;
}
case "System.DateTime": //日期类型
DateTime dateV;
DateTime.TryParse(drValue, out dateV);
newCell.SetCellValue(dateV);
newCell.CellStyle = dateStyle; //格式化显示
break;
case "System.Boolean": //布尔型
bool boolV = false;
bool.TryParse(drValue, out boolV);
newCell.SetCellValue(boolV);
break;
case "System.Int16": //整型
case "System.Int32":
case "System.Int64":
case "System.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(drValue.ToString());
break;
}
}
#endregion
rowIndex++;
}
using (MemoryStream ms = new MemoryStream())
{
workbook.Write(ms);
ms.Flush();
ms.Position = 0;
return ms;
}
}
/// <summary>
/// 导出为xlsx文件内部方法
/// </summary>
/// <param name="dtSource">datatable数据源</param>
/// <param name="strHeaderText">表名</param>
/// <param name="fs">文件流</param>
/// <param name="readfs">内存流</param>
/// <param name="sheetnum">sheet索引</param>
private static void ExportDataTable(DataTable dtSource, string strHeaderText, FileStream fs, MemoryStream readfs, Dictionary<string, string> dir, int sheetnum)
{
IWorkbook workbook = new XSSFWorkbook();
if (readfs.Length > 0 && sheetnum > 0)
{
workbook = WorkbookFactory.Create(readfs);
}
ISheet sheet = null;
ICellStyle dateStyle = workbook.CreateCellStyle();
IDataFormat format = workbook.CreateDataFormat();
dateStyle.DataFormat = format.GetFormat("yyyy-mm-dd");
//取得列宽
int[] arrColWidth = new int[dtSource.Columns.Count];
foreach (DataColumn item in dtSource.Columns)
{
arrColWidth[item.Ordinal] = Encoding.GetEncoding(936).GetBytes(item.ColumnName.ToString()).Length;
}
for (int i = 0; i < dtSource.Rows.Count; i++)
{
for (int j = 0; j < dtSource.Columns.Count; j++)
{
int intTemp = Encoding.GetEncoding(936).GetBytes(dtSource.Rows[i][j].ToString()).Length;
if (intTemp > arrColWidth[j])
{
arrColWidth[j] = intTemp;
}
}
}
int rowIndex = 0;
foreach (DataRow row in dtSource.Rows)
{
#region 新建表，填充表头，填充列头，样式
if (rowIndex == 0)
{
#region 表头及样式
{
string sheetName = strHeaderText + (sheetnum == 0 ? "" : sheetnum.ToString());
if (workbook.GetSheetIndex(sheetName) >= 0)
{
workbook.RemoveSheetAt(workbook.GetSheetIndex(sheetName));
}
sheet = workbook.CreateSheet(sheetName);
sheet.AddMergedRegion(new CellRangeAddress(0, 0, 0, dtSource.Columns.Count - 1));
IRow headerRow = sheet.CreateRow(0);
headerRow.HeightInPoints = 25;
headerRow.CreateCell(0).SetCellValue(strHeaderText);
ICellStyle headStyle = workbook.CreateCellStyle();
headStyle.Alignment = HorizontalAlignment.Center;
IFont font = workbook.CreateFont();
font.FontHeightInPoints = 20;
font.IsBold = true;
headStyle.SetFont(font);
headerRow.GetCell(0).CellStyle = headStyle;
}
#endregion
#region 列头及样式
{
IRow headerRow = sheet.CreateRow(1);
ICellStyle headStyle = workbook.CreateCellStyle();
headStyle.Alignment = HorizontalAlignment.Center;
IFont font = workbook.CreateFont();
font.FontHeightInPoints = 10;
font.IsBold = true;
headStyle.SetFont(font);
foreach (DataColumn column in dtSource.Columns)
{
headerRow.CreateCell(column.Ordinal).SetCellValue(dir[column.ColumnName]);
headerRow.GetCell(column.Ordinal).CellStyle = headStyle;
//设置列宽
sheet.SetColumnWidth(column.Ordinal, (arrColWidth[column.Ordinal] + 1) * 256 * 2);
}
}
#endregion
rowIndex = 2;
}
#endregion
#region 填充内容
IRow dataRow = sheet.CreateRow(rowIndex);
foreach (DataColumn column in dtSource.Columns)
{
ICell newCell = dataRow.CreateCell(column.Ordinal);
string drValue = row[column].ToString();
switch (column.DataType.ToString())
{
case "System.String": //字符串类型
double result;
if (isNumeric(drValue, out result))
{
double.TryParse(drValue, out result);
newCell.SetCellValue(result);
break;
}
else
{
newCell.SetCellValue(drValue);
break;
}
case "System.DateTime": //日期类型
DateTime dateV;
DateTime.TryParse(drValue, out dateV);
newCell.SetCellValue(dateV);
newCell.CellStyle = dateStyle; //格式化显示
break;
case "System.Boolean": //布尔型
bool boolV = false;
bool.TryParse(drValue, out boolV);
newCell.SetCellValue(boolV);
break;
case "System.Int16": //整型
case "System.Int32":
case "System.Int64":
case "System.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(drValue.ToString());
break;
}
}
#endregion
rowIndex++;
}
workbook.Write(fs);
fs.Close();
}
private static DataTable ListToDataTable<T>(IEnumerable<T> collection)
{
var props = typeof(T).GetProperties();
var dt = new DataTable();
dt.Columns.AddRange(props.Select(p => new DataColumn(p.Name, p.PropertyType)).ToArray());
if (collection.Count() > 0)
{
for (int i = 0; i < collection.Count(); i++)
{
ArrayList tempList = new ArrayList();
foreach (PropertyInfo pi in props)
{
object obj = pi.GetValue(collection.ElementAt(i), null);
tempList.Add(obj);
}
object[] array = tempList.ToArray();
dt.LoadDataRow(array, true);
}
}
return dt;
}
/// <summary>
/// 判断内容是否是数字
/// </summary>
/// <param name="message"></param>
/// <param name="result"></param>
/// <returns></returns>
private static bool isNumeric(String message, out double result)
{
Regex rex = new Regex(@"^[-]?\d+[.]?\d*$");
result = -1;
if (rex.IsMatch(message))
{
result = double.Parse(message);
return true;
}
else
return false;
}
/// <summary>
/// 获取excel文件的sheet数目
/// </summary>
/// <param name="outputFile"></param>
/// <returns></returns>
private static int GetSheetNumber(string outputFile)
{
int number = 0;
using (FileStream readfile = new FileStream(outputFile, FileMode.OpenOrCreate, FileAccess.Read))
{
if (readfile.Length > 0)
{
IWorkbook wb = WorkbookFactory.Create(readfile);
number = wb.NumberOfSheets;
}
}
return number;
}
#endregion
#region 2.从excel文件中将数据导出到DataTable/List
/// <summary>
/// 读取Excel文件特定名字sheet的内容到DataTable
/// </summary>
/// <param name="strFileName">excel文件路径</param>
/// <param name="sheet">需要导出的sheet</param>
/// <param name="HeaderRowIndex">列头所在行号，-1表示没有列头</param>
/// <param name="dir">excel列名和DataTable列名的对应字典</param>
/// <returns></returns>
public static DataTable ExcelToDataTable(string strFileName, Dictionary<string, string> dir, string SheetName, int HeaderRowIndex = 1)
{
DataTable table = new DataTable();
using (FileStream file = new FileStream(strFileName, FileMode.Open, FileAccess.Read))
{
if (file.Length > 0)
{
IWorkbook wb = WorkbookFactory.Create(file);
ISheet isheet = wb.GetSheet(SheetName);
table = ImportExcel(isheet, HeaderRowIndex, dir);
isheet = null;
}
}
return table;
}
/// <summary>
/// 读取Excel文件某一索引sheet的内容到DataTable
/// </summary>
/// <param name="strFileName">excel文件路径</param>
/// <param name="sheet">需要导出的sheet序号</param>
/// <param name="HeaderRowIndex">列头所在行号，-1表示没有列头</param>
/// <param name="dir">excel列名和DataTable列名的对应字典</param>
/// <returns></returns>
public static DataTable ExcelToDataTable(string strFileName, Dictionary<string, string> dir, int SheetIndex = 0, int HeaderRowIndex = 1)
{
DataTable table = new DataTable();
using (FileStream file = new FileStream(strFileName, FileMode.Open, FileAccess.Read))
{
if (file.Length > 0)
{
IWorkbook wb = WorkbookFactory.Create(file);
ISheet isheet = wb.GetSheetAt(SheetIndex);
table = ImportExcel(isheet, HeaderRowIndex, dir);
isheet = null;
}
}
return table;
}
/// <summary>
/// 读取Excel文件特定名字sheet的内容到List集合
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="strFileName"></param>
/// <param name="dir"></param>
/// <param name="SheetName"></param>
/// <param name="HeaderRowIndex"></param>
/// <returns></returns>
public static List<T> ExcelToList<T>(string strFileName, Dictionary<string, string> dir, string SheetName, int HeaderRowIndex = 1)
{
DataTable dataTable = ExcelToDataTable(strFileName, dir, SheetName, HeaderRowIndex);
return DataTableToList<T>(dataTable);
}
/// <summary>
/// 读取Excel文件某一索引sheet的内容到List集合
/// </summary>
/// <param name="strFileName">excel文件路径</param>
/// <param name="sheet">需要导出的sheet序号</param>
/// <param name="HeaderRowIndex">列头所在行号，-1表示没有列头</param>
/// <param name="dir">excel列名和DataTable列名的对应字典</param>
/// <returns></returns>
public static List<T> ExcelToList<T>(string strFileName, Dictionary<string, string> dir, int SheetIndex, int HeaderRowIndex = 1)
{
DataTable dataTable = ExcelToDataTable(strFileName, dir, SheetIndex, HeaderRowIndex);
return DataTableToList<T>(dataTable);
}
/// <summary>
/// 将制定sheet中的数据导出到datatable中
/// </summary>
/// <param name="sheet">需要导出的sheet</param>
/// <param name="HeaderRowIndex">列头所在行号，-1表示没有列头</param>
/// <param name="dir">excel列名和DataTable列名的对应字典</param>
/// <returns></returns>
private static DataTable ImportExcel(ISheet sheet, int HeaderRowIndex, Dictionary<string, string> dir)
{
DataTable table = new DataTable();
IRow headerRow;
int cellCount;
try
{
//没有标头或者不需要表头用excel列的序号（1,2,3..）作为DataTable的列名
if (HeaderRowIndex < 0)
{
headerRow = sheet.GetRow(0);
cellCount = headerRow.LastCellNum;
for (int i = headerRow.FirstCellNum; i <= cellCount; i++)
{
DataColumn column = new DataColumn(Convert.ToString(i));
table.Columns.Add(column);
}
}
//有表头，使用表头做为DataTable的列名
else
{
headerRow = sheet.GetRow(HeaderRowIndex);
cellCount = headerRow.LastCellNum;
for (int i = headerRow.FirstCellNum; i < cellCount; i++)
{
//如果excel某一列列名不存在：以该列的序号作为Datatable的列名，如果DataTable中包含了这个序列为名的列，那么列名为重复列名+序号
if (headerRow.GetCell(i) == null)
{
if (table.Columns.IndexOf(Convert.ToString(i)) > 0)
{
DataColumn column = new DataColumn(Convert.ToString("重复列名" + i));
table.Columns.Add(column);
}
else
{
DataColumn column = new DataColumn(Convert.ToString(i));
table.Columns.Add(column);
}
}
//excel中的某一列列名不为空，但是重复了：对应的Datatable列名为"重复列名+序号"
else if (table.Columns.IndexOf(headerRow.GetCell(i).ToString()) > 0)
{
DataColumn column = new DataColumn(Convert.ToString("重复列名" + i));
table.Columns.Add(column);
}
else
//正常情况，列名存在且不重复：用excel中的列名作为datatable中对应的列名
{
string colName = dir.Where(s => s.Value == headerRow.GetCell(i).ToString()).First().Key;
DataColumn column = new DataColumn(colName);
table.Columns.Add(column);
}
}
}
int rowCount = sheet.LastRowNum;
for (int i = (HeaderRowIndex + 1); i <= sheet.LastRowNum; i++)//excel行遍历
{
try
{
IRow row;
if (sheet.GetRow(i) == null)//如果excel有空行，则添加缺失的行
{
row = sheet.CreateRow(i);
}
else
{
row = sheet.GetRow(i);
}
DataRow dataRow = table.NewRow();
for (int j = row.FirstCellNum; j <= cellCount; j++)//excel列遍历
{
try
{
if (row.GetCell(j) != null)
{
switch (row.GetCell(j).CellType)
{
case CellType.String://字符串
string str = row.GetCell(j).StringCellValue;
if (str != null && str.Length > 0)
{
dataRow[j] = str.ToString();
}
else
{
dataRow[j] = default(string);
}
break;
case CellType.Numeric://数字
if (DateUtil.IsCellDateFormatted(row.GetCell(j)))//时间戳数字
{
dataRow[j] = DateTime.FromOADate(row.GetCell(j).NumericCellValue);
}
else
{
dataRow[j] = Convert.ToDouble(row.GetCell(j).NumericCellValue);
}
break;
case CellType.Boolean:
dataRow[j] = Convert.ToString(row.GetCell(j).BooleanCellValue);
break;
case CellType.Error:
dataRow[j] = ErrorEval.GetText(row.GetCell(j).ErrorCellValue);
break;
case CellType.Formula://公式
switch (row.GetCell(j).CachedFormulaResultType)
{
case CellType.String:
string strFORMULA = row.GetCell(j).StringCellValue;
if (strFORMULA != null && strFORMULA.Length > 0)
{
dataRow[j] = strFORMULA.ToString();
}
else
{
dataRow[j] = null;
}
break;
case CellType.Numeric:
dataRow[j] = Convert.ToString(row.GetCell(j).NumericCellValue);
break;
case CellType.Boolean:
dataRow[j] = Convert.ToString(row.GetCell(j).BooleanCellValue);
break;
case CellType.Error:
dataRow[j] = ErrorEval.GetText(row.GetCell(j).ErrorCellValue);
break;
default:
dataRow[j] = "";
break;
}
break;
default:
dataRow[j] = "";
break;
}
}
}
catch (Exception ex)
{
throw ex;
}
}
table.Rows.Add(dataRow);
}
catch (Exception ex)
{
throw ex;
}
}
}
catch (Exception ex)
{
throw ex;
}
return table;
}
private static List<T> DataTableToList<T>(DataTable table)
{
if (table == null)
{
return null;
}
List<DataRow> rows = new List<DataRow>();
foreach (DataRow row in table.Rows)
{
rows.Add(row);
}
return ConvertTo<T>(rows);
}
private static List<T> ConvertTo<T>(IList<DataRow> rows)
{
List<T> list = null;
if (rows != null)
{
list = new List<T>();
foreach (DataRow row in rows)
{
T item = CreateItem<T>(row);
list.Add(item);
}
}
return list;
}
private static T CreateItem<T>(DataRow row)
{
T obj = default(T);
if (row != null)
{
obj = Activator.CreateInstance<T>();
foreach (DataColumn column in row.Table.Columns)
{
PropertyInfo prop = obj.GetType().GetProperty(column.ColumnName);
try
{
object value = row[column.ColumnName];
SetObjectPropertyValue(obj, column.ColumnName, value.ToString());
}
catch (Exception ex)
{
throw ex;
}
}
}
return obj;
}
/// <summary>
/// 通过属性名称设置值
/// </summary>
/// <typeparam name="T">对象类型</typeparam>
/// <param name="obj">对象</param>
/// <param name="propertyName">属性名称</param>
/// <param name="value">值</param>
/// <returns>是否成功</returns>
private static bool SetObjectPropertyValue<T>(T obj, string propertyName, string value)
{
try
{
Type type = typeof(T);
object t = Convert.ChangeType(value, type.GetProperty(propertyName).PropertyType);
type.GetProperty(propertyName).SetValue(obj, t, null);
return true;
}
catch (Exception ex)
{
return false;
}
}
#endregion
#region Excel导入导出到DataGridView
/// <summary>
/// DataGridView导出到Excel
/// </summary>
/// <param name="filePath"></param>
/// <param name="dataGridView"></param>
/// <param name="isAppend"></param>
/// <returns></returns>
public static bool DataGridViewToExcel(string filePath, DataGridView dataGridView, bool isAppend = false)
{
if (isAppend)
{
return DataGridViewToExcelAdd(filePath, dataGridView);
}
else
{
return DataGridViewToExcelNew(filePath, dataGridView);
}
}
//------------【函数：将表格控件保存至Excel文件(新建/替换)】------------
//filePath要保存的目标Excel文件路径名
//datagGridView要保存至Excel的表格控件
//------------------------------------------------------------------------
private static bool DataGridViewToExcelNew(string filePath, DataGridView dataGridView)
{
bool result = true;
FileStream fs = null;//创建一个新的文件流
HSSFWorkbook workbook = null;//创建一个新的Excel文件
ISheet sheet = null;//为Excel创建一张工作表
//定义行数、列数、与当前Excel已有行数
int rowCount = dataGridView.RowCount;//记录表格中的行数
int colCount = dataGridView.ColumnCount;//记录表格中的列数
//判断文件夹是否存在
if (CheckAndCreatPath(DecomposePathAndName(filePath, DecomposePathEnum.PathOnly)) == "error")
{
result = false;
return result;
}
//创建工作表
try
{
fs = new FileStream(filePath, FileMode.Create, FileAccess.Write);
workbook = new HSSFWorkbook();
sheet = workbook.CreateSheet("Sheet1");
IRow row = sheet.CreateRow(0);
for (int j = 0; j < colCount; j++) //列循环
{
if (dataGridView.Columns[j].Visible && dataGridView.Rows[0].Cells[j].Value != null)
{
ICell cell = row.CreateCell(j);//创建列
cell.SetCellValue(dataGridView.Columns[j].HeaderText.ToString());//更改单元格值
}
}
}
catch
{
result = false;
return result;
}
for (int i = 0; i < rowCount; i++) //行循环
{
//防止行数超过Excel限制
if (i >= 65536)
{
result = false;
break;
}
IRow row = sheet.CreateRow(1 + i); //创建行
for (int j = 0; j < colCount; j++) //列循环
{
if (dataGridView.Columns[j].Visible && dataGridView.Rows[i].Cells[j].Value != null)
{
ICell cell = row.CreateCell(j);//创建列
cell.SetCellValue(dataGridView.Rows[i].Cells[j].Value.ToString());//更改单元格值
}
}
}
try
{
workbook.Write(fs);
}
catch
{
result = false;
return result;
}
finally
{
if (fs != null)
{
fs.Close();
fs.Dispose();
fs = null;
}
workbook = null;
}
return result;
}
//------------【函数：将表格控件保存至Excel文件(添加/新建)】------------
//filePath要保存的目标Excel文件路径名
//datagGridView要保存至Excel的表格控件
//------------------------------------------------
private static bool DataGridViewToExcelAdd(string filePath, DataGridView dataGridView)
{
bool result = true;
FileStream fs = null;//创建一个新的文件流
HSSFWorkbook workbook = null;//创建一个新的Excel文件
ISheet sheet = null;//为Excel创建一张工作表
//定义行数、列数、与当前Excel已有行数
int rowCount = dataGridView.RowCount;//记录表格中的行数
int colCount = dataGridView.ColumnCount;//记录表格中的列数
int numCount = 0;//Excell最后一行序号
//判断文件夹是否存在
if (CheckAndCreatPath(DecomposePathAndName(filePath, DecomposePathEnum.PathOnly)) == "error")
{
result = false;
return result;
}
//判断文件是否存在
if (!File.Exists(filePath))
{
try
{
fs = new FileStream(filePath, FileMode.Create, FileAccess.Write);
workbook = new HSSFWorkbook();
sheet = workbook.CreateSheet("Sheet1");
IRow row = sheet.CreateRow(0);
for (int j = 0; j < colCount; j++) //列循环
{
if (dataGridView.Columns[j].Visible && dataGridView.Rows[0].Cells[j].Value != null)
{
ICell cell = row.CreateCell(j);//创建列
cell.SetCellValue(dataGridView.Columns[j].HeaderText.ToString());//更改单元格值
}
}
workbook.Write(fs);
}
catch
{
result = false;
return result;
}
finally
{
if (fs != null)
{
fs.Close();
fs.Dispose();
fs = null;
}
workbook = null;
}
}
//创建指向文件的工作表
try
{
fs = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.ReadWrite);
workbook = new HSSFWorkbook(fs);//.xls
sheet = workbook.GetSheetAt(0);
if (sheet == null)
{
result = false;
return result;
}
numCount = sheet.LastRowNum + 1;
}
catch
{
result = false;
return result;
}
for (int i = 0; i < rowCount; i++) //行循环
{
//防止行数超过Excel限制
if (numCount + i >= 65536)
{
result = false;
break;
}
IRow row = sheet.CreateRow(numCount + i); //创建行
for (int j = 0; j < colCount; j++) //列循环
{
if (dataGridView.Columns[j].Visible && dataGridView.Rows[i].Cells[j].Value != null)
{
ICell cell = row.CreateCell(j);//创建列
cell.SetCellValue(dataGridView.Rows[i].Cells[j].Value.ToString());//更改单元格值
}
}
}
try
{
fs = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.ReadWrite);
workbook.Write(fs);
}
catch
{
result = false;
return result;
}
finally
{
if (fs != null)
{
fs.Close();
fs.Dispose();
fs = null;
}
workbook = null;
}
return result;
}
//------------【函数：从Excel文件读取数据到表格控件】------------
//filePath为Excel文件路径名
//datagGridView要显示数据的表格控件
//------------------------------------------------
public static bool ExcelToDataGridView(string filePath, DataGridView dataGridView, bool hastitle = false)
{
bool result = true;
FileStream fs = null;//创建一个新的文件流
HSSFWorkbook workbook = null;//创建一个新的Excel文件
ISheet sheet = null;//为Excel创建一张工作表
//定义行数、列数
int rowCount = 0;//记录Excel中的行数
int colCount = 0;//记录Excel中的列数
//判断文件是否存在
if (!File.Exists(filePath))
{
result = false;
return result;
}
//创建指向文件的工作表
try
{
fs = new FileStream(filePath, FileMode.Open, FileAccess.Read);
workbook = new HSSFWorkbook(fs);//.xls
if (fs != null)
{
fs.Close();
fs.Dispose();
fs = null;
}
sheet = workbook.GetSheetAt(0);
if (sheet == null)
{
result = false;
return result;
}
rowCount = sheet.LastRowNum;
colCount = sheet.GetRow(0).LastCellNum;
dataGridView.Rows.Clear();
dataGridView.Columns.Clear();
for (int j = 0; j < colCount; j++) //列循环
{
ICell cell = sheet.GetRow(0).GetCell(j);//获取列
dataGridView.Columns.Add(j.ToString() + cell.ToString(), cell.ToString());
}
for (int i = 1; i <= rowCount; i++) //行循环
{
IRow row = sheet.GetRow(i); //获取行
int index = dataGridView.Rows.Add();
colCount = row.LastCellNum;
for (int j = 0; j < colCount; j++) //列循环
{
ICell cell = row.GetCell(j);//获取列
dataGridView.Rows[index].Cells[j].Value = cell.ToString();
}
}
}
catch (Exception ex)
{
result = false;
return result;
}
return result;
}
//分解路径用枚举
public enum DecomposePathEnum
{
PathOnly = 0,//仅返回路径
NameAndExtension = 1,//返回文件名+扩展名
NameOnly = 2,//仅返回文件名
ExtensionOnly = 3,//仅返回扩展名(带.)
}
//------------【函数：将文件路径分解】------------
//filePath文件路径
//DecomposePathEnum返回类型
//------------------------------------------------
private static string DecomposePathAndName(string filePath, DecomposePathEnum decomposePathEnum)
{
string result = "";
switch (decomposePathEnum)
{
case DecomposePathEnum.PathOnly://仅返回路径
result = filePath.Substring(0, filePath.LastIndexOf("\\"));
break;
case DecomposePathEnum.NameAndExtension://返回文件名+扩展名
result = filePath.Substring(filePath.LastIndexOf("\\") + 1);
break;
case DecomposePathEnum.NameOnly://仅返回文件名
result = filePath.Substring(filePath.LastIndexOf("\\") + 1, filePath.LastIndexOf(".") - filePath.LastIndexOf("\\") - 1);
break;
case DecomposePathEnum.ExtensionOnly://仅返回扩展名(带.)
result = filePath.Substring(filePath.LastIndexOf("."));
break;
default://
result = "";
break;
}
return result;
}
//------------【函数：判断文件路径是否存在，不存在则创建】------------
//filePath文件夹路径
//DecomposePathEnum返回类型
//---------------------------------------------------------------------
private static string CheckAndCreatPath(string path)
{
if (Directory.Exists(path))
{
return path;
}
else
{
if (path.LastIndexOf("\\") <= 0)
{
try
{
Directory.CreateDirectory(path);
return path;
}
catch
{
return "error";
}
}
else
{
if (CheckAndCreatPath(DecomposePathAndName(path, DecomposePathEnum.PathOnly)) == "error")
{
return "error";
}
else
{
Directory.CreateDirectory(path);
return path;
}
}
}
}
#endregion
}
}
ExcelHelper API 文档
一、DataTable/List 导出到 Excel
1. DataTableToExcel
| 项 |
说明 |
| 函数名 |
public static void DataTableToExcel(DataTable dtSource, string strHeaderText, string strFileName, Dictionary<string, string> dir, bool isNew, int sheetRow = 50000) |
| 作用 |
将 DataTable 数据导出到 Excel，支持 .xls/.xlsx 格式，可分 Sheet 存储、覆盖/追加文件 |
| 参数解释 |
- dtSource：待导出的 DataTable 数据源 - strHeaderText：Excel 表头标题（首行合并显示） - strFileName：目标 Excel 文件路径（含后缀，如 "D:\test.xlsx"） - dir：列名映射字典（Key=DataTable 列名，Value=Excel 显示列名） - isNew：是否新建文件（true=覆盖，false=追加 Sheet） - sheetRow：单个 Sheet 最大行数（默认 50000，.xls 最大 65535） |
| 返回值 |
无（void） |
2. ListToExcel
| 项 |
说明 |
| 函数名 |
public static void ListToExcel<T>(List<T> list, string strHeaderText, string strFileName, Dictionary<string, string> dir, bool isNew, int sheetRow = 50000) |
| 作用 |
将 List 集合数据导出到 Excel（内部先转 DataTable，再调用 DataTableToExcel） |
| 参数解释 |
- list：待导出的 List 数据源（T 为实体类） - strHeaderText：Excel 表头标题 - strFileName：目标 Excel 文件路径 - dir：列名映射字典（Key=实体类属性名，Value=Excel 显示列名） - isNew：是否新建文件 - sheetRow：单个 Sheet 最大行数（默认 50000） |
| 返回值 |
无（void） |
二、Excel 导入到 DataTable/List
1. ExcelToDataTable（按 Sheet 名称）
| 项 |
说明 |
| 函数名 |
public static DataTable ExcelToDataTable(string strFileName, Dictionary<string, string> dir, string SheetName, int HeaderRowIndex = 1) |
| 作用 |
读取 Excel 中指定名称的 Sheet 数据，转为 DataTable |
| 参数解释 |
- strFileName：Excel 文件路径 - dir：列名映射字典（Key=DataTable 列名，Value=Excel 列名） - SheetName：目标 Sheet 名称（如 "Sheet1"） - HeaderRowIndex：列头所在行号（默认 1，-1 表示无列头） |
| 返回值 |
DataTable：转换后的 DataTable（列名按映射字典，数据为 Excel 单元格值） |
2. ExcelToDataTable（按 Sheet 索引）
| 项 |
说明 |
| 函数名 |
public static DataTable ExcelToDataTable(string strFileName, Dictionary<string, string> dir, int SheetIndex = 0, int HeaderRowIndex = 1) |
| 作用 |
读取 Excel 中指定索引的 Sheet 数据，转为 DataTable |
| 参数解释 |
- strFileName：Excel 文件路径 - dir：列名映射字典 - SheetIndex：目标 Sheet 索引（默认 0，即第一个 Sheet） - HeaderRowIndex：列头所在行号（默认 1） |
| 返回值 |
DataTable：转换后的 DataTable |
3. ExcelToList（按 Sheet 名称）
| 项 |
说明 |
| 函数名 |
public static List<T> ExcelToList<T>(string strFileName, Dictionary<string, string> dir, string SheetName, int HeaderRowIndex = 1) |
| 作用 |
读取 Excel 中指定名称的 Sheet 数据，转为 List 集合 |
| 参数解释 |
- strFileName：Excel 文件路径 - dir：列名映射字典（Key=实体类属性名，Value=Excel 列名） - SheetName：目标 Sheet 名称 - HeaderRowIndex：列头所在行号（默认 1） |
| 返回值 |
List<T>：转换后的 List 集合（T 为实体类，属性名与 DataTable 列名一致） |
4. ExcelToList（按 Sheet 索引）
| 项 |
说明 |
| 函数名 |
public static List<T> ExcelToList<T>(string strFileName, Dictionary<string, string> dir, int SheetIndex, int HeaderRowIndex = 1) |
| 作用 |
读取 Excel 中指定索引的 Sheet 数据，转为 List 集合 |
| 参数解释 |
- strFileName：Excel 文件路径 - dir：列名映射字典 - SheetIndex：目标 Sheet 索引 - HeaderRowIndex：列头所在行号（默认 1） |
| 返回值 |
List<T>：转换后的 List 集合 |
三、Excel 与 DataGridView 双向转换
1. DataGridViewToExcel
| 项 |
说明 |
| 函数名 |
public static bool DataGridViewToExcel(string filePath, DataGridView dataGridView, bool isAppend = false) |
| 作用 |
将 DataGridView 数据导出到 Excel，支持新建文件或追加到现有文件 |
| 参数解释 |
- filePath：目标 Excel 文件路径（仅支持 .xls 格式） - dataGridView：待导出的 DataGridView 控件 - isAppend：是否追加模式（true=追加到文件末尾，false=新建/覆盖） |
| 返回值 |
bool：导出结果（true=成功，false=失败） |
2. ExcelToDataGridView
| 项 |
说明 |
| 函数名 |
public static bool ExcelToDataGridView(string filePath, DataGridView dataGridView, bool hastitle = false) |
| 作用 |
读取 Excel 数据（仅第一个 Sheet），填充到 DataGridView 控件 |
| 参数解释 |
- filePath：Excel 文件路径（仅支持 .xls 格式） - dataGridView：目标 DataGridView 控件 - hastitle：是否含列头（默认 false，暂未实际生效，默认取 Excel 第一行为列头） |
| 返回值 |
bool：导入结果（true=成功，false=失败） |
四、辅助枚举
1. DecomposePathEnum
| 项 |
说明 |
| 枚举名 |
public enum DecomposePathEnum |
| 作用 |
用于分解文件路径，指定返回路径的不同部分 |
| 枚举值解释 |
- PathOnly（0）：仅返回路径（如 "D:\test"） - NameAndExtension（1）：返回文件名+扩展名（如 "test.xlsx"） - NameOnly（2）：仅返回文件名（如 "test"） - ExtensionOnly（3）：仅返回扩展名（如 ".xlsx"） |
| 返回值 |
无（枚举类型，用于参数传递） |
五、私有辅助方法（关键）
1. ListToDataTable
| 项 |
说明 |
| 函数名 |
private static DataTable ListToDataTable<T>(IEnumerable<T> collection) |
| 作用 |
将 List 集合转为 DataTable（反射获取实体类属性，生成列和数据） |
| 参数解释 |
- collection：待转换的 List 集合（IEnumerable 类型） |
| 返回值 |
DataTable：转换后的 DataTable（列名=实体类属性名，数据=属性值） |
2. GetSheetNumber
| 项 |
说明 |
| 函数名 |
private static int GetSheetNumber(string outputFile) |
| 作用 |
获取 Excel 文件中已存在的 Sheet 数量 |
| 参数解释 |
- outputFile：Excel 文件路径 |
| 返回值 |
int：Sheet 数量（文件不存在或无 Sheet 时返回 0） |
3. DecomposePathAndName
| 项 |
说明 |
| 函数名 |
private static string DecomposePathAndName(string filePath, DecomposePathEnum decomposePathEnum) |
| 作用 |
按指定枚举类型分解文件路径，返回路径的指定部分 |
| 参数解释 |
- filePath：完整文件路径 - decomposePathEnum：分解类型枚举（DecomposePathEnum） |
| 返回值 |
string：分解后的路径部分（如枚举为 PathOnly 时返回文件夹路径） |
4. CheckAndCreatPath
| 项 |
说明 |
| 函数名 |
private static string CheckAndCreatPath(string path) |
| 作用 |
检查文件夹路径是否存在，不存在则递归创建 |
| 参数解释 |
- path：待检查的文件夹路径 |
| 返回值 |
string：成功返回路径字符串，失败返回 "error" |
7.数据类型验证DataVaildateHelper
代码
csharp
复制代码
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
namespace ToolsLib
{
public class DataValidateHelper
{
/// <summary>
/// 验证是否为整数
/// </summary>
/// <param name="text"></param>
/// <returns></returns>
public static bool IsInteger(string text)
{
Regex regex = new Regex(@"^[0-9]\d*$");
return regex.IsMatch(text);
}
/// <summary>
/// 验证是否是Email
/// </summary>
/// <param name="txt">字符串</param>
/// <returns>结果</returns>
public static bool IsEmail(string txt)
{
Regex objReg = new Regex(@"\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*");
return objReg.IsMatch(txt);
}
/// <summary>
/// 验证身份证
/// </summary>
/// <param name="txt">字符串</param>
/// <returns>结果</returns>
public static bool IsIdentityCard(string txt)
{
Regex objReg = new Regex(@"^(\d{15}$|^\d{18}$|^\d{17}(\d|X|x))$");
return objReg.IsMatch(txt);
}
/// <summary>
/// 是否为有效IP地址
/// </summary>
/// <param name="ip">字符串</param>
/// <returns>结果</returns>
public static bool IsIPAddress(string ip)
{
if (string.IsNullOrEmpty(ip) || ip.Length < 7 || ip.Length > 15) return false;
string regformat = @"^(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])$";
Regex regex = new Regex(regformat, RegexOptions.IgnoreCase);
return regex.IsMatch(ip);
}
/// <summary>
/// 是否为有效端口
/// </summary>
/// <param name="port">字符串</param>
/// <returns>结果</returns>
public static bool IsIPPort(string port)
{
bool isPort = false;
int portNum;
isPort = Int32.TryParse(port, out portNum);
if (isPort && portNum >= 0 && portNum <= 65535)
{
isPort = true;
}
else
{
isPort = false;
}
return isPort;
}
}
}
8.加密类
代码
csharp
复制代码
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
namespace ToolsLib
{
/// <summary>
/// 字符串加密解密类
/// </summary>
public class StringSecurityHelper
{
private static string md5Begin = "Hello";
private static string md5End = "World";
#region SHA1 加密
/// <summary>
/// 使用SHA1加密字符串。
/// </summary>
/// <param name="inputString">输入字符串。</param>
/// <returns>加密后的字符串。（40个字符）</returns>
public static string SHA1Encrypt(string inputString)
{
SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider();
byte[] encryptedBytes = sha1.ComputeHash(Encoding.ASCII.GetBytes(inputString));
StringBuilder sb = new StringBuilder();
for (int i = 0; i < encryptedBytes.Length; i++)
{
sb.AppendFormat("{0:x2}", encryptedBytes[i]);
}
return sb.ToString();
}
#endregion
#region DES 加密/解密
private static byte[] key = Encoding.ASCII.GetBytes("uiertysd");
private static byte[] iv = Encoding.ASCII.GetBytes("99008855");
/// <summary>
/// DES加密。
/// </summary>
/// <param name="inputString">输入字符串。</param>
/// <returns>加密后的字符串。</returns>
public static string DESEncrypt(string inputString)
{
MemoryStream ms = null;
CryptoStream cs = null;
StreamWriter sw = null;
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
try
{
ms = new MemoryStream();
cs = new CryptoStream(ms, des.CreateEncryptor(key, iv), CryptoStreamMode.Write);
sw = new StreamWriter(cs);
sw.Write(inputString);
sw.Flush();
cs.FlushFinalBlock();
return Convert.ToBase64String(ms.GetBuffer(), 0, (int)ms.Length);
}
finally
{
if (sw != null) sw.Close();
if (cs != null) cs.Close();
if (ms != null) ms.Close();
}
}
/// <summary>
/// DES解密。
/// </summary>
/// <param name="inputString">输入字符串。</param>
/// <returns>解密后的字符串。</returns>
public static string DESDecrypt(string inputString)
{
MemoryStream ms = null;
CryptoStream cs = null;
StreamReader sr = null;
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
try
{
ms = new MemoryStream(Convert.FromBase64String(inputString));
cs = new CryptoStream(ms, des.CreateDecryptor(key, iv), CryptoStreamMode.Read);
sr = new StreamReader(cs);
return sr.ReadToEnd();
}
catch
{
return string.Empty;
}
finally
{
if (sr != null) sr.Close();
if (cs != null) cs.Close();
if (ms != null) ms.Close();
}
}
#endregion
/// <summary>
/// MD5加密
/// </summary>
/// <param name="str">MD5加密前字符串</param>
/// <returns>MD5加密后字符串</returns>
public static string MD5Encrypt(string str)
{
str = string.Concat(md5Begin, str, md5End);
MD5 md5 = new MD5CryptoServiceProvider();
byte[] fromData = Encoding.Unicode.GetBytes(str);
byte[] targetData = md5.ComputeHash(fromData);
string md5String = string.Empty;
foreach (var b in targetData)
md5String += b.ToString("x2");
return md5String;
}
}
}
9.CPU信息类
代码
csharp
复制代码
using System;
using System.Collections.Generic;
using System.Linq;
using System.Management;
using System.Text;
using System.Threading.Tasks;
namespace ToolsLib
{
/// <summary>
/// CPUInfoHelper
/// </summary>
public class CPUInfoHelper
{
private static string defaultValue = "abcdefgh";
/// <summary>
/// 获取计算机信息
/// </summary>
/// <returns>获取结果</returns>
public static string GetComputerInfo()
{
string cpu = GetCPUInfo();
string bios = GetBIOSInfo();
return string.Concat(cpu, bios);
}
public static string GetCPUInfo()
{
return GetHardWareInfo("Win32_Processor", "ProcessorId");
}
public static string GetBIOSInfo()
{
string info = GetHardWareInfo("Win32_BIOS", "SerialNumber");
if (!string.IsNullOrEmpty(info) && info != "To be filled by O.E.M" && !info.Contains("O.E.M") && !info.Contains("OEM") && !info.Contains("Default"))
{
return info;
}
else
{
return defaultValue;
}
}
private static string GetHardWareInfo(string typePath, string key)
{
ManagementClass managementClass = new ManagementClass(typePath);
ManagementObjectCollection mn = managementClass.GetInstances();
PropertyDataCollection properties = managementClass.Properties;
foreach (PropertyData property in properties)
{
if (property.Name == key)
{
foreach (ManagementObject m in mn)
{
return m.Properties[property.Name].Value.ToString();
}
}
}
return string.Empty;
}
/// <summary>
/// 加密结果
/// </summary>
/// <returns>返回加密结果</returns>
public static string Encrypt()
{
return StringSecurityHelper.DESEncrypt(StringSecurityHelper.MD5Encrypt(GetComputerInfo()));
}
/// <summary>
/// 验证是否正确
/// </summary>
/// <param name="Code">字符串</param>
/// <returns>结果</returns>
public static bool Check(string Code)
{
if (StringSecurityHelper.DESDecrypt(Code) == StringSecurityHelper.MD5Encrypt(GetComputerInfo()))
{
return true;
}
else
{
return false;
}
}
}
}
10.注册表帮助类
代码
csharp
复制代码
using Microsoft.Win32;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ToolsLib
{
/// <summary>
/// 注册表
/// </summary>
public class RegeditHelper
{
private const string SUB_KEY = "SOFTWARE";
private static readonly RegistryKey HKML;
private static readonly RegistryKey SOFTWARE;
static RegeditHelper()
{
//Win10 读写LocalMachine权限，没有访问权限
HKML = Registry.CurrentUser;
SOFTWARE = HKML.OpenSubKey(SUB_KEY, true);
}
/// <summary>
/// 读取数据
/// </summary>
/// <param name="node">节点</param>
/// <param name="name">名称</param>
/// <returns>返回数据</returns>
public static object ReadData(string node, string name)
{
RegistryKey tmp = SOFTWARE.OpenSubKey(node, true);
object result = tmp?.GetValue(name);
tmp?.Close();
return result;
}
/// <summary>
/// 写入值
/// </summary>
/// <param name="node">节点</param>
/// <param name="item">名称</param>
/// <param name="value">值</param>
public static void WriteData(string node, string item, object value)
{
RegistryKey tmp = SOFTWARE.CreateSubKey(node);
tmp?.SetValue(item, value);
tmp?.Close();
}
/// <summary>
/// 删除
/// </summary>
/// <param name="node">节点</param>
/// <param name="item">名称</param>
/// <param name="value">值</param>
public static void DeleteNode(string node)
{
SOFTWARE.DeleteSubKey(node);
}
}
}