यह जांचने का बेहतर तरीका है कि क्या पथ एक फ़ाइल या निर्देशिका है?

Question

मैं TreeViewनिर्देशिकाओं और फ़ाइलों का प्रसंस्करण कर रहा हूं । एक उपयोगकर्ता किसी फ़ाइल या निर्देशिका का चयन कर सकता है और फिर उसके साथ कुछ कर सकता है। इसके लिए मुझे एक विधि की आवश्यकता होती है जो उपयोगकर्ता के चयन के आधार पर विभिन्न क्रियाएं करती है।

फिलहाल मैं यह निर्धारित करने के लिए कुछ ऐसा कर रहा हूं कि क्या पथ एक फाइल है या निर्देशिका है:

bool bIsFile = false;
bool bIsDirectory = false;

try
{
    string[] subfolders = Directory.GetDirectories(strFilePath);

    bIsDirectory = true;
    bIsFile = false;
}
catch(System.IO.IOException)
{
    bIsFolder = false;
    bIsFile = true;
}

मैं यह महसूस करने में मदद नहीं कर सकता कि ऐसा करने का एक बेहतर तरीका है! मैं इसे संभालने के लिए एक मानक .NET विधि खोजने की उम्मीद कर रहा था, लेकिन मैं ऐसा नहीं कर पाया। क्या ऐसी कोई विधि मौजूद है, और यदि नहीं, तो यह निर्धारित करने के लिए सबसे सरल साधन क्या है कि एक पथ एक फ़ाइल या निर्देशिका है?

Comments

क्या कोई "मौजूदा" फ़ाइल / निर्देशिका निर्दिष्ट करने के लिए प्रश्न शीर्षक को संपादित कर सकता है ? सभी उत्तर डिस्क पर मौजूद फ़ाइल / निर्देशिका के लिए एक पथ पर लागू होते हैं।

— जेक बर्जर

@jberger कृपया नीचे मेरे उत्तर को देखें। मुझे फ़ाइलों / फ़ोल्डरों के पथ के लिए इसे पूरा करने का एक तरीका मिला जो मौजूद हो सकता है या नहीं भी हो सकता है।

— लान

.NET

— नवाफाल

आप इस ट्रीव्यू को कैसे आबाद कर रहे हैं? आप इससे कैसे रास्ता निकाल रहे हैं?

— रैंडम 832

Answer 1

से कैसे करता है, तो पथ फ़ाइल या निर्देशिका है बताने के लिए :

// get the file attributes for file or directory
FileAttributes attr = File.GetAttributes(@"c:\Temp");

//detect whether its a directory or file
if ((attr & FileAttributes.Directory) == FileAttributes.Directory)
    MessageBox.Show("Its a directory");
else
    MessageBox.Show("Its a file");

.NET 4.0+ के लिए अपडेट करें

नीचे दी गई टिप्पणियों के अनुसार, यदि आप .NET 4.0 या बाद में हैं (और अधिकतम प्रदर्शन महत्वपूर्ण नहीं है) तो आप कोड को क्लीनर तरीके से लिख सकते हैं:

// get the file attributes for file or directory
FileAttributes attr = File.GetAttributes(@"c:\Temp");

if (attr.HasFlag(FileAttributes.Directory))
    MessageBox.Show("Its a directory");
else
    MessageBox.Show("Its a file");

Comments

+1 यह बेहतर दृष्टिकोण है और मेरे द्वारा प्रस्तावित समाधान से काफी तेज है।

— एंड्रयू हरे

@ KeyMs92 इसका बिटवाइज गणित। मूल रूप से, attr कुछ द्विआधारी मूल्य है जिसका एक बिट अर्थ है "यह एक निर्देशिका है"। बिटवाइज़ और &ऑपरेटर एक बाइनरी वैल्यू लौटाएगा जहाँ दोनों ऑपरेंड में केवल बिट्स (1) चालू हैं। इस मामले में बिटवाइज़ और ऑपरेशन करने के लिए attrऔर यदि निर्देशिका फ़ाइल विशेषता बिट चालू है तो FileAttributes.Directoryमान वापस आ जाएगा FileAttributes.Directory। बेहतर स्पष्टीकरण के लिए en.wikipedia.org/wiki/Bitwise_operation देखें ।

— काइल ट्रुबरमैन

@jberger यदि पथ मौजूद नहीं है, तो यह अस्पष्ट है कि क्या C:\Tempकिसी निर्देशिका को संदर्भित किया जाता है जिसे Tempएक फ़ाइल कहा जाता है Temp। कोड का क्या मतलब है?

— ta.speot.is

@Key: .NET 4.0 के बाद, attr.HasFlag(FileAttributes.Directory)इसके बजाय इस्तेमाल किया जा सकता है।

— फाक गर

