Compartir a través de


Directory.EnumerateFiles Método

Definición

Devuelve una colección enumerable de nombres completos de archivo que satisfacen los criterios especificados.

Sobrecargas

EnumerateFiles(String, String, SearchOption)

Devuelve una colección enumerable de nombres completos de archivo que coinciden con un patrón de búsqueda en una ruta de acceso especificada y, opcionalmente, busca en subdirectorios.

EnumerateFiles(String, String, EnumerationOptions)

Devuelve una colección enumerable de nombres completos de archivos que coinciden con un patrón de búsqueda y con opciones de enumeración en una ruta de acceso especificada y, opcionalmente, busca en subdirectorios.

EnumerateFiles(String)

Devuelve una colección enumerable de nombres completos de archivo en una ruta de acceso especificada.

EnumerateFiles(String, String)

Devuelve una colección enumerable de nombres completos de archivo que coinciden con un patrón de búsqueda en una ruta de acceso especificada.

EnumerateFiles(String, String, SearchOption)

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

Devuelve una colección enumerable de nombres completos de archivo que coinciden con un patrón de búsqueda en una ruta de acceso especificada y, opcionalmente, busca en subdirectorios.

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

La ruta de acceso absoluta o relativa al directorio que se va a buscar. Esta cadena no distingue entre mayúsculas y minúsculas.

searchPattern
String

Cadena de búsqueda que debe coincidir con los nombres de los archivos de path. Este parámetro puede contener una combinación de ruta de acceso literal válida y caracteres comodín (* y ?), pero no admite expresiones regulares.

searchOption
SearchOption

Uno de los valores de enumeración que especifica si la operación de búsqueda debe incluir solo el directorio actual o debe incluir todos los subdirectorios. El valor predeterminado es TopDirectoryOnly.

Devoluciones

Una colección enumerable de nombres completos (con sus rutas de acceso) de los archivos del directorio especificado por path y que coinciden con el patrón de búsqueda y las opciones de búsqueda especificados.

Excepciones

Versiones de .NET Framework y .NET Core anteriores a 2.1: path es una cadena de longitud cero, contiene solo espacios en blanco o contiene caracteres no válidos. Puede consultar los caracteres no válidos con el método GetInvalidPathChars().

O bien

searchPattern no contiene un patrón válido.

path es null.

O bien

searchPattern es null.

searchOption no es un valor SearchOption válido.

path no es válido, como hacer referencia a una unidad no asignada.

path es un nombre del archivo.

La ruta de acceso especificada, el nombre de archivo o ambos combinados superan la longitud máxima definida por el sistema.

El llamador no dispone del permiso requerido.

El llamador no dispone del permiso requerido.

Ejemplos

En el ejemplo siguiente se muestra cómo recuperar todos los archivos de texto de un directorio y sus subdirectorios, y moverlos a un directorio nuevo. Después de mover los archivos, ya no existen en los directorios originales.

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

En el ejemplo siguiente se enumeran de forma recursiva todos los archivos que tienen la extensión .txt, se lee cada línea del archivo y se muestra la línea si contiene la cadena "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

Comentarios

searchPattern puede ser una combinación de caracteres literales y comodín, pero no admite expresiones regulares. Los siguientes especificadores de caracteres comodín se permiten en searchPattern.

Especificador de caracteres comodín Coincide
* (asterisco) Cero o más caracteres en esa posición.
? (signo de interrogación) Exactamente un carácter en esa posición.

Los caracteres distintos del carácter comodín son caracteres literales. Por ejemplo, la searchPattern cadena "*t" busca todos los nombres al path terminar con la letra "t". La searchPattern cadena "s*" busca todos los nombres path a partir de la letra "s".

Nota

