【C#】文件或文件夹操作汇总

一、删除文件或文件夹

File.Delete(fileName);
Directory.Delete(fileName, true);

/// <summary>
        /// 删除文件夹以及文件
        /// </summary>
        /// <param name="directoryPath"> 文件夹路径 </param>
        /// <param name="fileName"> 文件名称 </param>
        public static void DeleteDirectory(string directoryPath, string fileName)
        {

            //删除文件
            for (int i = 0; i < Directory.GetFiles(directoryPath).ToList().Count; i++)
            {
                if (Directory.GetFiles(directoryPath)[i] == fileName)
                {
                    File.Delete(fileName);
                }
            }

            //删除文件夹
            for (int i = 0; i < Directory.GetDirectories(directoryPath).ToList().Count; i++)
            {
                if (Directory.GetDirectories(directoryPath)[i] == fileName)
                {
                    Directory.Delete(fileName, true);
                }
            }
        }

https://www.cnblogs.com/foreverfendou/p/9667497.html

 

二、获取文件夹下所有的子文件

DirectoryInfo dirInfo = new DirectoryInfo(DirectoryPath);

FileInfo[] fileInfos = dirInfo.GetFiles();
foreach (FileInfo fileInfo in fileInfos)
{
   //fileInfo.Name
}

DirectoryInfo[] dirInfos = dirInfo.GetDirectories();
foreach (DirectoryInfo dirInfo1 in dirInfos)
{
   //dirInfo1.FullName
}

 

(1) https://blog.csdn.net/zhulongxi/article/details/51318910

(2) https://q.cnblogs.com/q/9527/


三、获取当前应用程序所在路径及环境变量

//获取应用程序的当前工作目录
string str3=Directory.GetCurrentDirectory();


//获取或设置包含该应用程序的目录的名称。
string str7=AppDomain.CurrentDomain.SetupInformation.ApplicationBase


//获取启动了应用程序的可执行文件的路径,不包括可执行文件的名称
string str5=Application.StartupPath;

https://www.cnblogs.com/xz4062006/p/4245474.html

 

四、排序

(1)文件排序

1、按名称顺序排列

  /// <summary>
  /// C#按文件名排序(顺序)
  /// </summary>
  /// <param name="arrFi">待排序数组</param>
  private void SortAsFileName(ref FileInfo[] arrFi)
  {
    Array.Sort(arrFi, delegate(FileInfo x, FileInfo y) { return x.Name.CompareTo(y.Name); });
  }
 
  调用方法:
 
  private void SortFiles()
  {
    string filePath = "E:\\";
    DirectoryInfo di = new DirectoryInfo(filePath);
 
    FileInfo[] arrFi = di.GetFiles("*.*");
    SortAsFileName(ref arrFi);
 
    for (int i = 0; i < arrFi.Length; i++)
      Response.Write(arrFi[i].Name + ":<br />");
  }

 

2、按名称倒序排列

/// <summary>
  /// C#按文件名排序(倒序)
  /// </summary>
  /// <param name="arrFi">待排序数组</param>
  private void SortAsFileName(ref FileInfo[] arrFi)
  {
    Array.Sort(arrFi, delegate(FileInfo x, FileInfo y) { return y.Name.CompareTo(x.Name); });
  }

 

3、按创建时间顺序排列

  /// <summary>
  /// C#按创建时间排序(顺序)
  /// </summary>
  /// <param name="arrFi">待排序数组</param>
  private void SortAsFileCreationTime(ref FileInfo[] arrFi)
  {
    Array.Sort(arrFi, delegate(FileInfo x, FileInfo y) { return x.CreationTime.CompareTo(y.CreationTime); });
  }

 

4、按创建时间倒序排列

  /// <summary>
  /// C#按创建时间排序(倒序)
  /// </summary>
  /// <param name="arrFi">待排序数组</param>
  private void SortAsFileCreationTime(ref FileInfo[] arrFi)
  {
    Array.Sort(arrFi, delegate(FileInfo x, FileInfo y) { return y.CreationTime.CompareTo(x.CreationTime); });
  }

 

(2)文件夹排序