@ AafakGür: एक समय संवेदनशील पाश के अंदर ऐसा मत करो। attr.HasFlag () नरक के रूप में धीमा है और प्रत्येक कॉल के लिए प्रतिबिंब का उपयोग करता है

— बसंत May६

Answer 2

इनका उपयोग कैसे करें?

File.Exists();
Directory.Exists();

Comments

इसके विपरीत, अमान्य पथ पर अपवाद न फेंकने का भी लाभ है File.GetAttributes()।

— डीनना

मैं अपने प्रोजेक्ट में BCL bcl.codeplex.com/ से लॉन्ग पाथ लाइब्रेरी का उपयोग करता हूं, इसलिए फ़ाइल विशेषताओं को प्राप्त करने का कोई तरीका नहीं है, लेकिन एक्ज़िस्ट को कॉल करना एक अच्छा समाधान है।

— प्यूटरेडो बोरेटो

@jberger मुझे उम्मीद है कि यह गैर-मौजूद फ़ाइलों / फ़ोल्डरों के पथ के लिए काम नहीं करेगा। File.Exists ("c: \\ temp \\ nonexistant.txt") को गलत तरीके से वापस लौटना चाहिए, क्योंकि यह करता है।

— माइकललॉस

यदि आप गैर-मौजूद फ़ाइलों / फ़ोल्डरों के बारे में चिंतित हैं, तो यह प्रयास करें public static bool? IsDirectory(string path){ if (Directory.Exists(path)) return true; // is a directory else if (File.Exists(path)) return false; // is a file else return null; // is a nothing }

— Dustin Townsend

इस पर अधिक जानकारी msdn.microsoft.com/en-us/library/…

— Moji

Answer 3

केवल इस पंक्ति के साथ आप पा सकते हैं यदि कोई पथ निर्देशिका या फ़ाइल है:

File.GetAttributes(data.Path).HasFlag(FileAttributes.Directory)

Comments

इसके लिए आपको कम से कम .NET 4.0 की आवश्यकता है। इसके अलावा अगर कोई वैध रास्ता नहीं है तो यह विस्फोट होगा।

— नवफाल

यदि पथ मौजूद है, तो जांचने के लिए FileInfo ऑब्जेक्ट का उपयोग करें: FileInfo pFinfo = नया FileInfo (फ़्लिस्ट [0]); if (pFinfo.Exists) {if (File.GetAttributes (FList [0])। HasFlag (FileAttributes.Directory)) {}}। यह मेरे लिए काम करता है।

— माइकल स्टिम्सन

यदि आप पहले से ही एक FileInfo ऑब्जेक्ट बना चुके हैं और उदाहरण की Exist संपत्ति का उपयोग कर रहे हैं, तो स्थैतिक File.GetAttributes () पद्धति का उपयोग करने के बजाय इसकी विशेषता संपत्ति तक क्यों नहीं पहुंचें?

— डायनेमिकल

Answer 4

ये मेरा:

    bool IsPathDirectory(string path)
    {
        if (path == null) throw new ArgumentNullException("path");
        path = path.Trim();

        if (Directory.Exists(path)) 
            return true;

        if (File.Exists(path)) 
            return false;

        // neither file nor directory exists. guess intention

        // if has trailing slash then it's a directory
        if (new[] {"\\", "/"}.Any(x => path.EndsWith(x)))
            return true; // ends with slash

        // if has extension then its a file; directory otherwise
        return string.IsNullOrWhiteSpace(Path.GetExtension(path));
    }

यह दूसरों के उत्तरों के समान है लेकिन बिल्कुल समान नहीं है।

Comments

तकनीकी रूप से आपको उपयोग करना चाहिए Path.DirectorySeparatorCharऔरPath.AltDirectorySeparatorChar

— 16

इरादे का अनुमान लगाने के लिए यह विचार दिलचस्प है। IMHO दो तरीकों में विभाजित करने के लिए बेहतर है। विधि एक अस्तित्व परीक्षण करता है, एक अशक्त बूलियन लौटाता है। यदि कॉलर करता है तो "अनुमान" भाग चाहता है, एक से एक अशक्त परिणाम पर, फिर विधि दो को कॉल करें, जो अनुमान लगाता है।

— टूलमेकरसेव

मैं इसे एक टपल वापस करने के लिए लिखूंगा कि क्या यह अनुमान लगाया गया था या नहीं।

— रॉनी ओवरबी

"अगर इसका एक्सटेंशन है तो इसकी फाइल है" - यह सच नहीं है। एक फाइल में एक एक्सटेंशन (यहां तक ​​कि विंडोज़ में) और एक निर्देशिका में "एक्सटेंशन" हो सकता है। उदाहरण के लिए यह एक फ़ाइल या एक निर्देशिका हो सकती है: "C: \ New folder.log"

— bytedev

@bytedev मुझे पता है कि, लेकिन उस समय फ़ंक्शन में, कोड इरादे का अनुमान लगा रहा है। ऐसा कहने पर भी एक टिप्पणी है। अधिकांश फाइलों में एक्सटेंशन होता है। अधिकांश निर्देशिका नहीं है।

— रॉनी ओवरबी

Answer 5

Directory.Exists () के विकल्प के रूप में, आप फ़ाइल या निर्देशिका की विशेषताओं को प्राप्त करने के लिए File.GetAttributes () विधि का उपयोग कर सकते हैं, इसलिए आप इस तरह से एक सहायक विधि बना सकते हैं:

private static bool IsDirectory(string path)
{
    System.IO.FileAttributes fa = System.IO.File.GetAttributes(path);
    return (fa & FileAttributes.Directory) != 0;
}

जब आप आइटम के लिए अतिरिक्त मेटाडेटा नियंत्रण को नियंत्रित करते हैं, तो आप TreeView नियंत्रण की टैग संपत्ति में कोई ऑब्जेक्ट जोड़ने पर विचार कर सकते हैं। उदाहरण के लिए, आप फ़ाइलों के लिए FileInfo ऑब्जेक्ट और डायरेक्टरी के लिए DirectoryInfo ऑब्जेक्ट जोड़ सकते हैं और फिर आइटम पर क्लिक करते समय उस डेटा को प्राप्त करने के लिए अतिरिक्त सिस्टम कॉल करने से बचाने के लिए टैग प्रॉपर्टी में आइटम प्रकार के लिए परीक्षण कर सकते हैं।

Comments

यह अन्य उत्तर

— जेक बर्गर

तर्क के उस भयानक ब्लॉक के बजाय, कोशिश करेंisDirectory = (fa & FileAttributes.Directory) != 0);

