分享一个收集到的文件和目录操作类FileSystemObject

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Data;
using System.Web;

    public abstract class FileSystemObject
    {
        // Methods
        protected FileSystemObject()
        {
        }

        public static string ConvertSizeToShow(int fileSize)
        {
            int num = fileSize / 0x400;
            if (num < 1)
            {
                return (fileSize.ToString() + "<span style='color:red'>&nbsp;&nbsp;B</span>");
            }
            if (num < 0x400)
            {
                return (num.ToString() + "<span style='color:red'>&nbsp;KB</span>");
            }
            int num2 = num / 0x400;
            if (num2 < 1)
            {
                return (num.ToString() + "<span style='color:red'>&nbsp;KB</span>");
            }
            if (num2 >= 0x400)
            {
                num2 /= 0x400;
                return (num2.ToString() + "<span style='color:red'>&nbsp;GB</span>");
            }
            return (num2.ToString() + "<span style='color:red'>&nbsp;MB</span>");
        }

        public static void CopyDirectory(string oldDir, string newDir)
        {
            DirectoryInfo od = new DirectoryInfo(oldDir);
            CopyDirInfo(od, oldDir, newDir);
        }

        private static void CopyDirInfo(DirectoryInfo od, string oldDir, string newDir)
        {
            if (!DirIsExist(newDir))
            {
                Create(newDir, FsoMethod.Folder);
            }
            foreach (DirectoryInfo info in od.GetDirectories())
            {
                CopyDirInfo(info, info.FullName, newDir + info.FullName.Replace(oldDir, ""));
            }
            foreach (FileInfo info2 in od.GetFiles())
            {
                CopyFile(info2.FullName, newDir + info2.FullName.Replace(oldDir, ""));
            }
        }

        public static DataTable CopyDT(DataTable parent, DataTable child)
        {
            for (int i = 0; i < child.Rows.Count; i++)
            {
                DataRow row = parent.NewRow();
                for (int j = 0; j < parent.Columns.Count; j++)
                {
                    row[j] = child.Rows[i][j];
                }
                parent.Rows.Add(row);
            }
            return parent;
        }

        public static void CopyFile(string oldFile, string newFile)
        {
            File.Copy(oldFile, newFile, true);
        }

        public static bool CopyFileStream(string oldPath, string newPath)
        {
            try
            {
                FileStream input = new FileStream(oldPath, FileMode.Open, FileAccess.Read);
                FileStream output = new FileStream(newPath, FileMode.Create, FileAccess.Write);
                BinaryReader reader = new BinaryReader(input);
                BinaryWriter writer = new BinaryWriter(output);
                reader.BaseStream.Seek(0L, SeekOrigin.Begin);
                reader.BaseStream.Seek(0L, SeekOrigin.End);
                while (reader.BaseStream.Position < reader.BaseStream.Length)
                {
                    writer.Write(reader.ReadByte());
                }
                reader.Close();
                writer.Close();
                input.Flush();
                input.Close();
                output.Flush();
                output.Close();
                return true;
            }
            catch
            {
                return false;
            }
        }

        public static void Create(string file, FsoMethod method)
        {
            try
            {
                if (method == FsoMethod.File)
                {
                    WriteFile(file, "");
                }
                else if (method == FsoMethod.Folder)
                {
                    Directory.CreateDirectory(file);
                }
            }
            catch
            {
                throw new UnauthorizedAccessException("没有权限！");
            }
        }




        /// <summary>
        /// 创建目录
        /// </summary>
        /// <param name="dirPath">相对路径</param>
        /// <returns>是否成功</returns>
        public static bool CreateDirectory(string dirPath)
        {
            if (string.IsNullOrEmpty(dirPath))
                return false;
            dirPath = HttpContext.Current.Server.MapPath(dirPath);
            DirectoryInfo dirInfo = new DirectoryInfo(dirPath);
            if (dirInfo.Exists)
                return true;
            try
            {
                Directory.CreateDirectory(dirPath);
                return true;
            }
            catch
            {
                return false;
            }
        }


        public static void Delete(string file, FsoMethod method)
        {
            if ((method == FsoMethod.File) && File.Exists(file))
            {
                File.Delete(file);
            }
            if ((method == FsoMethod.Folder) && Directory.Exists(file))
            {
                Directory.Delete(file, true);
            }
        }

        private static long[] DirInfo(DirectoryInfo d)
        {
            long[] numArray = new long[3];
            long num = 0L;
            long num2 = 0L;
            long num3 = 0L;
            FileInfo[] files = d.GetFiles();
            num3 += files.Length;
            foreach (FileInfo info in files)
            {
                num += info.Length;
            }
            DirectoryInfo[] directories = d.GetDirectories();
            num2 += directories.Length;
            foreach (DirectoryInfo info2 in directories)
            {
                num += DirInfo(info2)[0];
                num2 += DirInfo(info2)[1];
                num3 += DirInfo(info2)[2];
            }
            numArray[0] = num;
            numArray[1] = num2;
            numArray[2] = num3;
            return numArray;
        }

        private static DataTable GetDirectoryAllInfo(DirectoryInfo d, FsoMethod method)
        {
            DataRow row;
            DataTable parent = new DataTable();
            parent.Columns.Add("name");
            parent.Columns.Add("rname");
            parent.Columns.Add("content_type");
            parent.Columns.Add("type");
            parent.Columns.Add("path");
            parent.Columns.Add("creatime", typeof(DateTime));
            parent.Columns.Add("size", typeof(int));
            foreach (DirectoryInfo info in d.GetDirectories())
            {
                if (method == FsoMethod.File)
                {
                    parent = CopyDT(parent, GetDirectoryAllInfo(info, method));
                }
                else
                {
                    row = parent.NewRow();
                    row[0] = info.Name;
                    row[1] = info.FullName;
                    row[2] = "";
                    row[3] = 1;
                    row[4] = info.FullName.Replace(info.Name, "");
                    row[5] = info.CreationTime;
                    row[6] = "";
                    parent.Rows.Add(row);
                    parent = CopyDT(parent, GetDirectoryAllInfo(info, method));
                }
            }
            if (method != FsoMethod.Folder)
            {
                foreach (FileInfo info2 in d.GetFiles())
                {
                    row = parent.NewRow();
                    row[0] = info2.Name;
                    row[1] = info2.FullName;
                    row[2] = info2.Extension.Replace(".", "");
                    row[3] = 2;
                    row[4] = info2.DirectoryName + @"\";
                    row[5] = info2.CreationTime;
                    row[6] = info2.Length;
                    parent.Rows.Add(row);
                }
            }
            return parent;
        }

        public static DataTable GetDirectoryAllInfos(string dir, FsoMethod method)
        {
            DataTable directoryAllInfo;
            try
            {
                DirectoryInfo d = new DirectoryInfo(dir);
                directoryAllInfo = GetDirectoryAllInfo(d, method);
            }
            catch (Exception exception)
            {
                throw new FileNotFoundException(exception.ToString());
            }
            return directoryAllInfo;
        }

        public static DataTable GetDirectoryInfos(string dir, FsoMethod method)
        {
            DataRow row;
            DataTable table = new DataTable();
            table.Columns.Add("name", typeof(string));
            table.Columns.Add("type");
            table.Columns.Add("size", typeof(int));
            table.Columns.Add("content_type");
            table.Columns.Add("createTime", typeof(DateTime));
            table.Columns.Add("lastWriteTime", typeof(DateTime));
            if (method != FsoMethod.File)
            {
                for (int i = 0; i < getDirs(dir).Length; i++)
                {
                    row = table.NewRow();
                    DirectoryInfo d = new DirectoryInfo(getDirs(dir)[i]);
                    long[] numArray = DirInfo(d);
                    row[0] = d.Name;
                    row[1] = 1;
                    row[2] = numArray[0];
                    row[3] = "";
                    row[4] = d.CreationTime;
                    row[5] = d.LastWriteTime;
                    table.Rows.Add(row);
                }
            }
            if (method != FsoMethod.Folder)
            {
                for (int j = 0; j < getFiles(dir).Length; j++)
                {
                    row = table.NewRow();
                    FileInfo info2 = new FileInfo(getFiles(dir)[j]);
                    row[0] = info2.Name;
                    row[1] = 2;
                    row[2] = info2.Length;
                    row[3] = info2.Extension.Replace(".", "");
                    row[4] = info2.CreationTime;
                    row[5] = info2.LastWriteTime;
                    table.Rows.Add(row);
                }
            }
            return table;
        }

        public static long[] GetDirInfos(string dir)
        {
            long[] numArray = new long[3];
            DirectoryInfo d = new DirectoryInfo(dir);
            return DirInfo(d);
        }

        private static string[] getDirs(string dir)
        {
            return Directory.GetDirectories(dir);
        }

        private static string[] getFiles(string dir)
        {
            return Directory.GetFiles(dir);
        }

        public static string GetFileSize(string filePath)
        {
            FileInfo info = new FileInfo(filePath);
            float num = info.Length / 0x400L;
            return (num.ToString() + "KB");
        }


        /// <summary>
        /// 返回文件是否存在
        /// </summary>
        /// <param name="filename">文件名</param>
        /// <returns>是否存在</returns>
        public static bool FileExists(string filename)
        {
            return File.Exists(filename);
        }
        /// <summary>
        /// 返回目录是否存在
        /// </summary>
        /// <param name="filename">文件目录</param>
        /// <returns>是否存在</returns>
        public static bool DirIsExist(string file)
        {
            return  Directory.Exists(file);
        }


        public static bool IsExistCategoryDirAndCreate(string categorDir, HttpContext context)
        {
            if (context != null)
            {
                string file = Path.Combine(context.Request.PhysicalApplicationPath, categorDir);
                if (DirIsExist(file))
                {
                    return true;
                }
                Create(file, FsoMethod.Folder);
            }
            return false;
        }

        public static void Move(string oldFile, string newFile, FsoMethod method)
        {
            if (method == FsoMethod.File)
            {
                File.Move(oldFile, newFile);
            }
            if (method == FsoMethod.Folder)
            {
                Directory.Move(oldFile, newFile);
            }
        }

        public static string ReadFile(string file)
        {
            string str = "";
            using (FileStream stream = new FileStream(file, FileMode.Open, FileAccess.Read))
            {
                StreamReader reader = new StreamReader(stream, Encoding.Default);
                try
                {
                    return reader.ReadToEnd();
                }
                catch
                {
                    return str;
                }
                finally
                {
                    if (reader != null)
                    {
                        reader.Dispose();
                    }
                }
            }
        }

        public static void ReplaceFileContent(string dir, string originalContent, string newContent)
        {
            DirectoryInfo info = new DirectoryInfo(dir);
            foreach (FileInfo info2 in info.GetFiles("*.*", SearchOption.AllDirectories))
            {
                StreamReader reader = info2.OpenText();
                string str = reader.ReadToEnd();
                reader.Dispose();
                if (str.Contains(originalContent))
                {
                    WriteFile(info2.FullName, str.Replace(originalContent, newContent));
                }
            }
        }

        public static DataTable SearchFileContent(string dir, string searchPattern)
        {
            DataTable table = new DataTable();
            DirectoryInfo info = new DirectoryInfo(dir);
            table.Columns.Add("name");
            table.Columns.Add("type");
            table.Columns.Add("size", typeof(int));
            table.Columns.Add("content_type");
            table.Columns.Add("createTime", typeof(DateTime));
            table.Columns.Add("lastWriteTime", typeof(DateTime));
            foreach (FileInfo info2 in info.GetFiles("*.*", SearchOption.AllDirectories))
            {
                DataRow row = table.NewRow();
                StreamReader reader = info2.OpenText();
                string str = reader.ReadToEnd();
                reader.Dispose();
                if (str.Contains(searchPattern))
                {
                    row[0] = info2.FullName.Remove(0, info.FullName.Length);
                    row[1] = 2;
                    row[2] = info2.Length;
                    row[3] = info2.Extension.Replace(".", "");
                    row[4] = info2.CreationTime;
                    row[5] = info2.LastWriteTime;
                    table.Rows.Add(row);
                }
            }
            return table;
        }

        public static DataTable SearchFiles(string dir, string searchPattern)
        {
            DataTable table = new DataTable();
            DirectoryInfo info = new DirectoryInfo(dir);
            table.Columns.Add("name");
            table.Columns.Add("type");
            table.Columns.Add("size", typeof(int));
            table.Columns.Add("content_type");
            table.Columns.Add("createTime", typeof(DateTime));
            table.Columns.Add("lastWriteTime", typeof(DateTime));
            foreach (FileInfo info2 in info.GetFiles(searchPattern, SearchOption.AllDirectories))
            {
                DataRow row = table.NewRow();
                row[0] = info2.FullName.Remove(0, info.FullName.Length);
                row[1] = 2;
                row[2] = info2.Length;
                row[3] = info2.Extension.Replace(".", "");
                row[4] = info2.CreationTime;
                row[5] = info2.LastWriteTime;
                table.Rows.Add(row);
            }
            return table;
        }

        public static DataTable SearchTemplateFiles(string dir, string searchPattern)
        {
            DataTable table = new DataTable();
            DirectoryInfo info = new DirectoryInfo(dir);
            string str = searchPattern;
            string str2 = searchPattern.ToLower();
            int length = searchPattern.Length;
            if (length < 4)
            {
                str = "*" + str + "*.html";
            }
            else if ((str2.Substring(length - 4, 4) != ".html") || (str2.Substring(length - 3, 3) != ".htm"))
            {
                str = "*" + str + "*.html";
            }
            table.Columns.Add("name");
            table.Columns.Add("type");
            table.Columns.Add("size", typeof(int));
            table.Columns.Add("content_type");
            table.Columns.Add("createTime", typeof(DateTime));
            table.Columns.Add("lastWriteTime", typeof(DateTime));
            try
            {
                foreach (FileInfo info2 in info.GetFiles(str, SearchOption.AllDirectories))
                {
                    DataRow row = table.NewRow();
                    row[0] = info2.FullName.Remove(0, info.FullName.Length).Replace("/", "\"");
                    row[1] = 2;
                    row[2] = info2.Length;
                    row[3] = info2.Extension.Replace(".", "");
                    row[4] = info2.CreationTime;
                    row[5] = info2.LastWriteTime;
                    table.Rows.Add(row);
                }
            }
            catch (ArgumentException)
            {
            }
            return table;
        }

        public static string WriteAppend(string file, string fileContent)
        {
            string str;
            FileInfo info = new FileInfo(file);
            if (!Directory.Exists(info.DirectoryName))
            {
                Directory.CreateDirectory(info.DirectoryName);
            }
            FileStream stream = new FileStream(file, FileMode.Append, FileAccess.Write);
            StreamWriter writer = new StreamWriter(stream, Encoding.GetEncoding("utf-8"));
            try
            {
                writer.Write(fileContent);
                str = fileContent;
            }
            catch (Exception exception)
            {
                throw new FileNotFoundException(exception.ToString());
            }
            finally
            {
                writer.Flush();
                stream.Flush();
                writer.Close();
                stream.Close();
            }
            return str;
        }

        public static string WriteFile(string file, string fileContent)
        {
            string str;
            FileInfo info = new FileInfo(file);
            if (!Directory.Exists(info.DirectoryName))
            {
                Directory.CreateDirectory(info.DirectoryName);
            }
            FileStream stream = new FileStream(file, FileMode.Create, FileAccess.Write);
            StreamWriter writer = new StreamWriter(stream, Encoding.UTF8);
            try
            {
                writer.Write(fileContent);
                str = fileContent;
            }
            catch (Exception exception)
            {
                throw new FileNotFoundException(exception.ToString());
            }
            finally
            {
                writer.Flush();
                stream.Flush();
                writer.Close();
                stream.Close();
            }
            return str;
        }

        public static void WriteFile(string file, string fileContent, bool append)
        {
            FileInfo info = new FileInfo(file);
            if (!Directory.Exists(info.DirectoryName))
            {
                Directory.CreateDirectory(info.DirectoryName);
            }
            StreamWriter writer = new StreamWriter(file, append, Encoding.GetEncoding("utf-8"));
            try
            {
                writer.Write(fileContent);
            }
            catch (Exception exception)
            {
                throw new FileNotFoundException(exception.ToString());
            }
            finally
            {
                writer.Flush();
                writer.Close();
            }
        }
    }

    public enum FsoMethod
    {
        Folder,
        File,
        All
    }