.NET文件操作帮助类

标签：

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

namespace ZC.Utils
{
    public partial class FileHelper
    {

        //public static string  GetUpFilesPath(string Project__)
        //{
        //    string RootPath = HttpContext.Current.Server.MapPath("/") + "UpFiles";
        //    if (!Directory.Exists(RootPath)) RootPath = HttpContext.Current.Server.MapPath("../") + "UpFiles";
        //    if (!Directory.Exists(RootPath))
        //    {
        //        RootPath = HttpContext.Current.Request.Url.ToString();
        //        RootPath = RootPath.Substring(0, RootPath.IndexOf("/" + Project__ + "/") + 1);
        //    }
        //    return RootPath;
        //}


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

            if (File.Exists(fileName))
            {
                return true;
            }

            return false;
        }

        /// <summary>
        /// 判断目录是否存在
        /// </summary>
        /// <param name="fileName"></param>
        /// <returns></returns>
        public static bool ExistsDir(string dir)
        {
            if (Directory.Exists(dir))
            {
                return true;
            }

            return false;
        }


        /// <summary>
        /// 创建文件夹
        /// </summary>
        /// <param name="dirName"></param>
        /// <returns></returns>
        public static bool CreateDir(string dirName)
        {

          

            if (!Directory.Exists(dirName))
            {
                Directory.CreateDirectory(dirName);
            }
            return true;
        }

        /// <summary>
        /// 为全路径文件创建文件夹
        /// </summary>
        /// <param name="dirName"></param>
        /// <returns></returns>
        public static bool CreateDirByFilePath(string FilePath)
        {
            CreateDir(GetDirForFile(FilePath));
            return true;
        }

        /// <summary>
        /// 为全路径文件创建文件夹
        /// </summary>
        /// <param name="dirName"></param>
        /// <returns></returns>
        public static string  GetDirForFile(string FilePath)
        {
            return  FilePath.Substring(0, FilePath.LastIndexOf( Path.DirectorySeparatorChar));
        }


        /// <summary>
        /// 创建新文件,如果存在,则先删除
        /// </summary>
        /// <param name="fileName"></param>
        /// <returns></returns>
        public static bool CreateNewFile(string fileName)
        {
            if (FileHelper.Exists(fileName))  FileHelper.DeleteFile(fileName) ;
            
            CreateDir(fileName.Substring(0, fileName.LastIndexOf("\\")));

            if (!File.Exists(fileName))
            {
                FileStream fs = File.Create(fileName);
                fs.Close();
                fs.Dispose();
            }
            return true;

        }


        /// <summary>
        /// 创建文件
        /// </summary>
        /// <param name="fileName"></param>
        /// <returns></returns>
        public static bool CreateFile(string fileName)
        {

            CreateDir(PathHelper.GetParentPath(fileName));

            if (!File.Exists(fileName))
            {
                FileStream fs = File.Create(fileName);
                fs.Close();
                fs.Dispose();
            }
            return true;

        }


        /// <summary>
        /// 读文件内容
        /// </summary>
        /// <param name="fileName"></param>
        /// <returns></returns>
        public static string Read(string fileName)
        {
            if (!Exists(fileName))
            {
                return null;
            }
            //将文件信息读入流中
            using (FileStream fs = new FileStream(fileName, FileMode.Open))
            {
                return new StreamReader(fs).ReadToEnd();
            }
        }

        /// <summary>
        /// 读ReadUtf8文件内容
        /// </summary>
        /// <param name="fileName"></param>
        /// <returns></returns>
        public static string ReadUtf8(string fileName)
        {
                if (!Exists(fileName))
                {
                    throw new FileNotFoundException();
                }
                //将文件信息读入流中
                using (FileStream fs = new FileStream(fileName, FileMode.Open))
                {
                    return new StreamReader(fs, System.Text.Encoding.UTF8).ReadToEnd();
                }
        }