1、按名称顺序排列

  /// <summary>
  /// C#按文件夹名称排序(顺序)
  /// </summary>
  /// <param name="dirs">待排序文件夹数组</param>
  private void SortAsFolderName(ref DirectoryInfo[] dirs)
  {
    Array.Sort(dirs, delegate(DirectoryInfo x, DirectoryInfo y) { return x.Name.CompareTo(y.Name); });
  }
 
  调用方法:
 
  private void FolderSort()
  {
    string filePath = "E:\\";
    DirectoryInfo di = new DirectoryInfo(filePath);
 
    DirectoryInfo[] arrDir = di.GetDirectories();
    SortAsFolderName(ref arrDir);
 
    for (int i = 0; i < arrDir.Length; i++)
      Response.Write(arrDir[i].Name + ":<br />");
  }

 

2、按名称倒序排列

 

  /// <summary>
  /// C#按文件夹名称排序(倒序)
  /// </summary>
  /// <param name="dirs">待排序文件夹数组</param>
  private void SortAsFolderName(ref DirectoryInfo[] dirs)
  {
    Array.Sort(dirs, delegate(DirectoryInfo x, DirectoryInfo y) { return y.Name.CompareTo(x.Name); });
  }

 

3、按创建时间顺序排列

 

  /// <summary>
  /// C#按文件夹夹创建时间排序(顺序)
  /// </summary>
  /// <param name="dirs">待排序文件夹数组</param>
  private void SortAsFolderCreationTime(ref DirectoryInfo[] dirs)
  {
    Array.Sort(dirs, delegate(DirectoryInfo x, DirectoryInfo y) { return x.CreationTime.CompareTo(y.CreationTime); });
  }

 

4、按创建时间倒序排列

  /// <summary>
  /// C#按文件夹创建时间排序(倒序)
  /// </summary>
  /// <param name="dirs">待排序文件夹数组</param>
  private void SortAsFolderCreationTime(ref DirectoryInfo[] dirs)
  {
    Array.Sort(dirs, delegate(DirectoryInfo x, DirectoryInfo y) { return y.CreationTime.CompareTo(x.CreationTime); });
  }

https://blog.csdn.net/sy95122/article/details/93971483

 

五、文件或文件夹压缩和解压

1、代码

