c# 文本操作

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.IO;
using System.Text;

/// <summary>
/// 文件读取
/// </summary>
public static class FileUtility
{
    /// <summary>
    /// 读取文件,使用File读取
    /// </summary>
    /// <param name="fileName"> 文件所在的绝对路径</param>
    /// <returns>文本的内容</returns>
    public static string OpenTextFile(string fileName)
    {
        StreamReader streamReader = File.OpenText(fileName);
        if (streamReader == null)
        {
            Debug.Log("open file failed! filename : " + fileName);
            return string.Empty;
        }
        string fileBuffer = streamReader.ReadToEnd();
        streamReader.Close();
        streamReader.Dispose();
        return fileBuffer;
    }
    /// <summary>
    /// 读取文件,使用FileStream读取
    /// </summary>
    /// <param name="fileName">文件所在的绝对路径</param>
    /// <returns>文本的内容</returns>
    public static string OpenTextFile1(string fileName)
    {
        FileStream fileStream = new FileStream(fileName,FileMode.Open,FileAccess.Read);
        byte[] data = new byte[fileStream.Length];
        fileStream.Read(data,0,fileName.Length);
        fileStream.Close();
        fileStream.Dispose();
        return Encoding.UTF8.GetString(data, 0, fileName.Length);
    }
    /// <summary>
    /// 写入文件，使用FileSteam 写入
    /// </summary>
    /// <param name="fileName">文件所在位置</param>
    /// <param name="content">写入文件内容</param>
    /// <param name="appendData">是否重新创建</param>
    public static void writeTxtFile(string fileName, string content, bool appendData = false)
    {
        // 检测路径是否存在,如果不存在就创建一个
        CreateDir(GetFilePath(fileName));
        byte[] bytes = Encoding.UTF8.GetBytes(content);
        FileStream file = null;
        if (appendData)
        {
            file = new FileStream(fileName, FileMode.Append, FileAccess.Write);
        }
        else
        {
            file = new FileStream(fileName, FileMode.Create, FileAccess.Write);
        }
        file.Write(bytes, 0, bytes.Length);
        file.Close();
        file.Dispose();
    }
   /// <summary>
   /// 写人文件，使用StreamWriter写入
   /// </summary>
   /// <param name="fileName"></param>
   /// <param name="content"></param>
   /// <param name="appendData"></param>
	public static void WriteTextFile1(string fileName,string content, bool appendData = false)
    {
        FileStream file = null;
        if (appendData)
        {
            file = new FileStream(fileName, FileMode.Append, FileAccess.Write);
        }
        else
        {
            file = new FileStream(fileName, FileMode.Create, FileAccess.Write);
        }
        StreamWriter sw = new StreamWriter(file);
        sw.Write(content);
        sw.Close();
        file.Close();
    }
    /// <summary>
    /// 该路径是否存在
    /// </summary>
    /// <param name="filepath">路径</param>
    /// <returns></returns>
    public static bool IsExistFile(string filepath)
	{
		return File.Exists(filepath);
	}
	
