Editare

Partajați prin


Directory.EnumerateFiles Method

Definition

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

Overloads

EnumerateFiles(String, String, SearchOption)

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

EnumerateFiles(String, String, EnumerationOptions)

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

EnumerateFiles(String)

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

EnumerateFiles(String, String)

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

EnumerateFiles(String, String, SearchOption)

Source:
Directory.cs
Source:
Directory.cs
Source:
Directory.cs

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

public:
 static System::Collections::Generic::IEnumerable<System::String ^> ^ EnumerateFiles(System::String ^ path, System::String ^ searchPattern, System::IO::SearchOption searchOption);
public static System.Collections.Generic.IEnumerable<string> EnumerateFiles (string path, string searchPattern, System.IO.SearchOption searchOption);
static member EnumerateFiles : string * string * System.IO.SearchOption -> seq<string>
Public Shared Function EnumerateFiles (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

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

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

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

Exceptions

.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.

-or-

searchPattern does not contain a valid pattern.

path is null.

-or-

searchPattern is null.

searchOption is not a valid SearchOption value.

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

path is a file name.

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

The caller does not have the required permission.

The caller does not have the required permission.

Examples

The following example shows how to retrieve all the text files in a directory and its subdirectories, and move them to a new directory. After the files are moved, they no longer exist in the original directories.

using System;
using System.IO;

namespace ConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            string sourceDirectory = @"C:\current";
            string archiveDirectory = @"C:\archive";

            try
            {
                var txtFiles = Directory.EnumerateFiles(sourceDirectory, "*.txt", SearchOption.AllDirectories);

                foreach (string currentFile in txtFiles)
                {
                    string fileName = currentFile.Substring(sourceDirectory.Length + 1);
                    Directory.Move(currentFile, Path.Combine(archiveDirectory, fileName));
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
        }
    }
}
open System.IO

let sourceDirectory = @"C:\current"
let archiveDirectory = @"C:\archive"

try
    let txtFiles = Directory.EnumerateFiles(sourceDirectory, "*.txt", SearchOption.AllDirectories)

    for currentFile in txtFiles do
        let fileName = currentFile.Substring(sourceDirectory.Length + 1)
        Directory.Move(currentFile, Path.Combine(archiveDirectory, fileName))
with e ->
    printfn $"{e.Message}"
Imports System.IO

Module Module1

    Sub Main()
        Dim sourceDirectory As String = "C:\current"
        Dim archiveDirectory As String = "C:\archive"

        Try
            Dim txtFiles = Directory.EnumerateFiles(sourceDirectory, "*.txt", SearchOption.AllDirectories)

            For Each currentFile As String In txtFiles
                Dim fileName = currentFile.Substring(sourceDirectory.Length + 1)
                Directory.Move(currentFile, Path.Combine(archiveDirectory, fileName))
            Next
        Catch e As Exception
            Console.WriteLine(e.Message)
        End Try

    End Sub

End Module

The following example recursively enumerates all files that have the extension .txt, reads each line of the file, and displays the line if it contains the string "Microsoft".

using System;
using System.IO;
using System.Linq;

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

            var files = from file in Directory.EnumerateFiles(docPath, "*.txt", SearchOption.AllDirectories)
                        from line in File.ReadLines(file)
                        where line.Contains("Microsoft")
                        select new
                        {
                            File = file,
                            Line = line
                        };

            foreach (var f in files)
            {
                Console.WriteLine($"{f.File}\t{f.Line}");
            }
            Console.WriteLine($"{files.Count().ToString()} files found.");
        }
        catch (UnauthorizedAccessException uAEx)
        {
            Console.WriteLine(uAEx.Message);
        }
        catch (PathTooLongException pathEx)
        {
            Console.WriteLine(pathEx.Message);
        }
    }
}
open System
open System.IO

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

    let files =
        query {
            for file in Directory.EnumerateFiles(docPath, "*.txt", SearchOption.AllDirectories) do
            for line in File.ReadLines file do
            where (line.Contains "Microsoft")
            select {| File = file; Line = line |}
        }

    for f in files do
        printfn $"{f.File}\t{f.Line}"
    printfn $"{Seq.length files} files found."

with
| :? UnauthorizedAccessException as uAEx -> printfn $"{uAEx.Message}"
| :? PathTooLongException as pathEx -> printfn $"{pathEx.Message}"
Imports System.IO
Imports System.Xml.Linq