        /// <summary>
        /// 读ReadUtf8文件内容
        /// </summary>
        /// <param name="fileName"></param>
        /// <returns></returns>
        public static StringBuilder ReadUtf8StringBuilder(string fileName)
        {
            try
            {
                if (!Exists(fileName))
                {
                    return null;
                }
                //将文件信息读入流中
                using (FileStream fs = new FileStream(fileName, FileMode.Open))
                {
                    return new StringBuilder(new StreamReader(fs, System.Text.Encoding.UTF8).ReadToEnd());
                }
            }
            catch
            {
                return new StringBuilder();
            }
        }

        /// <summary>
        /// 读ReadDefault文件内容
        /// </summary>
        /// <param name="fileName"></param>
        /// <returns></returns>
        public static string ReadDefault(string fileName)
        {
            if (!Exists(fileName))
            {
                return null;
            }
            //将文件信息读入流中
            using (FileStream fs = new FileStream(fileName, FileMode.Open))
            {
                return new StreamReader(fs, System.Text.Encoding.Default).ReadToEnd();
            }
        }

        ///// <summary>
        ///// 写WriteDefault文件
        ///// </summary>
        ///// <param name="fileName">文件名</param>
        ///// <param name="content">文件内容</param>
        ///// <returns></returns>
        //public static bool WriteDefault(string fileName, string content)
        //{
        //    if (!Exists(fileName) || content == null)
        //    {
        //        return false;
        //    }

        //    //将文件信息读入流中
        //    using (FileStream fs = new FileStream(fileName, FileMode.Create))
        //    {
        //        lock (fs)//锁住流
        //        {
        //            if (!fs.CanWrite)
        //            {
        //                throw new System.Security.SecurityException("文件fileName=" + fileName + "是只读文件不能写入!");
        //            }

        //            byte[] buffer = Encoding.Default.GetBytes(content);
        //            fs.Write(buffer, 0, buffer.Length);
        //            return true;
        //        }
        //    }
        //}

        /// <summary>
        /// 读ReadJson文件内容
        /// </summary>
        /// <param name="fileName"></param>
        /// <returns></returns>
        public static string ReadJson(string fileName)
        {
            if (!Exists(fileName))
            {
                return null;
            }
            //将文件信息读入流中
            using (FileStream fs = new FileStream(fileName, FileMode.Open))
            {


                return new StreamReader(fs, System.Text.Encoding.Default).ReadToEnd();
            }
        }


        public static string ReadLine(string fileName)
        {
            if (!Exists(fileName))
            {
                return null;
            }
            using (FileStream fs = new FileStream(fileName, FileMode.Open))
            {
                return new StreamReader(fs).ReadLine();
            }
        }


         /// <summary>
        /// 写WriteUtf8文件
        /// </summary>
        /// <param name="fileName">文件名</param>
        /// <param name="content">文件内容</param>
        /// <returns></returns>
        public static bool WriteDefault(string fileName, string content, bool IsCreate = true, bool IsOverWrite = true)
        {
            if (content == null) return false;

            if (Exists(fileName) && IsOverWrite == false)
            {
                return false;
            }

            if (IsCreate)
            {
                FileHelper.CreateFile(fileName);
            }

            //将文件信息读入流中
            using (FileStream fs = new FileStream(fileName, FileMode.Create))
            {
                lock (fs)//锁住流
                {
                    if (!fs.CanWrite)
                    {
                        throw new System.Security.SecurityException("文件fileName=" + fileName + "是只读文件不能写入!");
                    }

                    byte[] buffer = Encoding.Default.GetBytes(content);
                    fs.Write(buffer, 0, buffer.Length);
                    return true;
                }
            }
        }

