जाँच करें कि क्या कोई पथ मान्य है

110

मैं बस सोच रहा हूं: अगर कोई दिया गया रास्ता वैध है तो मैं उसे वैध करने का रास्ता तलाश रहा हूं। (नोट: मैं जांच नहीं करना चाहता कि क्या कोई फ़ाइल मौजूद है! मैं केवल पथ की वैधता का प्रमाण देना चाहता हूं - इसलिए यदि कोई फ़ाइल संभवतः स्थान पर मौजूद हो सकती है) ।

समस्या यह है कि, मुझे .net API में कुछ भी नहीं मिल रहा है। कई स्वरूपों और स्थानों के कारण जो विंडोज का समर्थन करता है, मैं एमएस-देशी के बजाय कुछ का उपयोग करता हूं।

चूंकि फ़ंक्शन के खिलाफ जाँच करने में सक्षम होना चाहिए:

रिश्तेदार पथ (? /)

पूर्ण पथ (c: \ tmp)

UNC-Pathes (\ some-pc \ c $)

पूर्ण पथ 1024 वर्णों की तरह NTFS- सीमाएँ - अगर मैं गलत नहीं हूँ तो पथ से अधिक होने से कई आंतरिक विंडोज कार्यों के लिए एक फ़ाइल अप्राप्य हो जाएगी। एक्सप्लोरर के साथ इसका नाम बदलना अभी भी काम करता है

वॉल्यूम गाइड पथ: "\? \ वॉल्यूम {GUID} \ somefile.foo

किसी को भी इस तरह एक समारोह है?

c# .net winapi path

— टोबीज बोसखे
स्रोत

Windows के तहत दी गई स्ट्रिंग कानूनी है (अनुमति दी गई है) फ़ाइल नाम की जाँच कैसे

— नवफाल

58

कोशिश करें Uri.IsWellFormedUriString():

स्ट्रिंग सही ढंग से बच नहीं है।
```
http://www.example.com/path???/file name
```
स्ट्रिंग एक पूर्ण Uri है जो एक अंतर्निहित फ़ाइल Uri का प्रतिनिधित्व करती है।
```
c:\\directory\filename
```
स्ट्रिंग एक पूर्ण URI है जो पथ से पहले एक स्लैश याद कर रहा है।
```
file://c:/directory/filename
```
आगे की स्लैश के रूप में व्यवहार किए जाने पर भी स्ट्रिंग में बिना पीछे के बैकस्लैश होते हैं।
```
http:\\host/path/file
```
स्ट्रिंग एक पदानुक्रमित निरपेक्ष उरी का प्रतिनिधित्व करती है और इसमें ": //" शामिल नहीं है।
```
www.example.com/path/file
```
Uri.Scheme के लिए पार्सर इंगित करता है कि मूल स्ट्रिंग अच्छी तरह से नहीं बनाई गई थी।
```
The example depends on the scheme of the URI.
```

— abatishchev
स्रोत

9

यह गलत है @"foo\bar\baz", जो पूरी तरह से मान्य सापेक्ष पथ है ...

— थॉमस लेवेस्क

5

थॉमस: उरीकाइंड आपने क्या निर्दिष्ट किया? आप Absolute, Relative या AbsoluteOrRelative का उपयोग कर सकते हैं।

— डान गोरान लुंडे

1

रिश्तेदार या निरपेक्ष के रूप में उरीकिन्द के साथ भी थॉमस जैसे रिश्तेदार रास्तों के लिए काम नहीं किया। मैंने पटको के उत्तर का उपयोग करने के बजाय समाप्त कर दिया और यह मेरे उद्देश्यों के लिए काम करता है।

— जॉनीएम

1

मैंने पाया कि IsWellFormedUriString (मेरी प्रारंभिक अपेक्षा के विपरीत) का उपयोग करते समय \\ computerName \ Dir नाम के साथ Spaces \ fileName जैसे एक पथ को फेंकता है, क्योंकि रिक्त स्थान ठीक से एन्कोड नहीं किए गए हैं। मैंने पाया कि मैं उरी (स्ट्रिंग) कंस्ट्रक्टर को केवल अपने सत्यापन के रूप में उपयोग कर सकता हूं, जिससे, स्ट्रिंग को सत्यापन के बिना ठीक से एन्कोड नहीं किया जा सकेगा।

