Directory.EnumerateFiles Metodo

Riferimento

Definizione

Spazio dei nomi:: System.IO

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

Assembly:: System.IO.FileSystem.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Restituisce una raccolta enumerabile dei nomi di file completi che soddisfano i criteri specificati.

Overload

EnumerateFiles(String, String, SearchOption)	Restituisce una raccolta enumerabile dei nomi di file completi che corrispondono a un criterio di ricerca in un percorso specificato e con ricerca facoltativa nelle sottodirectory.
EnumerateFiles(String, String, EnumerationOptions)	Restituisce una raccolta enumerabile dei nomi di file completi che corrispondono a un criterio di ricerca a alle opzioni di enumerazione in un percorso specificato, con ricerca facoltativa nelle sottodirectory.
EnumerateFiles(String)	Restituisce una raccolta enumerabile dei nomi di file completi in un percorso specificato.
EnumerateFiles(String, String)	Restituisce una raccolta enumerabile dei nomi di file completi che corrispondono a un criterio di ricerca in un percorso specificato.

EnumerateFiles(String, String, SearchOption)

Origine:: Directory.cs

Origine:: Directory.cs

Origine:: Directory.cs

Restituisce una raccolta enumerabile dei nomi di file completi che corrispondono a un criterio di ricerca in un percorso specificato e con ricerca facoltativa nelle sottodirectory.

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)

Parametri

path: String

Percorso relativo o assoluto della directory in cui eseguire la ricerca. Stringa senza distinzione tra maiuscole e minuscole.

searchPattern: String

Stringa di ricerca in base alla quale confrontare i nomi dei file in path. Questo parametro può contenere una combinazione di caratteri del percorso letterale e caratteri jolly (* e ?) validi, ma non supporta le espressioni regolari.

searchOption: SearchOption

Uno dei valori di enumerazione che specifica se l'operazione di ricerca deve includere solo la directory corrente o tutte le sottodirectory. Il valore predefinito è TopDirectoryOnly.

Restituisce

IEnumerable<String>

Raccolta enumerabile dei nomi completi (inclusi i percorsi) per i file inclusi nella directory specificata da path e corrispondenti al criterio di ricerca e all'opzione di ricerca specificati.

Eccezioni

ArgumentException

.NET Framework e versioni di .NET Core precedenti a 2.1: path è una stringa a lunghezza zero, contiene solo spazi vuoti o contiene caratteri non validi. È possibile cercare i caratteri non validi usando il metodo GetInvalidPathChars().

-oppure-

searchPattern non contiene un modello valido.

ArgumentNullException

path è null.

-oppure-

searchPattern è null.

ArgumentOutOfRangeException

searchOption non è un valore valido di SearchOption.

DirectoryNotFoundException

path non è valido, ad esempio fa riferimento a un'unità non mappata.

IOException

path è un nome file.

PathTooLongException

Il percorso specificato, il nome file o la combinazione di entrambi supera la lunghezza massima definita dal sistema.

SecurityException

Il chiamante non dispone dell'autorizzazione richiesta.

UnauthorizedAccessException

Il chiamante non dispone dell'autorizzazione richiesta.

Esempio

Nell'esempio seguente viene illustrato come recuperare tutti i file di testo in una directory e le relative sottodirectory e spostarli in una nuova directory. Dopo aver spostato i file, non esistono più nelle directory originali.

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

Nell'esempio seguente enumera in modo ricorsivo tutti i file con estensione .txt, legge ogni riga del file e visualizza la riga se contiene la stringa "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

Commenti

searchPattern può essere una combinazione di caratteri letterali e jolly, ma non supporta espressioni regolari. Gli identificatori jolly seguenti sono consentiti in searchPattern.

Identificatore jolly	Corrispondenze
* (asterisco)	Zero o più caratteri in tale posizione.
? (punto interrogativo)	Esattamente un carattere in tale posizione.

I caratteri diversi dal carattere jolly sono caratteri letterali. Ad esempio, la searchPattern stringa "*t" cerca tutti i nomi path che terminano con la lettera "t". La searchPattern stringa "s*" cerca tutti i nomi in path inizio con la lettera "s".

Nota

