文件流通用操作类

public class FileHelper
{
#region 公有方法
/// <summary>
/// 检测文件夹是否存在
/// </summary>
/// <param name="folderName"></param>
/// <returns></returns>
public static bool IsExistsFolder(string folderName)
{
return Directory.Exists(folderName);
}

/// <summary>
/// 创建文件夹
/// </summary>
/// <param name="folderName">文件夹名称</param>
/// <param name="message">操作信息</param>
/// <returns>是否创建成功.1,成功;-1,失败</returns>
public static void CreateFolder(string folderName)
{
//判断文件夹是否存在.若存在,则直接返回
if (FileHelper.IsExistsFolder(folderName)) return;
Directory.CreateDirectory(folderName);
}

/// <summary>
/// 递归创建文件夹,用于文件复制
/// </summary>
/// <param name="fileFullName"></param>
public static void CreateFolderByFile(string fileFullName)
{
bool isExistsFile = false;

if (File.Exists(fileFullName))
{
isExistsFile = true;
}
else
{
//判断路径中的文件夹是否存在
string dirpath = fileFullName.Substring(0, fileFullName.LastIndexOf('\\'));

string[] pathes = dirpath.Split('\\');
if (pathes.Length > 1)
{
string path = pathes[0];
for (int i = 1; i < pathes.Length; i++)
{
path += "\\" + pathes[i];
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
}
}
}
}

/// <summary>
/// 删除文件夹
/// </summary>
/// <param name="as_folder">文件夹名称</param>
/// <returns>是否删除成功.1,成功;-1,失败</returns>
public static void DeleteFolder(string as_folder)
{
//若存在文件夹,则删除
if (Directory.Exists(as_folder))
{
foreach (string d in Directory.GetFileSystemEntries(as_folder))
{
if (File.Exists(d))
{
//直接删除其中的文件
File.Delete(d);
}
else
{
//递归删除子文件夹
FileHelper.DeleteFolder(d);
}
}

//删除已空的文件夹
Directory.Delete(as_folder, true);
}
}

/// <summary>
/// 判断文件是否存在
/// </summary>
/// <param name="fileName"></param>
/// <returns></returns>
public static bool IsExistsFile(string fileName)
{
return File.Exists(fileName);
}

/// <summary>
/// 生成文件名称,根据日期
/// </summary>
/// <returns></returns>
public static string GetFileNameByDate()
{
string s_filename = DateTime.Now.ToString("yyyyMMdd");
return s_filename;

}
/// <summary>
/// 生成文件名称,根据时间
/// </summary>
/// <returns></returns>
public static string GetFileNameByTime()
{
string s_filename = DateTime.Now.ToString("HHmmss");
return s_filename;

}
/// <summary>
/// 生成文件名称,根据日期时间
/// </summary>
/// <returns></returns>
public static string GetFileNameByDateTime()
{
string s_filename = DateTime.Now.ToString("yyyyMMddHHmmss");
return s_filename;

}

/// <summary>
/// 创建文件
/// </summary>
/// <param name="fileName"></param>
/// <returns></returns>
public static void CreateFile(string fileName)
{
if (FileHelper.IsExistsFile(fileName))
{
File.Delete(fileName);
}

File.Create(fileName);
}

/// <summary>
/// 删除文件
/// </summary>
/// <param name="as_filename">文件名称</param>
/// <param name="message">操作信息</param>
/// <returns>删除是否成功.1,成功;-1,失败</returns>
public static void DeleteFile(string fileName)
{
//判断文件是否存在.若不存在,则不必删除
if (FileHelper.IsExistsFile(fileName) == false) return;
File.Delete(fileName);
}

/// <summary>
/// 复制文件
/// </summary>
/// <param name="sourceFile">源文件名称</param>
/// <param name="targetFile">目标文件名称</param>
/// <param name="overWrite">是否覆盖</param>
/// <returns>复制是否成功.1,成功;-1,失败</returns>
public static void CopyFile(string sourceFile, string targetFile, bool overWrite)
{
//判断源文件是否存在
if (!FileHelper.IsExistsFile(sourceFile)) return;
File.Copy(sourceFile, targetFile, overWrite);
}

/// <summary>
/// 移动文件
/// </summary>
/// <param name="fileName">源文件名称</param>
/// <param name="targetFileName">目标文件名称</param>
/// <param name="append">是否覆盖</param>
/// <returns>移动是否成功.1,成功;-1,失败</returns>
public static void MoveFile(string fileName, string targetFileName, bool append)
{
//判断是否存在
if (!File.Exists(fileName)) throw new FileNotFoundException(fileName + "文件未找到");

//是否覆盖,若是则删除文件
if (append)
{
if (FileHelper.IsExistsFile(targetFileName))
{
FileHelper.DeleteFile(targetFileName);
}
}

File.Move(fileName, targetFileName);
}

/// <summary>
/// 重命名文件名称
/// </summary>
/// <param name="oldFileName"></param>
/// <param name="newFileName"></param>
/// <returns></returns>
public static void RenameFile(string oldFileName, string newFileName)
{
//判断是否存在
if (!File.Exists(oldFileName)) throw new FileNotFoundException(oldFileName + "文件未找到");

//是否覆盖,若是则删除文件
if (FileHelper.IsExistsFile(newFileName))
{
FileHelper.DeleteFile(newFileName);
}

File.Move(oldFileName, newFileName);
}

/// <summary>
/// 读取文件内容
/// </summary>
/// <param name="fileName"></param>
/// <returns></returns>
public static string ReadFileByText(string fileName)
{
string fileContent = string.Empty;

//判断文件是否存在
if (!File.Exists(fileName)) throw new FileNotFoundException(fileName + "文件未找到");

fileContent = File.ReadAllText(fileName);
return fileContent;
}
/// <summary>
/// 读取文件内容
/// </summary>
/// <param name="as_filename"></param>
/// <param name="encoding"></param>
/// <returns></returns>
public static string ReadFileByText(string fileName, Encoding encoding)
{
string fileContent = string.Empty;

//判断文件是否存在
if (!File.Exists(fileName)) throw new FileNotFoundException(fileName + "文件未找到");

fileContent = File.ReadAllText(fileName, encoding);
return fileContent;
}

/// <summary>
/// 逐行读取文件内容
/// </summary>
/// <param name="fileName">文件名称</param>
/// <returns>文件内容</returns>
public static List<string> ReadFileByTextAndLine(string fileName, Encoding encoding)
{
List<string> listLine = null;

//判断文件是否存在
if (!File.Exists(fileName)) throw new FileNotFoundException(fileName + "文件未找到");

string[] arrayLine = File.ReadAllLines(fileName, encoding);
if (arrayLine.Length <= 0) return listLine;

listLine = new List<string>();
for (int i = 0; i < arrayLine.Length; i++)
{
listLine.Add(arrayLine[i]);
}

return listLine;
}

/// <summary>
/// Text文件内容写入
/// </summary>
/// <param name="fileName"></param>
/// <param name="content"></param>
/// <param name="coding"></param>
/// <returns></returns>
public static void WriteFileToText(string fileName, string content, Encoding coding)
{
File.AppendAllText(fileName, content, coding);
}

/// <summary>
/// 压缩文件
/// </summary>
/// <param name="sourceFile">源文件名称</param>
/// <param name="targetFile">目标文件名称</param>
/// <returns>压缩是否成功</returns>
public static void CompressFile(string sourceFile, string targetFile)
{
if (!File.Exists(sourceFile)) throw new FileNotFoundException(sourceFile + "文件未找到");
using (FileStream sourceStream = new FileStream(sourceFile, FileMode.Open, FileAccess.Read, FileShare.Read))
{
byte[] buffer = new byte[sourceStream.Length];
int checkCounter = sourceStream.Read(buffer, 0, buffer.Length);
if (checkCounter != buffer.Length) throw new ApplicationException();
using (FileStream destinationStream = new FileStream(targetFile, FileMode.OpenOrCreate, FileAccess.Write))
{
using (GZipStream compressedStream = new GZipStream(destinationStream, CompressionMode.Compress, true))
{
compressedStream.Write(buffer, 0, buffer.Length);
}
}
}
}

/// <summary>
/// 解压缩文件
/// </summary>
/// <param name="as_sourcefile">源文件名称</param>
/// <param name="as_targetfile">目标文件名称</param>
/// <returns>解压缩是否成功</returns>
public static void UnCompressFile(string sourceFile, string targetFile)
{
if (!File.Exists(sourceFile)) throw new FileNotFoundException(sourceFile + "文件未找到");

using (FileStream sourceStream = new FileStream(sourceFile, FileMode.Open))
{
byte[] quartetBuffer = new byte[4];
int position = (int)sourceStream.Length - 4;
sourceStream.Position = position;
sourceStream.Read(quartetBuffer, 0, 4);
sourceStream.Position = 0;
int checkLength = BitConverter.ToInt32(quartetBuffer, 0);
byte[] buffer = new byte[checkLength + 100];
using (GZipStream decompressedStream = new GZipStream(sourceStream, CompressionMode.Decompress, true))
{
int total = 0;
for (int offset = 0; ; )
{
int bytesRead = decompressedStream.Read(buffer, offset, 100);
if (bytesRead == 0) break;
offset += bytesRead;
total += bytesRead;
}
using (FileStream destinationStream = new FileStream(targetFile, FileMode.Create))
{
destinationStream.Write(buffer, 0, total);
destinationStream.Flush();
}
}
}
}

/// <summary>
/// 读取文件内容,生成二进制对象
/// </summary>
/// <param name="as_filename">文件名称</param>
/// <returns>文件内容</returns>
public static byte[] ReadFileToByte(string fileName)
{
if (!File.Exists(fileName)) throw new FileNotFoundException(fileName + "文件未找到");

FileStream fileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read);
BinaryReader binaryReader = new BinaryReader(fileStream);

byte[] file = binaryReader.ReadBytes(((int)fileStream.Length));
binaryReader.Close();
fileStream.Close();

return file;
}

