• FileHelper


    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Linq;
    using System.Windows.Forms;
     
    namespace DocDecrypt.Common
    {
        public class FileHelper
        {
            private static readonly log4net.ILog _logger = log4net.LogManager.GetLogger("FileHelper");
     
            private static void PrintExcetpion(string errors, Exception ex)
            {
                _logger.ErrorFormat(errors + "    {0} 
     {1}", ex.Message, ex.StackTrace);
            }
     
            public static string GetTempFileName(string fileName)
            {
                return Path.Combine(Path.GetTempPath(), string.IsNullOrEmpty(fileName) ? "~temp.tmp" : fileName);
            }
     
            ///////////////////////////////////
            // 文件基本操作
            public static void ClearOrCreatePath(string dstPath)
            {
                if (Directory.Exists(dstPath))
                    ClearPath(dstPath);
                else
                    CreateDirectoy(dstPath);
            }
     
            public static void ClearPath(string dstPath)
            {
                try
                {
                    if (!new System.IO.DirectoryInfo(dstPath).Exists)
                        return;
     
                    foreach (string d in System.IO.Directory.GetFileSystemEntries(dstPath))
                    {
                        if (System.IO.File.Exists(d))
                        {
                            System.IO.FileInfo fi = new System.IO.FileInfo(d);
                            DeleteFile(fi); // 直接删除其中的文件
                        }
                        else
                        {
                            System.IO.DirectoryInfo di = new System.IO.DirectoryInfo(d);
                            DeletePath(di.FullName); // 删除子文件夹   
                        }
                    }
                }
                catch (Exception ex)
                {
                    PrintExcetpion(string.Format("清除文件夹失败-{0}", dstPath),ex);
                }
            }
     
            /// <summary>
            /// 删除目录下的所有文件(只删除文件)
            /// </summary>
            /// <param name="dstPath"></param>
            public static void DeleteFiles(string dstPath)
            {
                try
                {
                    if (!new System.IO.DirectoryInfo(dstPath).Exists)
                        return;
     
                    foreach (string d in System.IO.Directory.GetFiles(dstPath))
                    {
                        if (System.IO.File.Exists(d))
                        {
                            System.IO.FileInfo fi = new System.IO.FileInfo(d);
                            DeleteFile(fi); // 直接删除其中的文件
                        }
                    }
                }
                catch (Exception ex)
                {
                    PrintExcetpion(string.Format("删除目录下的所有文件失败-{0}", dstPath), ex);
                }
            }
     
            public static void DeletePath(string dstPath)
            {            
                try
                {
                    if (!Directory.Exists(dstPath))
                        return;
     
                    foreach (string d in System.IO.Directory.GetFileSystemEntries(dstPath))
                    {
                        if (System.IO.File.Exists(d))
                        {
                            System.IO.FileInfo fi = new System.IO.FileInfo(d);
                            DeleteFile(fi); // 直接删除其中的文件
                        }
                        else
                            DeletePath(d); // 递归删除子文件夹   
                    }
     
                    System.IO.Directory.Delete(dstPath); // 删除已空文件夹
                }
                catch (Exception ex)
                {
                    PrintExcetpion(string.Format("删除文件夹失败-{0}", dstPath), ex);
                }
            }
     
            public static void CopyFile(string src, string dst)
            {
                try
                {
                    if (src.ToLower() == dst.ToLower())
                        return;
     
                    if (!File.Exists(src))
                        return;
     
                    FileHelper.DeleteFile(dst);
                    FileHelper.CreateDirectoy(Path.GetDirectoryName(dst));
     
                    System.IO.File.Copy(src, dst);
                }
                catch (Exception ex)
                {
                    PrintExcetpion(string.Format("拷贝文件失败-{0}:{1}", src,dst), ex);
                }
            }
            
            public static bool IsFileExist(string file)
            {
                return !string.IsNullOrEmpty(file) && File.Exists(file);
            }
     
            public static bool IsDirExist(string dir)
            {
                return !string.IsNullOrEmpty(dir) && Directory.Exists(dir);
            }
     
            public static void MoveFile(string src, string dst)
            {
                try
                {
                    if (string.Equals(src, dst, StringComparison.CurrentCultureIgnoreCase))
                        return;
     
                    if (!File.Exists(src))
                        return;
     
                    FileHelper.DeleteFile(dst);
                    FileHelper.CreateDirectoy(Path.GetDirectoryName(dst));
     
                    System.IO.File.Move(src, dst);
                }
                catch (Exception ex)
                {
                    PrintExcetpion($"移动文件失败-{src}:{dst}", ex);
                }
            }
     
            public static void MovePath(string srcPath, string dstPath)
            {
                try
                {
                    if (srcPath.ToLower() == dstPath.ToLower())
                        return;
     
                    if (!Directory.Exists(srcPath))
                        return;
     
                    ClearOrCreatePath(dstPath);
     
                    System.IO.Directory.Move(srcPath, dstPath);
                }
                catch (Exception ex)
                {
                    PrintExcetpion(string.Format("拷贝文件失败-{0}:{1}", srcPath, dstPath), ex);
                }
            }
     
            public static string DiskTypeInfo = "Disk";
     
            public static void MovePath_copy_delete(string srcPath, string dstPath)
            {
                try
                {
                    if (srcPath.ToLower() == dstPath.ToLower())
                        return;
     
                    if (!Directory.Exists(srcPath))
                        return;
     
                    ClearOrCreatePath(dstPath);
     
                    MoveDirectory(srcPath, dstPath);
                    if (DiskTypeInfo == "Disk")
                    {
                        DeletePath(srcPath);
                    }
                   
                }
                catch (Exception ex)
                {
                    PrintExcetpion($"拷贝删除文件失败-{srcPath}:{dstPath}", ex);
                }
            }
     
            /// <summary>
            /// 移动整个文件夹
            /// </summary>
            /// <param name="srcDir"></param>
            /// <param name="tgtDir"></param>
            public static void MoveDirectory(string srcDir, string tgtDir)
            {
                if (string.Equals(srcDir, tgtDir, StringComparison.CurrentCultureIgnoreCase))
                    return;
     
                if (!Directory.Exists(srcDir))
                    return;
     
                DirectoryInfo source = new DirectoryInfo(srcDir);
                DirectoryInfo target = new DirectoryInfo(tgtDir);
     
                if (target.FullName.StartsWith(source.FullName, StringComparison.CurrentCultureIgnoreCase))
                {
                    throw new Exception("父目录不能拷贝到子目录!");
                }
     
                if (!source.Exists)
                {
                    return;
                }
     
                if (!target.Exists)
                {
                    target.Create();
                }
     
                FileInfo[] files = source.GetFiles();
     
                foreach (var file in files)
                {
                    if (DiskTypeInfo == "Disk")
                    {
                        File.Move(file.FullName, target.FullName + @"" + file.Name);
                    }
                    else
                        File.Copy(file.FullName, target.FullName + @"" + file.Name);
                }
     
                DirectoryInfo[] dirs = source.GetDirectories();
     
                foreach (var dir in dirs)
                {
                    MoveDirectory(dir.FullName, target.FullName + @"" + dir.Name);
                }
            }
     
            public static void CopyDirectory(string srcDir, string tgtDir)
            {
                if (srcDir.ToLower() == tgtDir.ToLower())
                    return;
     
                if (!Directory.Exists(srcDir))
                    return;
     
                DirectoryInfo source = new DirectoryInfo(srcDir);
                DirectoryInfo target = new DirectoryInfo(tgtDir);
     
                if (target.FullName.StartsWith(source.FullName, StringComparison.CurrentCultureIgnoreCase))
                {
                    throw new Exception("父目录不能拷贝到子目录!");
                }
     
                if (!source.Exists)
                {
                    return;
                }
     
                if (!target.Exists)
                {
                    target.Create();
                }
     
                FileInfo[] files = source.GetFiles();
     
                foreach (var file in files)
                {
                    File.Copy(file.FullName, target.FullName + @"" + file.Name, true);
                }
     
                DirectoryInfo[] dirs = source.GetDirectories();
     
                foreach (var dir in dirs)
                {
                    CopyDirectory(dir.FullName, target.FullName + @"" + dir.Name);
                }
            }
     
            public static void DeleteFile(string fileName)
            {
                try
                {
                    FileInfo fi = new System.IO.FileInfo(fileName);
                    DeleteFile(fi);
                }
                catch (Exception ex)
                {
                    PrintExcetpion($"删除文件失败-{fileName}", ex);
                }
            }
     
            public static void DeleteFile(FileInfo fi)
            {
                try
                {
                    if (fi.Exists)
                    {
                        if (fi.Attributes.ToString().IndexOf("ReadOnly") != -1)
                            fi.Attributes = System.IO.FileAttributes.Normal;
                        System.IO.File.Delete(fi.FullName);
     
                        fi.Delete();
                    }
                }
                catch (Exception ex)
                {
                    PrintExcetpion($"删除文件失败-{fi.FullName}", ex);
                }
            }
     
            public static void CreateDirectoyFromFileName(string fileName)
            {
                try
                {
                    string path = Path.GetDirectoryName(fileName);
                    if (!new System.IO.DirectoryInfo(path).Exists)
                        System.IO.Directory.CreateDirectory(path);
                }
                catch (Exception ex)
                {
                    PrintExcetpion($"创建文件夹失败-{fileName}", ex);
                }
            }
     
            public static void CreateDirectoyByFileName(string fileName)
            {
                try
                {
                    string dir = Path.GetDirectoryName(fileName);
                    CreateDirectoy(dir);
                }
                catch (Exception ex)
                {
                    PrintExcetpion($"由文件创建文件夹失败-{fileName}", ex);
                }
            }
     
            public static void CreateDirectoy(string dir)
            {
                try
                {
                    if (!new System.IO.DirectoryInfo(dir).Exists)
                        System.IO.Directory.CreateDirectory(dir);
                }
                catch (Exception ex)
                {
                    PrintExcetpion($"创建文件夹失败-{dir}", ex);
                }
            }
     
            public static string[] GetAllSubDirs(string root, SearchOption searchOption)
            {
                string[] all = null;
                try
                {
                    all = Directory.GetDirectories(root, "*", searchOption);
                }
                catch
                {
                    // ignored
                }
     
                return all;
            }
     
            public static List<string> GetAllPureSubDirs(string root)
            {
                List<string> list = new List<string>();
                try
                {
                    string[] all = Directory.GetDirectories(root, "*", SearchOption.TopDirectoryOnly);
                    foreach (string path in all)
                    {
                        string s = System.IO.Path.GetFileName(path);
                        list.Add(s);
                    }
                }
                catch
                {
                    // ignored
                }
     
                return list;
            }
     
            public static long GetFilesSize(string[] fileNames)
            {
                return fileNames.Sum(fileName => GetFileSize(fileName));
            }
     
            public static long GetFileSize(string fileName)
            {
                if (!string.IsNullOrEmpty(fileName) && File.Exists(fileName))
                    return new FileInfo(fileName).Length;
     
                return 0;
            }
     
            /// <summary>
            /// Files the content.
            /// </summary>
            /// <param name="fileName">Name of the file.</param>
            /// <returns></returns>
            public static byte[] FileContent(string fileName)
            {
                FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read);
                try
                {
                    byte[] buffur = new byte[fs.Length];
                    fs.Read(buffur, 0, (int)fs.Length);
     
                    return buffur;
                }
                catch (Exception ex)
                {
                    Console.WriteLine("读取文件字节流失败: {0}", ex.Message);
                    return null;
                }
                finally
                {
                    if (fs != null)
                    {
                        //关闭资源
                        fs.Close();
                    }
                }
            }
     
            public static bool SaveString2File(string content, string fileName)
            {
                StreamWriter sw = null;
     
                try
                {
                    CreateDirectoyFromFileName(fileName);
     
                    sw = new StreamWriter(fileName);
                    sw.WriteLine(content);
                }
                catch (Exception ex)
                {
                    PrintExcetpion($"保存内容错误-{fileName}", ex);
                    return false;
                }
     
                if (sw != null)
                    sw.Close();
     
                return true;
            }
     
            public static string LoadStringFromFile(string fileName)
            {
                string content = string.Empty;
     
                StreamReader sr = null;
                try
                {
                    sr = new StreamReader(fileName,System.Text.Encoding.UTF8);
                    content = sr.ReadToEnd();
                }
                catch (Exception ex)
                {
                    PrintExcetpion($"读取内容错误-{fileName}", ex);
                }
     
                if (sr != null)
                    sr.Close();
     
                return content;
            } 
     
            public static string GetLocalFileName(string lastPath, string displayName, string[] typeNames)
            {
                OpenFileDialog ofd = new System.Windows.Forms.OpenFileDialog();
     
                // ofd.InitialDirectory = lastPath;
                ofd.RestoreDirectory = true;
     
                // "动画(.flc;.fli;.gif;.swf)|*.flc;*.fli;*.gif;*.swf|Animation(.flc,.fli)|*.flc;*.fli|Gif89a(.gif)|*.gif|SWF(*.swf)|*.swf|"
                // displayName + "(*.epub|All files (*.*)|*.*";
                string filter = displayName + "(";
     
                filter = typeNames.Aggregate(filter, (current, ext) => current + ("." + ext + ";"));
     
                filter += ")|";
     
                for (int i = 0; i < typeNames.Length; i++)
                {
                    filter += "*." + typeNames[i];
                    if (i < typeNames.Length - 1)
                        filter += ";";
                }
     
                // filter += "|全部文件 (*.*)|*.*";
                ofd.Filter = filter;
     
                return ofd.ShowDialog() != System.Windows.Forms.DialogResult.OK ? string.Empty : ofd.FileName;
            }
     
            /// <summary>
            /// 获取差异的文件列表
            /// </summary>
            /// <param name="srcDir"></param>
            /// <param name="destDir"></param>
            /// <returns></returns>
            public static List<string> GetNotSameFiles(string srcDir, string destDir)
            {
                var oldData = new List<string>();
                var newData = new List<string>();
                new DirectoryInfo(srcDir).GetFiles().ToList().ForEach((f) =>
                {
                    newData.Add(f.Name);
                });
     
                new DirectoryInfo(destDir).GetFiles().ToList().ForEach((f) =>
                {
                    oldData.Add(f.Name);
                });
     
                //求交集
                var dupComparer = new InlineComparer<string>((i1, i2) => i1.Equals(i2), i => i.GetHashCode());
                var _IntersectData = oldData.Intersect(newData, dupComparer);
     
                if (_IntersectData == null || _IntersectData.Count() == 0)
                    return null;
     
                // 处理交集文件里可能有差异的内容。
                var _files = new List<string>();
     
                // 通过md5先过滤一部分数据 然后找到有差异的文件列表
                _IntersectData.ToList().ForEach((s) =>
                {
                    var o = Path.Combine(destDir, s);
                    var n = Path.Combine(srcDir, s);
     
                    var omd5 = Md5FileHelper.MD5File(o);
                    var nmd5 = Md5FileHelper.MD5File(n);
     
                    if (!omd5.Equals(nmd5))
                    {
                        _files.Add(s);
                    }
                });
     
                return _files;
            }
     
            /// <summary>
            /// 获取root文件夹下所有的文件,包含子文件夹中的文件
            /// </summary>
            /// <param name="root">文件夹路径</param>
            /// <param name="extension">文件扩展名,默认为所有文件</param>
            /// <returns>root文件夹下所有的文件的列表</returns>
            public static List<string> GetAllFileList(string root, string extension = "")
            {
                if (Directory.Exists(root))
                {
                    var dirList = GetAllSubDirs(root, SearchOption.AllDirectories).ToList();
                    dirList.Add(root);
     
                    var list = new List<string>();
     
                    foreach (var dir in dirList)
                    {
                        DirectoryInfo dirInfo = new DirectoryInfo(dir);
                        dirInfo.GetFiles().ToList().ForEach(f =>
                        {
                            if (!string.IsNullOrWhiteSpace(extension))
                            {
                                if (f.Extension == (extension.Contains(".") ? extension : "." + extension))
                                {
                                    list.Add(f.FullName);
                                }
                            }
                            else
                            {
                                list.Add(f.FullName);
                            }
                        });
                    }
     
                    return list;
                }
                else
                {
                    return null;
                }
            }
     
            public class InlineComparer<T> : IEqualityComparer<T>
            {
                private readonly Func<T, T, bool> getEquals;
                private readonly Func<T, int> getHashCode;
     
                public InlineComparer(Func<T, T, bool> equals, Func<T, int> hashCode)
                {
                    this.getEquals = equals;
                    this.getHashCode = hashCode;
                }
     
                public bool Equals(T x, T y)
                {
                    return this.getEquals(x, y);
                }
     
                public int GetHashCode(T obj)
                {
                    return this.getHashCode(obj);
                }
            }
        }
    }
    --------------------- 
    作者:代码养家 
    来源:CSDN 
    原文:https://blog.csdn.net/wangzl1163/article/details/79306885 
    版权声明:本文为博主原创文章,转载请附上博文链接!
  • 相关阅读:
    Java数组
    Java非访问修饰符
    Java 循环结构
    Java修饰符
    Java语句
    DDK
    HDC中的前景色与背景色
    如何控制一个程序只能有一个进程
    把一个bmp转换成cur显示出来(掩码mask)
    怎么设置IE代理服务器
  • 原文地址:https://www.cnblogs.com/nocanstillbb/p/10652962.html
Copyright © 2020-2023  润新知