程序師世界是廣大編程愛好者互助、分享、學習的平台,程序師世界有你更精彩!
首頁
編程語言
C語言|JAVA編程
Python編程
網頁編程
ASP編程|PHP編程
JSP編程
數據庫知識
MYSQL數據庫|SqlServer數據庫
Oracle數據庫|DB2數據庫
 程式師世界 >> 編程語言 >> .NET網頁編程 >> C# >> C#入門知識 >> c#文件助手類分享(讀取文件內容 操作日記文件)

c#文件助手類分享(讀取文件內容 操作日記文件)

編輯:C#入門知識

c#文件助手類分享(讀取文件內容 操作日記文件)。本站提示廣大學習愛好者:(c#文件助手類分享(讀取文件內容 操作日記文件))文章只能為提供參考,不一定能成為您想要的結果。以下是c#文件助手類分享(讀取文件內容 操作日記文件)正文



using System;
using System.Collections.Generic;
using System.IO;
using System.Text.RegularExpressions;
using System.Linq;
using System.Runtime.InteropServices;
namespace Humep.FileWatcher
{
    /// <summary>
    /// 日記文件操作
    /// Date:2011-06-01
    /// </summary>
    public static class FileHelper
    {
        /// <summary>
        /// 獲得文件途徑中最初的目次名
        /// </summary>
        /// <param name="path"></param>
        /// <returns></returns>
        public static string GetDirectoryName(string fullName)
        {
            if (string.IsNullOrWhiteSpace(fullName))
            {
                return null;
            }
            return fullName.Substring(0,fullName.LastIndexOf('\\')+1);
        }
        /// <summary>
        /// 獲得途徑中的文件稱號
        /// </summary>
        /// <param name="filePath"></param>
        /// <returns></returns>
        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);
        }

        /// <summary>
        /// 文件名能否知足filePattern格局。
        /// </summary>
        /// <param name="fileName"></param>
        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);
        }

        /// <summary>
        /// 讀取文件內容
        /// </summary>
        /// <param name="file"></param>
        /// <returns></returns>
        public static string ReadAllText(string filePath)
        {
            if (string.IsNullOrWhiteSpace(filePath) || File.Exists(filePath) == false)
            {
                return string.Empty;
            }
            return File.ReadAllText(filePath);
        }
        /// <summary>
        /// 刪除文件
        /// </summary>
        /// <param name="filePath"></param>
        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);
        }
        /// <summary>
        /// 刪除目次下一切過時文件
        /// </summary>
        /// <param name="directory"></param>
        /// <param name="expiredDays"></param>
        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<FileInfo> 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;
        }
        /// <summary>
        /// 刪除目次下一切過時文件
        /// </summary>
        /// <param name="dirs">目次數組</param>
        /// <param name="expiredDays"></param>
        /// <returns></returns>
        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;
        }
        /// <summary>
        /// 刪除過時目次及其子目次和文件
        /// </summary>
        /// <param name="directories">目次數組</param>
        /// <param name="expiredDays"></param>
        /// <returns></returns>
        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;
        }
        /// <summary>
        /// 深度列舉出一切子目次(包含子目次的子目次)
        /// </summary>
        /// <param name="directory"></param>
        /// <returns></returns>
        public static IList<string> EnumerateAllSubDirectories(string directory)
        {
            List<string> direcotryList = new List<string>();
            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;
        }
        /// <summary>
        /// 依據時光查詢文件
        /// </summary>
        /// <param name="directory"></param>
        /// <param name="maxCount"></param>
        /// <returns></returns>
        public static IList<string> FindFiles(string directory, int maxCount, int days)
        {
            IList<string> fileList = new List<string>();
            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<string>();
            return fileList;
        }
        /// <summary>
        /// 查詢目次下的一切文件,將recursive設為True可查詢子目次中的一切文件。
        /// </summary>
        /// <param name="directory"></param>
        /// <param name="filePattern"></param>
        /// <param name="maxCount"></param>
        /// <param name="recursive"></param>
        /// <returns></returns>
        public static IList<FileInfo> FindFiles(string directory, string filePattern, int maxCount, bool recursive)
        {
            if (!recursive)
            {
                return FileHelper.FindFiles(directory, filePattern, maxCount);
            }
            IList<string> directories = EnumerateAllSubDirectories(directory);
            return FindFiles(directories,filePattern, maxCount);
        }
        public static IList<FileInfo> FindFiles(IList<string> directories,string filePattern, int maxCount)
        {
            List<FileInfo> files = new List<FileInfo>();
            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));
        }
        /// <summary>
        /// 默許查找20個文件
        /// </summary>
        /// <param name="directory"></param>
        /// <param name="filePattern"></param>
        /// <returns></returns>
        public static IList<FileInfo> FindFiles(string directory, string filePattern)
        {
            int maxCount = 20;
            return FindFiles(directory, filePattern, maxCount);
        }
        /// <summary>
        /// 獲得文件
        /// </summary>
        /// <param name="directory"></param>
        /// <param name="filePattern"></param>
        /// <returns></returns>
        public static IList<FileInfo> FindFiles(string directory, string filePattern, int maxCount)
        {
            List<FileInfo> matchedFiles = new List<FileInfo>();
            IList<FileInfo> 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;
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="directory"></param>
        /// <param name="filePattern"></param>
        /// <returns></returns>
        public static IList<FileInfo> FindAllFiles(string directory)
        {
            IList<FileInfo> fileInfos = new List<FileInfo>();
            if (string.IsNullOrWhiteSpace(directory))
            {
                return fileInfos;
            }
            if (!Directory.Exists(directory))
            {
                return fileInfos;
            }
            DirectoryInfo dir = new DirectoryInfo(directory);
            fileInfos = dir.GetFiles();
            return fileInfos;
        }
        /// <summary>
        /// 單個文件挪動
        /// </summary>
        /// <param name="sourcePath"></param>
        /// <param name="targetDirectory"></param>
        /// <returns></returns>
        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(@"\\?\"+sourcePath,@"\\?\"+ 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);
        /// <summary>
        /// 單個文件挪動
        /// </summary>
        /// <param name="fileName"></param>
        /// <param name="sourceDirectory"></param>
        /// <param name="targetDirectory"></param>
        /// <returns></returns>
        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.WordStr(sourceDirectory, targetDirectory);
            string fileDir=Path.GetDirectoryName(filePath);
            if(!DirectoryHelper.CreateDirectory(fileDir))
            {
                return false;
            }
            return MoveFile(fileName, fileDir);
        }
        /// <summary>
        /// 從新生成新的文件途徑
        /// </summary>
        /// <param name="filePath"></param>
        /// <returns></returns>
        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;
        }

    }
}

  1. 上一頁:
  2. 下一頁:
Copyright © 程式師世界 All Rights Reserved