檔案助手類

using System;
using System.Collections.Generic;
using System.IO;
using System.Text.RegularExpressions;
using System.Linq;
using System.Runtime.InteropServices;

namespace Humep.FileWatcher
{
    ///

    /// 日誌檔案操作
    /// Date:2011-06-01
    ///

    public static class FileHelper
    {
        ///

        /// 獲取檔案路徑中最後的目錄名
        ///

        ///
        ///
        public static string GetDirectoryName(string fullName)
        {
            if (string.IsNullOrWhiteSpace(fullName))
            {
                return null;
            }

            return fullName.Substring(0,fullName.LastIndexOf('\\')+1);
        }

        ///

        /// 獲取路徑中的檔名稱
        ///

        ///
        ///
        public static string GetFileName(string filePath)
        {
            if (string.IsNullOrWhiteSpace(filePath))
            {
                return string.Empty;
            }

            if (filePath.Length > 260)
            {
                return filePath.Substring(filePath.LastIndexOf('\\') + 1, int.MaxValue);
            }

            return Path.GetFileName(filePath);
        }

        ///

        /// 檔名是否滿足filePattern格式。
        ///

        ///
        public static bool IsMatched(string fileName, string filePattern)
        {
            if (string.IsNullOrWhiteSpace(fileName))
            {
                return false;
            }

            if (string.IsNullOrWhiteSpace(filePattern))
            {
                return false;
            }

            Regex regex = new Regex(filePattern, RegexOptions.IgnoreCase);
            return regex.IsMatch(fileName);
        }

        ///

        /// 讀取檔案內容
        ///

        ///
        ///
        public static string ReadAllText(string filePath)
        {
            if (string.IsNullOrWhiteSpace(filePath) || File.Exists(filePath) == false)
            {
                return string.Empty;
            }

            return File.ReadAllText(filePath);
        }

        ///

        /// 刪除檔案
        ///

        ///
        public static bool Delete(string filePath)
        {
            if (string.IsNullOrWhiteSpace(filePath))
            {
                return false;
            }

            if (!File.Exists(filePath))
            {
                return false;
            }

            File.Delete(filePath);

            return !File.Exists(filePath);
        }

        ///

        /// 刪除目錄下所有過期檔案
        ///

        ///
        ///
        public static int ClearExpiredFiles(string directory, int expiredDays)
        {
            if (!Directory.Exists(directory))
            {
                return 0;
            }

            if (expiredDays <= 0)
            {
                return 0;
            }

            DirectoryInfo dir = new DirectoryInfo(directory);
            IList fileInfos =dir.GetFiles();

            if (fileInfos == null || fileInfos.Count < 1)
            {
                return 0;
            }

            int count = 0;

            foreach (FileInfo fileInfo in fileInfos)
            {
                if (fileInfo.CreationTime.AddDays(expiredDays) < DateTime.Now)
                {
                    //added by yangbinggang
                    fileInfo.Attributes = FileAttributes.Normal;
                    FileHelper.Delete(fileInfo.FullName);
                    count = count + 1;
                }
            }

            return count;
        }

        ///

        /// 刪除目錄下所有過期檔案
        ///

        /// 目錄陣列
        ///
        ///
        public static int ClearExpiredFiles(string[] dirs, int expiredDays)
        {
            if (dirs == null)
            {
                return 0;
            }

            if (dirs.Length <= 0)
            {
                return 0;
            }

            int count = 0;

            foreach (string dir in dirs)
            {
                count = count + ClearExpiredFiles(dir, expiredDays);
            }

            return count;
        }

        ///

        /// 刪除過期目錄及其子目錄和檔案
        ///

        /// 目錄陣列
        ///
        ///
        public static int ClearExpiredDirectories(string[] directories, int expiredDays)
        {
            if (directories == null || directories.Length <= 0)
            {
                return 0;
            }

            if (expiredDays < 0)
            {
                return 0;
            }

            int count = 0;

            foreach (string directory in directories)
            {
                if (!Directory.Exists(directory))
                {
                    continue;
                }

                count += ClearExpiredFiles(directory, expiredDays);

                DirectoryInfo directoryInfo = new DirectoryInfo(directory);

                if (directoryInfo.CreationTime.AddDays(expiredDays) < DateTime.Now)
                {
                    directoryInfo.Attributes = FileAttributes.Normal;
                    Directory.Delete(directory, true);
                }
            }

            return count;
        }

        ///

        /// 深度列舉出所有子目錄（包括子目錄的子目錄）
        ///

        ///
        ///
        public static IList EnumerateAllSubDirectories(string directory)
        {
            List direcotryList = new List();

            if (string.IsNullOrWhiteSpace(directory))
            {
                return direcotryList;
            }

            if (!Directory.Exists(directory))
            {
                return direcotryList;
            }

            string[] folders = Directory.GetDirectories(directory);
            direcotryList.AddRange(folders);

            foreach (string folder in folders)
            {
                direcotryList.AddRange(EnumerateAllSubDirectories(folder));
            }
            return direcotryList;
        }

        ///

        /// 根據時間查詢檔案
        ///