— अमर ब्लू

Answer 6

यह सबसे अच्छा था जिसे मैं अस्तित्व और गुण के व्यवहार को देखते हुए आ सकता था:

using System.IO;

public static class FileSystemInfoExtensions
{
    /// <summary>
    /// Checks whether a FileInfo or DirectoryInfo object is a directory, or intended to be a directory.
    /// </summary>
    /// <param name="fileSystemInfo"></param>
    /// <returns></returns>
    public static bool IsDirectory(this FileSystemInfo fileSystemInfo)
    {
        if (fileSystemInfo == null)
        {
            return false;
        }

        if ((int)fileSystemInfo.Attributes != -1)
        {
            // if attributes are initialized check the directory flag
            return fileSystemInfo.Attributes.HasFlag(FileAttributes.Directory);
        }

        // If we get here the file probably doesn't exist yet.  The best we can do is 
        // try to judge intent.  Because directories can have extensions and files
        // can lack them, we can't rely on filename.
        // 
        // We can reasonably assume that if the path doesn't exist yet and 
        // FileSystemInfo is a DirectoryInfo, a directory is intended.  FileInfo can 
        // make a directory, but it would be a bizarre code path.

        return fileSystemInfo is DirectoryInfo;
    }
}

यहां बताया गया है कि यह कैसे परीक्षण करता है:

    [TestMethod]
    public void IsDirectoryTest()
    {
        // non-existing file, FileAttributes not conclusive, rely on type of FileSystemInfo
        const string nonExistentFile = @"C:\TotallyFakeFile.exe";

        var nonExistentFileDirectoryInfo = new DirectoryInfo(nonExistentFile);
        Assert.IsTrue(nonExistentFileDirectoryInfo.IsDirectory());

        var nonExistentFileFileInfo = new FileInfo(nonExistentFile);
        Assert.IsFalse(nonExistentFileFileInfo.IsDirectory());

        // non-existing directory, FileAttributes not conclusive, rely on type of FileSystemInfo
        const string nonExistentDirectory = @"C:\FakeDirectory";

        var nonExistentDirectoryInfo = new DirectoryInfo(nonExistentDirectory);
        Assert.IsTrue(nonExistentDirectoryInfo.IsDirectory());

        var nonExistentFileInfo = new FileInfo(nonExistentDirectory);
        Assert.IsFalse(nonExistentFileInfo.IsDirectory());

        // Existing, rely on FileAttributes
        const string existingDirectory = @"C:\Windows";

        var existingDirectoryInfo = new DirectoryInfo(existingDirectory);
        Assert.IsTrue(existingDirectoryInfo.IsDirectory());

        var existingDirectoryFileInfo = new FileInfo(existingDirectory);
        Assert.IsTrue(existingDirectoryFileInfo.IsDirectory());

        // Existing, rely on FileAttributes
        const string existingFile = @"C:\Windows\notepad.exe";

        var existingFileDirectoryInfo = new DirectoryInfo(existingFile);
        Assert.IsFalse(existingFileDirectoryInfo.IsDirectory());

        var existingFileFileInfo = new FileInfo(existingFile);
        Assert.IsFalse(existingFileFileInfo.IsDirectory());
    }