Solo .NET Framework: Quando si usa il carattere jolly asterisco in searchPattern e si specifica un'estensione di file a tre caratteri, ad esempio "*.txt", questo metodo restituisce anche file con estensioni che iniziano con l'estensione specificata. Ad esempio, il modello di ricerca "*.xls" restituisce sia "book.xls" sia "book.xlsx". Questo comportamento si verifica solo se un asterisco viene usato nel modello di ricerca e l'estensione del file fornita è esattamente tre caratteri. Se si usa il carattere jolly punto interrogativo in un punto qualsiasi nel modello di ricerca, questo metodo restituisce solo file che corrispondono esattamente all'estensione di file specificata. Nella tabella seguente viene illustrata questa anomalia in .NET Framework.

File nella directory	Modello di ricerca	.NET 5+ restituisce	.NET Framework restituisce
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	ello.txt, hello.txt	ello.txt, hello.txt

searchPattern non può terminare in due periodi ("..") o contenere due periodi ("..") seguiti da DirectorySeparatorChar o AltDirectorySeparatorChar, né può contenere caratteri non validi. È possibile cercare i caratteri non validi usando il metodo GetInvalidPathChars.

È possibile specificare le informazioni relative sul percorso con il path parametro . Le informazioni relative sul percorso vengono interpretate come relative alla directory di lavoro corrente, che è possibile determinare usando il GetCurrentDirectory metodo .

I EnumerateFiles metodi e GetFiles differiscono come indicato di seguito: quando si usa EnumerateFiles, è possibile iniziare a enumerare la raccolta di nomi prima che venga restituita l'intera raccolta. Quando si usa GetFiles, è necessario attendere che venga restituita l'intera matrice di nomi prima di poter accedere alla matrice. Pertanto, quando si utilizzano molti file e directory, EnumerateFiles può essere più efficiente.

La raccolta restituita non viene memorizzata nella cache. Ogni chiamata alla GetEnumerator raccolta avvia una nuova enumerazione.

Si applica a

EnumerateFiles(String, String, EnumerationOptions)

Origine:: Directory.cs

Origine:: Directory.cs

Origine:: Directory.cs

Restituisce una raccolta enumerabile dei nomi di file completi che corrispondono a un criterio di ricerca a alle opzioni di enumerazione in un percorso specificato, con ricerca facoltativa nelle sottodirectory.

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)

Parametri

path: String

Percorso relativo o assoluto della directory in cui eseguire la ricerca. Stringa senza distinzione tra maiuscole e minuscole.

searchPattern: String

enumerationOptions: EnumerationOptions

Oggetto che descrive la configurazione di ricerca ed enumerazione da usare.

Restituisce

IEnumerable<String>

Raccolta enumerabile dei nomi completi (inclusi i percorsi) per i file inclusi nella directory specificata da path e corrispondenti al criterio di ricerca e alle opzioni di enumerazione specificati.

Eccezioni

ArgumentException

-oppure-

searchPattern non contiene un modello valido.

ArgumentNullException

path è null.

-oppure-

searchPattern è null.

ArgumentOutOfRangeException

searchOption non è un valore valido di SearchOption.

DirectoryNotFoundException

path non è valido, ad esempio fa riferimento a un'unità non mappata.

IOException

path è un nome file.

PathTooLongException

Il percorso specificato, il nome file o la combinazione di entrambi supera la lunghezza massima definita dal sistema.

UnauthorizedAccessException

Il chiamante non dispone dell'autorizzazione richiesta.

Commenti

searchPattern può essere una combinazione di caratteri letterali e jolly, ma non supporta espressioni regolari. Gli identificatori jolly seguenti sono consentiti in searchPattern.

Identificatore jolly	Corrispondenze
* (asterisco)	Zero o più caratteri in tale posizione.
? (punto interrogativo)	Esattamente un carattere in tale posizione.

Nota

File nella directory	Modello di ricerca	.NET 5+ restituisce	.NET Framework restituisce
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	ello.txt, hello.txt	ello.txt, hello.txt

La raccolta restituita non viene memorizzata nella cache. Ogni chiamata alla GetEnumerator raccolta avvia una nuova enumerazione.

Si applica a

EnumerateFiles(String)

Origine:: Directory.cs

Origine:: Directory.cs

Origine:: Directory.cs

Restituisce una raccolta enumerabile dei nomi di file completi in un percorso specificato.

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)

Parametri

path: String

Percorso relativo o assoluto della directory in cui eseguire la ricerca. Stringa senza distinzione tra maiuscole e minuscole.

Restituisce

IEnumerable<String>

Raccolta enumerabile dei nomi completi (inclusi i percorsi) per i file inclusi nella directory specificata da path.

Eccezioni

ArgumentException

ArgumentNullException

path è null.

DirectoryNotFoundException