        /// <summary>
        /// 写WriteUtf8文件
        /// </summary>
        /// <param name="fileName">文件名</param>
        /// <param name="content">文件内容</param>
        /// <returns></returns>
        public static bool WriteUtf8(string fileName, string content ,bool IsCreate=true,bool IsOverWrite=true)
        {
            if (content == null) return false;

            if (Exists(fileName) && IsOverWrite == false)
            {
                return false;
            }

            if (IsCreate)
            {
                FileHelper.CreateFile(fileName);
            }

            //将文件信息读入流中
            using (FileStream fs = new FileStream(fileName, FileMode.Create))
            {
                lock (fs)//锁住流
                {
                    if (!fs.CanWrite)
                    {
                        throw new System.Security.SecurityException("文件fileName=" + fileName + "是只读文件不能写入!");
                    }

                    byte[] buffer = Encoding.UTF8.GetBytes(content);
                    fs.Write(buffer, 0, buffer.Length);
                    fs.Flush();
                    fs.Close();
                    return true;
                }
            }
        }

   
        /// <summary>
        /// 写文件
        /// </summary>
        /// <param name="fileName">文件名</param>
        /// <param name="content">文件内容</param>
        /// <returns></returns>
        public static bool Write(string fileName, string content)
        {
            if (!Exists(fileName) || content == null)
            {
                return false;
            }

            //将文件信息读入流中
            using (FileStream fs = new FileStream(fileName, FileMode.Create))
            {
                lock (fs)//锁住流
                {
                    if (!fs.CanWrite)
                    {
                        throw new System.Security.SecurityException("文件fileName=" + fileName + "是只读文件不能写入!");
                    }

                    byte[] buffer = Encoding.Default.GetBytes(content);
                    fs.Write(buffer, 0, buffer.Length);
                    fs.Flush();
                    fs.Close();
                    return true;
                }
            }
        }


 
        /// <summary>
        /// 写入一行
        /// </summary>
        /// <param name="fileName">文件名</param>
        /// <param name="content">内容</param>
        /// <returns></returns>
        public static bool WriteLine(string fileName, string content)
        {
            using (FileStream fs = new FileStream(fileName, FileMode.OpenOrCreate | FileMode.Append))
            {
                lock (fs)
                {
                    if (!fs.CanWrite)
                    {
                        throw new System.Security.SecurityException("文件fileName=" + fileName + "是只读文件不能写入!");
                    }

                    StreamWriter sw = new StreamWriter(fs);
                    sw.WriteLine(content);
                    sw.Dispose();
                    sw.Close();
                    fs.Flush();
                    fs.Close();
                    return true;
                }
            }
        }


        public static bool CopyDir(DirectoryInfo fromDir, string toDir)
        {
            return CopyDir(fromDir, toDir, fromDir.FullName);
        }


        /// <summary>
        /// 复制目录
        /// </summary>
        /// <param name="fromDir">被复制的目录</param>
        /// <param name="toDir">复制到的目录</param>
        /// <returns></returns>
        public static bool CopyDir(string fromDir, string toDir)
        {
            if (fromDir == null || toDir == null)
            {
                throw new NullReferenceException("参数为空");
            }

            if (fromDir == toDir)
            {
                throw new Exception("两个目录都是" + fromDir);
            }

            if (!Directory.Exists(fromDir))
            {
                throw new IOException("目录fromDir=" + fromDir + "不存在");
            }

            DirectoryInfo dir = new DirectoryInfo(fromDir);
            return CopyDir(dir, toDir, dir.FullName);
        }

        /// <summary>
        /// 拷贝文件
        /// </summary>
        /// <param name="OrignFile">原始文件</param>
        /// <param name="NewFile">新文件路径</param>
        public static void FileCopy(string OrignFile, string NewFile,bool IsOverWrite=true)
        {
            File.Copy(OrignFile, NewFile, IsOverWrite);
        }

        /// <summary>
        /// 移动文件
        /// </summary>
        /// <param name="OrignFile">原始路径</param>
        /// <param name="NewFile">新路径</param>
        public static void FileMove(string OrignFile, string NewFile)
        {
            if (Exists(NewFile)) DeleteFile(NewFile);
            File.Move(OrignFile, NewFile);
        }