Answer 7

अन्य उत्तरों से सुझावों के संयोजन के बाद, मुझे एहसास हुआ कि मैं रोनी ओवरबी के उत्तर के बारे में एक ही बात के साथ आया हूं । यहां कुछ चीजों के बारे में सोचने के लिए कुछ परीक्षण दिए गए हैं:

1. फ़ोल्डर में "एक्सटेंशन" हो सकते हैं: C:\Temp\folder_with.dot
2. फ़ाइलें एक निर्देशिका विभाजक (स्लैश) के साथ समाप्त नहीं हो सकती
3. तकनीकी रूप से दो निर्देशिका विभाजक हैं जो प्लेटफ़ॉर्म विशिष्ट हैं - यानी स्लैश ( और ) नहीं हो सकते हैंPath.DirectorySeparatorCharPath.AltDirectorySeparatorChar

टेस्ट (लिनकैप)

var paths = new[] {
    // exists
    @"C:\Temp\dir_test\folder_is_a_dir",
    @"C:\Temp\dir_test\is_a_dir_trailing_slash\",
    @"C:\Temp\dir_test\existing_folder_with.ext",
    @"C:\Temp\dir_test\file_thats_not_a_dir",
    @"C:\Temp\dir_test\notadir.txt",
    // doesn't exist
    @"C:\Temp\dir_test\dne_folder_is_a_dir",
    @"C:\Temp\dir_test\dne_folder_trailing_slash\",
    @"C:\Temp\dir_test\non_existing_folder_with.ext",
    @"C:\Temp\dir_test\dne_file_thats_not_a_dir",
    @"C:\Temp\dir_test\dne_notadir.txt",        
};

foreach(var path in paths) {
    IsFolder(path/*, false*/).Dump(path);
}

परिणाम

C:\Temp\dir_test\folder_is_a_dir
  True 
C:\Temp\dir_test\is_a_dir_trailing_slash\
  True 
C:\Temp\dir_test\existing_folder_with.ext
  True 
C:\Temp\dir_test\file_thats_not_a_dir
  False 
C:\Temp\dir_test\notadir.txt
  False 
C:\Temp\dir_test\dne_folder_is_a_dir
  True 
C:\Temp\dir_test\dne_folder_trailing_slash\
  True 
C:\Temp\dir_test\non_existing_folder_with.ext
  False (this is the weird one)
C:\Temp\dir_test\dne_file_thats_not_a_dir
  True 
C:\Temp\dir_test\dne_notadir.txt
  False 

तरीका

/// <summary>
/// Whether the <paramref name="path"/> is a folder (existing or not); 
/// optionally assume that if it doesn't "look like" a file then it's a directory.
/// </summary>
/// <param name="path">Path to check</param>
/// <param name="assumeDneLookAlike">If the <paramref name="path"/> doesn't exist, does it at least look like a directory name?  As in, it doesn't look like a file.</param>
/// <returns><c>True</c> if a folder/directory, <c>false</c> if not.</returns>
public static bool IsFolder(string path, bool assumeDneLookAlike = true)
{
    // /programming/1395205/better-way-to-check-if-path-is-a-file-or-a-directory
    // turns out to be about the same as https://stackoverflow.com/a/19596821/1037948

    // check in order of verisimilitude

    // exists or ends with a directory separator -- files cannot end with directory separator, right?
    if (Directory.Exists(path)
        // use system values rather than assume slashes
        || path.EndsWith("" + Path.DirectorySeparatorChar)
        || path.EndsWith("" + Path.AltDirectorySeparatorChar))
        return true;

    // if we know for sure that it's an actual file...
    if (File.Exists(path))
        return false;

    // if it has an extension it should be a file, so vice versa
    // although technically directories can have extensions...
    if (!Path.HasExtension(path) && assumeDneLookAlike)
        return true;

    // only works for existing files, kinda redundant with `.Exists` above
    //if( File.GetAttributes(path).HasFlag(FileAttributes.Directory) ) ...; 

    // no idea -- could return an 'indeterminate' value (nullable bool)
    // or assume that if we don't know then it's not a folder
    return false;
}

Comments

Path.DirectorySeparatorChar.ToString()के बजाय स्ट्रिंग समतल के साथ ""?

— कोडिंग किया गया

@ गॉनकोडिंग शायद; उस समय मैं अशक्त गुणों के एक समूह के साथ काम कर रहा था, इसलिए मुझे अशक्त होने के बारे में चिंता करने के बजाय "खाली स्ट्रिंग के साथ कॉनकट" की आदत पड़ गई। आप भी new String(Path.DirectorySeparatorChar, 1)वैसा ही कर सकते हैं जैसा ToStringआप वास्तव में अनुकूलित करना चाहते हैं ।