/// <summary>
/// 将二进制数据写入Txt文件
/// </summary>
/// <param name="as_filename">文件名称</param>
/// <param name="byte_content">二进制数据</param>
/// <returns>是否写入成功.1,成功;-1,失败</returns>
public static void WriteFileByByte(string fileName, byte[] fileContent)
{
if (!File.Exists(fileName)) throw new FileNotFoundException(fileName + "文件未找到");

FileStream fileStream = new FileStream(fileName, FileMode.Create);

fileStream.Write(fileContent, 0, fileContent.Length);
fileStream.Close();
}

/// <summary>
/// 生成文件流MD5值
/// 参考地址1:http://www.cnblogs.com/lujin49/p/3669884.html
/// 参考地址2:http://www.cnblogs.com/fierceeagle/p/3507345.html
/// </summary>
/// <param name="stream"></param>
/// <returns></returns>
public static string GetStreamMD5(Stream stream)
{
string md5Data = string.Empty;
MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();

//计算指定stream对象的哈希值
byte[] arrayHashValue = md5.ComputeHash(stream);

//由以连接字符分隔的十六进制构成的String,其中每一对表示value对应的元素，例如"F-2C-4A"
md5Data = System.BitConverter.ToString(arrayHashValue);

//替换
md5Data = md5Data.Replace("-", "");
return md5Data;
}

public static Stream GetStreamByFile(string fileName)
{
// 打开文件
FileStream fileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read);

// 读取文件的 byte[]
byte[] bytes = new byte[fileStream.Length];
fileStream.Read(bytes, 0, bytes.Length);
fileStream.Close();

// 把 byte[] 转换成 Stream
Stream stream = new MemoryStream(bytes);
return stream;
}
#endregion
}