— quintessential5

3

एक पूरी तरह से ठीक फ़ाइल पथ पर झूठे रिटर्न।

— इवगेनी पेत्रोव

29

या का उपयोग FileInfo के रूप में सुझाव दिया में सी # जाँच लें कि फ़ाइल नाम है संभवतः वैध (नहीं है कि यह मौजूद है) ।

— Patko
स्रोत

"LamdaComplex" द्वारा एक ही धागे पर पोस्ट किए गए समाधान का उपयोग करना, अधिक सटीक लगता है: stackoverflow.com/a/11636052/2546739

— Xav987

7

private bool IsValidPath(string path)
{
    Regex driveCheck = new Regex(@"^[a-zA-Z]:\\$");
    if (!driveCheck.IsMatch(path.Substring(0, 3))) return false;
    string strTheseAreInvalidFileNameChars = new string(Path.GetInvalidPathChars());
    strTheseAreInvalidFileNameChars += @":/?*" + "\"";
    Regex containsABadCharacter = new Regex("[" + Regex.Escape(strTheseAreInvalidFileNameChars) + "]");
    if (containsABadCharacter.IsMatch(path.Substring(3, path.Length - 3)))
        return false;

    DirectoryInfo dir = new DirectoryInfo(Path.GetFullPath(path));
    if (!dir.Exists)
        dir.Create();
    return true;
}

— एलेक्स जोलीग
स्रोत

7