— drzaus

Answer 8

सबसे सटीक दृष्टिकोण shlwapi.dll से कुछ इंटरॉप कोड का उपयोग करने वाला है

[DllImport(SHLWAPI, CharSet = CharSet.Unicode)]
[return: MarshalAsAttribute(UnmanagedType.Bool)]
[ResourceExposure(ResourceScope.None)]
internal static extern bool PathIsDirectory([MarshalAsAttribute(UnmanagedType.LPWStr), In] string pszPath);

फिर आप इसे इस तरह कहेंगे:

#region IsDirectory
/// <summary>
/// Verifies that a path is a valid directory.
/// </summary>
/// <param name="path">The path to verify.</param>
/// <returns><see langword="true"/> if the path is a valid directory; 
/// otherwise, <see langword="false"/>.</returns>
/// <exception cref="T:System.ArgumentNullException">
/// <para><paramref name="path"/> is <see langword="null"/>.</para>
/// </exception>
/// <exception cref="T:System.ArgumentException">
/// <para><paramref name="path"/> is <see cref="F:System.String.Empty">String.Empty</see>.</para>
/// </exception>
public static bool IsDirectory(string path)
{
    return PathIsDirectory(path);
}

Comments

बदसूरत। मैं इन सरल कार्यों को करने के लिए इंटरोप से नफरत करता हूं। और यह पोर्टेबल नहीं है। और यह बदसूरत है। क्या मैंने कहा कि यह बदसूरत है? :)

— इग्नासियो सोलर गार्सिया

@SoMoS यह आपकी राय में "बदसूरत" हो सकता है, लेकिन यह अभी भी सबसे सटीक दृष्टिकोण है। हां, यह एक पोर्टेबल समाधान नहीं है, लेकिन यह सवाल क्या पूछा गया था नहीं था।

— स्कॉट डोरमैन

आप सटीक के साथ वास्तव में क्या मतलब है? यह क्विन विल्सन और आवश्यक इंटरॉप के जवाब के समान परिणाम देता है जो पोर्टेबिलिटी को तोड़ता है। मेरे लिए अन्य समाधानों के रूप में सटीक है और साइड इफेक्ट दूसरों को नहीं है।

— इग्नासियो सोलर गार्सिया 10

ऐसा करने के लिए एक फ्रेमवर्क एपीआई है। इंटरोप का उपयोग करने का रास्ता नहीं है।

— टॉमएक्सपी ४११

हां यह काम करता है, लेकिन यह "सबसे सटीक" समाधान नहीं है - मौजूदा .NET फ्रेमवर्क का उपयोग करने से अधिक नहीं है। इसके बजाय, आप .NET फ्रेमवर्क के साथ एक पंक्ति में क्या किया जा सकता है, इसे बदलने के लिए कोड की 6 लाइनें लेते हैं, और स्वयं को केवल विंडोज का उपयोग करने में बंद कर देते हैं, क्योंकि मोनो परियोजना के साथ इसे पोर्ट करने की क्षमता को खोलने के लिए विरोध किया जाता है। .NET फ्रेमवर्क अधिक सुरुचिपूर्ण समाधान प्रदान करने पर कभी भी इंटरोप का उपयोग न करें।

— रस

Answer 9

यहाँ हम उपयोग करते हैं:

using System;

using System.IO;

namespace crmachine.CommonClasses
{

  public static class CRMPath
  {

    public static bool IsDirectory(string path)
    {
      if (path == null)
      {
        throw new ArgumentNullException("path");
      }

      string reason;
      if (!IsValidPathString(path, out reason))
      {
        throw new ArgumentException(reason);
      }

      if (!(Directory.Exists(path) || File.Exists(path)))
      {
        throw new InvalidOperationException(string.Format("Could not find a part of the path '{0}'",path));
      }

      return (new System.IO.FileInfo(path).Attributes & FileAttributes.Directory) == FileAttributes.Directory;
    } 

    public static bool IsValidPathString(string pathStringToTest, out string reasonForError)
    {
      reasonForError = "";
      if (string.IsNullOrWhiteSpace(pathStringToTest))
      {
        reasonForError = "Path is Null or Whitespace.";
        return false;
      }
      if (pathStringToTest.Length > CRMConst.MAXPATH) // MAXPATH == 260
      {
        reasonForError = "Length of path exceeds MAXPATH.";
        return false;
      }
      if (PathContainsInvalidCharacters(pathStringToTest))
      {
        reasonForError = "Path contains invalid path characters.";
        return false;
      }
      if (pathStringToTest == ":")
      {
        reasonForError = "Path consists of only a volume designator.";
        return false;
      }
      if (pathStringToTest[0] == ':')
      {
        reasonForError = "Path begins with a volume designator.";
        return false;
      }

      if (pathStringToTest.Contains(":") && pathStringToTest.IndexOf(':') != 1)
      {
        reasonForError = "Path contains a volume designator that is not part of a drive label.";
        return false;
      }
      return true;
    }

