Directory.EnumerateFiles Método

Definição

Espaço de Nomes:: System.IO

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

Assemblagens:: netstandard.dll, System.Runtime.dll

Assemblagens:: netstandard.dll, System.IO.FileSystem.dll

Assemblagens:: netstandard.dll, System.IO.FileSystem.dll, System.Runtime.dll

Assemblagem:: System.IO.FileSystem.dll

Assemblagem:: mscorlib.dll

Assemblagem:: netstandard.dll

Importante

Algumas informações dizem respeito a um produto pré-lançado que pode ser substancialmente modificado antes de ser lançado. A Microsoft não faz garantias, de forma expressa ou implícita, em relação à informação aqui apresentada.

Devolve uma coleção enumerável de nomes completos de ficheiros que cumprem critérios especificados.

Sobrecargas

Name	Description
EnumerateFiles(String, String, SearchOption)	Devolve uma coleção enumerável de nomes completos de ficheiros que correspondem a um padrão de pesquisa num caminho especificado e, opcionalmente, pesquisa subdiretórios.
EnumerateFiles(String, String, EnumerationOptions)	Devolve uma coleção enumerável de nomes completos de ficheiros que correspondem a um padrão de pesquisa e opções de enumeração num caminho especificado, e opcionalmente pesquisa subdiretórios.
EnumerateFiles(String)	Devolve uma coleção enumerável de nomes completos de ficheiros num caminho especificado.
EnumerateFiles(String, String)	Devolve uma coleção enumerável de nomes completos de ficheiros que correspondem a um padrão de pesquisa num caminho especificado.

EnumerateFiles(String, String, SearchOption)

Origem:: Directory.cs

Origem:: Directory.cs

Origem:: Directory.cs

Origem:: Directory.cs

Origem:: Directory.cs

Devolve uma coleção enumerável de nomes completos de ficheiros que correspondem a um padrão de pesquisa num caminho especificado e, opcionalmente, pesquisa subdiretórios.

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)

Parâmetros

path: String

O caminho relativo ou absoluto para o diretório a pesquisar. Esta cadeia não é sensível a maiúsculas minúsculas.

searchPattern: String

A cadeia de pesquisa para comparar com os nomes dos ficheiros em path. Este parâmetro pode conter uma combinação de caracteres válidos de path literais e wildcard (* e ?), mas não suporta expressões regulares.

searchOption: SearchOption

Um dos valores de enumeração que especifica se a operação de pesquisa deve incluir apenas o diretório atual ou deve incluir todos os subdiretórios. O valor predefinido é TopDirectoryOnly.

Devoluções

IEnumerable<String>

Uma coleção enumerável dos nomes completos (incluindo caminhos) dos ficheiros no diretório especificados por path e que correspondem ao padrão de pesquisa e à opção de pesquisa especificados.

Exceções

ArgumentException

.NET Framework e .NET Core versões anteriores à 2.1: path é uma string de comprimento zero, contém apenas espaço em branco ou contém caracteres inválidos. Pode consultar caracteres inválidos usando o GetInvalidPathChars() método.

-ou-

searchPattern não contém um padrão válido.

ArgumentNullException

path é null.

-ou-

searchPattern é null.

ArgumentOutOfRangeException

searchOption não é um valor válido SearchOption .

DirectoryNotFoundException

path é inválido, como referir-se a um disco não mapeado.

IOException

path é um nome de ficheiro.

PathTooLongException

O caminho, nome do ficheiro ou combinação especificados excedem o comprimento máximo definido pelo sistema.

SecurityException

O interlocutor não tem a permissão necessária.

UnauthorizedAccessException

O interlocutor não tem a permissão necessária.

Exemplos

O exemplo seguinte mostra como recuperar todos os ficheiros de texto de um diretório e dos seus subdiretórios, e movê-los para um novo diretório. Depois de os ficheiros serem transferidos, deixam de existir nos diretórios originais.

using System;
using System.IO;

