有没有办法在.Net中检查路径中的字符串是否包含无效字符？我知道我可以迭代Path.InvalidPathChars中的每个字符，看看我的String是否包含一个，但我更喜欢一个简单的，也许更正式的解决方案。
有吗？
如果我只检查Get
，我发现我仍然会遇到异常更新
我发现GetInvalidPathChars并未涵盖每个无效路径字符。 GetInvalidFileNameChars还有5个，包括'？'，我遇到过。我将改用它，我会报告它是否也证明是不合适的。
更新2：
GetInvalidFileNameChars绝对不是我想要的。它包含'：'，任何绝对路径将包含（“C：\ whatever”）。我想我毕竟不得不使用GetInvalidPathChars，并添加'？'以及任何其他导致我出现问题的角色。欢迎更好的解决方案。
答案 0 :(得分：40)
不推荐使用InvalidPathChars。改为使用GetInvalidPathChars（）：
public static bool FilePathHasInvalidChars(string path)
{
return (!string.IsNullOrEmpty(path) && path.IndexOfAny(System.IO.Path.GetInvalidPathChars()) >= 0);
}
编辑：稍长，但在一个函数中处理路径与文件无效字符：
// WARNING: Not tested
public static bool FilePathHasInvalidChars(string path)
{
bool ret = false;
if(!string.IsNullOrEmpty(path))
{
try
{
// Careful!
// Path.GetDirectoryName("C:\Directory\SubDirectory")
// returns "C:\Directory", which may not be what you want in
// this case. You may need to explicitly add a trailing \
// if path is a directory and not a file path. As written,
// this function just assumes path is a file path.
string fileName = System.IO.Path.GetFileName(path);
string fileDirectory = System.IO.Path.GetDirectoryName(path);
// we don't need to do anything else,
// if we got here without throwing an
// exception, then the path does not
// contain invalid characters
}
catch (ArgumentException)
{
// Path functions will throw this
// if path contains invalid chars
ret = true;
}
}
return ret;
}
答案 1 :(得分：4)
依赖Path.GetInvalidFileNameChars时要小心，这可能不如你想象的那么可靠。请注意Path.GetInvalidFileNameChars上的MSDN文档中的以下注释：
从此方法返回的数组不保证包含文件和目录名称中无效的完整字符集。完整的无效字符集可能因文件系统而异。例如，在基于Windows的桌面平台上，无效路径字符可能包括ASCII / Unicode字符1到31，以及quote（“），小于（＆lt;），大于（＆gt;），pipe（|），退格（\ b），null（\ 0）和制表符（\ t）。
使用Path.GetInvalidPathChars方法并不是更好。它包含完全相同的注释。
答案 2 :(得分：2)
对你来说可能为时已晚，但可能对其他人有所帮助。 我遇到了同样的问题，需要找到一种可靠的方法来消毒道路。
以下是我最终使用的步骤，分为3个步骤：
第1步：自定义清洁。
public static string RemoveSpecialCharactersUsingCustomMethod(this string expression, bool removeSpecialLettersHavingASign = true)
{
var newCharacterWithSpace = " ";
var newCharacter = "";
// Return carriage handling
// ASCII LINE-FEED character (LF),
expression = expression.Replace("\n", newCharacterWithSpace);
// ASCII CARRIAGE-RETURN character (CR)
expression = expression.Replace("\r", newCharacterWithSpace);
// less than : used to redirect input, allowed in Unix filenames, see Note 1
expression = expression.Replace(@"<", newCharacter);
// greater than : used to redirect output, allowed in Unix filenames, see Note 1
expression = expression.Replace(@">", newCharacter);
// colon: used to determine the mount point / drive on Windows;
// used to determine the virtual device or physical device such as a drive on AmigaOS, RT-11 and VMS;
// used as a pathname separator in classic Mac OS. Doubled after a name on VMS,
// indicates the DECnet nodename (equivalent to a NetBIOS (Windows networking) hostname preceded by "\\".).
// Colon is also used in Windows to separate an alternative data stream from the main file.
expression = expression.Replace(@":", newCharacter);
// quote : used to mark beginning and end of filenames containing spaces in Windows, see Note 1
expression = expression.Replace(@"""", newCharacter);
// slash : used as a path name component separator in Unix-like, Windows, and Amiga systems.
// (The MS-DOS command.com shell would consume it as a switch character, but Windows itself always accepts it as a separator.[16][vague])
expression = expression.Replace(@"/", newCharacter);
// backslash : Also used as a path name component separator in MS-DOS, OS/2 and Windows (where there are few differences between slash and backslash); allowed in Unix filenames, see Note 1
expression = expression.Replace(@"\", newCharacter);
// vertical bar or pipe : designates software pipelining in Unix and Windows; allowed in Unix filenames, see Note 1
expression = expression.Replace(@"|", newCharacter);
// question mark : used as a wildcard in Unix, Windows and AmigaOS; marks a single character. Allowed in Unix filenames, see Note 1
expression = expression.Replace(@"?", newCharacter);
expression = expression.Replace(@"!", newCharacter);
// asterisk or star : used as a wildcard in Unix, MS-DOS, RT-11, VMS and Windows. Marks any sequence of characters
// (Unix, Windows, later versions of MS-DOS) or any sequence of characters in either the basename or extension
// (thus "*.*" in early versions of MS-DOS means "all files". Allowed in Unix filenames, see note 1
expression = expression.Replace(@"*", newCharacter);
// percent : used as a wildcard in RT-11; marks a single character.
expression = expression.Replace(@"%", newCharacter);
// period or dot : allowed but the last occurrence will be interpreted to be the extension separator in VMS, MS-DOS and Windows.
// In other OSes, usually considered as part of the filename, and more than one period (full stop) may be allowed.
// In Unix, a leading period means the file or folder is normally hidden.
expression = expression.Replace(@".", newCharacter);
// space : allowed (apart MS-DOS) but the space is also used as a parameter separator in command line applications.
// This can be solved by quoting, but typing quotes around the name every time is inconvenient.
//expression = expression.Replace(@"%", " ");
expression = expression.Replace(@" ", newCharacter);
if (removeSpecialLettersHavingASign)
{
// Because then issues to zip
// More at : http://www.thesauruslex.com/typo/eng/enghtml.htm
expression = expression.Replace(@"ê", "e");
expression = expression.Replace(@"ë", "e");
expression = expression.Replace(@"ï", "i");
expression = expression.Replace(@"œ", "oe");
}
return expression;
}
第2步：检查尚未删除的任何无效字符。
一个额外的验证步骤，我使用上面发布的Path.GetInvalidPathChars()方法来检测尚未删除的任何潜在无效字符。
public static bool ContainsAnyInvalidCharacters(this string path)
{
return (!string.IsNullOrEmpty(path) && path.IndexOfAny(Path.GetInvalidPathChars()) >= 0);
}
步骤3：清除步骤2中检测到的所有特殊字符。
最后，我使用这种方法作为清理任何东西的最后一步。 （来自How to remove illegal characters from path and filenames?）：
public static string RemoveSpecialCharactersUsingFrameworkMethod(this string path)
{
return Path.GetInvalidFileNameChars().Aggregate(path, (current, c) => current.Replace(c.ToString(), string.Empty));
}
我记录了第一步中未清除的任何无效字符。一旦“泄漏”，我就选择这样做以改进我的自定义方法。被检测到。我不能依赖Path.GetInvalidFileNameChars()，因为上面报告了以下语句（来自MSDN）：
＆＃34;从此方法返回的数组不保证包含 文件和目录中无效的完整字符集 名。 ＆＃34;
它可能不是理想的解决方案，但鉴于我的应用环境和所需的可靠性水平，这是我找到的最佳解决方案。
答案 3 :(得分：1)
我最终借用并组合了一些内部.NET实现来提出一种高性能的方法：
/// <summary>Determines if the path contains invalid characters.</summary>
/// <remarks>This method is intended to prevent ArgumentException's from being thrown when creating a new FileInfo on a file path with invalid characters.</remarks>
/// <param name="filePath">File path.</param>
/// <returns>True if file path contains invalid characters.</returns>
private static bool ContainsInvalidPathCharacters(string filePath)
{
for (var i = 0; i < filePath.Length; i++)
{
int c = filePath[i];
if (c == '\"' || c == '<' || c == '>' || c == '|' || c == '*' || c == '?' || c < 32)
return true;
}
return false;
}
然后我就像这样使用它，但为了安全起见，还将它包装在try / catch块中：
if ( !string.IsNullOrWhiteSpace(path) && !ContainsInvalidPathCharacters(path))
{
FileInfo fileInfo = null;
try
{
fileInfo = new FileInfo(path);
}
catch (ArgumentException)
{
}
...
}
答案 4 :(得分：1)
从 .NET 4.7.2 开始，Path.GetInvalidFileNameChars()报告以下41个“不良”字符。
0x0000 0 '\0' | 0x000d 13 '\r' | 0x001b 27 '\u001b'
0x0001 1 '\u0001' | 0x000e 14 '\u000e' | 0x001c 28 '\u001c'
0x0002 2 '\u0002' | 0x000f 15 '\u000f' | 0x001d 29 '\u001d'
0x0003 3 '\u0003' | 0x0010 16 '\u0010' | 0x001e 30 '\u001e'
0x0004 4 '\u0004' | 0x0011 17 '\u0011' | 0x001f 31 '\u001f'
0x0005 5 '\u0005' | 0x0012 18 '\u0012' | 0x0022 34 '"'
0x0006 6 '\u0006' | 0x0013 19 '\u0013' | 0x002a 42 '*'
0x0007 7 '\a' | 0x0014 20 '\u0014' | 0x002f 47 '/'
0x0008 8 '\b' | 0x0015 21 '\u0015' | 0x003a 58 ':'
0x0009 9 '\t' | 0x0016 22 '\u0016' | 0x003c 60 '<'
0x000a 10 '\n' | 0x0017 23 '\u0017' | 0x003e 62 '>'
0x000b 11 '\v' | 0x0018 24 '\u0018' | 0x003f 63 '?'
0x000c 12 '\f' | 0x0019 25 '\u0019' | 0x005c 92 '\\'
| 0x001a 26 '\u001a' | 0x007c 124 '|'
正如另一位发帖人的noted一样，这是Path.GetInvalidPathChars()返回的字符集中的proper superset。您可以使用以下代码行来检测此确切的字符集：
public static bool IsInvalidFileNameChar(Char c) => c < 64U ?
(1UL << c & 0xD4008404FFFFFFFFUL) != 0 :
c == '\\' || c == '|';
答案 5 :(得分：0)
我也来不及了。但是，如果任务是验证用户是否输入了有效的路径作为路径，则有一种针对路径的组合解决方案。
Path.GetInvalidFileNameChars()返回文件非法字符列表，但是目录遵循文件规则，除了分隔符（我们可以从系统获取）和根说明符（C:，我们可以删除它）通过搜索）。是的，Path.GetInvalidFileNameChars()不会返回完整的集合，但是比尝试手动查找所有集合要好。
所以：
private static bool CheckInvalidPath(string targetDir)
{
string root;
try
{
root = Path.GetPathRoot(targetDir);
}
catch
{
// the path is definitely invalid if it has crashed
return false;
}
// of course it is better to cache it as it creates
// new array on each call
char[] chars = Path.GetInvalidFileNameChars();
// ignore root
for (int i = root.Length; i < targetDir.Length; i++)
{
char c = targetDir[i];
// separators are allowed
if (c == Path.DirectorySeparatorChar || c == Path.AltDirectorySeparatorChar)
continue;
// check for illegal chars
for (int j = 0; j < chars.Length; j++)
if (c == chars[j])
return false;
}
return true;
}
我发现类似Path.GetFileName的方法不会对类似C:\*的路径崩溃（这是完全无效的），甚至基于异常的检查也是不够的。唯一会导致Path.GetPathRoot崩溃的是无效的根（例如CC:\someDir）。因此，其他所有操作都应手动完成。
答案 6 :(得分：0)
简单而正确，可以考虑MS文档：
bool IsPathValid(String path)
{
for (int i = 0; i < path.Length; ++i)
if (Path.GetInvalidFileNameChars().Contains(path[i]))
return false
return true;
}
答案 7 :(得分：0)
仅供参考，该框架具有执行此操作的内部方法-但不幸的是，它们被标记为internal。
相关的位供参考，类似于此处接受的答案。
internal static bool HasIllegalCharacters(string path, bool checkAdditional = false) => (AppContextSwitches.UseLegacyPathHandling || !PathInternal.IsDevice(path)) && PathInternal.AnyPathHasIllegalCharacters(path, checkAdditional);
internal static bool AnyPathHasIllegalCharacters(string path, bool checkAdditional = false)
{
if (path.IndexOfAny(PathInternal.InvalidPathChars) >= 0)
return true;
return checkAdditional && PathInternal.AnyPathHasWildCardCharacters(path);
}
internal static bool HasWildCardCharacters(string path)
{
int startIndex = AppContextSwitches.UseLegacyPathHandling ? 0 : (PathInternal.IsDevice(path) ? "\\\\?\\".Length : 0);
return PathInternal.AnyPathHasWildCardCharacters(path, startIndex);
}
internal static bool AnyPathHasWildCardCharacters(string path, int startIndex = 0)
{
for (int index = startIndex; index < path.Length; ++index)
{
switch (path[index])
{
case '*':
case '?':
return true;
default:
continue;
}
}
return false;
}