public class Path_File
{
public string AppPath
{
get
{
return AppDomain.CurrentDomain.BaseDirectory;
}
}
public Path_File()
{
}
/// <summary>
/// 查找指定路径下的文件夹
/// </summary>
/// <param name="parentDirPath">指定路径</param>
/// <param name="findDir">文件夹</param>
/// <param name="findDirPath">文件夹路径</param>
/// <returns>是否找到</returns>
public bool FindDirectory(
string parentDirPath,
string findDir,
ref string findDirPath,
bool isRecursion =
true)
{
bool isFind =
false;
try
{
DirectoryInfo folder =
new DirectoryInfo(parentDirPath.Trim());
//指定搜索文件夹
if (folder.Exists && !parentDirPath.Contains(findDir))
//存在 文件夹
{
DirectoryInfo[] listDirInfos = folder.GetDirectories();
//取得给定文件夹下的文件夹组
if (listDirInfos !=
null)
{
foreach (DirectoryInfo dirInfo
in listDirInfos)
//遍历
{
if (dirInfo.Name.ToLower() ==
findDir.Trim().ToLower())
{
findDirPath =
dirInfo.FullName;
isFind =
true;
break;
}
}
if (!isFind && isRecursion)
//目录内未找到切递归子目录查找
{
foreach (DirectoryInfo dirInfo
in listDirInfos)
//遍历
{
string newParentDirPath =
Path.Combine(parentDirPath, dirInfo.Name);
isFind = FindDirectory(newParentDirPath, findDir,
ref findDirPath, isRecursion);
if (isFind)
{
break;
}
}
}
}
}
else
{
int count = parentDirPath.LastIndexOf(findDir) +
findDir.Length;
findDirPath = parentDirPath.Substring(
0, count);
isFind =
true;
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
return isFind;
}
/// <summary>
/// 获取指定目录下的子目录名集
/// </summary>
/// <param name="parentDirPath">指定目录</param>
/// <returns>子目录名集</returns>
public List<
string> getChildDirectories(
string parentDirPath,
bool isFullName =
false)
{
List<
string> listDirs =
new List<
string>
();
DirectoryInfo folder =
new DirectoryInfo(parentDirPath.Trim());
//指定搜索文件夹
if (folder.Exists)
//存在 文件夹
{
DirectoryInfo[] listDirInfos = folder.GetDirectories();
//取得给定文件夹下的文件夹组
if (listDirs !=
null)
{
foreach (DirectoryInfo dirInfo
in listDirInfos)
//遍历
{
if (isFullName)
{
listDirs.Add(dirInfo.FullName);
}
else
{
listDirs.Add(dirInfo.Name);
}
}
}
}
return listDirs;
}
/// <summary>
/// 获取指定目录下的子文件名集
/// </summary>
/// <param name="parentDirPath">指定目录</param>
/// <returns>子目录名集</returns>
public List<
string> getChildFiles(
string parentDirPath,
bool isFullName =
false)
{
List<
string> listFiles =
new List<
string>
();
DirectoryInfo folder =
new DirectoryInfo(parentDirPath.Trim());
//指定搜索文件夹
if (folder.Exists)
//存在 文件夹
{
FileInfo[] listFileInfos = folder.GetFiles();
//取得给定文件夹下的文件夹组
if (listFiles !=
null)
{
foreach (FileInfo fileInfo
in listFileInfos)
//遍历
{
if (isFullName)
{
listFiles.Add(fileInfo.FullName);
}
else
{
listFiles.Add(fileInfo.Name);
}
}
}
}
return listFiles;
}
/// <summary>
/// 复制文件夹
/// </summary>
/// <param name="sourcePath">源目录</param>
/// <param name="targetPath">目的目录</param>
public bool CopyFolder(
string sourcePath,
string targetPath)
{
bool isSuccess =
true;
try
{
DirectoryInfo sourceInfo =
new DirectoryInfo(sourcePath);
if (sourceInfo.Exists)
//源目录存在
{
DirectoryInfo targetInfo =
new DirectoryInfo(targetPath);
if (!
targetInfo.Exists)
{
targetInfo.Create();
}
FileInfo[] files = sourceInfo.GetFiles();
//拷贝文件
foreach (FileInfo file
in files)
{
file.CopyTo(Path.Combine(targetPath, file.Name), true);
}
DirectoryInfo[] childDirInfos = sourceInfo.GetDirectories();
//拷贝目录
foreach (DirectoryInfo dirInfo
in childDirInfos)
{
CopyFolder(Path.Combine(sourcePath, dirInfo.Name), Path.Combine(targetPath, dirInfo.Name));
}
}
}
catch (Exception)
{
isSuccess =
false;
}
return isSuccess;
}
/// <summary>
/// 确认路径存在(不存在则创建路径)
/// </summary>
/// <param name="path"></param>
/// <returns></returns>
public bool ConfirmPathExist(
string path)
{
bool isExist =
true;
try
{
DirectoryInfo folder =
new DirectoryInfo(path.Trim());
if (!folder.Exists)
//不存在 文件夹
{
folder.Create();
}
}
catch(Exception ex)
{
isExist =
false;
}
return isExist;
}
/// <summary>
/// 删除指定文件
/// </summary>
/// <param name="fFullName"></param>
/// <returns></returns>
public bool DeleteFile(
string fFullName)
{
bool isSuccess =
true;
try
{
FileInfo fInfo =
new FileInfo(fFullName);
if (fInfo.Exists)
//存在 文件
{
fInfo.Delete();
}
}
catch (Exception ex)
{
isSuccess =
false;
}
return isSuccess;
}
/// <summary>
/// 删除指定文件夹
/// </summary>
/// <param name="folderPath"></param>
/// <returns></returns>
public bool DeleteFolder(
string folderPath)
{
bool isSuccess =
true;
try
{
DirectoryInfo dirInfo =
new DirectoryInfo(folderPath);
if (dirInfo.Exists)
//存在 文件夹
{
dirInfo.Delete(true);
}
}
catch (Exception ex)
{
isSuccess =
false;
}
return isSuccess;
}
/// <summary>
/// 替换路径下文件名中的标识
/// </summary>
/// <param name="filePath"></param>
/// <param name="oldTag"></param>
/// <param name="newTag"></param>
/// <returns></returns>
public bool ReplaceTagFromName(
string filePath,
string oldTag,
string newTag,
bool isIgnorCase =
false)
{
bool isSuccess =
true;
try
{
DirectoryInfo dirInfo =
new DirectoryInfo(filePath);
if (!
dirInfo.Exists)
{
dirInfo.Create();
}
FileInfo[] fileInfos =
dirInfo.GetFiles();
foreach (FileInfo fileInfo
in fileInfos)
{
string name =
Path.GetFileNameWithoutExtension(fileInfo.Name);
if (isIgnorCase)
{
name =
name.ToLower();
oldTag =
oldTag.ToLower();
}
string newName =
name.Replace(oldTag, newTag);
string newFileName = newName +
fileInfo.Extension;
string fullName =
Path.Combine(filePath,newFileName);
fileInfo.MoveTo(fullName);
}
}
catch (Exception ex)
{
isSuccess =
false;
}
return isSuccess;
}
/// <summary>
/// 更级名称
/// </summary>
/// <param name="fileFullName"></param>
/// <param name="i"></param>
/// <returns></returns>
public string getUniqueName(
string fileFullName,
int i =
0)
{
string fileName =
fileFullName;
try
{
FileInfo fInfo =
new FileInfo(fileFullName);
if (fInfo.Exists)
{
string ext =
fInfo.Extension;
int length =
fileFullName.LastIndexOf(ext);
fileName = fInfo.FullName.Substring(
0, length) + i +
ext;
//string fileNamePath = Path.GetDirectoryName(fileFullName);
//string fileNameWithoutExt = Path.GetFileNameWithoutExtension(fileFullName); //仅获取文件名,不包含路径
//fileName = fileNameWithoutExt + i + ext;
//fileName = Path.Combine(fileNamePath,fileName);
fInfo =
new FileInfo(fileName);
if (fInfo.Exists)
{
i++
;
fileName =
getUniqueName(fileFullName, i);
}
}
}
catch
{
}
return fileName;
}
/// <summary>
/// 更级名称
/// </summary>
/// <param name="fileFullName"></param>
/// <param name="i"></param>
/// <returns></returns>
public bool UpdateName(
string fileFullName)
{
bool isSuccess =
true;
try
{
string newName =
getUniqueName(fileFullName);
FileInfo fInfo =
new FileInfo(fileFullName);
if (fInfo.Exists)
{
fInfo.MoveTo(newName);
}
}
catch
{
isSuccess =
false;
}
return isSuccess;
}
public bool SaveInfos(
string fileFullName, Dictionary<
string,
string> booksInfo,
string tag =
"|")
{
bool isSuccess =
true;
try
{
FileInfo fInfo =
new FileInfo(fileFullName);
FileStream fStream =
null;
if (!
fInfo.Exists)
{
fStream =
fInfo.Create();
}
else
{
fStream =
fInfo.Open(FileMode.CreateNew,FileAccess.ReadWrite);
}
StreamWriter sWrite =
new StreamWriter(fStream);
//(fileFullName, true);
foreach (
string bookId
in booksInfo.Keys)
{
string lineInfo = bookId + tag +
booksInfo[bookId];
sWrite.WriteLine(lineInfo);
sWrite.Flush();
}
sWrite.Close();
}
catch
{
isSuccess =
false;
}
return isSuccess;
}
public bool AppendInfo(
string fileFullName,
string Info)
{
bool isSuccess =
true;
try
{
FileInfo fInfo =
new FileInfo(fileFullName);
FileStream fStream =
null;
if (!
fInfo.Exists)
{
fStream =
fInfo.Create();
}
else
{
fStream =
fInfo.Open(FileMode.Append, FileAccess.ReadWrite);
}
StreamWriter sWrite =
new StreamWriter(fStream);
sWrite.WriteLine(Info);
sWrite.Flush();
sWrite.Close();
}
catch
{
isSuccess =
false;
}
return isSuccess;
}
}
View Code
+ 去掉.
:string ext = Path.GetExtension(fileName.Trim()).Replace(".",string.Empty);
+文件名称是否包含标识字符串:
public bool isFileNameContainsFlags(
string fileName,List<
string>
contentFlags)
{
bool isContain =
false;
if (contentFlags ==
null || contentFlags.Count ==
0)
{
isContain =
true;
}
else
{
foreach (
string flag
in contentFlags)
{
if (fileName.Contains(flag.Trim()))
{
isContain =
true;
break;
}
}
}
return isContain;
}
View Code
+过滤特殊字符
/// <summary>
/// 过滤掉非法字符和点字符
/// </summary>
/// <param name="directoryName"></param>
/// <returns></returns>
public String DirectoryNameFilter(String directoryName)
{
string invalidChars =
"\\/:*?\"<>|.";
//自定义非法字符(比系统的多了个.)
foreach (
char c
in invalidChars)
{
directoryName = directoryName.Replace(c.ToString(),
string.Empty);
}
return directoryName;
}
/// <summary>
/// 过滤掉非法字符
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public String NameFilter(String name)
{
string invalidChars =
"\\/:*?\"<>|";
//自定义非法字符(比系统的多了个.)
foreach (
char c
in invalidChars)
{
name = name.Replace(c.ToString(),
string.Empty);
}
return name;
}
View Code
+打开文件夹浏览器
/// <summary>
/// 打开文件夹浏览器
/// </summary>
/// <param name="dirPath"></param>
private string ShowFolderDialog(
string dirPath)
{
string forderPath =
dirPath.Trim();
if (!
string.IsNullOrEmpty(forderPath))
{
this.fld_dlg.SelectedPath =
forderPath;
}
DialogResult dlgResult =
fld_dlg.ShowDialog();
if (dlgResult ==
DialogResult.OK)
{
forderPath =
fld_dlg.SelectedPath;
}
return forderPath;
}
View Code
+批量修改文件名
/// <summary>
/// 修改文件名
/// </summary>
/// <param name="baseDirPath">基路径</param>
/// <param name="partName">修改文件名</param>
/// <param name="changeType">类型(0:替换,1:+前面,2:+后面)</param>
/// <param name="isRecursion">是递归</param>
/// <returns></returns>
public bool ChangeFilesName(
string baseDirPath,
string partName,
int changeType,
bool isRecursion)
{
bool isSuccess =
true;
try
{
this.ConfirmPathExist(baseDirPath);
List<
string> fileNames =
this.getChildFiles(baseDirPath);
switch(changeType)
{
case 0:
int i =
0;
foreach(
string fName
in fileNames)
{
string srcFullName =
Path.Combine(baseDirPath,fName);
FileInfo fInfo =
new FileInfo(srcFullName);
string dstFileName = partName + i +
Path.GetExtension(fName);
string dstFullName =
Path.Combine(baseDirPath, dstFileName);
fInfo.MoveTo(dstFullName);
i++
;
}
break;
case 1:
foreach(
string fName
in fileNames)
{
string srcFullName =
Path.Combine(baseDirPath,fName);
FileInfo fInfo =
new FileInfo(srcFullName);
string dstFileName = partName +
fName;
string dstFullName =
Path.Combine(baseDirPath, dstFileName);
fInfo.MoveTo(dstFullName);
}
break;
case 2:
foreach (
string fName
in fileNames)
{
string srcFullName =
Path.Combine(baseDirPath, fName);
FileInfo fInfo =
new FileInfo(srcFullName);
string dstFileName = Path.GetFileNameWithoutExtension(fName) + partName +
Path.GetExtension(fName);
string dstFullName =
Path.Combine(baseDirPath, dstFileName);
fInfo.MoveTo(dstFullName);
}
break;
default:
break;
}
if (isRecursion)
{
List<
string> dirFullNames = getChildDirectories(baseDirPath,
true);
foreach(
string dirFullName
in dirFullNames)
{
ChangeFilesName(dirFullName, partName, changeType, isRecursion);
}
}
}
catch (Exception ex)
{
isSuccess =
false;
}
return isSuccess;
}
View Code
+删除、清空目录
private void DeleteDirector(
string path)
{
if (!
Directory.Exists(path))
return;
string[] subdir =
Directory.GetDirectories(path);
foreach (
string dir
in subdir)
DeleteDirector(dir);
string[] files =
Directory.GetFiles(path);
foreach (
string file
in files)
{
File.Delete(file);
}
Directory.Delete(path);
}
/// <summary>
/// 清空目录
/// </summary>
/// <param name="path">目录全路径</param>
private void ClearDirectory(
string path)
{
if (!
Directory.Exists(path))
return;
string[] files =
Directory.GetFiles(path);
foreach (
string file
in files)
{
try
{
File.Delete(file);
}
catch (Exception e)
{
_logger.Info("删除文件失败: ", e);
}
}
string[] dirs =
Directory.GetDirectories(path);
foreach (
string dir
in dirs)
{
try
{
ClearDirectory(dir);
Directory.Delete(dir);
}
catch (Exception e)
{
_logger.Info("删除目录失败: ", e);
}
}
}
View Code
更多:http://www.cnblogs.com/shenchao/p/5431163.html
转载于:https://www.cnblogs.com/shenchao/p/5128218.html