Directory.Exists(String) Metoda

public:
 static bool Exists(System::String ^ path);

public static bool Exists(string path);

public static bool Exists(string? path);

static member Exists : string -> bool

Public Shared Function Exists (path As String) As Boolean

Parametry

Zwraca

true jeśli path odwołuje się do istniejącego katalogu; false jeśli katalog nie istnieje lub wystąpi błąd podczas próby ustalenia, czy określony katalog istnieje.

Przykłady

Poniższy przykład przyjmuje tablicę nazw plików lub katalogów w wierszu polecenia, określa, jakiego rodzaju nazwa jest i przetwarza odpowiednio.

// For File.Exists, Directory.Exists
using System;
using System.IO;
using System.Collections;

public class RecursiveFileProcessor
{
    public static void Main(string[] args)
    {
        foreach(string path in args)
        {
            if(File.Exists(path))
            {
                // This path is a file
                ProcessFile(path);
            }
            else if(Directory.Exists(path))
            {
                // This path is a directory
                ProcessDirectory(path);
            }
            else
            {
                Console.WriteLine("{0} is not a valid file or directory.", path);
            }
        }
    }

    // Process all files in the directory passed in, recurse on any directories
    // that are found, and process the files they contain.
    public static void ProcessDirectory(string targetDirectory)
    {
        // Process the list of files found in the directory.
        string [] fileEntries = Directory.GetFiles(targetDirectory);
        foreach(string fileName in fileEntries)
            ProcessFile(fileName);

        // Recurse into subdirectories of this directory.
        string [] subdirectoryEntries = Directory.GetDirectories(targetDirectory);
        foreach(string subdirectory in subdirectoryEntries)
            ProcessDirectory(subdirectory);
    }

    // Insert logic for processing found files here.
    public static void ProcessFile(string path)
    {
        Console.WriteLine("Processed file '{0}'.", path);	
    }
}

module RecursiveFileProcessor

open System.IO

// Insert logic for processing found files here.
let processFile path =
    printfn $"Processed file '%s{path}'."

// Process all files in the directory passed in, recurse on any directories
// that are found, and process the files they contain.
let rec processDirectory targetDirectory =
    // Process the list of files found in the directory.
    let fileEntries = Directory.GetFiles targetDirectory
    for fileName in fileEntries do
        processFile fileName

    // Recurse into subdirectories of this directory.
    let subdirectoryEntries = Directory.GetDirectories targetDirectory
    for subdirectory in subdirectoryEntries do
        processDirectory subdirectory

[<EntryPoint>]
let main args =
    for path in args do
        if File.Exists path then
            // This path is a file
            processFile path
        elif Directory.Exists path then
            // This path is a directory
            processDirectory path
        else
            printfn $"{path} is not a valid file or directory."
    0

' For File.Exists, Directory.Exists 

Imports System.IO
Imports System.Collections

Public Class RecursiveFileProcessor

    Public Overloads Shared Sub Main(ByVal args() As String)
        Dim path As String
        For Each path In args
            If File.Exists(path) Then
                ' This path is a file.
                ProcessFile(path)
            Else
                If Directory.Exists(path) Then
                    ' This path is a directory.
                    ProcessDirectory(path)
                Else
                    Console.WriteLine("{0} is not a valid file or directory.", path)
                End If
            End If
        Next path
    End Sub


    ' Process all files in the directory passed in, recurse on any directories 
    ' that are found, and process the files they contain.
    Public Shared Sub ProcessDirectory(ByVal targetDirectory As String)
        Dim fileEntries As String() = Directory.GetFiles(targetDirectory)
        ' Process the list of files found in the directory.
        Dim fileName As String
        For Each fileName In fileEntries
            ProcessFile(fileName)

        Next fileName
        Dim subdirectoryEntries As String() = Directory.GetDirectories(targetDirectory)
        ' Recurse into subdirectories of this directory.
        Dim subdirectory As String
        For Each subdirectory In subdirectoryEntries
            ProcessDirectory(subdirectory)
        Next subdirectory

    End Sub

    ' Insert logic for processing found files here.
    Public Shared Sub ProcessFile(ByVal path As String)
        Console.WriteLine("Processed file '{0}'.", path)
    End Sub
End Class

Uwagi

Parametr path może określać informacje o ścieżce względnej lub bezwzględnej. Informacje o ścieżce względnej są interpretowane jako względem bieżącego katalogu roboczego.

Spacje końcowe są usuwane z końca parametru path przed sprawdzeniem, czy katalog istnieje.

Wielkość liter parametru path odpowiada ważności liter systemu plików, na którym jest uruchomiony kod. Na przykład nie jest rozróżniana wielkość liter w systemie plików NTFS (domyślny system plików systemu Windows) i uwzględnia wielkość liter w systemach plików systemu Linux.

Jeśli nie masz co najmniej uprawnień tylko do odczytu do katalogu, Exists metoda zwróci falsewartość .

Metoda Exists zwraca false , jeśli wystąpi jakikolwiek błąd podczas próby ustalenia, czy określony plik istnieje. Może to wystąpić w sytuacjach, które zgłaszają wyjątki, takie jak przekazywanie nazwy pliku z nieprawidłowymi znakami lub zbyt wiele znaków, awaria lub brak dysku lub jeśli obiekt wywołujący nie ma uprawnień do odczytu pliku.

Zobacz też

• DirectoryInfo
• Wejście/Wyjście plików i strumieni
• Instrukcje: odczytywanie tekstu z pliku
• Instrukcje: zapisywanie tekstu w pliku