        /// <summary>
        /// 复制目录不带Html文件
        /// </summary>
        /// <param name="fromDir">被复制的目录</param>
        /// <param name="toDir">复制到的目录</param>
        /// <param name="rootDir">被复制的根目录</param>
        /// <returns></returns>
        public  static bool CopyDirWithoutHtml(DirectoryInfo fromDir, string toDir, string rootDir)
        {
            string filePath = string.Empty;
            foreach (FileInfo f in fromDir.GetFiles())
            {
                if (f.Name.ToLower().EndsWith("_.html")) continue;
                if (f.Name.ToLower().EndsWith("lck")) continue;
                filePath = toDir + f.FullName.Substring(rootDir.Length);
                string newDir = filePath.Substring(0, filePath.LastIndexOf("\\"));
                CreateDir(newDir);
                File.Copy(f.FullName, filePath, true);
            }

            foreach (DirectoryInfo dir in fromDir.GetDirectories())
            {
                CopyDirWithoutHtml(dir, toDir, rootDir);
            }

            return true;
        }

        /// <summary>
        /// 复制目录不带Html文件
        /// </summary>
        /// <param name="fromDir">被复制的目录</param>
        /// <param name="toDir">复制到的目录</param>
        /// <param name="rootDir">被复制的根目录</param>
        /// <returns></returns>
        public static bool CopyDirWithoutHtmlRoot(DirectoryInfo fromDir, string toDir, string rootDir, IList<string> Dics)
        {
            string filePath = string.Empty;
            foreach (FileInfo f in fromDir.GetFiles())
            {
                string fn = f.Name.ToLower();

                if (f.Name.ToLower().EndsWith("_.html")) continue;
                if (f.Name.ToLower().EndsWith("lck")) continue;
                if (f.Name.ToLower().EndsWith("db")) continue;
                if (f.Name.ToLower().EndsWith("docx")) continue;
                if (f.Name.ToLower().EndsWith("swf")) continue;

                var CsFile = new string[] { "index.html", "global.asax", "robots.txt", "uploadImg.html", "web.config" };
                if (CsFile.Contains(fn)) continue;
    
                filePath = toDir + f.FullName.Substring(rootDir.Length);
                string newDir = filePath.Substring(0, filePath.LastIndexOf("\\"));
                CreateDir(newDir);
                try
                {
                    File.Copy(f.FullName, filePath, true);
                }
                catch { }

                //continue;

                string f_ = f.Extension.ToLower();

                if (!(f_ == ".css") && !(f_ == ".js")) continue;

                string htmlStr = FileHelper.ReadUtf8(f.FullName);

                if (string.IsNullOrEmpty(htmlStr))
                {
                    htmlStr = "";
                }

                foreach (string FN in Dics)
                {

                    if (FN.ToLower() == "index.html")
                    {
                        htmlStr = htmlStr.Replace(FN, "/");
                        continue;
                    }

                    string FN_ = FN.Substring(0, FN.LastIndexOf("_."));
                    string[] Names = FN_.Split(‘_‘);
                    if (Names[1].ToLower() == "index")
                    {
                       if(!string.IsNullOrEmpty(htmlStr))  htmlStr = htmlStr.Replace(FN, "/" + Names[0] + "/");
                    }
                    else
                    {
                        if (!string.IsNullOrEmpty(htmlStr)) htmlStr = htmlStr.Replace(FN, "/" + Names[0] + "/" + Names[1] + "/");
                    }
                }

               

                //链接更改为根目录
                htmlStr = htmlStr.Replace("href=\"css", "href=\"/css");
                htmlStr = htmlStr.Replace("href=‘css", "href=‘/css");
                htmlStr = htmlStr.Replace("src=\"images", "src=\"/images");
                htmlStr = htmlStr.Replace("src=‘images", "src=‘/images");
                htmlStr = htmlStr.Replace("<img src=\"images", "<img src=\"/images");
                htmlStr = htmlStr.Replace("<img src=‘images", "<img src=‘/images");
                htmlStr = htmlStr.Replace("url(‘project", "url(‘/project");
                htmlStr = htmlStr.Replace("src=\"js", "src=\"/js");
                htmlStr = htmlStr.Replace("src=\‘js", "src=\‘/js");
                htmlStr = htmlStr.Replace("href=\"project", "href=\"/project");
                htmlStr = htmlStr.Replace("href=‘project", "href=‘/project");
                htmlStr = htmlStr.Replace("src=\"project", "src=\"/project");
                htmlStr = htmlStr.Replace("src=‘project", "src=‘/project");
                htmlStr = htmlStr.Replace("url(\"project", "url(\"/project");
                htmlStr = htmlStr.Replace("url(‘project", "url(‘/project");
                htmlStr = htmlStr.Replace("/10-16/images/", "/images/");
                htmlStr = htmlStr.Replace("href=\"Index.html\"", "href=\"/\"");
                htmlStr = htmlStr.Replace("href=‘Index.html‘", "href=‘/‘");
                htmlStr = htmlStr.Replace("/happy/To", "/To");
                htmlStr = htmlStr.Replace("/happy/", "/");
                
                htmlStr = htmlStr.Replace("http://10.35.128.68/PanPan_Member/", "/");
                if(htmlStr.Contains("10.35.128.68")){

                }
                FileHelper.WriteUtf8(filePath, htmlStr);

            }

            foreach (DirectoryInfo dir in fromDir.GetDirectories())
            {
                var CsDir = new string[] { "admin", "ashx", "autoMapping", "bin", "content", "happy", "upFiles", "views", "swf", "xml" };
                if (CsDir.Contains(dir.Name.ToLower())) continue;
                CopyDirWithoutHtmlRoot(dir, toDir, rootDir,Dics);
            }

            return true;
        }


