文件队列处理工具

文件队列

写了一个文件队列处理的小工具。

    /// <summary>
    /// 文件队列工具。
    /// </summary>
    public class FileQueueTool
    {
        /// <summary>
        /// 将文件加入到本地队列。
        /// </summary>
        /// <param name="queueDir">文件夹。</param>
        /// <param name="fileName">文件名。</param>
        /// <param name="fileContent">内容。</param>
        public static void AddFileToQueue(string queueDir, string fileName, string fileContent)
        {
            var saveDir = GetSaveDir(queueDir);
            if (!Directory.Exists(saveDir))
                Directory.CreateDirectory(saveDir);

            var savePath = Path.Combine(saveDir, fileName);

            string tempFilePath = string.Format(@"{0}.bak", savePath);
            using (var fs = new FileStream(tempFilePath, FileMode.Create, FileAccess.ReadWrite))
            {
                using (var sw = new StreamWriter(fs))
                {
                    sw.Write(fileContent);
                }
            }
            File.Copy(tempFilePath, savePath, true);
            File.Delete(tempFilePath);
        }

        /// <summary>
        /// 从队列中移除文件。
        /// </summary>
        public static void RemoveFileFromQueue(string filePath)
        {
            File.Delete(filePath);
        }

        /// <summary>
        /// 从队列中移除文件。
        /// </summary>
        public static void RemoveFileFromQueue(FileInfo fileInfo)
        {
            File.Delete(fileInfo.FullName);
        }

        /// <summary>
        /// 获取文件。
        /// </summary>
        public static List<FileInfo> GetFilesFromQueue(string queueDir, int takeCount, string type = "")
        {
            var items = new List<FileInfo>();
            if (!Directory.Exists(queueDir))
                return items;

            DirectoryInfo homeDir = new DirectoryInfo(queueDir);
            DirectoryInfo[] dirs = homeDir.GetDirectories().OrderBy(p => Convert.ToInt32(p.Name)).ToArray();
            for (int i = 0; i < dirs.Length; i++)
            {
                DirectoryInfo dir = dirs[i];
                var fileInfos = !string.IsNullOrEmpty(type) ? dir.GetFiles(type) : dir.GetFiles();

                if (fileInfos.Length == 0)
                {
                    //做一个队列延迟
                    if (dir.CreationTime < DateTime.Now.AddMinutes(-2))
                    {
                        var files = dir.GetFiles();
                        if (files.Length == 0)
                            Directory.Delete(dir.FullName, false);
                        else
                        {
                            foreach (var file in files)
                            {
                                if (file.Name.EndsWith(".data"))
                                    continue;

                                if (file.Name.EndsWith(".bak"))
                                {
                                    file.MoveTo(file.FullName.Replace(".bak", ""));
                                }
                            }
                        }
                    }
                }


                foreach (var fileInfo in fileInfos)
                {
                    items.Add(fileInfo);
                    if (items.Count >= takeCount)
                        return items;
                }
            }


            return items;
        }

        /// <summary>
        /// 读取文件内容。
        /// </summary>
        public static T ReadObjectFromQueue<T>(string filePath)
        {
            T t = default(T);

            var fi = new FileInfo(filePath);
            if (fi.Exists)
            {
                using (FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
                {
                    string content;
                    using (StreamReader sr = new StreamReader(fs))
                    {
                        content = sr.ReadToEnd();
                    }
                    if (!string.IsNullOrEmpty(content))
                    {
                        t = JsonConvert.DeserializeObject<T>(content);
                    }
                    fs.Close();
                }
            }

            return t;
        }

        /// <summary>
        /// 读取文件内容。
        /// </summary>
        public static string ReadStringFromQueue(string filePath)
        {
            string content = "";

            var fi = new FileInfo(filePath);
            if (fi.Exists)
            {
                using (FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
                {
                    using (StreamReader sr = new StreamReader(fs))
                    {
                        content = sr.ReadToEnd();
                    }
                    fs.Close();
                }
            }
            return content;
        }

        public static DirectoryInfo[] GetQueueDirs(string queueDir)
        {
            DirectoryInfo homeDir = new DirectoryInfo(queueDir);
            return homeDir.GetDirectories();
        }

        private static string GetSaveDir(string queuePath)
        {
            if (!Directory.Exists(queuePath))
            {
                Directory.CreateDirectory(queuePath);
            }
            return Path.Combine(queuePath, DateTime.Now.ToString("yyMMddHHmm"));
        }
    }

python版本，练习用的：

#!usr/bin/env python
# coding=utf-8

import datetime
import glob
import os
import shutil


def addtoqueue(dir, name, content):
    """ 将文件添加到队列中
    Args：
        dir：目标目录
        name：文件名称如'log.txt'
        content：文件内容，文本类型
    Returns:
        None
    Raises:
        Nothing
    """

    if os.path.exists(dir) == False:
        os.makedirs(dir)

    try:
        save_path = os.path.join(dir, name)
        file = open(save_path, 'w')
        file.write(content)
        file.close()
    except IOError, e:
        print e


def delfromqueue(dir, name):
    fpath = os.path.join(dir, name)
    if os.path.exists(fpath) == False:
        print "文件不存在"
        return
    os.remove(fpath)


def getsavedir(basedir):
    if os.path.exists(basedir) == False:
        os.makedirs(basedir)
    fdir = os.path.join(basedir, datetime.datetime.now().strftime('%m%d%H%M'))
    return fdir


def getchachedfiles(basedir, count):
    files = []
    if os.path.exists(basedir) == False:
        return files
    # 生成一个按时间排序的文件列
    dirs = sorted(os.listdir(basedir), key=lambda x: os.path.getctime(
        os.path.join(basedir, x)), reverse=False)

    for dir in dirs:
        curdir = os.path.join(basedir, dir)
        print curdir, os.path.isdir(curdir)
        if os.path.isdir(curdir):
            filenames = os.listdir(curdir)
            if len(filenames) == 0:
                if dir < datetime.datetime.now().strftime('%m%d%H%M'):
                    os.rmdir(curdir)
                    continue
            for filename in filenames:
                curfile = os.path.join(curdir, filename)
                if os.path.isdir(curfile) == False:
                    files.append(curfile)
                    if len(files) > count:
                        return files
                else:
                    shutil.rmtree(curfile)
        else:
            os.remove(curdir)

    return files

转载于:https://www.cnblogs.com/krockey/p/9098626.html