    public static bool PathContainsInvalidCharacters(string path)
    {
      if (path == null)
      {
        throw new ArgumentNullException("path");
      }

      bool containedInvalidCharacters = false;

      for (int i = 0; i < path.Length; i++)
      {
        int n = path[i];
        if (
            (n == 0x22) || // "
            (n == 0x3c) || // <
            (n == 0x3e) || // >
            (n == 0x7c) || // |
            (n  < 0x20)    // the control characters
          )
        {
          containedInvalidCharacters = true;
        }
      }

      return containedInvalidCharacters;
    }


    public static bool FilenameContainsInvalidCharacters(string filename)
    {
      if (filename == null)
      {
        throw new ArgumentNullException("filename");
      }

      bool containedInvalidCharacters = false;

      for (int i = 0; i < filename.Length; i++)
      {
        int n = filename[i];
        if (
            (n == 0x22) || // "
            (n == 0x3c) || // <
            (n == 0x3e) || // >
            (n == 0x7c) || // |
            (n == 0x3a) || // : 
            (n == 0x2a) || // * 
            (n == 0x3f) || // ? 
            (n == 0x5c) || // \ 
            (n == 0x2f) || // /
            (n  < 0x20)    // the control characters
          )
        {
          containedInvalidCharacters = true;
        }
      }

      return containedInvalidCharacters;
    }

  }

}

Answer 10

मैं एक समान समस्या का सामना करते समय इस पर आया था, सिवाय इसके कि मुझे यह जांचने की आवश्यकता है कि क्या कोई फ़ाइल या फ़ोल्डर के लिए एक पथ है जब फ़ाइल या फ़ोल्डर वास्तव में मौजूद हो सकता है । ऊपर दिए गए जवाबों पर कुछ टिप्पणियां दी गई थीं, जिनका उल्लेख था कि वे इस परिदृश्य के लिए काम नहीं करेंगे। मुझे एक समाधान मिला (मैं VB.NET का उपयोग करता हूं, लेकिन अगर आप की जरूरत है तो आप इसे बदल सकते हैं) जो मेरे लिए अच्छा काम करता है:

Dim path As String = "myFakeFolder\ThisDoesNotExist\"
Dim bIsFolder As Boolean = (IO.Path.GetExtension(path) = "")
'returns True

Dim path As String = "myFakeFolder\ThisDoesNotExist\File.jpg"
Dim bIsFolder As Boolean = (IO.Path.GetExtension(path) = "")
'returns False

उम्मीद है कि यह किसी के लिए उपयोगी हो सकता है!

Comments

क्या आपने Path.HasExtension विधि आजमाई है?

— जेक बर्गर 12

यदि यह मौजूद नहीं है, तो यह एक फ़ाइल या निर्देशिका नहीं है। कोई भी नाम बनाया जा सकता है। यदि आप इसे बनाने का इरादा रखते हैं, तो आपको पता होना चाहिए कि आप क्या बना रहे हैं, और यदि आप नहीं बनाते हैं, तो आपको संभवतः इस जानकारी की आवश्यकता क्यों हो सकती है?

— रैंडम 832

एक फ़ोल्डर को नाम दिया जा सकता है test.txtऔर एक फाइल का नाम दिया जा सकता है test- इन मामलों में आपका कोड गलत परिणाम देगा

— Stephan Bauer

System.IO.FIle और System.IO.Directory कक्षाओं में एक -Exist पद्धति है। यह करने की बात है। निर्देशिकाएँ में एक्सटेंशन हो सकते हैं; मैं इसे अक्सर देखता हूं।

— टॉमएक्सपी 411

Answer 11

खेल में देर से मुझे पता है, लेकिन मुझे लगता है कि यह वैसे भी साझा करेंगे। यदि आप स्ट्रिंग्स के रूप में पथों के साथ पूरी तरह से काम कर रहे हैं, तो यह पता लगाना पाई के रूप में आसान है:

private bool IsFolder(string ThePath)
{
    string BS = Path.DirectorySeparatorChar.ToString();
    return Path.GetDirectoryName(ThePath) == ThePath.TrimEnd(BS.ToCharArray());
}

उदाहरण के लिए: ThePath == "C:\SomeFolder\File1.txt"अंत में यह होगा:

return "C:\SomeFolder" == "C:\SomeFolder\File1.txt" (FALSE)

एक और उदाहरण: ThePath == "C:\SomeFolder\"अंत में यह होगा:

return "C:\SomeFolder" == "C:\SomeFolder" (TRUE)