मुझे नीचे दिए गए कोड से कोई समस्या नहीं है। (सापेक्ष पथ '/' या '\' से शुरू होने चाहिए)।

private bool IsValidPath(string path, bool allowRelativePaths = false)
{
    bool isValid = true;

    try
    {
        string fullPath = Path.GetFullPath(path);

        if (allowRelativePaths)
        {
            isValid = Path.IsPathRooted(path);
        }
        else
        {
            string root = Path.GetPathRoot(path);
            isValid = string.IsNullOrEmpty(root.Trim(new char[] { '\\', '/' })) == false;
        }
    }
    catch(Exception ex)
    {
        isValid = false;
    }

    return isValid;
}

उदाहरण के लिए ये गलत वापस आएंगे:

IsValidPath("C:/abc*d");
IsValidPath("C:/abc?d");
IsValidPath("C:/abc\"d");
IsValidPath("C:/abc<d");
IsValidPath("C:/abc>d");
IsValidPath("C:/abc|d");
IsValidPath("C:/abc:d");
IsValidPath("");
IsValidPath("./abc");
IsValidPath("./abc", true);
IsValidPath("/abc");
IsValidPath("abc");
IsValidPath("abc", true);

और ये सच होंगे:

IsValidPath(@"C:\\abc");
IsValidPath(@"F:\FILES\");
IsValidPath(@"C:\\abc.docx\\defg.docx");
IsValidPath(@"C:/abc/defg");
IsValidPath(@"C:\\\//\/\\/\\\/abc/\/\/\/\///\\\//\defg");
IsValidPath(@"C:/abc/def~`!@#$%^&()_-+={[}];',.g");
IsValidPath(@"C:\\\\\abc////////defg");
IsValidPath(@"/abc", true);
IsValidPath(@"\abc", true);

— दाऊ सीकर
स्रोत

3

आप इस कोड को आज़मा सकते हैं:

try
{
  Path.GetDirectoryName(myPath);
}
catch
{
  // Path is not valid
}

मुझे यकीन नहीं है कि यह सभी मामलों को कवर करता है ...

— निमरॉड
स्रोत

2

मैं जितना करीब आया हूं, इसे बनाने की कोशिश कर रहा हूं, और यह देखने के बाद कि क्या यह सफल हुआ।

— Martijn
स्रोत

2

यहाँ पर बहुत सारे अच्छे समाधान हैं, लेकिन तब तक किसी की भी जाँच नहीं है कि क्या मौजूदा ड्राइव में रूट निहित है या नहीं :

private bool IsValidPath(string path)
{
    // Check if the path is rooted in a driver
    if (path.Length < 3) return false;
    Regex driveCheck = new Regex(@"^[a-zA-Z]:\\$");
    if (!driveCheck.IsMatch(path.Substring(0, 3))) return false;

    // Check if such driver exists
    IEnumerable<string> allMachineDrivers = DriveInfo.GetDrives().Select(drive => drive.Name);
    if (!allMachineDrivers.Contains(path.Substring(0, 3))) return false;

    // Check if the rest of the path is valid
    string InvalidFileNameChars = new string(Path.GetInvalidPathChars());
    InvalidFileNameChars += @":/?*" + "\"";
    Regex containsABadCharacter = new Regex("[" + Regex.Escape(InvalidFileNameChars) + "]");
    if (containsABadCharacter.IsMatch(path.Substring(3, path.Length - 3)))
        return false;
    if (path[path.Length - 1] == '.') return false;

    return true;
}

यह समाधान है नहीं खाते में संबंधित पथ ले।

— गर्क गार्सिया
स्रोत

1

से अमान्य वर्ण प्राप्त करें System.IO.Path.GetInvalidPathChars();और जांचें कि क्या आपके स्ट्रिंग (निर्देशिका पथ) में वे हैं या नहीं।

— उमेश छिलका
स्रोत

3

यह पूरी तरह से मान्य नहीं है। "C: \ new.folder" वैध है जबकि "C: \ newfolder।" नहीं है। '।' पथ / फ़ाइल नाम के लिए एक मान्य वर्ण है, लेकिन uri के अंत में नहीं है।

— क्लेउडेकेनिलोल

0

Directory.Exists?

— markpsmith
स्रोत

4

"[...] यह जांचना नहीं चाहता है कि कोई फ़ाइल मौजूद है या नहीं!"

— स्टीफन

3

मौजूदा निर्देशिका के लिए वह परीक्षण, न कि इसके लिए एक वैध मार्ग है (जहाँ कोई मौजूद हो सकता है, या बनाया जा सकता है, उचित निजीकृत दिया जा सकता है)

— Martijn

3

@ जेसन - यह केवल फ़ोल्डर युक्त फ़ाइल की जाँच नहीं करता है।

— मार्कशीट

8

लेकिन एक वैध निर्देशिका पथ अभी भी मौजूद नहीं हो सकता है।

— स्टीफन

-2

private bool IsValidPath(string path)
{
    Regex driveCheck = new Regex(@"^[a-zA-Z]:\\$");

    if (string.IsNullOrWhiteSpace(path) || path.Length < 3)
    {
        return false;
    }

    if (!driveCheck.IsMatch(path.Substring(0, 3)))
    {
        return false;
    }

    var x1 = (path.Substring(3, path.Length - 3));
    string strTheseAreInvalidFileNameChars = new string(Path.GetInvalidPathChars());
    strTheseAreInvalidFileNameChars += @":?*";
    Regex containsABadCharacter = new Regex("[" + Regex.Escape(strTheseAreInvalidFileNameChars) + "]");

    if (containsABadCharacter.IsMatch(path.Substring(3, path.Length - 3)))
    {
        return false;
    }

    var driveLetterWithColonAndSlash = Path.GetPathRoot(path);

    if (!DriveInfo.GetDrives().Any(x => x.Name == driveLetterWithColonAndSlash))
    {
        return false;
    }

    return true;
}

— घिसलेन जैबातो
स्रोत

1

X1 का उद्देश्य क्या है?

— JayJay

-3

जस्ट सिंपल यूज

if (System.IO.Directory.Exists(path))
{
    ...
}

— महदी अस्तेनी
स्रोत

-4

आप पथ के साथ संयोजन में Path.IsPathRooted () Path.GetInvalidFileNameChars () का उपयोग करके यह सुनिश्चित कर सकते हैं कि मार्ग आधा-ठीक है।

— एलन मिल्कोविच
स्रोत