partial class Example1
{
    static void SearchOptionExample()
    {
        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

Partial Class Example1
    Shared Sub SearchOptionsExample()

        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 Class

O exemplo seguinte enumera recursivamente todos os ficheiros que têm a extensão .txt, lê cada linha do ficheiro e mostra a linha se esta contiver a cadeia "Microsoft".

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

partial class Example2
{
    static void SearchOptionExample()
    {
        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()} 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

Partial Class Example2
    Shared Sub SearchOptionExample()

        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.curFile}\t{f.curLine}")
            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 Class

Observações

searchPattern pode ser uma combinação de caracteres literais e coringa, mas não suporta expressões regulares. Os seguintes indicadores de wildcard são permitidos em searchPattern.

Especificador de coringa	Resultados correspondentes
* (asterisco)	Zero ou mais personagens nessa posição.
? (ponto de interrogação)	Exatamente uma personagem nessa posição.

Personagens que não sejam o coringa são personagens literais. Por exemplo, a searchPattern cadeia "*t" procura todos os nomes que path terminam com a letra "t". A searchPattern cadeia "s*" procura todos os nomes começando path pela letra "s".

Note

.NET Framework apenas: Quando usa o carácter coringa asterisco em searchPattern e especifica uma extensão de ficheiro de três caracteres, por exemplo, "*.txt", este método também devolve ficheiros com extensões que begin com a extensão especificada. Por exemplo, o padrão de pesquisa "*.xls" devolve tanto "book.xls" como "book.xlsx". Este comportamento só ocorre se for usado um asterisco no padrão de pesquisa e a extensão do ficheiro fornecida for exatamente de três caracteres. Se usar o carácter coringa de ponto de interrogação em algum ponto do padrão de pesquisa, este método devolve apenas ficheiros que correspondem exatamente à extensão de ficheiro especificada. A tabela seguinte mostra esta anomalia no .NET Framework.

Ficheiros no diretório	Padrão de pesquisa	.NET 5+ retorna	Retornos do framework .NET
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 não pode terminar em dois períodos ("..") nem conter dois períodos ("..") seguidos de DirectorySeparatorChar ou AltDirectorySeparatorChar, nem pode conter caracteres inválidos. Pode consultar caracteres inválidos usando o GetInvalidPathChars método.

Pode especificar a informação relativa do caminho com o path parâmetro. A informação relativa do caminho é interpretada como relativa ao diretório de trabalho atual, que pode determinar usando o GetCurrentDirectory método.

Os EnumerateFiles métodos e GetFiles diferem da seguinte forma: Quando usa EnumerateFiles, pode começar a enumerar a coleção de nomes antes de a coleção completa ser devolvida. Quando usa GetFiles, tem de esperar que todo o array de nomes seja devolvido antes de poder aceder ao array. Por isso, quando trabalha com muitos ficheiros e diretórios, EnumerateFiles pode ser mais eficiente.

A coleção devolvida não é armazenada em cache. Cada chamada para a GetEnumerator coleção inicia uma nova enumeração.

Aplica-se a

EnumerateFiles(String, String, EnumerationOptions)

Origem:: Directory.cs

Origem:: Directory.cs

Origem:: Directory.cs

Origem:: Directory.cs

Origem:: Directory.cs

Devolve uma coleção enumerável de nomes completos de ficheiros que correspondem a um padrão de pesquisa e opções de enumeração num caminho especificado, e opcionalmente pesquisa subdiretórios.

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)

Parâmetros

path: String

O caminho relativo ou absoluto para o diretório a pesquisar. Esta cadeia não é sensível a maiúsculas minúsculas.

searchPattern: String

enumerationOptions: EnumerationOptions

Um objeto que descreve a configuração de pesquisa e enumeração a utilizar.

Devoluções

IEnumerable<String>

Uma coleção enumerável dos nomes completos (incluindo caminhos) dos ficheiros no diretório especificados por path e que correspondem ao padrão de pesquisa e às opções de enumeração especificados.

Exceções

ArgumentException

-ou-

searchPattern não contém um padrão válido.

ArgumentNullException

path é null.

-ou-

searchPattern é null.

DirectoryNotFoundException

path é inválido, como referir-se a um disco não mapeado.

IOException

path é um nome de ficheiro.

PathTooLongException

O caminho, nome do ficheiro ou combinação especificados excedem o comprimento máximo definido pelo sistema.

UnauthorizedAccessException

O interlocutor não tem a permissão necessária.

Exemplos

O exemplo seguinte mostra como recuperar todos os ficheiros de texto de um diretório e dos seus subdiretórios e movê-los para um novo diretório. Depois de os ficheiros serem transferidos, deixam de existir nos diretórios originais.

using System;
using System.IO;

partial class Example1
{
    static void EnumerationOptionsExample()
    {
        string sourceDirectory = @"C:\current";
        string archiveDirectory = @"C:\archive";

        var options = new EnumerationOptions
        {
            MatchCasing = MatchCasing.CaseInsensitive,
            MatchType = MatchType.Simple,
            RecurseSubdirectories = true
        };

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

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

open System.IO

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

let options = new EnumerationOptions(
    MatchCasing = MatchCasing.CaseInsensitive,
    MatchType = MatchType.Simple,
    RecurseSubdirectories = true
)

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

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

Imports System.IO

Partial Class Example1
    Shared Sub EnumerationOptionsExample()

        Dim sourceDirectory As String = "C:\current"
        Dim archiveDirectory As String = "C:\archive"

        Dim options As New EnumerationOptions() With {
            .MatchCasing = MatchCasing.CaseInsensitive,
            .MatchType = MatchType.Simple,
            .RecurseSubdirectories = True
        }

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

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

    End Sub
End Class

O exemplo seguinte enumera recursivamente todos os ficheiros com a .txt extensão, ignorando diretórios e ficheiros inacessíveis. Lê cada linha do ficheiro e apresenta a linha se esta contiver a cadeia "Microsoft".

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

partial class Example2
{
    static void EnumerationOptionsExample()
    {
        try
        {
            // Set a variable to the My Documents path.
            string docPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);

            // Set the options for the enumeration.
            var options = new EnumerationOptions
            {
                IgnoreInaccessible = true,
                MatchCasing = MatchCasing.CaseInsensitive,
                MatchType = MatchType.Simple,
                RecurseSubdirectories = true
            };

            var files = from file in Directory.EnumerateFiles(docPath, "*.txt", options)
                        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()} files found.");
        }
        catch (PathTooLongException pathEx)
        {
            Console.WriteLine(pathEx.Message);
        }
        catch (Exception 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

    // Set the options for the enumeration.
    let options = new EnumerationOptions(
        IgnoreInaccessible = true,
        MatchCasing = MatchCasing.CaseInsensitive,
        MatchType = MatchType.Simple,
        RecurseSubdirectories = true
    )

    let files =
        query {
            for file in Directory.EnumerateFiles(docPath, "*.txt", options) 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
| :? PathTooLongException as pathEx -> printfn $"{pathEx.Message}"
| ex -> printfn $"{ex.Message}"

Imports System.IO
Imports System.Xml.Linq

Partial Class Example2
    Shared Sub EnumerationOptionsExample()

        Try
            ' Set a variable to the My Documents Path.
            Dim docPath As String = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments)

            ' Set the options for the enumeration.
            Dim options As New EnumerationOptions() With {
                .IgnoreInaccessible = True,
                .MatchCasing = MatchCasing.CaseInsensitive,
                .MatchType = MatchType.Simple,
                .RecurseSubdirectories = True
            }

            Dim files = From chkFile In Directory.EnumerateFiles(docPath, "*.txt", options)
                        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.curFile}\t{f.curLine}")
            Next

            Console.WriteLine($"{files.Count} files found.")
        Catch pathEx As PathTooLongException
            Console.WriteLine(pathEx.Message)
        Catch ex As Exception
            Console.WriteLine(ex.Message)
        End Try

    End Sub
End Class

Observações

searchPattern pode ser uma combinação de caracteres literais e coringa, mas não suporta expressões regulares. Os seguintes indicadores de wildcard são permitidos em searchPattern.

Especificador de coringa	Resultados correspondentes
* (asterisco)	Zero ou mais personagens nessa posição.
? (ponto de interrogação)	Exatamente uma personagem nessa posição.

Note

Ficheiros no diretório	Padrão de pesquisa	.NET 5+ retorna	Retornos do framework .NET
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

A coleção devolvida não é armazenada em cache. Cada chamada para a GetEnumerator coleção inicia uma nova enumeração.

Aplica-se a

EnumerateFiles(String)

Origem:: Directory.cs

Origem:: Directory.cs

Origem:: Directory.cs

Origem:: Directory.cs

Origem:: Directory.cs

Devolve uma coleção enumerável de nomes completos de ficheiros num caminho especificado.

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)

Parâmetros

path: String

O caminho relativo ou absoluto para o diretório a pesquisar. Esta cadeia não é sensível a maiúsculas minúsculas.

Devoluções

IEnumerable<String>

Uma coleção enumerável dos nomes completos (incluindo caminhos) para os ficheiros no diretório especificado por path.

Exceções

ArgumentException

ArgumentNullException

path é null.

DirectoryNotFoundException

path é inválido, como referir-se a um disco não mapeado.

IOException

path é um nome de ficheiro.

PathTooLongException

O caminho, nome do ficheiro ou combinação especificados excedem o comprimento máximo definido pelo sistema.

SecurityException

O interlocutor não tem a permissão necessária.

UnauthorizedAccessException

O interlocutor não tem a permissão necessária.

Exemplos

O exemplo seguinte mostra como recuperar todos os ficheiros de um diretório e movê-los para um novo diretório. Depois de os ficheiros serem movidos, deixam de existir no diretório original.

using System;
using System.IO;

partial class Example1
{
    static void OneStringExample()
    {
        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

Partial Class Example1
    Shared Sub OneStringExample()

        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 Class

O exemplo seguinte enumera os ficheiros no diretório especificado, lê cada linha do ficheiro e mostra a linha se esta contiver a cadeia "Europe".

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

partial class Example2
{
    static void OneStringExample()
    {
        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

Partial Class Example2
    Shared Sub OneStringExample()

        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 Class

Observações

A coleção devolvida não é armazenada em cache; Cada chamada à GetEnumerator coleção iniciará uma nova enumeração.

Aplica-se a

EnumerateFiles(String, String)

Origem:: Directory.cs

Origem:: Directory.cs

Origem:: Directory.cs

Origem:: Directory.cs

Origem:: Directory.cs

Devolve uma coleção enumerável de nomes completos de ficheiros que correspondem a um padrão de pesquisa num caminho especificado.

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)

Parâmetros

path: String

O caminho relativo ou absoluto para o diretório a pesquisar. Esta cadeia não é sensível a maiúsculas minúsculas.

searchPattern: String

Devoluções

IEnumerable<String>

Uma coleção enumerável dos nomes completos (incluindo caminhos) dos ficheiros no diretório especificados por path e que correspondem ao padrão de pesquisa especificado.

Exceções

ArgumentException

-ou-

searchPattern não contém um padrão válido.

ArgumentNullException

path é null.

-ou-

searchPattern é null.

DirectoryNotFoundException

path é inválido, como referir-se a um disco não mapeado.

IOException

path é um nome de ficheiro.

PathTooLongException

O caminho, nome do ficheiro ou combinação especificados excedem o comprimento máximo definido pelo sistema.

SecurityException

O interlocutor não tem a permissão necessária.

UnauthorizedAccessException

O interlocutor não tem a permissão necessária.

Exemplos

O exemplo seguinte mostra como recuperar todos os ficheiros de texto de um diretório e movê-los para um novo diretório. Depois de os ficheiros serem movidos, deixam de existir no diretório original.

using System;
using System.IO;

partial class Example1
{
    static void TwoStringsExample()
    {
        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

Partial Class Example1
    Shared Sub TwoStringExample()

        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 Class

O exemplo seguinte enumera os ficheiros no diretório especificado que têm uma extensão ".txt", lê cada linha do ficheiro e apresenta a linha se esta contiver a cadeia "Europe".

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

partial class Example2
{
    static void TwoStringsExample()
    {
        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

Partial Class Example2
    Shared Sub TwoStringsExample()

        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 Class

Observações

searchPattern pode ser uma combinação de caracteres literais e coringa, mas não suporta expressões regulares. Os seguintes indicadores de wildcard são permitidos em searchPattern.

Especificador de coringa	Resultados correspondentes
* (asterisco)	Zero ou mais personagens nessa posição.
? (ponto de interrogação)	Exatamente uma personagem nessa posição.

Note

Ficheiros no diretório	Padrão de pesquisa	.NET 5+ retorna	Retornos do framework .NET
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

Os EnumerateFiles métodos e GetFiles diferem da seguinte forma: Quando usa EnumerateFiles, pode começar a enumerar a coleção de nomes antes de a coleção completa ser devolvida; quando usar GetFiles, deve esperar que todo o array de nomes seja devolvido antes de poder aceder ao array. Por isso, quando trabalha com muitos ficheiros e diretórios, EnumerateFiles pode ser mais eficiente.

A coleção devolvida não é armazenada em cache. Cada chamada para a GetEnumerator coleção inicia uma nova enumeração.

Aplica-se a

Comentários

Esta página foi útil?