        ///
        ///
        ///
        public static IList FindFiles(string directory, int maxCount, int days)
        {
            IList fileList = new List();

            if (!Directory.Exists(directory) || maxCount <= 0)
            {
                return fileList;
            }

            string[] files = Directory.GetFiles(directory);
            if(files==null)
            {
                return fileList;
            }

            //modified by yangbinggang 2012-12-10  DTS2012121004132\DTS2012121004404\DTS2012121004291
            DateTime lastTime = DateTime.Now.AddDays(-Math.Abs(days));

            fileList = files.Where(item =>
                            {
                                if (maxCount <= 0)
                                {
                                    return false;
                                }
                                FileInfo fileInfo = new FileInfo(item);
                                if (fileInfo.LastWriteTime >= lastTime)
                                {
                                    maxCount--;
                                    return true;
                                }
                                return false;

                            }).ToList();
            return fileList;
        }

        ///

        /// 查詢目錄下的所有檔案，將recursive設為True可查詢子目錄中的所有檔案。
        ///

        ///
        ///
        ///
        ///
        ///
        public static IList FindFiles(string directory, string filePattern, int maxCount, bool recursive)
        {
            if (!recursive)
            {
                return FileHelper.FindFiles(directory, filePattern, maxCount);
            }

            IList directories = EnumerateAllSubDirectories(directory);
            return FindFiles(directories,filePattern, maxCount);
        }

        public static IList FindFiles(IList directories,string filePattern, int maxCount)
        {
            List files = new List();
            foreach (string directoryItem in directories)
            {
                files.AddRange(FileHelper.FindFiles(directoryItem, filePattern, maxCount));

                if (files.Count > maxCount)
                {
                    break;
                }
            }
            return files.GetRange(0, Math.Min(files.Count, maxCount));
        }

        ///

        /// 預設查詢20個檔案
        ///

        ///
        ///
        ///
        public static IList FindFiles(string directory, string filePattern)
        {
            int maxCount = 20;
            return FindFiles(directory, filePattern, maxCount);
        }

        ///

        /// 獲取檔案
        ///

        ///
        ///
        ///
        public static IList FindFiles(string directory, string filePattern, int maxCount)
        {
            List matchedFiles = new List();
            IList fileInfos = FindAllFiles(directory);

            if (string.IsNullOrWhiteSpace(filePattern))
            {
                return matchedFiles;
            }

            if (maxCount < 0 || maxCount > fileInfos.Count)
            {
                maxCount = fileInfos.Count;
            }

            maxCount--;

            foreach (var fileInfo in fileInfos)
            {
                if (maxCount <0)
                {
                    break;
                }

                if (FileHelper.IsMatched(fileInfo.Name, filePattern))
                {
                    matchedFiles.Add(fileInfo);
                }

                maxCount--;
            }

            return matchedFiles;
        }

        ///

        ///
        ///

        ///
        ///
        ///
        public static IList FindAllFiles(string directory)
        {
            IList fileInfos = new List();
            if (string.IsNullOrWhiteSpace(directory))
            {
                return fileInfos;
            }

            if (!Directory.Exists(directory))
            {
                return fileInfos;
            }

            DirectoryInfo dir = new DirectoryInfo(directory);
            fileInfos = dir.GetFiles();

            return fileInfos;
        }

        ///

        /// 單個檔案移動
        ///

        ///
        ///
        ///
        public static bool MoveFile(string sourcePath, string targetDirectory)
        {
            if (!File.Exists(sourcePath))
            {
                return false;
            }

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

            var targetPath = string.Format("{0}\\{1}", targetDirectory, FileHelper.GetFileName(sourcePath));

            while (File.Exists(targetPath))
            {
                targetPath = FileHelper.Rename(targetPath);
            }

            if (sourcePath.Length > 260 || targetPath.Length > 260)
            {
                return MoveLongPathFile(@""+ targetPath);
            }

            File.Move(sourcePath, targetPath);

            return true;
        }

        [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true, EntryPoint = "MoveFile")]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool MoveLongPathFile(string lpExistingFileName, string lpNewFileName);

        ///

        /// 單個檔案移動
        ///

        ///
        ///
        ///
        ///
        public static bool MoveFile(string fileName, string sourceDirectory, string targetDirectory)
        {
            if (!File.Exists(fileName))
            {
                return false;
            }

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

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

            string filePath = fileName.Replace(sourceDirectory, targetDirectory);
            string fileDir=Path.GetDirectoryName(filePath);
            if(!DirectoryHelper.CreateDirectory(fileDir))
            {
                return false;
            }

            return MoveFile(fileName, fileDir);
        }

        ///

        /// 重新生成新的檔案路徑
        ///

        ///
        ///
        public static string Rename(string filePath)
        {
            if (string.IsNullOrWhiteSpace(filePath))
            {
                return string.Empty;
            }

            string lastFileName = Path.GetFileNameWithoutExtension(filePath);
            string lastFileExtension = Path.GetExtension(filePath);

            //重新命名，則隨機在原來檔名後面加幾個隨機數字進行組裝成新的名字
            Random random = new Random(System.DateTime.Now.Millisecond);

            string randomData = random.Next().ToString();

            //把原檔名的名字加上隨機數，組裝成新的檔名（避免重名）
            string newFileName = lastFileName + randomData;
            return Path.GetDirectoryName(filePath) + "\\" + newFileName + lastFileExtension;
        }

    }
}