        /// <summary>
        /// 复制目录
        /// </summary>
        /// <param name="fromDir">被复制的目录</param>
        /// <param name="toDir">复制到的目录</param>
        /// <param name="rootDir">被复制的根目录</param>
        /// <returns></returns>
        private static bool CopyDir(DirectoryInfo fromDir, string toDir, string rootDir)
        {
            string filePath = string.Empty;
            foreach (FileInfo f in fromDir.GetFiles())
            {
                filePath = toDir + f.FullName.Substring(rootDir.Length);
                string newDir = filePath.Substring(0, filePath.LastIndexOf("\\"));
                CreateDir(newDir);
                File.Copy(f.FullName, filePath, true);
            }

            foreach (DirectoryInfo dir in fromDir.GetDirectories())
            {
                CopyDir(dir, toDir, rootDir);
            }

            return true;
        }


        /// <summary>
        /// 删除文件
        /// </summary>
        /// <param name="fileName">文件的完整路径</param>
        /// <returns></returns>
        public static bool DeleteFile(string fileName)
        {
            if (Exists(fileName))
            {
                File.Delete(fileName);
                return true;
            }
            return false;
        }


        public static void DeleteDir(DirectoryInfo dir)
        {
            if (dir == null)
            {
                throw new NullReferenceException("目录不存在");
            }

            try
            {
                foreach (DirectoryInfo d in dir.GetDirectories())
                {
                    DeleteDir(d);
                }


                foreach (FileInfo f in dir.GetFiles())
                {
                    DeleteFile(f.FullName);
                }


                dir.Delete();

            }
            catch { }

        }


        public static void DeleteDir(string  dir)
        {
            DeleteDir(new DirectoryInfo(dir));

        }

