Directory.EnumerateDirectories Method

Reference

Definition

Namespace:: System.IO

Assemblies:: mscorlib.dll, System.IO.FileSystem.dll

Assembly:: System.IO.FileSystem.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.

Returns an enumerable collection of directory full names that meet specified criteria.

Overloads

EnumerateDirectories(String)	Returns an enumerable collection of directory full names in a specified path.
EnumerateDirectories(String, String)	Returns an enumerable collection of directory full names that match a search pattern in a specified path.
EnumerateDirectories(String, String, EnumerationOptions)	Returns an enumerable collection of the directory full names that match a search pattern in a specified path, and optionally searches subdirectories.
EnumerateDirectories(String, String, SearchOption)	Returns an enumerable collection of directory full names that match a search pattern in a specified path, and optionally searches subdirectories.

EnumerateDirectories(String)

Source:: Directory.cs

Source:: Directory.cs

Source:: Directory.cs

Returns an enumerable collection of directory full names in a specified path.

public:
 static System::Collections::Generic::IEnumerable<System::String ^> ^ EnumerateDirectories(System::String ^ path);

public static System.Collections.Generic.IEnumerable<string> EnumerateDirectories (string path);

static member EnumerateDirectories : string -> seq<string>

Public Shared Function EnumerateDirectories (path As String) As IEnumerable(Of String)

Parameters

path: String

The relative or absolute path to the directory to search. This string is not case-sensitive.

Returns

IEnumerable<String>

An enumerable collection of the full names (including paths) for the directories in the directory specified by path.

Exceptions

ArgumentException

.NET Framework and .NET Core versions older than 2.1: path is a zero-length string, contains only white space, or contains invalid characters. You can query for invalid characters by using the GetInvalidPathChars() method.

ArgumentNullException

path is null.

DirectoryNotFoundException

path is invalid, such as referring to an unmapped drive.

IOException

path is a file name.

PathTooLongException

The specified path, file name, or combined exceed the system-defined maximum length.

SecurityException

The caller does not have the required permission.

UnauthorizedAccessException

The caller does not have the required permission.

Examples

The following example enumerates the top-level directories in a specified path.

using System;
using System.Collections.Generic;
using System.IO;

class Program
{
    private static void Main(string[] args)
    {
        try
        {
            // Set a variable to the My Documents path.
            string docPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);

            List<string> dirs = new List<string>(Directory.EnumerateDirectories(docPath));

            foreach (var dir in dirs)
            {
                Console.WriteLine($"{dir.Substring(dir.LastIndexOf(Path.DirectorySeparatorChar) + 1)}");
            }
            Console.WriteLine($"{dirs.Count} directories found.");
        }
        catch (UnauthorizedAccessException ex)
        {
            Console.WriteLine(ex.Message);
        }
        catch (PathTooLongException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}

open System
open System.IO

try
    // Set a variable to the My Documents path.
    let docPath = Environment.GetFolderPath Environment.SpecialFolder.MyDocuments

    let dirs = Directory.EnumerateDirectories docPath |> Seq.toList

    for dir in dirs do
        printfn $"{dir.Substring(dir.LastIndexOf Path.DirectorySeparatorChar + 1)}"
    printfn $"{dirs.Length} directories found."

with
| :? UnauthorizedAccessException as ex ->
    printfn $"{ex.Message}"
| :? PathTooLongException as ex ->
    printfn $"{ex.Message}"

Imports System.Collections.Generic
Imports System.IO

Module Module1

    Sub Main()
        Try
            Dim dirPath As String = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments)

            Dim dirs As List(Of String) = New List(Of String)(Directory.EnumerateDirectories(dirPath))

            For Each folder In dirs
                Console.WriteLine($"{dir.Substring(dir.LastIndexOf(Path.DirectorySeparatorChar) + 1)}")
            Next
            Console.WriteLine($"{dirs.Count} directories found.")
        Catch ex As UnauthorizedAccessException
            Console.WriteLine(ex.Message)
        Catch ex As PathTooLongException
            Console.WriteLine(ex.Message)
        End Try

    End Sub
End Module

Remarks

You can specify relative or absolute path information in the path parameter. Relative path information is interpreted as relative to the current working directory, which you can determine by using the GetCurrentDirectory method. The returned directory names are prefixed with the value you provided in the path parameter. For example, if you provide a relative path in the path parameter, the returned directory names will contain a relative path.