using ICSharpCode.SharpZipLib.Checksums;
using ICSharpCode.SharpZipLib.Zip;
using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace WindowsFormsApplication1.UserClass
{
    class CompressHelper
    {
        public void ZipFile(string strFile, string strZip)
        {
            if (strFile[strFile.Length - 1] != Path.DirectorySeparatorChar)
            {
                strFile += Path.DirectorySeparatorChar;
            }
            ZipOutputStream outstream = new ZipOutputStream(File.Create(strZip));

            Encoding gbk = Encoding.GetEncoding("GB18030");
            ZipConstants.DefaultCodePage = gbk.CodePage;   //解决中文乱码问题

            outstream.SetLevel(6);
            ZipCompress(strFile, outstream, strFile);
            outstream.Finish();
            outstream.Close();
        }

        public void ZipCompress(string strFile, ZipOutputStream outstream, string staticFile)
        {
            if (strFile[strFile.Length - 1] != Path.DirectorySeparatorChar)
            {
                strFile += Path.DirectorySeparatorChar;
            }
            Crc32 crc = new Crc32();
            //获取指定目录下所有文件和子目录文件名称
            string[] filenames = Directory.GetFileSystemEntries(strFile);
            //遍历文件
            foreach (string file in filenames)
            {
                if (Directory.Exists(file))//压缩文件夹
                {
                    ZipCompress(file, outstream, staticFile); 
                }
                //否则,直接压缩文件
                else
                {
                    //打开文件
                    FileStream fs = File.OpenRead(file);
                    //定义缓存区对象
                    byte[] buffer = new byte[fs.Length];
                    //通过字符流,读取文件
                    fs.Read(buffer, 0, buffer.Length);
                    //得到目录下的文件
                    string tempfile = file.Substring(staticFile.LastIndexOf("\\") + 1);
                    ZipEntry entry = new ZipEntry(tempfile);
                    entry.DateTime = DateTime.Now;
                    entry.Size = fs.Length;
                    fs.Close();
                    crc.Reset();
                    crc.Update(buffer);
                    entry.Crc = crc.Value;
                    outstream.PutNextEntry(entry);
                    //写文件
                    outstream.Write(buffer, 0, buffer.Length);
                }
            }
       }

        public string UnZipFile(string TargetFile, string fileDir)
        {
            string rootFile = "";
            try
            {
                if (!Directory.Exists(fileDir))
                {
                    Directory.CreateDirectory(fileDir);
                }

                Encoding gbk = Encoding.GetEncoding("GB18030");
                ZipConstants.DefaultCodePage = gbk.CodePage;   //解决中文乱码问题

                //读取压缩文件(zip文件),准备解压缩
                ZipInputStream inputstream = new ZipInputStream(File.OpenRead(TargetFile.Trim()));
                ZipEntry entry;

                string path = fileDir;
                //解压出来的文件保存路径
                string rootDir = "";
                //根目录下的第一个子文件夹的名称
                while ((entry = inputstream.GetNextEntry()) != null)
                {
                    rootDir = Path.GetDirectoryName(entry.Name);
                    //得到根目录下的第一级子文件夹的名称
                    if (rootDir.IndexOf("\\") >= 0)
                    {
                        rootDir = rootDir.Substring(0, rootDir.IndexOf("\\") + 1);
                    }
                    string dir = Path.GetDirectoryName(entry.Name);
                    //得到根目录下的第一级子文件夹下的子文件夹名称
                    string fileName = Path.GetFileName(entry.Name);
                    //根目录下的文件名称
                    if (dir != "")
                    {
                        //创建根目录下的子文件夹,不限制级别
                        if (!Directory.Exists(fileDir + "\\" + dir))
                        {
                            path = fileDir + "\\" + dir;
                            //在指定的路径创建文件夹
                            Directory.CreateDirectory(path);
                        }
                    }
                    else if (dir == "" && fileName != "")
                    {
                        //根目录下的文件
                        path = fileDir;
                        rootFile = fileName;
                    }
                    else if (dir != "" && fileName != "")
                    {
                        //根目录下的第一级子文件夹下的文件
                        if (dir.IndexOf("\\") > 0)
                        {
                            //指定文件保存路径
                            path = fileDir + "\\" + dir;
                        }
                    }
                    if (dir == rootDir)
                    {
                        //判断是不是需要保存在根目录下的文件
                        path = fileDir + "\\" + rootDir;
                    }

                    //以下为解压zip文件的基本步骤
                    //基本思路:遍历压缩文件里的所有文件,创建一个相同的文件
                    if (fileName != String.Empty)
                    {
                        FileStream fs = File.Create(path + "\\" + fileName);
                        int size = 2048;
                        byte[] data = new byte[2048];
                        while (true)
                        {
                            size = inputstream.Read(data, 0, data.Length);
                            if (size > 0)
                            {
                                fs.Write(data, 0, size);
                            }
                            else
                            {
                                break;
                            }
                        }
                        fs.Close();
                    }
                }
                inputstream.Close();
                return rootFile;
            }
            catch (Exception ex)
            {
                return ex.Message;
            }
        }

        /// <summary>
        ///  批量压缩事件
        /// </summary>
        /// <param name="dirPath">待压缩的目录文件</param>
        /// <param name="zipPath">压缩后存放目录文件</param>
        public void MultiZip(string dirPath, string zipPath)
        {
            //获取指定目录下所有文件和子文件名称(所有待压缩的文件)
            string[] files = Directory.GetFileSystemEntries(dirPath);
            //遍历指定目录下文件路径
            foreach (string file in files)
            {
                //截取文件路径的文件名
                var filename = file.Substring(file.LastIndexOf("\\") + 1);
                //调用压缩方法(参数1:待压缩的文件目录,参数2:压缩后的文件目录(包含后缀))
                if (!Directory.Exists(zipPath)) //不存在则创建
                {
                    Directory.CreateDirectory(zipPath);
                }
                ZipFile(dirPath + filename, zipPath + filename + ".zip");
            }
        }

        /// <summary>
        /// 批量解压事件
        /// </summary>
        /// <param name="path1">待解压的压缩文件路径(带后缀名)</param>
        /// <param name="dirPath">解压后存放的文件路径</param>
        public void MultiUnZip(string dirPath, string unzipPath)
        {
            string msg = "";
            //获取指定目录下所有文件和子文件名称(所有待解压的压缩文件)
            string[] files = Directory.GetFileSystemEntries(dirPath);
            //UnZipFloClass uzc = new UnZipFloClass();
            //遍历所有压缩文件路径
            foreach (string file in files)
            {
                //获取压缩包名称(包括后缀名.zip)
                var filename = file.Substring(file.LastIndexOf("\\") + 1);
                //得到压缩包名称(没有后缀)
                filename = filename.Substring(0, filename.LastIndexOf("."));
                //判断解压的路径是否存在
                if (!Directory.Exists(unzipPath + filename))
                {
                    //没有,则创建这个路径
                    Directory.CreateDirectory(unzipPath + filename);
                }
                //调用解压方法(参数1:待解压的压缩文件路径(带后缀名),参数2:解压后存放的文件路径,参数3:返工是否解压成功)
                UnZipFile(file, unzipPath + filename);
            }
        }

        /// <summary>
        /// 获取某一文件夹的大小
        /// </summary>
        /// <param name="dirPath">文件夹目录</param>
        /// <param name="dirSize">文件夹大小 GB</param>
        public bool GetDirSize(string dirPath, ref long dirSize)
        {
            bool res = true;
            try
            {
                DirectoryInfo dirInfo = new DirectoryInfo(dirPath);

                DirectoryInfo[] dirs = dirInfo.GetDirectories();
                FileInfo[] files = dirInfo.GetFiles();

                foreach (var item in dirs)
                {
                    GetDirSize(item.FullName, ref dirSize);
                }

                foreach (var item in files)
                {
                    dirSize += item.Length;
                }
            }
            catch (Exception ex)
            {
                res = false;
            }
            return res;
        }

        public double GetDirSize(string dirPath)
        {
            long dirSize = 0;
            double size = 0;

            //单位换算
            if(GetDirSize(dirPath, ref dirSize))
            {
                size = dirSize / 1024.0 / 1024.0 / 1024.0; //byte换算为GB
            }
            return size;
        }

        public bool DeleteFiles(string dirPath)
        {
            try
            {
                DirectoryInfo dirInfo = new DirectoryInfo(dirPath);

                DirectoryInfo[] dirs = dirInfo.GetDirectories();
                FileInfo[] files = dirInfo.GetFiles();

                foreach (var item in dirs)
                {
                    Directory.Delete(item.FullName, true);
                }

                foreach (var item in files)
                {
                    File.Delete(item.FullName);
                }
            }
            catch
            {
                return false;
            }

            return true;
        }
    }
}

 