path non è valido, ad esempio fa riferimento a un'unità non mappata.

IOException

path è un nome file.

PathTooLongException

Il percorso specificato, il nome file o la combinazione di entrambi supera la lunghezza massima definita dal sistema.

SecurityException

Il chiamante non dispone dell'autorizzazione richiesta.

UnauthorizedAccessException

Il chiamante non dispone dell'autorizzazione richiesta.

Esempio

Nell'esempio seguente viene illustrato come recuperare tutti i file in una directory e spostarli in una nuova directory. Dopo aver spostato i file, non esistono più nella directory originale.

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

L'esempio seguente enumera i file nella directory specificata, legge ogni riga del file e visualizza la riga se contiene la stringa "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

Commenti

La raccolta restituita non viene memorizzata nella cache; ogni chiamata all'oggetto nella GetEnumerator raccolta avvierà una nuova enumerazione.

Si applica a

EnumerateFiles(String, String)

Origine:: Directory.cs

Origine:: Directory.cs

Origine:: Directory.cs

Restituisce una raccolta enumerabile dei nomi di file completi che corrispondono a un criterio di ricerca in un percorso specificato.

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)

Parametri

path: String

Percorso relativo o assoluto della directory in cui eseguire la ricerca. Stringa senza distinzione tra maiuscole e minuscole.

searchPattern: String

Restituisce

IEnumerable<String>

Raccolta enumerabile dei nomi completi (inclusi i percorsi) per i file inclusi nella directory specificata da path e corrispondenti al criterio di ricerca specificato.

Eccezioni

ArgumentException

-oppure-

searchPattern non contiene un modello valido.

ArgumentNullException

path è null.

-oppure-

searchPattern è null.

DirectoryNotFoundException

path non è valido, ad esempio fa riferimento a un'unità non mappata.

IOException

path è un nome file.

PathTooLongException

Il percorso specificato, il nome file o la combinazione di entrambi supera la lunghezza massima definita dal sistema.

SecurityException

Il chiamante non dispone dell'autorizzazione richiesta.

UnauthorizedAccessException

Il chiamante non dispone dell'autorizzazione richiesta.

Esempio

Nell'esempio seguente viene illustrato come recuperare tutti i file di testo in una directory e spostarli in una nuova directory. Dopo aver spostato i file, non esistono più nella directory originale.

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

L'esempio seguente enumera i file nella directory specificata con estensione ".txt", legge ogni riga del file e visualizza la riga se contiene la stringa "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

Commenti

searchPattern può essere una combinazione di caratteri letterali e jolly, ma non supporta espressioni regolari. Gli identificatori jolly seguenti sono consentiti in searchPattern.

Identificatore jolly	Corrispondenze
* (asterisco)	Zero o più caratteri in tale posizione.
? (punto interrogativo)	Esattamente un carattere in tale posizione.

Nota

File nella directory	Modello di ricerca	.NET 5+ restituisce	.NET Framework restituisce
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	ello.txt, hello.txt	ello.txt, hello.txt

searchPattern non può terminare in due punti ("..") o contenere due punti ("..") seguiti da DirectorySeparatorChar o AltDirectorySeparatorChar, né può contenere caratteri non validi. È possibile cercare i caratteri non validi usando il metodo GetInvalidPathChars.

È possibile specificare informazioni relative sul percorso con il path parametro . Le informazioni relative sul percorso vengono interpretate come relative alla directory di lavoro corrente, che è possibile determinare usando il GetCurrentDirectory metodo .

I EnumerateFiles metodi e GetFiles differiscono nel modo seguente: quando si utilizza EnumerateFiles, è possibile iniziare a enumerare la raccolta di nomi prima che venga restituita l'intera raccolta. Quando si utilizza GetFiles, è necessario attendere che venga restituita l'intera matrice di nomi prima di poter accedere alla matrice. Pertanto, quando si lavora con molti file e directory, EnumerateFiles può essere più efficiente.

La raccolta restituita non viene memorizzata nella cache. Ogni chiamata a nella GetEnumerator raccolta avvia una nuova enumerazione.

Si applica a

Directory.EnumerateFiles Metodo

Definizione

Overload

EnumerateFiles(String, String, SearchOption)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Si applica a

EnumerateFiles(String, String, EnumerationOptions)

Parametri

Restituisce

Eccezioni

Commenti

Si applica a

EnumerateFiles(String)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Si applica a

EnumerateFiles(String, String)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Si applica a

Commenti e suggerimenti

Risorse aggiuntive