C# 中IO操作通用类

using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp3
{
    /*
     Io Options Common Methods
     */
    public class GenericIoTask
    {
        public static bool CopyDirectory(string sourceDir, string destDir, bool recursive)
        {
            var sourceDirInfo = new DirectoryInfo(sourceDir);
            if (!sourceDirInfo.Exists)
            {
                return false;
            }
            DirectoryInfo[] sourceDirs = sourceDirInfo.GetDirectories();
            if (!Directory.Exists(destDir))
            {
                Directory.CreateDirectory(destDir);
            }
            foreach (var fileInfo in sourceDirInfo.GetFiles())
            {
                string targetFilePath = Path.Combine(destDir, fileInfo.Name);
                fileInfo.CopyTo(targetFilePath);
            }
            if (recursive)
            {
                foreach (var subDir in sourceDirs)
                {
                    string newDestDir = Path.Combine(destDir, subDir.Name);
                    CopyDirectory(subDir.FullName, newDestDir, true);
                }
                return true;
            }
            else
            {
                return true;
            }
        }

        public static IEnumerable<string> GetDirectoryFiles(string destDir, Func<string, bool> predicate, bool recursive)
        {
            IEnumerable<string> files = Array.Empty<string>();
            if (!Directory.Exists(destDir))
            {
                return files;
            }
            SearchOption searchOption = SearchOption.TopDirectoryOnly;
            if (recursive)
            {
                searchOption = SearchOption.AllDirectories;
            }
            files = Directory.EnumerateFiles(destDir, "*.*", searchOption);
            if (predicate != null)
            {
                files = files.Where(predicate);
            }
            return files;
        }

        public static bool BinaryWriterEntity<T>(string path, T data)
        {
            try
            {
                using FileStream fileStream =
                    new FileStream(path, FileMode.OpenOrCreate, FileAccess.Write, FileShare.Write);
                using BinaryWriter binaryWriter = new BinaryWriter(fileStream);
                binaryWriter.Write(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(data)));
                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }

        public static bool BinaryReadEntity<T>(string path, out T? data)
        {
            bool readFalg = false;
            data = default;
            try
            {
                using FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);
                using BinaryReader binaryReader = new BinaryReader(fileStream);
                byte[] dataBuf = binaryReader.ReadBytes((int)fileStream.Length);
                data = JsonConvert.DeserializeObject<T>(Encoding.UTF8.GetString(dataBuf));
                readFalg = true;
            }
            catch (Exception)
            {
                readFalg = false;
            }
            return readFalg;
        }

        public static async Task<bool> WriteLogAsync(string messsage, TextWriter writer)
        {
            try
            {
                await writer.WriteAsync(messsage);
                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }

        public static async Task<List<string>> ReadLogAsync(TextReader reader)
        {
            List<string> list = new List<string>();
            try
            {
                string? linLog;
                while ((linLog = await reader.ReadLineAsync()) != null)
                {
                    list.Add(linLog);
                }
            }
            catch (Exception)
            {
            }
            return list;
        }

        public static async Task<bool> StreamWriterAsync(string path, string msg)
        {
            using StreamWriter sw = new StreamWriter(path, true);
            await sw.WriteAsync(msg);
            //await File.AppendAllLinesAsync(path,msg)
            //await File.AppendAllTextAsync(path, msg);
            return true;
        }

        public static async Task<byte[]> CompressOptionAsync(byte[]? bytes, CompressOptionType optionType)
        {
            using MemoryStream destSm = new MemoryStream();
            if (bytes == null || bytes.Length <= 0)
            {
                return destSm.ToArray();
            }
            using MemoryStream sourceSm = new MemoryStream(bytes);
            Stream? optionerSm = default;
            switch (optionType)
            {
                case CompressOptionType.ZipCompress:
                    optionerSm = new GZipStream(destSm, CompressionMode.Compress);
                    await sourceSm.CopyToAsync(optionerSm);
                    break;
                case CompressOptionType.DeflateCompress:
                    optionerSm = new DeflateStream(destSm, CompressionMode.Compress);
                    await sourceSm.CopyToAsync(optionerSm);
                    break;
                case CompressOptionType.ZipDeCompress:
                    optionerSm = new GZipStream(sourceSm, CompressionMode.Decompress);
                    await optionerSm.CopyToAsync(destSm);
                    break;
                case CompressOptionType.DeflateDeCompress:
                    optionerSm = new DeflateStream(sourceSm, CompressionMode.Decompress);
                    await optionerSm.CopyToAsync(destSm);
                    break;
                default:
                    break;
            }
            optionerSm?.Flush();
            optionerSm?.Dispose();
            return destSm.ToArray();
        }

        public static async Task CompressAsync(DirectoryInfo directorySelected)
        {
            foreach (var fileToCompress in directorySelected.GetFiles())
            {
                using FileStream OriginalFileStream = fileToCompress.OpenRead();
                var originalAtt = File.GetAttributes(fileToCompress.FullName);
                if (originalAtt == FileAttributes.Compressed)
                {
                    continue;
                }
                using FileStream compressFileStrem = File.Create(fileToCompress + ".gz");
                using GZipStream gZipStream = new GZipStream(compressFileStrem, CompressionMode.Compress);
                await OriginalFileStream.CopyToAsync(gZipStream);
                await gZipStream.FlushAsync();
            }
        }
    }

    public enum CompressOptionType : byte
    {
        ZipCompress,
        DeflateCompress,
        ZipDeCompress,
        DeflateDeCompress,
    }
}