        /// <summary>
        /// 删除目录
        /// </summary>
        /// <param name="dir">制定目录</param>
        /// <param name="onlyDir">是否只删除目录</param>
        /// <returns></returns>
        public static bool DeleteDir(string dir, bool onlyDir)
        {
            if (dir == null || dir.Trim() == "")
            {
                throw new NullReferenceException("目录dir=" + dir + "不存在");
            }

            if (!Directory.Exists(dir))
            {
                return false;
            }

            DirectoryInfo dirInfo = new DirectoryInfo(dir);
            if (dirInfo.GetFiles().Length == 0 && dirInfo.GetDirectories().Length == 0)
            {
                Directory.Delete(dir);
                return true;
            }


            if (!onlyDir)
            {
                return false;
            }
            else
            {
                DeleteDir(dirInfo);
                return true;
            }

        }




        /// <summary>
        /// 在指定的目录中查找文件
        /// </summary>
        /// <param name="dir">目录</param>
        /// <param name="fileName">文件名</param>
        /// <returns></returns>
        public static bool FindFile(string dir, string fileName)
        {
            if (dir == null || dir.Trim() == "" || fileName == null || fileName.Trim() == "" || !Directory.Exists(dir))
            {
                return false;
            }

            DirectoryInfo dirInfo = new DirectoryInfo(dir);
            return FindFile(dirInfo, fileName);

        }

        public static IList<FileInfo> GetImportHmtlList(string Path)
        {
            IList<FileInfo> Files = new List<FileInfo>();


            DirectoryInfo theDir = new DirectoryInfo(Path);

            FileInfo[] subFiles = theDir.GetFiles();//获得文件

            foreach (FileInfo FileInfo in subFiles)
            {
              

                string name = FileInfo.Name.ToLower();


                if (name == "index.html") {
                    Files.Add(FileInfo);
                    continue; }

                if (!name.EndsWith("_.html") ) continue;

                string[] Name = name.Replace("_.html","").Split(‘_‘);
                if (Name.Length != 2) continue;

                Files.Add(FileInfo);
            }



            return Files;
        }

        public static IList<FileInfo> GetFileList(string Path)
        {
            IList<FileInfo> Files = new List<FileInfo>();

     
            DirectoryInfo theDir = new DirectoryInfo(Path);

            FileInfo[] subFiles = theDir.GetFiles();//获得文件

            foreach (FileInfo FileInfo in subFiles)
            {
                Files.Add(FileInfo);
            }
            return Files;
        }

        /// <summary>
        /// 获取目录及下级的所有文件
        /// </summary>
        /// <param name="Path"></param>
        /// <returns></returns>
        public static IList<FileInfo> GetAllFileList(string Path)
        {
            IList<FileInfo> Files = new List<FileInfo>();

            foreach (var F in GetFileList(Path))
            {
                Files.Add(F);
            }

            IList<string> Foldes = new List<string>();
            DirectoryInfo[] subDirectories = new DirectoryInfo(Path).GetDirectories();//获得目录

            foreach (DirectoryInfo dirinfo in subDirectories)
            {
               // Foldes.Add(dirinfo.Name);

                foreach (var F in GetFileList(dirinfo.FullName))
                {
                    Files.Add(F);
                }

            }

            return Files;
        }


        public static IList<string> GetFoldList(string Path)
        {
            IList<string> Foldes = new List<string>();
 
       
            DirectoryInfo theDir = new DirectoryInfo(Path);



            DirectoryInfo[] subDirectories = theDir.GetDirectories();//获得目录

            foreach (DirectoryInfo dirinfo in subDirectories)
            {
                Foldes.Add(dirinfo.Name);
            }
            return Foldes;
        }


        public static bool FindFile(DirectoryInfo dir, string fileName)
        {
              

            foreach (DirectoryInfo d in dir.GetDirectories())
            {
                if (File.Exists(d.FullName + "//" + fileName))
                {
                    return true;
                }
                FindFile(d, fileName);
            }

            return false;
        }
        
    }
}

.NET文件操作帮助类

标签：

原文地址：http://www.cnblogs.com/huangdegen/p/4656705.html