You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
408 lines
12 KiB
408 lines
12 KiB
using System;
|
|
using System.IO;
|
|
using System.Collections.Generic;
|
|
using System.Security.Cryptography;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using SiteServer.Utils.Enumerations;
|
|
|
|
namespace SiteServer.Utils
|
|
{
|
|
public static class FileUtils
|
|
{
|
|
public static string TryReadText(string filePath)
|
|
{
|
|
var text = string.Empty;
|
|
|
|
try
|
|
{
|
|
if (IsFileExists(filePath))
|
|
{
|
|
text = ReadText(filePath, Encoding.UTF8);
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// ignored
|
|
}
|
|
|
|
return text;
|
|
}
|
|
|
|
public static string ReadText(string filePath, ECharset charset)
|
|
{
|
|
var sr = new StreamReader(filePath, ECharsetUtils.GetEncoding(charset));
|
|
var text = sr.ReadToEnd();
|
|
sr.Close();
|
|
return text;
|
|
}
|
|
|
|
public static string ReadText(string filePath, Encoding encoding)
|
|
{
|
|
var sr = new StreamReader(filePath, encoding);
|
|
var text = sr.ReadToEnd();
|
|
sr.Close();
|
|
return text;
|
|
}
|
|
|
|
public static async Task<string> ReadTextAsync(string filePath, Encoding encoding)
|
|
{
|
|
var sr = new StreamReader(filePath, encoding);
|
|
var text = await sr.ReadToEndAsync();
|
|
sr.Close();
|
|
return text;
|
|
}
|
|
|
|
public static async Task WriteTextAsync(string filePath, Encoding encoding, string content)
|
|
{
|
|
DirectoryUtils.CreateDirectoryIfNotExists(filePath);
|
|
|
|
byte[] encodedText = encoding.GetBytes(content);
|
|
|
|
using (FileStream sourceStream = new FileStream(filePath,
|
|
FileMode.Create, FileAccess.ReadWrite, FileShare.None, bufferSize: 4096, useAsync: true))
|
|
{
|
|
await sourceStream.WriteAsync(encodedText, 0, encodedText.Length);
|
|
}
|
|
}
|
|
|
|
public static void WriteText(string filePath, ECharset charset, string content)
|
|
{
|
|
WriteText(filePath, ECharsetUtils.GetEncoding(charset), content);
|
|
}
|
|
|
|
public static void WriteText(string filePath, string content)
|
|
{
|
|
WriteText(filePath, Encoding.UTF8, content);
|
|
}
|
|
|
|
public static void WriteText(string filePath, Encoding encoding, string content)
|
|
{
|
|
DirectoryUtils.CreateDirectoryIfNotExists(filePath);
|
|
|
|
var file = new FileStream(filePath, FileMode.Create, FileAccess.ReadWrite);
|
|
using (var writer = new StreamWriter(file, encoding))
|
|
{
|
|
writer.Write(content);
|
|
writer.Flush();
|
|
writer.Close();
|
|
|
|
file.Close();
|
|
}
|
|
}
|
|
|
|
public static void AppendText(string filePath, string content)
|
|
{
|
|
AppendText(filePath, Encoding.UTF8, content);
|
|
}
|
|
|
|
public static void AppendText(string filePath, ECharset charset, string content)
|
|
{
|
|
AppendText(filePath, ECharsetUtils.GetEncoding(charset), content);
|
|
}
|
|
|
|
public static void AppendText(string filePath, Encoding encoding, string content)
|
|
{
|
|
DirectoryUtils.CreateDirectoryIfNotExists(filePath);
|
|
|
|
var file = new FileStream(filePath, FileMode.Append, FileAccess.Write);
|
|
using (var writer = new StreamWriter(file, encoding))
|
|
{
|
|
writer.Write(content);
|
|
writer.Flush();
|
|
writer.Close();
|
|
|
|
file.Close();
|
|
}
|
|
}
|
|
|
|
public static async Task AppendTextAsync(string filePath, Encoding encoding, string content)
|
|
{
|
|
DirectoryUtils.CreateDirectoryIfNotExists(filePath);
|
|
|
|
var file = new FileStream(filePath, FileMode.Append, FileAccess.Write);
|
|
using (var writer = new StreamWriter(file, encoding))
|
|
{
|
|
await writer.WriteAsync(content);
|
|
writer.Flush();
|
|
writer.Close();
|
|
|
|
file.Close();
|
|
}
|
|
}
|
|
|
|
public static void RemoveReadOnlyAndHiddenIfExists(string filePath)
|
|
{
|
|
if (File.Exists(filePath))
|
|
{
|
|
var fileAttributes = File.GetAttributes(filePath);
|
|
if (IsReadOnly(fileAttributes) || IsHidden(fileAttributes))
|
|
{
|
|
File.SetAttributes(filePath, FileAttributes.Normal);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static bool IsReadOnly(FileAttributes fileAttributes)
|
|
{
|
|
return ((fileAttributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly);
|
|
}
|
|
|
|
public static bool IsHidden(FileAttributes fileAttributes)
|
|
{
|
|
return (fileAttributes & FileAttributes.Hidden) == FileAttributes.Hidden;
|
|
}
|
|
|
|
public static FileStream GetFileStreamReadOnly(string filePath)
|
|
{
|
|
return new FileStream(filePath, FileMode.Open);
|
|
}
|
|
|
|
public static string ReadBase64StringFromFile(string filePath)
|
|
{
|
|
var fin = new FileStream(filePath, FileMode.Open, FileAccess.Read);
|
|
var storage = new byte[fin.Length];
|
|
fin.Read(storage, 0, storage.Length);
|
|
fin.Close();
|
|
var text = Convert.ToBase64String(storage, 0, storage.Length);
|
|
return text;
|
|
}
|
|
|
|
public static bool IsFileExists(string filePath)
|
|
{
|
|
return File.Exists(filePath);
|
|
}
|
|
|
|
public static bool DeleteFileIfExists(string filePath)
|
|
{
|
|
var retval = true;
|
|
try
|
|
{
|
|
if (IsFileExists(filePath))
|
|
{
|
|
File.Delete(filePath);
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
//try
|
|
//{
|
|
// Scripting.FileSystemObject fso = new Scripting.FileSystemObjectClass();
|
|
// fso.DeleteFile(filePath, true);
|
|
//}
|
|
//catch
|
|
//{
|
|
// retval = false;
|
|
//}
|
|
retval = false;
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
public static void DeleteFilesIfExists(string directoryPath, List<string> fileNameArrayList)
|
|
{
|
|
foreach (string fileName in fileNameArrayList)
|
|
{
|
|
var filePath = Path.Combine(directoryPath, fileName);
|
|
DeleteFileIfExists(filePath);
|
|
}
|
|
}
|
|
|
|
public static void DeleteFilesIfExists(string[] filePaths)
|
|
{
|
|
foreach (var filePath in filePaths)
|
|
{
|
|
DeleteFileIfExists(filePath);
|
|
}
|
|
}
|
|
|
|
public static bool CopyFile(string sourceFilePath, string destFilePath)
|
|
{
|
|
return CopyFile(sourceFilePath, destFilePath, true);
|
|
}
|
|
|
|
public static bool CopyFile(string sourceFilePath, string destFilePath, bool isOverride)
|
|
{
|
|
var retval = true;
|
|
try
|
|
{
|
|
DirectoryUtils.CreateDirectoryIfNotExists(destFilePath);
|
|
|
|
File.Copy(sourceFilePath, destFilePath, isOverride);
|
|
}
|
|
catch
|
|
{
|
|
retval = false;
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
//public static bool MoveFile(string sourceFilePath, string destFilePath)
|
|
//{
|
|
// DirectoryUtils.CreateDirectoryIfNotExists(destFilePath);
|
|
// bool retval = true;
|
|
// try
|
|
// {
|
|
// File.Move(sourceFilePath, destFilePath);
|
|
// }
|
|
// catch
|
|
// {
|
|
// retval = false;
|
|
// }
|
|
// return retval;
|
|
//}
|
|
|
|
public static void MoveFile(string sourceFilePath, string destFilePath, bool isOverride)
|
|
{
|
|
//如果文件不存在，则进行复制。
|
|
var isExists = IsFileExists(destFilePath);
|
|
if (isOverride)
|
|
{
|
|
if (isExists)
|
|
{
|
|
DeleteFileIfExists(destFilePath);
|
|
}
|
|
CopyFile(sourceFilePath, destFilePath);
|
|
}
|
|
else if (!isExists)
|
|
{
|
|
CopyFile(sourceFilePath, destFilePath);
|
|
}
|
|
}
|
|
|
|
public static ECharset GetFileCharset(string filePath)
|
|
{
|
|
var encoding = EncodingType.GetType(filePath);
|
|
return ECharsetUtils.GetEnumType(encoding.BodyName);
|
|
}
|
|
|
|
public static string ComputeHash(string filePath)
|
|
{
|
|
using (var md5 = MD5.Create())
|
|
{
|
|
using (var stream = File.OpenRead(filePath))
|
|
{
|
|
return BitConverter.ToString(md5.ComputeHash(stream)).Replace("-", "").ToLower();
|
|
}
|
|
}
|
|
}
|
|
|
|
public class EncodingType
|
|
{
|
|
/// <summary>
|
|
/// 给定文件的路径，读取文件的二进制数据，判断文件的编码类型
|
|
/// </summary>
|
|
/// <param name="fileName">文件路径</param>
|
|
/// <returns>文件的编码类型</returns>
|
|
public static Encoding GetType(string fileName)
|
|
{
|
|
var fs = new FileStream(fileName, FileMode.Open, FileAccess.Read);
|
|
var r = GetType(fs);
|
|
fs.Close();
|
|
return r;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 通过给定的文件流，判断文件的编码类型
|
|
/// </summary>
|
|
/// <param name="fs">文件流</param>
|
|
/// <returns>文件的编码类型</returns>
|
|
public static Encoding GetType(FileStream fs)
|
|
{
|
|
var reVal = Encoding.Default;
|
|
|
|
var r = new BinaryReader(fs, Encoding.Default);
|
|
//int i;
|
|
//int.TryParse(fs.Length.ToString(), out i);
|
|
var i = TranslateUtils.ToInt(fs.Length.ToString());
|
|
var ss = r.ReadBytes(i);
|
|
if (IsUtf8Bytes(ss) || (ss[0] == 0xEF && ss[1] == 0xBB && ss[2] == 0xBF))
|
|
{
|
|
reVal = Encoding.UTF8;
|
|
}
|
|
else if (ss[0] == 0xFE && ss[1] == 0xFF && ss[2] == 0x00)
|
|
{
|
|
reVal = Encoding.BigEndianUnicode;
|
|
}
|
|
else if (ss[0] == 0xFF && ss[1] == 0xFE && ss[2] == 0x41)
|
|
{
|
|
reVal = Encoding.Unicode;
|
|
}
|
|
r.Close();
|
|
return reVal;
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// 判断是否是不带 BOM 的 UTF8 格式
|
|
/// </summary>
|
|
/// <param name="data"></param>
|
|
/// <returns></returns>
|
|
private static bool IsUtf8Bytes(byte[] data)
|
|
{
|
|
var charByteCounter = 1; //计算当前正分析的字符应还有的字节数
|
|
|
|
foreach (var t in data)
|
|
{
|
|
var curByte = t;
|
|
if (charByteCounter == 1)
|
|
{
|
|
if (curByte >= 0x80)
|
|
{
|
|
//判断当前
|
|
while (((curByte <<= 1) & 0x80) != 0)
|
|
{
|
|
charByteCounter++;
|
|
}
|
|
//标记位首位若为非0 则至少以2个1开始 如:110XXXXX...........1111110X
|
|
if (charByteCounter == 1 || charByteCounter > 6)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//若是UTF-8 此时第一位必须为1
|
|
if ((curByte & 0xC0) != 0x80)
|
|
{
|
|
return false;
|
|
}
|
|
charByteCounter--;
|
|
}
|
|
}
|
|
if (charByteCounter > 1)
|
|
{
|
|
throw new Exception("非预期的byte格式");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
}
|
|
|
|
public static string GetFileSizeByFilePath(string filePath)
|
|
{
|
|
if (!string.IsNullOrEmpty(filePath))
|
|
{
|
|
var theFile = new FileInfo(filePath);
|
|
var fileSize = theFile.Length;
|
|
if (fileSize < 1024)
|
|
{
|
|
return fileSize.ToString() + "B";
|
|
}
|
|
else if (fileSize >= 1024 && fileSize < 1048576)
|
|
{
|
|
return (fileSize / 1024).ToString() + "KB";
|
|
}
|
|
else
|
|
{
|
|
return (fileSize / 1048576).ToString() + "MB";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return string.Empty;
|
|
}
|
|
}
|
|
}
|
|
}
|