直接上代码:(其中有些引用在C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0)你的VS安装目录,具体请自行百度。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
using System.IO.Packaging;
using System.Xml;
using System.Web;
namespace YcPackageTool.Utils
{
class FileIOManager
{
#region 检测指定目录是否存在
/// <summary>
/// 检测指定目录是否存在
/// </summary>
/// <param name="directoryPath">目录的绝对路径</param>
public static bool isExistDirectory(string directoryPath)
{
return Directory.Exists(directoryPath);
}
#endregion
#region 检测指定文件是否存在
/// <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 bool isEmptyDirectory(string directoryPath)
{
try
{
//判断是否存在文件
string[] fileNames = getFileNames(directoryPath);
if (fileNames.Length > 0)
{
return false;
}
//判断是否存在文件夹
string[] directoryNames = getDirectories(directoryPath);
return directoryNames.Length <= 0;
}
catch
{
return false;
}
}
#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);
//判断指定文件是否存在
return fileNames.Length != 0;
}
catch
{
return false;
}
}
/// <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);
//判断指定文件是否存在
return fileNames.Length != 0;
}
catch
{
return false;
}
}
#endregion
#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 bool createFile(string filePath)
{
try
{
//如果文件不存在则创建该文件
if (!isExistFile(filePath))
{
//创建一个FileInfo对象
FileInfo file = new FileInfo(filePath);
//创建文件
FileStream fs = file.Create();
//关闭文件流
fs.Close();
}
}
catch
{
return false;
}
return true;
}
/// <summary>
/// 创建一个文件,并将字节流写入文件。
/// </summary>
/// <param name="filePath">文件的绝对路径</param>
/// <param name="buffer">二进制流数据</param>
public static bool 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
{
return false;
}
return true;
}
#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;
}
/// <summary>
/// 获取一个文件的长度,单位为KB
/// </summary>
/// <param name="filePath">文件的路径</param>
public static double getFileSizeByKB(string filePath)
{
//创建一个文件对象
FileInfo fi = new FileInfo(filePath);
long size = fi.Length / 1024;
//获取文件的大小
return double.Parse(size.ToString());
}
/// <summary>
/// 获取一个文件的长度,单位为MB
/// </summary>
/// <param name="filePath">文件的路径</param>
public static double getFileSizeByMB(string filePath)
{
//创建一个文件对象
FileInfo fi = new FileInfo(filePath);
long size = fi.Length / 1024 / 1024;
//获取文件的大小
return double.Parse(size.ToString());
}
#endregion
#region 获取指定目录中的文件列表
/// <summary>
/// 获取指定目录中所有文件列表
/// </summary>
/// <param name="directoryPath">指定目录的绝对路径</param>
public static string[] getFileNames(string directoryPath)
{
//如果目录不存在,则抛出异常
if (!isExistDirectory(directoryPath))
{
throw new FileNotFoundException();
}
//获取文件列表
return Directory.GetFiles(directoryPath);
}
/// <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
{
return Directory.GetFiles(directoryPath, searchPattern, isSearchChild ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly);
}
catch
{
return null;
}
}
#endregion
#region 获取指定目录中的子目录列表
/// <summary>
/// 获取指定目录中所有子目录列表,若要搜索嵌套的子目录列表,请使用重载方法.
/// </summary>
/// <param name="directoryPath">指定目录的绝对路径</param>
public static string[] getDirectories(string directoryPath)
{
try
{
return Directory.GetDirectories(directoryPath);
}
catch
{
return null;
}
}
/// <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
{
return Directory.GetDirectories(directoryPath, searchPattern, isSearchChild ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly);
}
catch
{
throw null;
}
}
#endregion
#region 向文本文件写入内容
/// <summary>
/// 向文本文件中写入内容
/// </summary>
/// <param name="filePath">文件的绝对路径</param>
/// <param name="content">写入的内容</param>
public static void writeText2File(string filePath, string content)
{
//向文件写入内容
File.WriteAllText(filePath, content);
}
#endregion
#region 向文本文件的尾部追加内容
/// <summary>
/// 向文本文件的尾部追加内容
/// </summary>
/// <param name="filePath">文件的绝对路径</param>
/// <param name="content">写入的内容</param>
public static void appendText2File(string filePath, string content)
{
File.AppendAllText(filePath, content);
}
#endregion
#region 将现有文件的内容复制到新文件中
/// <summary>
/// 将源文件的内容复制到目标文件中
/// </summary>
/// <param name="sourceFilePath">源文件的绝对路径</param>
/// <param name="destFilePath">目标文件的绝对路径</param>
public static bool copyFile(string sourceFilePath, string destFilePath, bool ignoreRepeat = true)
{
if (!ignoreRepeat && isExistFile(destFilePath))
{
LogUtil.PtShowLog("文件有重复 正在合并中.....");
mergeFileByRepeatName(sourceFilePath, destFilePath);
return true;
}
File.Copy(sourceFilePath, destFilePath, ignoreRepeat);
return true;
}
#endregion
#region 拷贝文件夹
/// <summary>
/// 拷贝文件夹
/// </summary>
/// <param name="sourcePath">源文件夹绝对路径</param>
/// <param name="destPath">目的文件夹绝对路径</param>
/// <param name="ignoreRepeat">是否忽略文件重复</param>
/// <returns>拷贝结果</returns>
public static bool copyDirectory(string sourcePath, string destPath, bool ignoreRepeat = true)
{
if (!isExistDirectory(sourcePath))
{
return false;
}
createDirectory(destPath);
string[] _dicNames = getDirectories(sourcePath, "*", true);
if (null != _dicNames)
{
foreach (string _dicName in _dicNames)
{
string _newDiectory = _dicName.Replace(sourcePath, destPath);
createDirectory(_newDiectory);
}
}
string[] _fileNames = getFileNames(sourcePath, "*", true);
if (null != _fileNames)
{
foreach (string _fileName in _fileNames)
{
string _newFile = _fileName.Replace(sourcePath, destPath);
copyFile(_fileName, _newFile, ignoreRepeat);
}
}
return true;
}
#endregion
#region 合并重复文件名的文件
/// <summary>
/// 合并重复文件名的文件
/// </summary>
/// <param name="source"></param>
/// <param name="des"></param>
private static void mergeFileByRepeatName(String source, String des)
{
if (source.Substring(source.Length - 3, 3) == "xml")
{
XmlDocument doc1 = new XmlDocument();
doc1.Load(source);
XmlDocument doc2 = new XmlDocument();
doc2.Load(des);
XmlNode root1 = doc1.DocumentElement;
foreach (XmlNode n in doc2.DocumentElement.ChildNodes)
{
XmlNode root2 = doc1.ImportNode(n, true);
root1.AppendChild(root2);
}
doc1.Save(des);
}
}
#endregion
#region 将文件移动到指定目录
/// <summary>
/// 将文件移动到指定目录
/// </summary>
/// <param name="sourceFilePath">需要移动的源文件的绝对路径</param>
/// <param name="descDirectoryPath">移动到的目录的绝对路径</param>
public static void moveFile2Directory(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="stream">原始流</param>
public static byte[] streamToBytes(Stream stream)
{
try
{
//创建缓冲区
byte[] buffer = new byte[stream.Length];
//读取流
stream.Read(buffer, 0, int.Parse(stream.Length.ToString()));
//返回流
return buffer;
}
catch
{
return null;
}
finally
{
//关闭流
stream.Close();
}
}
#endregion
#region 将文件读取到缓冲区中
/// <summary>
/// 将文件读取到缓冲区中
/// </summary>
/// <param name="filePath">文件的绝对路径</param>
public static byte[] fileToBytes(string filePath)
{
//获取文件的大小
int fileSize = getFileSize(filePath);
//创建一个临时缓冲区
byte[] buffer = new byte[fileSize];
//创建一个文件流
FileInfo fi = new FileInfo(filePath);
FileStream fs = fi.Open(FileMode.Open);
try
{
//将文件流读入缓冲区
fs.Read(buffer, 0, fileSize);
return buffer;
}
catch
{
return null;
}
finally
{
//关闭文件流
fs.Close();
}
}
#endregion
#region 将文件读取到字符串中
/// <summary>
/// 将文件读取到字符串中
/// </summary>
/// <param name="filePath">文件的绝对路径</param>
public static string fileToString(string filePath)
{
return fileToString(filePath, Encoding.Default);
}
/// <summary>
/// 将文件读取到字符串中
/// </summary>
/// <param name="filePath">文件的绝对路径</param>
/// <param name="encoding">字符编码</param>
public static string fileToString(string filePath, Encoding encoding)
{
//创建流读取器
StreamReader reader = new StreamReader(filePath, encoding);
try
{
//读取流
return reader.ReadToEnd();
}
catch
{
return string.Empty;
}
finally
{
//关闭流读取器
reader.Close();
}
}
#endregion
#region 读取文件(默认编码)
/// <summary>
/// 读取文件到StringBuilder 默认编码
/// </summary>
/// <param name="filePath">文件路径</param>
/// <returns></returns>
public static StringBuilder readFile(String filePath)
{
return readFile(filePath, Encoding.Default);
}
#endregion
#region 读取文件(指定编码)
/// <summary>
/// 读取文件到StringBuilder 指定编码
/// </summary>
/// <param name="filePath">文件路径</param>
/// <param name="encoding">文件编码方式</param>
/// <returns></returns>
public static StringBuilder readFile(String filePath, Encoding encoding)
{
if (File.Exists(filePath))
{
StreamReader _sr = new StreamReader(filePath, encoding);
String _line;
StringBuilder _str = new StringBuilder();
while ((_line = _sr.ReadLine()) != null)
{
_str.Append(_line + "\r\n");
}
_sr.Close();
return _str;
}
else
{
return null;
}
}
#endregion
#region 从文件的绝对路径中获取文件名( 包含扩展名 )
/// <summary>
/// 从文件的绝对路径中获取文件名( 包含扩展名 )
/// </summary>
/// <param name="filePath">文件的绝对路径</param>
public static string getFileName(string filePath)
{
//获取文件的名称
FileInfo fi = new FileInfo(filePath);
return fi.Name;
}
#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;
}
#endregion
#region 判断文件的扩展名是否正确
/// <summary>
/// 判断文件的扩展名是否正确
/// </summary>
/// <param name="filePath"></param>
/// <param name="extension"></param>
/// <returns></returns>
public static bool CheckExtension(string filePath, string extension)
{
string _extension = getExtension(filePath);
if (null == extension || extension.Length == 0)
{
return false;
}
if (null == _extension || _extension.Length == 0)
{
return false;
}
if (extension.Equals(_extension))
{
return true;
}
return false;
}
#endregion
#region 清空指定目录
/// <summary>
/// 清空指定目录下所有文件及子目录,但该目录依然保存.
/// </summary>
/// <param name="directoryPath">指定目录的绝对路径</param>
public static void clearDirectory(string directoryPath)
{
if (isExistDirectory(directoryPath))
{
//删除目录中所有的文件
string[] fileNames = getFileNames(directoryPath);
foreach (string t in fileNames)
{
deleteFile(t);
}
//删除目录中所有的子目录
string[] directoryNames = getDirectories(directoryPath);
foreach (string t in directoryNames)
{
deleteDirectory(t);
}
}
}
#endregion
#region 清空文件内容
/// <summary>
/// 清空文件内容
/// </summary>
/// <param name="filePath">文件的绝对路径</param>
public static void clearFileContent(string filePath)
{
//删除文件
File.Delete(filePath);
//重新创建该文件
createFile(filePath);
}
#endregion
#region 删除指定文件
/// <summary>
/// 删除指定文件
/// </summary>
/// <param name="filePath">文件的绝对路径</param>
public static void deleteFile(string filePath)
{
if (isExistFile(filePath))
{
File.Delete(filePath);
}
}
#endregion
#region 删除指定目录
/// <summary>
/// 删除指定目录及其所有子目录
/// </summary>
/// <param name="directoryPath">指定目录的绝对路径</param>
public static void deleteDirectory(string directoryPath)
{
if (isExistDirectory(directoryPath))
{
Directory.Delete(directoryPath, true);
}
}
#endregion
#region 解压缩
/// <summary>
/// Extract a container Zip. NOTE: container must be created as Open Packaging Conventions (OPC) specification
/// </summary>
/// <param name="folderName">The folder to extract the package to</param>
/// <param name="compressedFileName">The package file</param>
/// <param name="overrideExisting">override existing files</param>
/// <returns></returns>
public static bool UncompressFile(string folderName, string compressedFileName, bool overrideExisting)
{
bool result = false;
try
{
if (!File.Exists(compressedFileName))
{
return result;
}
DirectoryInfo directoryInfo = new DirectoryInfo(folderName);
if (!directoryInfo.Exists)
directoryInfo.Create();
using (Package package = Package.Open(compressedFileName, FileMode.Open, FileAccess.Read))
{
foreach (PackagePart packagePart in package.GetParts())
{
extractPart(packagePart, folderName, overrideExisting);
}
}
result = true;
}
catch (Exception e)
{
throw new Exception("Error unzipping file " + compressedFileName, e);
}
return result;
}
public static void extractPart(PackagePart packagePart, string targetDirectory, bool overrideExisting)
{
string stringPart = targetDirectory + HttpUtility.UrlDecode(packagePart.Uri.ToString()).Replace('\\', '/');
if (!Directory.Exists(Path.GetDirectoryName(stringPart)))
Directory.CreateDirectory(Path.GetDirectoryName(stringPart));
if (!overrideExisting && File.Exists(stringPart))
return;
using (FileStream fileStream = new FileStream(stringPart, FileMode.Create))
{
packagePart.GetStream().CopyTo(fileStream);
}
}
#endregion
#region 记录错误日志到文件方法
/// <summary>
/// 记录错误日志到文件方法
/// </summary>
/// <param name="exMessage"></param>
/// <param name="exMethod"></param>
/// <param name="userID"></param>
/// <param name="logPath">在指定目录下创建日志文件</param>
/// <param name="currentDir">如果为true,则在当前目录下创建Log文件夹的日志文件</param>
public static void errorLog2File(string exMessage, string exMethod, int userID, string logPath, bool currentDir)
{
try
{
string errVir = "/Log/Error/" + DateTime.Now.ToShortDateString() + ".txt";
string errPath = currentDir ? (Environment.CurrentDirectory + "\\Log\\") : logPath;
File.AppendAllText(errPath,
"{userID:" + userID + ",exMedthod:" + exMethod + ",exMessage:" + exMessage + "}");
}
catch
{
}
}
#endregion
}
}