और यह भी पीछे हटने के बिना काम ThePath == "C:\SomeFolder"करेगा: यह होने जा रहा है:

return "C:\SomeFolder" == "C:\SomeFolder" (TRUE)

यहां ध्यान रखें कि यह केवल पथों के साथ काम करता है, न कि पथ और "भौतिक डिस्क" के बीच संबंध ... इसलिए यह आपको यह नहीं बता सकता है कि क्या पथ / फ़ाइल मौजूद है या ऐसा कुछ भी है, लेकिन यह सुनिश्चित है यदि पथ एक फ़ोल्डर या फ़ाइल है, तो आपको बता सकता है ...

Comments

System.IO.FileSystemWatcherतब से काम नहीं करता है जब एक निर्देशिका को हटा दिया जाता है यह c:\my_directoryएक तर्क के रूप में भेजता है जो समान है जब एक एक्सटेंशन कम फ़ाइल c:\my_directoryहटा दी जाती है।

— रे चेंग

GetDirectoryName('C:\SomeFolder')रिटर्न 'C:\', इसलिए आपका अंतिम मामला काम नहीं करता है। यह निर्देशिका और फ़ाइलों के बीच कोई एक्सटेंशन के बीच अंतर नहीं करता है।

— लुसी

आप गलत तरीके से मानते हैं कि एक निर्देशिका पथ में हमेशा अंतिम "\" शामिल होगा। उदाहरण के लिए, Path.GetDirectoryName("C:\SomeFolder\SomeSubFolder")वापस आ जाएगी C:\SomeFolder। ध्यान दें कि GetDirectoryName रिटर्न के अपने स्वयं के उदाहरण बताते हैं कि यह एक ऐसा रास्ता देता है जो बैकस्लैश में समाप्त नहीं होता है । इसका मतलब है कि अगर कोई निर्देशिका पथ प्राप्त करने के लिए कहीं और GetDirectoryName का उपयोग करता है, और फिर इसे आपकी विधि को खिलाता है, तो उन्हें गलत उत्तर मिलेगा।

— टूलमेकरसेव

Answer 12

यदि आप निर्देशिकाओं को खोजना चाहते हैं, जिनमें "छिपी" और "प्रणाली" चिह्नित हैं, तो यह कोशिश करें (.NET V4 की आवश्यकता है):

FileAttributes fa = File.GetAttributes(path);
if(fa.HasFlag(FileAttributes.Directory)) 

Answer 13

मुझे इसकी आवश्यकता थी, पदों ने मदद की, यह इसे एक पंक्ति में ले जाता है, और यदि पथ बिल्कुल भी नहीं है, तो यह बस वापस आ जाता है और विधि से बाहर निकल जाता है। यह उपरोक्त सभी चिंताओं का समाधान करता है, अनुगामी स्लैश की आवश्यकता नहीं है।

if (!Directory.Exists(@"C:\folderName")) return;

Answer 14

मैं निम्नलिखित का उपयोग करता हूं, यह एक्सटेंशन का परीक्षण भी करता है जिसका अर्थ है कि इसका उपयोग परीक्षण के लिए किया जा सकता है यदि आपूर्ति की गई फ़ाइल एक फ़ाइल है, लेकिन एक फ़ाइल जो मौजूद नहीं है।

private static bool isDirectory(string path)
{
    bool result = true;
    System.IO.FileInfo fileTest = new System.IO.FileInfo(path);
    if (fileTest.Exists == true)
    {
        result = false;
    }
    else
    {
        if (fileTest.Extension != "")
        {
            result = false;
        }
    }
    return result;
}

Comments

FileInfo एक्सटेंशन (Imao) न के बराबर रास्तों पर जाँच करने के लिए एक अच्छा विकल्प है

— dataCore

आपकी दूसरी स्थिति (और) बदबूदार है। यदि यह एक मौजूदा फ़ाइल नहीं है, तो आप नहीं जानते कि यह संभवतः क्या हो सकता है (निर्देशिका कुछ ".txt" की तरह भी समाप्त हो सकती हैं)।

— नवफाल

Answer 15

using System;
using System.IO;
namespace FileOrDirectory
{
     class Program
     {
          public static string FileOrDirectory(string path)
          {
               if (File.Exists(path))
                    return "File";
               if (Directory.Exists(path))
                    return "Directory";
               return "Path Not Exists";
          }
          static void Main()
          {
               Console.WriteLine("Enter The Path:");
               string path = Console.ReadLine();
               Console.WriteLine(FileOrDirectory(path));
          }
     }
}

Answer 16