The EnumerateDirectories and GetDirectories methods differ as follows: When you use EnumerateDirectories, you can start enumerating the collection of names before the whole collection is returned; when you use GetDirectories, you must wait for the whole array of names to be returned before you can access the array. Therefore, when you are working with many files and directories, EnumerateDirectories can be more efficient.

The returned collection is not cached; each call to the GetEnumerator on the collection will start a new enumeration.

Applies to

EnumerateDirectories(String, String)

Source:: Directory.cs

Source:: Directory.cs

Source:: Directory.cs

Returns an enumerable collection of directory full names that match a search pattern in a specified path.

public:
 static System::Collections::Generic::IEnumerable<System::String ^> ^ EnumerateDirectories(System::String ^ path, System::String ^ searchPattern);

public static System.Collections.Generic.IEnumerable<string> EnumerateDirectories (string path, string searchPattern);

static member EnumerateDirectories : string * string -> seq<string>

Public Shared Function EnumerateDirectories (path As String, searchPattern As String) As IEnumerable(Of String)

Parameters

path: String

The relative or absolute path to the directory to search. This string is not case-sensitive.

searchPattern: String

The search string to match against the names of directories in path. This parameter can contain a combination of valid literal path and wildcard (* and ?) characters, but it doesn't support regular expressions.

Returns

IEnumerable<String>

An enumerable collection of the full names (including paths) for the directories in the directory specified by path and that match the specified search pattern.

Exceptions

ArgumentException

-or-

searchPattern does not contain a valid pattern.

ArgumentNullException

path is null.

-or-

searchPattern is null.

DirectoryNotFoundException

path is invalid, such as referring to an unmapped drive.

IOException

path is a file name.

PathTooLongException

The specified path, file name, or combined exceed the system-defined maximum length.

SecurityException

The caller does not have the required permission.

UnauthorizedAccessException

The caller does not have the required permission.

Examples

The following example enumerates the top-level directories in a specified path that match a specified search pattern.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;

class Program
{

    private static void Main(string[] args)
    {
        try
        {
            string dirPath = @"\\archives\2009\reports";

            // LINQ query.
            var dirs = from dir in
                     Directory.EnumerateDirectories(dirPath, "dv_*")
                       select dir;

            // Show results.
            foreach (var dir in dirs)
            {
                // Remove path information from string.
                Console.WriteLine("{0}",
                    dir.Substring(dir.LastIndexOf("\\") + 1));
            }
            Console.WriteLine("{0} directories found.",
                dirs.Count<string>().ToString());

            // Optionally create a List collection.
            List<string> workDirs = new List<string>(dirs);
        }
        catch (UnauthorizedAccessException UAEx)
        {
            Console.WriteLine(UAEx.Message);
        }
        catch (PathTooLongException PathEx)
        {
            Console.WriteLine(PathEx.Message);
        }
    }
}

open System
open System.IO

try
    let dirPath = @"\\archives\2009\reports"

    let dirs = 
        Directory.EnumerateDirectories(dirPath, "dv_*")
        |> Seq.cache

    // Show results.
    for dir in dirs do
        // Remove path information from string.
        printfn $"{dir.Substring(dir.LastIndexOf '\\' + 1)}"
    printfn $"{Seq.length dirs} directories found."

    // Optionally create a list collection.
    let workDirs = Seq.toList dirs
    ()
    
with 
| :? UnauthorizedAccessException as uaEx ->
    printfn $"{uaEx.Message}"
| :? PathTooLongException as pathEx ->
    printfn $"{pathEx.Message}"

Imports System.Collections.Generic
Imports System.IO
Imports System.Linq