	/// <summary>
	/// 判断文件夹是否存在
	/// </summary>
	/// <param name="Folderpath"></param>
	public static void IsExisFolder(string Folderpath)
	{
		if (!Directory.Exists(Folderpath))
			Directory.CreateDirectory(Folderpath);
	}
	/// <summary>
	/// 删除文件
	/// </summary>
	/// <param name="filepath"></param>
	public static void DeleteFile(string filepath)
	{
		File.Delete(filepath);
	}
	/// <summary>
	/// 返回Sprite图片
	/// </summary>
	/// <param name="path">路径</param>
	/// <param name="width">图片宽</param>
	/// <param name="height">图片高</param>
	/// <returns></returns>
	public static Sprite LoadByIO(string path, int width, int height)
	{
		FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read);
		fileStream.Seek(0, SeekOrigin.Begin);
		byte[] bytes = new byte[fileStream.Length];
		fileStream.Read(bytes, 0, (int)fileStream.Length);
		fileStream.Close();
		fileStream.Dispose();
		fileStream = null;
		Texture2D texture2D = new Texture2D(width, height);
		texture2D.LoadImage(bytes);
		return Sprite.Create(texture2D, new Rect(0, 0, texture2D.width, texture2D.height), Vector2.zero);
	}
	public static Texture LoadByIO(string path)
	{
		FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read);
		fileStream.Seek(0, SeekOrigin.Begin);
		byte[] bytes = new byte[fileStream.Length];
		fileStream.Read(bytes, 0, (int)fileStream.Length);
		fileStream.Close();
		fileStream.Dispose();
		fileStream = null;
		Texture2D texture2D = new Texture2D(0, 0);
		texture2D.LoadImage(bytes);
		texture2D.Apply();
		return texture2D;
	}
    /// <summary>
    /// 检查文件的路径
    /// </summary>
    /// <param name="path">文件的路径</param>
	public static void ValidPath(ref string path)
	{
		if (path.Length > 0)
		{
			//不以/结尾的，则加上/
			if (path[path.Length - 1] != '/')
			{
				path += '/';
			}
		}
	}
	/// <summary>
    /// 删除文件
    /// </summary>
    /// <param name="path">文件所在的路径</param>
	public static void DeleteFolder(string path)
	{
		ValidPath(ref path);
		string[] dirlist = Directory.GetDirectories(path);
		// 先删除文件夹
		foreach (var item in dirlist)
		{
			DeleteFolder(item);
		}
		// 再删除所有文件
		string[] fileList = Directory.GetFiles(path);
		foreach (var item in fileList)
		{
			DeleteFile(item);
		}
		// 再删除文件夹自身
		Directory.Delete(path);
	}
	public static bool DeleteEmptyFolder(string path, bool deleteSelfIfEmpty = true)
	{
		ValidPath(ref path);
		// 先删除所有空的文件夹
		string[] dirList = Directory.GetDirectories(path);
		bool isEmpty = true;
		foreach (var item in dirList)
		{
			isEmpty = DeleteEmptyFolder(item, true) && isEmpty;
		}
		isEmpty = isEmpty && Directory.GetFiles(path).Length == 0;
		if (isEmpty && deleteSelfIfEmpty)
		{
			Directory.Delete(path);
		}
		return isEmpty;
	}
    /// <summary>
    /// 移动文件夹
    /// </summary>
    /// <param name="source"></param>
    /// <param name="dest"></param>
    /// <param name="overwrite"></param>
	public static void MoveFile(string source, string dest, bool overwrite = true)
	{
		if (IsExistFile(dest))
		{
			// 先删除目标文件,因为File.Move不支持覆盖文件,目标文件存在时,File.Move会失败
			if (overwrite)
			{
				DeleteFile(dest);
			}
			else
			{
				return;
			}
		}
		else
		{
			string parentDir = GetFilePath(dest);
			CreateDir(parentDir);
		}
		File.Move(source, dest);
	}
	public static void CopyFile(string source, string dest, bool overwrite = true)
	{
		// 如果目标文件所在的目录不存在，则先创建目录
		string parentDir = GetFilePath(dest);
		CreateDir(parentDir);
		File.Copy(source, dest, overwrite);
	}
    /// <summary>
    /// 获取文件的大小
    /// </summary>
    /// <param name="file"></param>
    /// <returns></returns>
	public static int GetFileSize(string file)
	{
		try
		{
			FileInfo fileInfo = new FileInfo(file);
			int length = (int)fileInfo.Length;
			return length;
		}
		catch
		{
			return 0;
		}
	}
    /// <summary>
    /// 创建文件的路径
    /// </summary>
    /// <param name="dir"></param>
	public static void CreateDir(string dir)
	{
		if (IsDirExist(dir))
		{
			return;
		}
		string parentDir = GetFilePath(dir);
		if (parentDir != dir)
		{
			CreateDir(parentDir);
		}
		Directory.CreateDirectory(dir);
	}
    /// <summary>
    /// 路径是否存在
    /// </summary>
    /// <param name="dir">路径</param>
    /// <returns></returns>
	public static bool IsDirExist(string dir)
	{
		return Directory.Exists(dir);
	}
    /// <summary>
    /// 获取文件的路径
    /// </summary>
    /// <param name="fileName">文件的绝对路径+文件名称</param>
    /// <returns></returns>
	public static string GetFilePath(string fileName)
	{
		RightToLeft(ref fileName);
		int lastPos = fileName.LastIndexOf('/');
		if (lastPos != -1)
		{
			return fileName.Substring(0, lastPos);
		}
		return string.Empty;
	}
    /// <summary>
    /// 将路径中 \\ 修改为/
    /// </summary>
    /// <param name="str"></param>
    public static void RightToLeft(ref string str)
    {
        str = str.Replace('\\', '/');
    }
    /// <summary>
    /// 将路径中/ 修改为 \\
    /// </summary>
    /// <param name="str"></param>
    public static void LeftToRight(ref string str)
    {
        str = str.Replace('/', '\\');
    }

    public static int GetFileCount(string path)
    {
        DirectoryInfo folder = new DirectoryInfo(path);
        FileInfo[] fileInfoList = folder.GetFiles();
        int fileCount = fileInfoList.Length;
        return fileCount;
    }
    public static void FindFiles(string path, ref List<string> fileList, List<string> patterns = null, bool recursive = true)
    {
        //检查文件路径
        ValidPath(ref path);
        //检查是否存在路径
        if (!IsDirExist(path))
        {
            return;
        }
        DirectoryInfo folder = new DirectoryInfo(path);
        FileInfo[] fileInfoList = folder.GetFiles();
        int fileCount = fileInfoList.Length;
        int patternCount = patterns != null ? patterns.Count : 0;
        for (int i = 0; i < fileCount; ++i)
        {
            string fileName = fileInfoList[i].Name;
            // 如果需要过滤后缀名,则判断后缀
            if (patternCount > 0)
            {
                for (int j = 0; j < patternCount; ++j)
                {
                    if (EndWith(fileName, patterns[j], false))
                    {
                        fileList.Add(path + fileName);
                    }
                }
            }
            // 不需要过滤,则直接放入列表
            else
            {
                fileList.Add(path + fileName);
            }
        }
        // 查找所有子目录
        if (recursive)
        {
            string[] dirs = Directory.GetDirectories(path);
            foreach (var item in dirs)
            {
                findFiles(item, ref fileList, patterns, recursive);
            }
        }
    }
    public static bool EndWith(string oriString, string pattern, bool sensitive = true)
    {
        if (oriString.Length < pattern.Length)
        {
            return false;
        }
        string endString = oriString.Substring(oriString.Length - pattern.Length, pattern.Length);
        if (sensitive)
        {
            return endString == pattern;
        }
        else
        {
            return endString.ToLower() == pattern.ToLower();
        }
    }
}