Module Module1

    Sub Main()
        Try
            Dim docPath As String = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments)
            Dim files = From chkFile In Directory.EnumerateFiles(docPath, "*.txt", SearchOption.AllDirectories)
                        From line In File.ReadLines(chkFile)
                        Where line.Contains("Microsoft")
                        Select New With {.curFile = chkFile, .curLine = line}

            For Each f In files
                Console.WriteLine($"{f.File}\t{f.Line}")
            Next
            Console.WriteLine($"{files.Count} files found.")
        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".

Note

.NET Framework only: When you use the asterisk wildcard character in searchPattern and you specify a three-character file extension, for example, "*.txt", this method also returns files with extensions that begin with the specified extension. For example, the search pattern "*.xls" returns both "book.xls" and "book.xlsx". This behavior only occurs if an asterisk is used in the search pattern and the file extension provided is exactly three characters. If you use the question mark wildcard character somewhere in the search pattern, this method returns only files that match the specified file extension exactly. The following table depicts this anomaly in .NET Framework.

Files in directory Search pattern .NET 5+ returns .NET Framework returns
file.ai, file.aif *.ai file.ai file.ai
book.xls, book.xlsx *.xls book.xls book.xls, book.xlsx
ello.txt, hello.txt, hello.txtt ?ello.txt hello.txt hello.txt

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.

You can specify relative path information with 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 EnumerateFiles and GetFiles methods differ as follows: When you use EnumerateFiles, you can start enumerating the collection of names before the whole collection is returned. When you use GetFiles, 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, EnumerateFiles can be more efficient.

The returned collection is not cached. Each call to the GetEnumerator on the collection starts a new enumeration.

Applies to

EnumerateFiles(String, String, EnumerationOptions)

Source:
Directory.cs
Source:
Directory.cs
Source:
Directory.cs

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

public:
 static System::Collections::Generic::IEnumerable<System::String ^> ^ EnumerateFiles(System::String ^ path, System::String ^ searchPattern, System::IO::EnumerationOptions ^ enumerationOptions);