Solo .NET Framework: Cuando se usa el carácter comodín de asterisco en searchPattern y se especifica una extensión de archivo de tres caracteres, por ejemplo, "*.txt", este método también devuelve archivos con extensiones que comienzan por la extensión especificada. Por ejemplo, el patrón de búsqueda "*.xls" devuelve "book.xls" y "book.xlsx". Este comportamiento solo se produce si se usa un asterisco en el patrón de búsqueda y la extensión de archivo proporcionada es exactamente tres caracteres. Si usa el carácter comodín de signo de interrogación en algún lugar del patrón de búsqueda, este método devuelve solo los archivos que coinciden exactamente con la extensión de archivo especificada. En la tabla siguiente se muestra esta anomalía en .NET Framework.

Archivos en el directorio Patrón de búsqueda Devuelve .NET 5+ Devuelve .NET Framework
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 no puede terminar en dos puntos ("..") ni contener dos puntos ("..") seguidos de DirectorySeparatorChar o AltDirectorySeparatorChar, ni puede contener caracteres no válidos. Puede consultar los caracteres no válidos con el método GetInvalidPathChars.

Puede especificar información de ruta de acceso relativa con el path parámetro . La información de ruta de acceso relativa se interpreta como relativa al directorio de trabajo actual, que puede determinar mediante el GetCurrentDirectory método .

Los EnumerateFiles métodos y GetFiles difieren de la siguiente manera: cuando se usa EnumerateFiles, puede empezar a enumerar la colección de nombres antes de que se devuelva toda la colección. Cuando se usa GetFiles, debe esperar a que se devuelva toda la matriz de nombres para poder acceder a la matriz. Por lo tanto, cuando se trabaja con muchos archivos y directorios, EnumerateFiles puede ser más eficaz.

La colección devuelta no se almacena en caché. Cada llamada a GetEnumerator en la colección inicia una nueva enumeración.

Se aplica a

EnumerateFiles(String, String, EnumerationOptions)

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

Devuelve una colección enumerable de nombres completos de archivos que coinciden con un patrón de búsqueda y con opciones de enumeración en una ruta de acceso especificada y, opcionalmente, busca en subdirectorios.

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

La ruta de acceso absoluta o relativa al directorio que se va a buscar. Esta cadena no distingue entre mayúsculas y minúsculas.

searchPattern
String

Cadena de búsqueda que debe coincidir con los nombres de los archivos de path. Este parámetro puede contener una combinación de ruta de acceso literal válida y caracteres comodín (* y ?), pero no admite expresiones regulares.

enumerationOptions
EnumerationOptions

Un objeto que describe la configuración de búsqueda y enumeración que se va a usar.

Devoluciones

Una colección enumerable de nombres completos (con sus rutas de acceso) de los archivos del directorio especificado por path y que coinciden con el patrón de búsqueda y las opciones de enumeración especificados.

Excepciones

Versiones de .NET Framework y .NET Core anteriores a 2.1: path es una cadena de longitud cero, contiene solo espacios en blanco o contiene caracteres no válidos. Puede consultar los caracteres no válidos con el método GetInvalidPathChars().

O bien

searchPattern no contiene un patrón válido.

path es null.

O bien

searchPattern es null.

searchOption no es un valor SearchOption válido.

path no es válido, como hacer referencia a una unidad no asignada.

path es un nombre del archivo.

La ruta de acceso especificada, el nombre de archivo o ambos combinados superan la longitud máxima definida por el sistema.

El llamador no dispone del permiso requerido.

Comentarios

searchPattern puede ser una combinación de caracteres literales y comodín, pero no admite expresiones regulares. Los siguientes especificadores de caracteres comodín se permiten en searchPattern.

Especificador de caracteres comodín Coincide
* (asterisco) Cero o más caracteres en esa posición.
? (signo de interrogación) Exactamente un carácter en esa posición.

Los caracteres distintos del carácter comodín son caracteres literales. Por ejemplo, la searchPattern cadena "*t" busca todos los nombres al path terminar con la letra "t". La searchPattern cadena "s*" busca todos los nombres a path partir de la letra "s".

Nota

