[工具类]文件或文件夹xx已存在，则重命名为xx(n)

写在前面

最近在弄一个文件传输的一个东东，在接收文件的时候，如果文件已经存在，该如何处理？提示？删除？感觉直接删除实在不太合适，万一这个文件对用户来说很重要，你给他删除了肯定不行。然后就想到了，windows系统在新建文件的时候，如果文件存在就以（n）这样的形式创建。当时觉得这种方式确实不错，查找了windows的api，未果，然后就想如果让自己实现，该如何去实现？

工具类

 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Text;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;

 namespace Wolfy.SaveAs
 {
     /// <summary>
     /// 重命名辅助类
     /// </summary>
     public class ReNameHelper
     {
         /// <summary>
         /// 保存同名文件时，进行重命名操作.
         /// 例如文件夹内已存在1.txt，则再次保存时保存为1(1).txt,....1(n).txt
         /// </summary>
         /// <param name="strFolderPath">保存的目录</param>
         /// <param name="strFileName">文件名</param>
         /// <returns>新的文件名</returns>
         public static string ReFileName(string strFolderPath, string strFileName)
         {
             //当前传进的文件名自带的索引
             int intCurrentFileIndex = ;
             string strNewName = string.Empty;
             //用来保存当前目录下的文件的最大索引。
             int intMaxIndex = ;
             //如果文件不存在，直接返回
             if (!File.Exists(Path.Combine(strFolderPath, strFileName)))
             {
                 return strFileName;
             }
             //根据传进来的文件名，获取扩展名
             string strExtention = Path.GetExtension(strFileName);
             string strFileNameWithoutExtion = Path.GetFileNameWithoutExtension(strFileName);
             //如果文件名中本身就包括括号，则需要还原原来的文件名
             string strNameContainsBracketsRegex = "(?<fileName>.+?)" + "([(（](?<fileNameIndex>\\d+)[）)])" + strExtention;
             Regex regexContain = new Regex(strNameContainsBracketsRegex, RegexOptions.Singleline);
             if (regexContain.IsMatch(strFileName))
             {
                 Match match = regexContain.Match(strFileName);
                 strFileNameWithoutExtion = match.Groups["fileName"].Value;
                 intCurrentFileIndex = Convert.ToInt32(match.Groups["fileNameIndex"].Value);
             }
             //根据传进来的文件名，通过正则匹配，找到类似的文件名,不区别中英文的括号并且括号及索引可有可无
             string strRegex = strFileNameWithoutExtion + "([(（](?<fileNameIndex>\\d+)[）)])" + strExtention;
             Regex regex = new Regex(strRegex, RegexOptions.Singleline);
             string[] strFileNames = Directory.GetFiles(strFolderPath, "*" + strExtention)
                 .Where(x => regex.IsMatch(x) || x.Contains(strFileNameWithoutExtion))
                 .ToArray();
             if (strFileNames != null && strFileNames.Length > )
             {
                 foreach (string item in strFileNames)
                 {
                     //因为获得的文件路径数组中都是匹配成功的路径，此处不再进行判断是否匹配
                     Match match = regex.Match(item);
                     //获得索引
                     string strIndex = match.Groups["fileNameIndex"].Value;
                     //如果为空，说明只有类似 1.txt这样的文件，则返回的文件就是1(1).txt
                     //否则找到最大索引，然后拼接最大索引加一的文件名
                     if (!string.IsNullOrEmpty(strIndex))
                     {
                         int intIndex = Convert.ToInt32(strIndex);
                         if (intMaxIndex < intIndex)
                         {
                             intMaxIndex = intIndex;
                         }
                     }
                 }
                 //如果目录中存在的文件索引大于或者等于当前传进来的文件的索引则使用新的名称，否则将返回传进来的文件名称
                 if (intMaxIndex >= intCurrentFileIndex)
                 {
                     //循环接收，求出了最大的索引，则新文件的索引就是最大索引加一
                     StringBuilder sb = new StringBuilder();
                     sb.Append(strFileNameWithoutExtion);
                     sb.Append("(");
                     sb.Append((intMaxIndex + ).ToString());
                     sb.Append(")");
                     sb.Append(strExtention);
                     strNewName = sb.ToString();
                 }
                 else
                 {
                     strNewName = strFileName;
                 }
             }
             else
             {
                 //如果没有匹配到相似的文件名结构，则说明是一个新的文件，则不做任何操作
                 strNewName = strFileName;
             }
             return strNewName;
         }
         /// <summary>
         /// 保存同名文件夹时，进行重命名操作.
         /// 例如文件夹内已存在1的文件夹，则再次保存时保存为1(1),....1(n)
         /// </summary>
         /// <param name="strFolderPath">保存的目录</param>
         /// <param name="strFolderPath">保存的目录</param>
         /// <returns>新的目录名</returns>
         public static string ReFolderName(string strFolderPath, string strFolderName)
         {
             //当前传进的文件夹自带的索引
             int intCurrentFolderIndex = ;
             string strNewName = string.Empty;
             //原始名字
             string strOriginalName = strFolderName;
             //用来保存当前目录下的文件的最大索引。
             int intMaxIndex = ;
             if (!Directory.Exists(Path.Combine(strFolderPath, strFolderName)))
             {
                 return strFolderName;
             }
             //根据传进来的文件名，通过正则匹配，找到文件夹是否已经带有索引。
             string strRegex = "(?<folderName>.+?)([(（](?<folderIndex>\\d+)[）)])";
             Regex regex = new Regex(strRegex, RegexOptions.Singleline);
             if (regex.IsMatch(strFolderName))
             {
                 Match match = regex.Match(strFolderName);
                 string strFolderIndex = match.Groups["folderIndex"].Value;
                 if (!string.IsNullOrEmpty(strFolderIndex))
                 {
                     intCurrentFolderIndex = Convert.ToInt32(strFolderIndex);
                     strOriginalName = match.Groups["folderName"].Value;
                 }
             }

             string[] strFolderNames = Directory.GetDirectories(strFolderPath)
                 .Where(x => regex.IsMatch(x))
                 .Select(x => x.Split(new char[] { '\\' })
                     .LastOrDefault())
                     .ToArray();
             if (strFolderNames != null && strFolderNames.Length > )
             {
                 foreach (string item in strFolderNames)
                 {
                     //因为获得的文件路径数组中都是匹配成功的路径，此处不再进行判断是否匹配
                     Match match = regex.Match(item);
                     //获得索引
                     string strIndex = match.Groups["folderIndex"].Value;
                     //如果为空，说明只有类似 1.txt这样的文件，则返回的文件就是1(1).txt
                     //否则找到最大索引，然后拼接最大索引加一的文件名
                     if (!string.IsNullOrEmpty(strIndex))
                     {
                         int intIndex = Convert.ToInt32(strIndex);
                         if (intMaxIndex < intIndex)
                         {
                             intMaxIndex = intIndex;
                         }
                     }
                 }
                 //如果目录中存在的文件索引大于或者等于当前传进来的文件的索引则使用新的名称，否则将返回传进来的文件名称
                 if (intMaxIndex >= intCurrentFolderIndex)
                 {
                     //循环接收，求出了最大的索引，则新文件的索引就是最大索引加一
                     StringBuilder sb = new StringBuilder();
                     sb.Append(strOriginalName);
                     sb.Append("(");
                     sb.Append((intMaxIndex + ).ToString());
                     sb.Append(")");
                     strNewName = sb.ToString();
                 }
                 else
                 {
                     strNewName = strFolderName;
                 }
             }
             else
             {
                 //如果没有匹配到相似的文件名结构，则说明是一个新的文件，则不做任何操作
                 strNewName = strFolderName;
             }
             return strNewName;
         }
     }
 }