public static System.Collections.Generic.IEnumerable<string> EnumerateFiles (string path, string searchPattern, System.IO.EnumerationOptions enumerationOptions);
static member EnumerateFiles : string * string * System.IO.EnumerationOptions -> seq<string>
Public Shared Function EnumerateFiles (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

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

enumerationOptions
EnumerationOptions

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

Returns

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

Exceptions

.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.

-or-

searchPattern does not contain a valid pattern.

path is null.

-or-

searchPattern is null.

searchOption is not a valid SearchOption value.

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

path is a file name.

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

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.

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".

Note

.NET Framework only: When you use the asterisk wildcard character in searchPattern and you specify a three-character file extension, for example, "*.txt", this method also returns files with extensions that begin with the specified extension. For example, the search pattern "*.xls" returns both "book.xls" and "book.xlsx". This behavior only occurs if an asterisk is used in the search pattern and the file extension provided is exactly three characters. If you use the question mark wildcard character somewhere in the search pattern, this method returns only files that match the specified file extension exactly. The following table depicts this anomaly in .NET Framework.

Files in directory Search pattern .NET 5+ returns .NET Framework returns
file.ai, file.aif *.ai file.ai file.ai
book.xls, book.xlsx *.xls book.xls book.xls, book.xlsx
ello.txt, hello.txt, hello.txtt ?ello.txt hello.txt hello.txt

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.

You can specify relative path information with 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 EnumerateFiles and GetFiles methods differ as follows: When you use EnumerateFiles, you can start enumerating the collection of names before the whole collection is returned. When you use GetFiles, 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, EnumerateFiles can be more efficient.

The returned collection is not cached. Each call to the GetEnumerator on the collection starts a new enumeration.

Applies to

EnumerateFiles(String)

Source:
Directory.cs
Source:
Directory.cs
Source:
Directory.cs

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

public:
 static System::Collections::Generic::IEnumerable<System::String ^> ^ EnumerateFiles(System::String ^ path);
public static System.Collections.Generic.IEnumerable<string> EnumerateFiles (string path);
static member EnumerateFiles : string -> seq<string>
Public Shared Function EnumerateFiles (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

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

Exceptions

.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.

path is null.

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

path is a file name.

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

The caller does not have the required permission.

The caller does not have the required permission.

Examples

The following example shows how to retrieve all the files in a directory and move them to a new directory. After the files are moved, they no longer exist in the original directory.

using System;
using System.IO;

namespace ConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            string sourceDirectory = @"C:\current";
            string archiveDirectory = @"C:\archive";

            try
            {
                var txtFiles = Directory.EnumerateFiles(sourceDirectory);

                foreach (string currentFile in txtFiles)
                {
                    string fileName = currentFile.Substring(sourceDirectory.Length + 1);
                    Directory.Move(currentFile, Path.Combine(archiveDirectory, fileName));
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
        }
    }
}
open System.IO

let sourceDirectory = @"C:\current"
let archiveDirectory = @"C:\archive"

try
    let txtFiles = Directory.EnumerateFiles sourceDirectory

    for currentFile in txtFiles do
        let fileName = currentFile.Substring(sourceDirectory.Length + 1)
        Directory.Move(currentFile, Path.Combine(archiveDirectory, fileName))
with e ->
    printfn $"{e.Message}"
Imports System.IO

Module Module1

    Sub Main()
        Dim sourceDirectory As String = "C:\current"
        Dim archiveDirectory As String = "C:\archive"

        Try
            Dim txtFiles = Directory.EnumerateFiles(sourceDirectory)

            For Each currentFile As String In txtFiles
                Dim fileName = currentFile.Substring(sourceDirectory.Length + 1)
                Directory.Move(currentFile, Path.Combine(archiveDirectory, fileName))
            Next
        Catch e As Exception
            Console.WriteLine(e.Message)
        End Try

    End Sub

End Module

The following example enumerates the files in the specified directory, reads each line of the file, and displays the line if it contains the string "Europe".

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

class Program
{
    static void Main(string[] args)
    {
        try
        {
            // LINQ query for all files containing the word 'Europe'.
            var files = from file in
                Directory.EnumerateFiles(@"\\archives1\library\")
                where file.ToLower().Contains("europe")
                select file;

            foreach (var file in files)
            {
                Console.WriteLine("{0}", file);
            }
            Console.WriteLine("{0} files found.", files.Count<string>().ToString());
        }
        catch (UnauthorizedAccessException UAEx)
        {
            Console.WriteLine(UAEx.Message);
        }
        catch (PathTooLongException PathEx)
        {
            Console.WriteLine(PathEx.Message);
        }
    }
}
open System
open System.IO

try
    // All files containing the word 'Europe'.
    let files =
        Directory.EnumerateFiles @"\\archives1\library\"
        |> Seq.filter (fun file -> file.ToLower().Contains "europe")

    for file in files do
        printfn $"{file}"
    printfn $"{Seq.length files} files found."

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

Module Module1

    Sub Main()
        Try
            ' LINQ query for all files containing the word 'Europe'.
            Dim files = From file In Directory.EnumerateFiles("\\archives1\library\")
                Where file.ToLower().Contains("europe")

            For Each file In files
                Console.WriteLine("{0}", file)
            Next
            Console.WriteLine("{0} files found.", files.Count.ToString())
        Catch UAEx As UnauthorizedAccessException
            Console.WriteLine(UAEx.Message)
        Catch PathEx As PathTooLongException
            Console.WriteLine(PathEx.Message)
        End Try
    End Sub

End Module

Remarks

You can specify relative path information with 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 EnumerateFiles and GetFiles methods differ as follows: When you use EnumerateFiles, you can start enumerating the collection of names before the whole collection is returned. When you use GetFiles, 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, EnumerateFiles 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

EnumerateFiles(String, String)

Source:
Directory.cs
Source:
Directory.cs
Source:
Directory.cs

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

public:
 static System::Collections::Generic::IEnumerable<System::String ^> ^ EnumerateFiles(System::String ^ path, System::String ^ searchPattern);
public static System.Collections.Generic.IEnumerable<string> EnumerateFiles (string path, string searchPattern);
static member EnumerateFiles : string * string -> seq<string>
Public Shared Function EnumerateFiles (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 files in path. This parameter can contain a combination of valid literal path and wildcard (* and ?) characters, but it doesn't support regular expressions.

Returns

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

Exceptions

.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.

-or-

searchPattern does not contain a valid pattern.

path is null.

-or-

searchPattern is null.

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

path is a file name.

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

The caller does not have the required permission.

The caller does not have the required permission.

Examples

The following example shows how to retrieve all the text files in a directory and move them to a new directory. After the files are moved, they no longer exist in the original directory.

using System;
using System.IO;

namespace ConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            string sourceDirectory = @"C:\current";
            string archiveDirectory = @"C:\archive";

            try
            {
                var txtFiles = Directory.EnumerateFiles(sourceDirectory, "*.txt");

                foreach (string currentFile in txtFiles)
                {
                    string fileName = currentFile.Substring(sourceDirectory.Length + 1);
                    Directory.Move(currentFile, Path.Combine(archiveDirectory, fileName));
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
        }
    }
}
open System.IO

let sourceDirectory = @"C:\current"
let archiveDirectory = @"C:\archive"

try
    let txtFiles = Directory.EnumerateFiles(sourceDirectory, "*.txt")

    for currentFile in txtFiles do
        let fileName = currentFile.Substring(sourceDirectory.Length + 1)
        Directory.Move(currentFile, Path.Combine(archiveDirectory, fileName))

with e ->
    printfn $"{e.Message}"
Imports System.IO

Module Module1

    Sub Main()
        Dim sourceDirectory As String = "C:\current"
        Dim archiveDirectory As String = "C:\archive"

        Try
            Dim txtFiles = Directory.EnumerateFiles(sourceDirectory, "*.txt")

            For Each currentFile As String In txtFiles
                Dim fileName = currentFile.Substring(sourceDirectory.Length + 1)
                Directory.Move(currentFile, Path.Combine(archiveDirectory, fileName))
            Next
        Catch e As Exception
            Console.WriteLine(e.Message)
        End Try
    End Sub

End Module

The following example enumerates the files in the specified directory that have a ".txt" extension, reads each line of the file, and displays the line if it contains the string "Europe".

using System;
using System.Linq;
using System.IO;

class Program
{
    static void Main(string[] args)
    {
        try
        {
            // LINQ query for all .txt files containing the word 'Europe'.
            var files = from file in Directory.EnumerateFiles(@"\\archives1\library\", "*.txt")
                where file.ToLower().Contains("europe")
                select file;

            foreach (var file in files)
            {
                Console.WriteLine("{0}", file);
            }
            Console.WriteLine("{0} files found.", files.Count<string>().ToString());
        }
            
        catch (UnauthorizedAccessException UAEx)
        {
            Console.WriteLine(UAEx.Message);
        }
        catch (PathTooLongException PathEx)
        {
            Console.WriteLine(PathEx.Message);
        }
    }
}
open System
open System.IO

try
    // All .txt files containing the word 'Europe'.
    let files = 
        Directory.EnumerateFiles(@"\\archives1\library\", "*.txt")
        |> Seq.filter(fun file -> file.ToLower().Contains "europe")

    for file in files do
        printfn $"{file}"
    printfn $"{Seq.length files} files found."

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

Module Module1

    Sub Main()
        Try
            ' LINQ query for all .txt files containing the word 'Europe'.
            Dim files = From file In Directory.EnumerateFiles("\\archives1\library\", "*.txt")
                Where file.ToLower().Contains("europe")

            For Each file In files
                Console.WriteLine("{0}", file)
            Next
            Console.WriteLine("{0} files found.", files.Count.ToString())
        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".

Note

.NET Framework only: When you use the asterisk wildcard character in searchPattern and you specify a three-character file extension, for example, "*.txt", this method also returns files with extensions that begin with the specified extension. For example, the search pattern "*.xls" returns both "book.xls" and "book.xlsx". This behavior only occurs if an asterisk is used in the search pattern and the file extension provided is exactly three characters. If you use the question mark wildcard character somewhere in the search pattern, this method returns only files that match the specified file extension exactly. The following table depicts this anomaly in .NET Framework.

Files in directory Search pattern .NET 5+ returns .NET Framework returns
file.ai, file.aif *.ai file.ai file.ai
book.xls, book.xlsx *.xls book.xls book.xls, book.xlsx
ello.txt, hello.txt, hello.txtt ?ello.txt hello.txt hello.txt

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.

You can specify relative path information with 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 EnumerateFiles and GetFiles methods differ as follows: When you use EnumerateFiles, you can start enumerating the collection of names before the whole collection is returned; when you use GetFiles, 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, EnumerateFiles can be more efficient.

The returned collection is not cached. Each call to the GetEnumerator on the collection starts a new enumeration.

Applies to