Solo .NET Framework: Cuando se usa el carácter comodín asterisco en searchPattern y se especifica una extensión de archivo de tres caracteres, por ejemplo, "*.txt", este método también devuelve archivos con extensiones que comienzan con la extensión especificada. Por ejemplo, el patrón de búsqueda "*.xls" devuelve "book.xls" y "book.xlsx". Este comportamiento solo se produce si se usa un asterisco en el patrón de búsqueda y la extensión de archivo proporcionada es exactamente tres caracteres. Si usa el carácter comodín de signo de interrogación en algún lugar del patrón de búsqueda, este método devuelve solo los archivos que coinciden exactamente con la extensión de archivo especificada. En la tabla siguiente se muestra esta anomalía en .NET Framework.

Archivos en el directorio Patrón de búsqueda Devuelve .NET 5+ Devuelve .NET Framework
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 no puede terminar en dos puntos ("..") ni contener dos puntos ("..") seguidos de DirectorySeparatorChar o AltDirectorySeparatorChar, ni puede contener caracteres no válidos. Puede consultar los caracteres no válidos con el método GetInvalidPathChars.

Puede especificar información de ruta de acceso relativa con el path parámetro . La información de ruta de acceso relativa se interpreta como relativa al directorio de trabajo actual, que puede determinar mediante el GetCurrentDirectory método .

Los EnumerateFiles métodos y GetFiles difieren de la siguiente manera: cuando se usa EnumerateFiles, puede empezar a enumerar la colección de nombres antes de que se devuelva toda la colección. Cuando se usa GetFiles, debe esperar a que se devuelva toda la matriz de nombres para poder acceder a la matriz. Por lo tanto, cuando se trabaja con muchos archivos y directorios, EnumerateFiles puede ser más eficaz.

La colección devuelta no se almacena en caché. Cada llamada a en GetEnumerator la colección inicia una nueva enumeración.

Se aplica a

EnumerateFiles(String)

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

Devuelve una colección enumerable de nombres completos de archivo en una ruta de acceso especificada.

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

La ruta de acceso absoluta o relativa al directorio que se va a buscar. Esta cadena no distingue entre mayúsculas y minúsculas.

Devoluciones

Una colección enumerable de nombres completos (con sus rutas de acceso) para los archivos en el directorio especificado por path.

Excepciones

Versiones de .NET Framework y .NET Core anteriores a 2.1: path es una cadena de longitud cero, solo contiene espacios en blanco o contiene caracteres no válidos. Puede consultar los caracteres no válidos con el método GetInvalidPathChars().

path es null.

path no es válido, como hacer referencia a una unidad no asignada.

path es un nombre del archivo.

La ruta de acceso especificada, el nombre de archivo o ambos combinados superan la longitud máxima definida por el sistema.

El llamador no dispone del permiso requerido.

El llamador no dispone del permiso requerido.

Ejemplos

En el ejemplo siguiente se muestra cómo recuperar todos los archivos de un directorio y moverlos a un directorio nuevo. Después de mover los archivos, ya no existen en el directorio original.

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

En el ejemplo siguiente se enumeran los archivos del directorio especificado, se lee cada línea del archivo y se muestra la línea si contiene la cadena "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

Comentarios

Puede especificar información de ruta de acceso relativa con el path parámetro . La información de ruta de acceso relativa se interpreta como relativa al directorio de trabajo actual, que puede determinar mediante el GetCurrentDirectory método .

Los EnumerateFiles métodos y GetFiles difieren de la siguiente manera: cuando se usa EnumerateFiles, puede empezar a enumerar la colección de nombres antes de que se devuelva toda la colección. Cuando se usa GetFiles, debe esperar a que se devuelva toda la matriz de nombres para poder acceder a la matriz. Por lo tanto, cuando se trabaja con muchos archivos y directorios, EnumerateFiles puede ser más eficaz.

La colección devuelta no se almacena en caché; cada llamada a GetEnumerator en la colección iniciará una nueva enumeración.

Se aplica a

EnumerateFiles(String, String)

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

Devuelve una colección enumerable de nombres completos de archivo que coinciden con un patrón de búsqueda en una ruta de acceso especificada.

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