测试

测试用的保存的目录，结构如下：

测试

如果接收的文件为1.txt，则获取到的新文件名1(2).txt，因为与1.txt名称相似的文件已经存在的最大文件索引为1.

如果接收的文件夹名称为新建文件夹，则获取到的新文件夹名为新建文件夹(3)，因为与新建文件夹名称相似的文件夹的最大索引为2。

  class Program
     {
         static void Main(string[] args)
         {
             string newName =ReNameHelper.ReFileName(@"C:\Users\Wolfy\Desktop\Test", "1.txt");
             string strNewFolderName = ReNameHelper.ReFolderName(@"C:\Users\Wolfy\Desktop\Test\", "新建文件夹");
             Console.WriteLine(newName);
             Console.WriteLine(strNewFolderName);
             Console.ReadKey();
         }
     }

测试结果

如果接收的文件为1(1).txt，则获取到的新文件名1(2).txt，因为与1(1).txt名称相似的文件已经存在的最大文件索引为1.

如果接收的文件夹名称为新建文件夹(1)，则获取到的新文件夹名为新建文件夹(3)，因为与新建文件夹名称相似的文件夹的最大索引为2。

测试结果

如果接收的文件为1(2).txt，则获取到的新文件名1(2).txt，因为与1.txt名称相似的文件已经存在的最大文件索引为1.(传进来的文件名中带的索引大于已经存在的索引)

如果接收的文件夹名称为新建文件夹(1)，则获取到的新文件夹名为新建文件夹(3)，因为与新建文件夹名称相似的文件夹的最大索引为2（这里在调用该方法的时候，可以首先判断一下该目录是否存在，如果不存在，直接创建不再走该方法，那么保存的文件名为：新建文件夹(1)）。

如果接收的文件夹名称为新建文件夹（3）,索引大于已经存在的文件夹的最大索引，则保存为新建文件夹（3）

这里只对文件名为1（1）（1）.txt的做了处理，文件夹的以类似新建文件夹（n）这样的名称为主。

  static void Main(string[] args)
         {
             string newName = ReNameHelper.ReFileName(@"C:\Users\Wolfy\Desktop\Test", "1（1）（2）.txt");
             string strNewFolderName = ReNameHelper.ReFolderName(@"C:\Users\Wolfy\Desktop\Test\", "新建文件夹 (2) （1）");
             Console.WriteLine(newName);
             Console.WriteLine(strNewFolderName);
             Console.ReadKey();
         }

如果test目录下已经存在：1（1）（2）.txt和新建文件夹 (2) （1），则返回的结果

总结

这个类确实解决了一些问题，但是针对一些恶意输入的文件或者文件夹名也是没办法的，只能在调用重命名方法之前再加上一个判断文件或者目录是否存在的情况，如果存在再走重命名方法，如果不存在则直接保存就行。

如果您有更好的方式，请留言。

也许你会看这篇文章：

[工具类]文件或文件夹xx已存在，则重命名为xx(n)（2）