इस पोस्ट पर चयनित उत्तर का उपयोग करते हुए, मैंने टिप्पणियों को देखा और उनके जानकारी बिट्स के लिए @ GafakGür, @Anthony और @Quinn Wilson को विश्वास दिलाता हूं कि मुझे इस बेहतर उत्तर की ओर ले जाएं, जो मैंने लिखा और परीक्षण किया:

    /// <summary>
    /// Returns true if the path is a dir, false if it's a file and null if it's neither or doesn't exist.
    /// </summary>
    /// <param name="path"></param>
    /// <returns></returns>
    public static bool? IsDirFile(this string path)
    {
        bool? result = null;

        if(Directory.Exists(path) || File.Exists(path))
        {
            // get the file attributes for file or directory
            var fileAttr = File.GetAttributes(path);

            if (fileAttr.HasFlag(FileAttributes.Directory))
                result = true;
            else
                result = false;
        }

        return result;
    }

Comments

निर्देशिका / फ़ाइल अस्तित्व () के लिए पहले से जाँच करने के बाद विशेषताओं के लिए जाँच करने के लिए थोड़ा बेकार लगता है? वे दो कॉल अकेले ही यहाँ आवश्यक सभी काम करते हैं।

— कोडिंग हुआ

Answer 17

शायद UWP C # के लिए

public static async Task<IStorageItem> AsIStorageItemAsync(this string iStorageItemPath)
    {
        if (string.IsNullOrEmpty(iStorageItemPath)) return null;
        IStorageItem storageItem = null;
        try
        {
            storageItem = await StorageFolder.GetFolderFromPathAsync(iStorageItemPath);
            if (storageItem != null) return storageItem;
        } catch { }
        try
        {
            storageItem = await StorageFile.GetFileFromPathAsync(iStorageItemPath);
            if (storageItem != null) return storageItem;
        } catch { }
        return storageItem;
    }

Answer 18

मैं देखता हूं, मुझे पार्टी में 10 साल बहुत देर हो चुकी है। मैं स्थिति का सामना कर रहा था, जहां कुछ संपत्ति से मैं या तो एक फ़ाइल नाम या पूर्ण फ़ाइल पथ प्राप्त कर सकता हूं। यदि कोई पथ प्रदान नहीं किया गया है, तो मुझे एक अन्य संपत्ति द्वारा प्रदान की गई "वैश्विक" निर्देशिका-पथ संलग्न करके फ़ाइल-अस्तित्व की जांच करनी होगी।

मेरे मामले में

var isFileName = System.IO.Path.GetFileName (str) == str;

चाल चली। ठीक है, यह जादू नहीं है, लेकिन शायद यह किसी को कुछ मिनटों का पता लगा सकता है। चूँकि यह केवल एक स्ट्रिंग-पार्सिंग है, इसलिए डॉट्स वाले डॉट्स गलत नाम दे सकते हैं ...

Answer 19

यहाँ पार्टी के लिए बहुत देर हो चुकी है लेकिन मुझे Nullable<Boolean>रिटर्न वैल्यू काफी बदसूरत लग IsDirectory(string path)रही nullहै - बिना किसी टिप्पणी के गैर-मौजूद रास्ते के लिए वापसी करना समान नहीं है, इसलिए मैं निम्नलिखित बातों के साथ आया हूँ:

public static class PathHelper
{
    /// <summary>
    /// Determines whether the given path refers to an existing file or directory on disk.
    /// </summary>
    /// <param name="path">The path to test.</param>
    /// <param name="isDirectory">When this method returns, contains true if the path was found to be an existing directory, false in all other scenarios.</param>
    /// <returns>true if the path exists; otherwise, false.</returns>
    /// <exception cref="ArgumentNullException">If <paramref name="path"/> is null.</exception>
    /// <exception cref="ArgumentException">If <paramref name="path"/> equals <see cref="string.Empty"/></exception>
    public static bool PathExists(string path, out bool isDirectory)
    {
        if (path == null) throw new ArgumentNullException(nameof(path));
        if (path == string.Empty) throw new ArgumentException("Value cannot be empty.", nameof(path));

        isDirectory = Directory.Exists(path);

        return isDirectory || File.Exists(path);
    }
}

इस सहायक विधि को पहली बार पढ़ने के इरादे को समझने के लिए शब्दशः और संक्षिप्त रूप से लिखा गया है।

/// <summary>
/// Example usage of <see cref="PathExists(string, out bool)"/>
/// </summary>
public static void Usage()
{
    const string path = @"C:\dev";

    if (!PathHelper.PathExists(path, out var isDirectory))
        return;

    if (isDirectory)
    {
        // Do something with your directory
    }
    else
    {
        // Do something with your file
    }
}

Answer 20

क्या यह काम नहीं करेगा?

var isFile = Regex.IsMatch(path, @"\w{1,}\.\w{1,}$");

Comments

यह केवल इसलिए काम नहीं करेगा क्योंकि फ़ोल्डर के नाम में अवधि हो सकती है

— KSib

इसके अलावा फाइलों में अवधि नहीं होती है।

— कीथ पिंसन