Module Module1

    Sub Main()
        Try
            Dim dirPath As String = "\\archives\2009\reports"

            ' LINQ query.
            Dim dirs = From folder In _
                Directory.EnumerateDirectories(dirPath, "dv_*")
            For Each folder In dirs
                ' Remove path infomration from string.
                Console.WriteLine("{0}", _
                        folder.Substring(folder.LastIndexOf("\") + 1))
            Next
            Console.WriteLine("{0} directories found.", _
                dirs.Count.ToString())

            ' Optionally create a List collection.
            Dim workDirs As List(Of String) = New List(Of String)

        Catch UAEx As UnauthorizedAccessException
            Console.WriteLine(UAEx.Message)
        Catch PathEx As PathTooLongException
            Console.WriteLine(PathEx.Message)
        End Try
    End Sub
End Module

Remarks

searchPattern can be a combination of literal and wildcard characters, but it doesn't support regular expressions. The following wildcard specifiers are permitted in searchPattern.

Wildcard specifier	Matches
* (asterisk)	Zero or more characters in that position.
? (question mark)	Exactly one character in that position.

Characters other than the wildcard are literal characters. For example, the searchPattern string "*t" searches for all names in path ending with the letter "t". The searchPattern string "s*" searches for all names in path beginning with the letter "s".

searchPattern cannot end in two periods ("..") or contain two periods ("..") followed by DirectorySeparatorChar or AltDirectorySeparatorChar, nor can it contain any invalid characters. You can query for invalid characters by using the GetInvalidPathChars method.

The returned collection is not cached; each call to the GetEnumerator on the collection will start a new enumeration.

Applies to

EnumerateDirectories(String, String, EnumerationOptions)

Source:: Directory.cs

Source:: Directory.cs

Source:: Directory.cs

Returns an enumerable collection of the directory full names that match a search pattern in a specified path, and optionally searches subdirectories.

public:
 static System::Collections::Generic::IEnumerable<System::String ^> ^ EnumerateDirectories(System::String ^ path, System::String ^ searchPattern, System::IO::EnumerationOptions ^ enumerationOptions);

public static System.Collections.Generic.IEnumerable<string> EnumerateDirectories (string path, string searchPattern, System.IO.EnumerationOptions enumerationOptions);

static member EnumerateDirectories : string * string * System.IO.EnumerationOptions -> seq<string>

Public Shared Function EnumerateDirectories (path As String, searchPattern As String, enumerationOptions As EnumerationOptions) As IEnumerable(Of String)

Parameters

path: String

The relative or absolute path to the directory to search. This string is not case-sensitive.

searchPattern: String

enumerationOptions: EnumerationOptions

An object that describes the search and enumeration configuration to use.

Returns

IEnumerable<String>

An enumerable collection of the full names (including paths) for the directories in the directory specified by path and that match the specified search pattern and enumeration options.

Exceptions

ArgumentException

-or-

searchPattern does not contain a valid pattern.

ArgumentNullException

path or searchPattern is null.

ArgumentOutOfRangeException

searchOption is not a valid SearchOption value.

DirectoryNotFoundException

path is invalid, such as referring to an unmapped drive.

IOException

path is a file name.

PathTooLongException

The specified path, file name, or combined exceed the system-defined maximum length.

SecurityException

The caller does not have the required permission.

UnauthorizedAccessException

The caller does not have the required permission.

Remarks

searchPattern can be a combination of literal and wildcard characters, but it doesn't support regular expressions. The following wildcard specifiers are permitted in searchPattern.

Wildcard specifier	Matches
* (asterisk)	Zero or more characters in that position.
? (question mark)	Exactly one character in that position.

The returned collection is not cached; each call to the GetEnumerator on the collection will start a new enumeration.

Applies to

EnumerateDirectories(String, String, SearchOption)

Source:: Directory.cs

Source:: Directory.cs

Source:: Directory.cs

Returns an enumerable collection of directory full names that match a search pattern in a specified path, and optionally searches subdirectories.

public:
 static System::Collections::Generic::IEnumerable<System::String ^> ^ EnumerateDirectories(System::String ^ path, System::String ^ searchPattern, System::IO::SearchOption searchOption);

public static System.Collections.Generic.IEnumerable<string> EnumerateDirectories (string path, string searchPattern, System.IO.SearchOption searchOption);

static member EnumerateDirectories : string * string * System.IO.SearchOption -> seq<string>

Public Shared Function EnumerateDirectories (path As String, searchPattern As String, searchOption As SearchOption) As IEnumerable(Of String)

Parameters

path: String

The relative or absolute path to the directory to search. This string is not case-sensitive.

searchPattern: String

searchOption: SearchOption

One of the enumeration values that specifies whether the search operation should include only the current directory or should include all subdirectories. The default value is TopDirectoryOnly.

Returns

IEnumerable<String>

An enumerable collection of the full names (including paths) for the directories in the directory specified by path and that match the specified search pattern and search option.

Exceptions

ArgumentException

-or-

searchPattern does not contain a valid pattern.

ArgumentNullException

path is null.

-or-

searchPattern is null.

ArgumentOutOfRangeException

searchOption is not a valid SearchOption value.

DirectoryNotFoundException

path is invalid, such as referring to an unmapped drive.

IOException

path is a file name.

PathTooLongException

The specified path, file name, or combined exceed the system-defined maximum length.

SecurityException

The caller does not have the required permission.

UnauthorizedAccessException

The caller does not have the required permission.

Examples

The following example enumerates directories in a specified path that match a specified search pattern. It uses the searchOption parameter to specify that all subdirectories should be included in the search.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;

class Program
{

    private static void Main(string[] args)
    {
        try
        {
            string dirPath = @"\\archives\2009\reports";

            // LINQ query.
            var dirs = from dir in
                     Directory.EnumerateDirectories(dirPath, "dv_*",
                        SearchOption.AllDirectories)
                       select dir;

            // Show results.
            foreach (var dir in dirs)
            {
                // Remove path information from string.
                Console.WriteLine("{0}",
                    dir.Substring(dir.LastIndexOf("\\") + 1));
            }
            Console.WriteLine("{0} directories found.",
                dirs.Count<string>().ToString());

            // Optionally create a List collection.
            List<string> workDirs = new List<string>(dirs);
        }
        catch (UnauthorizedAccessException UAEx)
        {
            Console.WriteLine(UAEx.Message);
        }
        catch (PathTooLongException PathEx)
        {
            Console.WriteLine(PathEx.Message);
        }
    }
}

open System
open System.IO

try
    let dirPath = @"\\archives\2009\reports"

    let dirs =
        Directory.EnumerateDirectories(dirPath, "dv_*", SearchOption.AllDirectories)
        |> Seq.cache

    // Show results.
    for dir in dirs do
        // Remove path information from string.
        printfn $"{dir.Substring(dir.LastIndexOf '\\' + 1)}"
    printfn $"{Seq.length dirs} directories found."

    // Optionally create a List collection.
    let workDirs = Seq.toList dirs
    ()

with 
| :? UnauthorizedAccessException as uaEx ->
    printfn $"{uaEx.Message}"
| :? PathTooLongException as pathEx ->
    printfn $"{pathEx.Message}"

Imports System.Collections.Generic
Imports System.IO
Imports System.Linq

Module Module1

    Sub Main()
        Try
            Dim dirPath As String = "\\archives\2009\reports"

            ' LINQ query.
            Dim dirs = From folder In _
                Directory.EnumerateDirectories(dirPath, "dv_*", _
                    SearchOption.AllDirectories)
            For Each folder In dirs
                ' Remove path infomration from string.
                Console.WriteLine("{0}", _
                        folder.Substring(folder.LastIndexOf("\") + 1))
            Next
            Console.WriteLine("{0} directories found.", _
                dirs.Count.ToString())

            ' Optionally create a List collection.
            Dim workDirs As List(Of String) = New List(Of String)

        Catch UAEx As UnauthorizedAccessException
            Console.WriteLine(UAEx.Message)
        Catch PathEx As PathTooLongException
            Console.WriteLine(PathEx.Message)
        End Try
    End Sub
End Module

Remarks

searchPattern can be a combination of literal and wildcard characters, but it doesn't support regular expressions. The following wildcard specifiers are permitted in searchPattern.

Wildcard specifier	Matches
* (asterisk)	Zero or more characters in that position.
? (question mark)	Exactly one character in that position.

The returned collection is not cached; each call to the GetEnumerator on the collection will start a new enumeration.

Applies to

แชร์ผ่าน

Directory.EnumerateDirectories Method

Definition

Overloads

EnumerateDirectories(String)

Parameters

Returns

Exceptions

Examples

Remarks

Applies to

EnumerateDirectories(String, String)

Parameters

Returns

Exceptions

Examples

Remarks

Applies to

EnumerateDirectories(String, String, EnumerationOptions)

Parameters

Returns

Exceptions

Remarks

Applies to

EnumerateDirectories(String, String, SearchOption)

Parameters

Returns

Exceptions

Examples

Remarks

Applies to

แหล่งทรัพยากรเพิ่มเติม