La ruta de acceso absoluta o relativa al directorio que se va a buscar. Esta cadena no distingue entre mayúsculas y minúsculas.

searchPattern
String

Cadena de búsqueda que debe coincidir con los nombres de los archivos de path. Este parámetro puede contener una combinación de ruta de acceso literal válida y caracteres comodín (* y ?), pero no admite expresiones regulares.

Devoluciones

Una colección enumerable de nombres completos (con sus rutas de acceso) para los archivos en el directorio especificado por path y que coinciden con el patrón de búsqueda especificado.

Excepciones

Versiones de .NET Framework y .NET Core anteriores a 2.1: path es una cadena de longitud cero, solo contiene espacios en blanco o contiene caracteres no válidos. Puede consultar los caracteres no válidos con el método GetInvalidPathChars().

O bien

searchPattern no contiene un patrón válido.

path es null.

O bien

searchPattern es null.

path no es válido, como hacer referencia a una unidad no asignada.

path es un nombre del archivo.

La ruta de acceso especificada, el nombre de archivo o ambos combinados superan la longitud máxima definida por el sistema.

El llamador no dispone del permiso requerido.

El llamador no dispone del permiso requerido.

Ejemplos

En el ejemplo siguiente se muestra cómo recuperar todos los archivos de texto de un directorio y moverlos a un directorio nuevo. Después de mover los archivos, ya no existen en el directorio original.

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

En el ejemplo siguiente se enumeran los archivos del directorio especificado que tienen una extensión ".txt", se lee cada línea del archivo y se muestra la línea si contiene la cadena "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

Comentarios

searchPattern puede ser una combinación de caracteres literales y comodín, pero no admite expresiones regulares. Los siguientes especificadores de caracteres comodín se permiten en searchPattern.

Especificador de caracteres comodín Coincide
* (asterisco) Cero o más caracteres en esa posición.
? (signo de interrogación) Exactamente un carácter en esa posición.

Los caracteres distintos del carácter comodín son caracteres literales. Por ejemplo, la searchPattern cadena "*t" busca todos los nombres al path terminar con la letra "t". La searchPattern cadena "s*" busca todos los nombres a path partir de la letra "s".

Nota

Solo .NET Framework: Cuando se usa el carácter comodín asterisco en searchPattern y se especifica una extensión de archivo de tres caracteres, por ejemplo, "*.txt", este método también devuelve archivos con extensiones que comienzan con la extensión especificada. Por ejemplo, el patrón de búsqueda "*.xls" devuelve "book.xls" y "book.xlsx". Este comportamiento solo se produce si se usa un asterisco en el patrón de búsqueda y la extensión de archivo proporcionada es exactamente tres caracteres. Si usa el carácter comodín de signo de interrogación en algún lugar del patrón de búsqueda, este método devuelve solo los archivos que coinciden exactamente con la extensión de archivo especificada. En la tabla siguiente se muestra esta anomalía en .NET Framework.

Archivos en el directorio Patrón de búsqueda Devuelve .NET 5+ Devuelve .NET Framework
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 no puede terminar en dos puntos ("..") ni contener dos puntos ("..") seguidos de DirectorySeparatorChar o AltDirectorySeparatorChar, ni puede contener caracteres no válidos. Puede consultar los caracteres no válidos con el método GetInvalidPathChars.

Puede especificar información de ruta de acceso relativa con el path parámetro . La información de ruta de acceso relativa se interpreta como relativa al directorio de trabajo actual, que puede determinar mediante el GetCurrentDirectory método .

Los EnumerateFiles métodos y GetFiles difieren de la siguiente manera: cuando se usa EnumerateFiles, puede empezar a enumerar la colección de nombres antes de que se devuelva toda la colección; cuando se usa GetFiles, debe esperar a que se devuelva toda la matriz de nombres antes de poder acceder a la matriz. Por lo tanto, cuando se trabaja con muchos archivos y directorios, EnumerateFiles puede ser más eficaz.

La colección devuelta no se almacena en caché. Cada llamada a en GetEnumerator la colección inicia una nueva enumeración.

Se aplica a