https://www.cnblogs.com/1175429393wljblog/p/11593507.html

 

2、解决中文乱码问题

https://blog.csdn.net/qq_37979819/article/details/72674045

加入在压缩前这两句:

Encoding gbk = Encoding.GetEncoding("GB18030");
ZipConstants.DefaultCodePage = gbk.CodePage;

 

注意,低版本的ICSharpCode.SharpZipLib.dll可能会提示不存在DefaultCodePage参数,换个高版本的就可以了。

我的是从其他项目复制过来的,也不知道是哪个版本,总之能用,放出来供大家下载。

链接:https://pan.baidu.com/s/1kCueyTPkNN5mPFOymy5zIg
提取码:b36k

 

六、选择文件夹对话框

 

            System.Windows.Forms.FolderBrowserDialog dialog = new System.Windows.Forms.FolderBrowserDialog();
            dialog.Description = "请选择存储路径";
            if (dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                if (string.IsNullOrEmpty(dialog.SelectedPath))
                {
                    MessageBox.Show(this, "文件夹路径不能为空", "提示");
                    return;
                }
                else
                {

                }
            }

 

七、对话框过滤器

1、所有文件/特定文件

OpenFileDialog dialog = new OpenFileDialog();
dialog.Filter ="txt files (*.txt)|*.txt|All files (*.*)|*.*";

 

2、图像文件

dialog.Filter = "Image files (*.jpg, *.jpeg, *.jpe, *.jfif, *.png) | *.jpg; *.jpeg; *.jpe; *.jfif; *.png";

 

3、多种文件类型

dialog.Filter = "图片|*.gif;*.jpg;*.jpeg;*.bmp;*.jfif;*.png;|文档|*.doc;|Excel|*.xls;*.xlsx";

 

八、OpenFileDialog批量添加文件

OpenFileDialog openFileDialog1 = new OpenFileDialog();
openFileDialog1.Multiselect = true;
if (openFileDialog1.ShowDialog() == DialogResult.OK)
{
      AllPath = openFileDialog1.FileNames;
}

 

九、问题汇总

1、使用File.Create创建文件后,正由另一进程使用

使用using:

using (File.Create( "123.txt"))
{
                        
}

 

posted @ 2021-09-23 17:17  不溯流光  阅读(429)  评论(0编辑  收藏  举报