Directory.EnumerateFiles Methode

Referenz

Definition

Namespace:: System.IO

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

Assembly:: System.IO.FileSystem.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Gibt eine aufzählbare Sammlung von vollständigen Dateinamen zurück, die bestimmte Kriterien erfüllen.

Überlädt

EnumerateFiles(String, String, SearchOption)	Gibt eine aufzählbare Sammlung von vollständigen Dateinamen zurück, die einem Suchmuster in einem angegebenen Pfad entsprechen. Optional werden Unterverzeichnisse durchsucht.
EnumerateFiles(String, String, EnumerationOptions)	Gibt eine aufzählbare Sammlung von vollständigen Dateinamen zurück, die einem Suchmuster und Enumerationsoptionen in einem angegebenen Pfad entsprechen. Optional werden Unterverzeichnisse durchsucht.
EnumerateFiles(String)	Gibt eine aufzählbare Sammlung von vollständigen Dateinamen in einem angegebenen Pfad zurück.
EnumerateFiles(String, String)	Gibt eine aufzählbare Sammlung von vollständigen Dateinamen zurück, die einem Suchmuster in einem angegebenen Pfad entsprechen.

EnumerateFiles(String, String, SearchOption)

Quelle:: Directory.cs

Quelle:: Directory.cs

Quelle:: Directory.cs

Gibt eine aufzählbare Sammlung von vollständigen Dateinamen zurück, die einem Suchmuster in einem angegebenen Pfad entsprechen. Optional werden Unterverzeichnisse durchsucht.

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)

Parameter

path: String

Der relative oder absolute Pfad zum Verzeichnis, das durchsucht werden soll. Bei dieser Zeichenfolge wird die Groß-/Kleinschreibung nicht berücksichtigt.

searchPattern: String

Die Suchzeichenfolge für die Überprüfung der Namen von Dateien in path auf Übereinstimmungen. Dieser Parameter kann eine Kombination aus gültigen Literalpfad- und Platzhalterzeichen (* und ?) enthalten, unterstützt jedoch keine regulären Ausdrücke.

searchOption: SearchOption

Einer der Enumerationswerte, der angibt, ob nur das aktuelle Verzeichnis oder auch alle Unterverzeichnisse durchsucht werden sollen. Der Standardwert ist TopDirectoryOnly.

Gibt zurück

IEnumerable<String>

Eine aufzählbare Auflistung der vollständigen Namen (einschließlich Pfade) für die Dateien im Verzeichnis, die von path angegeben werden und dem angegebenen Suchmuster und der angegebenen Suchoption entsprechen.

Ausnahmen

ArgumentException

.NET Framework- und .NET Core-Versionen älter als 2.1: path ist eine Zeichenfolge der Länge null, enthält nur Leerzeichen oder ungültige Zeichen. Sie können Abfragen für ungültige Zeichen mithilfe der GetInvalidPathChars()-Methode ausführen.

- oder -

searchPattern enthält kein gültiges Muster.

ArgumentNullException

path ist null.

- oder -

searchPattern ist null.

ArgumentOutOfRangeException

searchOption ist kein gültiger SearchOption -Wert.

DirectoryNotFoundException

path ist ungültig (verweist z. B. auf ein nicht zugeordnetes Laufwerk).

IOException

path ist ein Dateiname.

PathTooLongException

Der angegebene Pfad und/oder Dateiname überschreiten die vom System definierte maximale Länge.

SecurityException

Der Aufrufer verfügt nicht über die erforderliche Berechtigung.

UnauthorizedAccessException

Der Aufrufer verfügt nicht über die erforderliche Berechtigung.

Beispiele

Das folgende Beispiel zeigt, wie Alle Textdateien in einem Verzeichnis und seinen Unterverzeichnissen abgerufen und in ein neues Verzeichnis verschoben werden. Nachdem die Dateien verschoben wurden, sind sie nicht mehr in den ursprünglichen Verzeichnissen vorhanden.

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

Im folgenden Beispiel werden alle Dateien mit der Erweiterung .txtrekursiv aufgelistet, jede Zeile der Datei gelesen und die Zeile angezeigt, wenn sie die Zeichenfolge "Microsoft" enthält.

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

Hinweise

searchPattern kann eine Kombination von Literal-und Platzhalterzeichen, jedoch werden reguläre Ausdrücke nicht unterstützt. Die folgenden Wildcard-Spezifizierer sind in searchPatternzulässig.

Wildcard-Spezifizierer	Treffer
* (Sternchen)	Null oder mehr Zeichen an dieser Position.
? (Fragezeichen)	Genau ein Zeichen in dieser Position.

Andere Zeichen als das Feldhalter sind Literalzeichen. Die Zeichenfolge "*t" sucht beispielsweise nach allen Namen, searchPatternpath die mit dem Buchstaben "t" enden. Die searchPattern Zeichenfolge "s*" sucht nach allen Namen, path die mit dem Buchstaben "s" beginnen.

Hinweis

nur .NET Framework: Wenn Sie das Sternchen-Platzhalterzeichen in searchPattern verwenden und eine dreistellige Dateierweiterung angeben, z. B. "*.txt", gibt diese Methode auch Dateien mit Erweiterungen zurück, die mit der angegebenen Erweiterung beginnen. Das Suchmuster "*.xls" gibt beispielsweise sowohl "book.xls" als auch "book.xlsx" zurück. Dieses Verhalten tritt nur auf, wenn im Suchmuster ein Sternchen verwendet wird und die bereitgestellte Dateierweiterung genau drei Zeichen umfasst. Wenn Sie das Fragezeichenplatzzeichen irgendwo im Suchmuster verwenden, gibt diese Methode nur Dateien zurück, die genau mit der angegebenen Dateierweiterung übereinstimmen. In der folgenden Tabelle wird diese Anomalie in .NET Framework dargestellt.

Dateien im Verzeichnis	Suchmuster	.NET 5+ gibt zurück	.NET Framework gibt zurück
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 kann nicht in zwei Perioden ("..") enden oder zwei Punkte ("..") gefolgt von DirectorySeparatorChar oder AltDirectorySeparatorCharenthalten, und es kann auch keine ungültigen Zeichen enthalten. Sie können Abfragen für ungültige Zeichen mithilfe der GetInvalidPathChars-Methode ausführen.

Sie können relative Pfadinformationen mit dem path Parameter angeben. Relative Pfadinformationen werden relativ zum aktuellen Arbeitsverzeichnis interpretiert, das Sie mithilfe der GetCurrentDirectory -Methode ermitteln können.

Die EnumerateFiles Methoden und GetFiles unterscheiden sich wie folgt: Wenn Sie verwenden EnumerateFiles, können Sie mit der Auflistung der Namen beginnen, bevor die gesamte Auflistung zurückgegeben wird. Wenn Sie verwenden GetFiles, müssen Sie warten, bis das gesamte Array von Namen zurückgegeben wird, bevor Sie auf das Array zugreifen können. Wenn Sie mit vielen Dateien und Verzeichnissen arbeiten, EnumerateFiles kann es daher effizienter sein.

Die zurückgegebene Auflistung wird nicht zwischengespeichert. Jeder Aufruf von in GetEnumerator der Auflistung startet eine neue Enumeration.

Gilt für:

EnumerateFiles(String, String, EnumerationOptions)

Quelle:: Directory.cs

Quelle:: Directory.cs

Quelle:: Directory.cs

Gibt eine aufzählbare Sammlung von vollständigen Dateinamen zurück, die einem Suchmuster und Enumerationsoptionen in einem angegebenen Pfad entsprechen. Optional werden Unterverzeichnisse durchsucht.

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)

Parameter

path: String

Der relative oder absolute Pfad zum Verzeichnis, das durchsucht werden soll. Bei dieser Zeichenfolge wird die Groß-/Kleinschreibung nicht berücksichtigt.

searchPattern: String

enumerationOptions: EnumerationOptions

Ein Objekt, das die zu verwendende Such- und Enumerationskonfiguration beschreibt.

Gibt zurück

IEnumerable<String>

Ausnahmen

ArgumentException

- oder -

searchPattern enthält kein gültiges Muster.

ArgumentNullException

path ist null.

- oder -

searchPattern ist null.

ArgumentOutOfRangeException

searchOption ist kein gültiger SearchOption -Wert.

DirectoryNotFoundException

path ist ungültig (verweist z. B. auf ein nicht zugeordnetes Laufwerk).

IOException

path ist ein Dateiname.

PathTooLongException

Der angegebene Pfad und/oder Dateiname überschreiten die vom System definierte maximale Länge.

UnauthorizedAccessException

Der Aufrufer verfügt nicht über die erforderliche Berechtigung.

Hinweise

searchPattern kann eine Kombination von Literal-und Platzhalterzeichen, jedoch werden reguläre Ausdrücke nicht unterstützt. Die folgenden Wildcard-Spezifizierer sind in searchPatternzulässig.

Wildcard-Spezifizierer	Treffer
* (Sternchen)	Null oder mehr Zeichen an dieser Position.
? (Fragezeichen)	Genau ein Zeichen in dieser Position.

Hinweis

Dateien im Verzeichnis	Suchmuster	.NET 5+ gibt zurück	.NET Framework gibt zurück
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

Die zurückgegebene Auflistung wird nicht zwischengespeichert. Jeder Aufruf von in GetEnumerator der Auflistung startet eine neue Enumeration.

Gilt für:

EnumerateFiles(String)

Quelle:: Directory.cs

Quelle:: Directory.cs

Quelle:: Directory.cs

Gibt eine aufzählbare Sammlung von vollständigen Dateinamen in einem angegebenen Pfad zurück.

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)

Parameter

path: String

Der relative oder absolute Pfad zum Verzeichnis, das durchsucht werden soll. Bei dieser Zeichenfolge wird die Groß-/Kleinschreibung nicht berücksichtigt.

Gibt zurück

IEnumerable<String>

Eine aufzählbare Auflistung der vollständigen Namen (einschließlich Pfade) für die Verzeichnisse im Verzeichnis, das von path angegeben wird.

Ausnahmen

ArgumentException

ArgumentNullException

path ist null.

DirectoryNotFoundException

path ist ungültig (verweist z. B. auf ein nicht zugeordnetes Laufwerk).

IOException

path ist ein Dateiname.

PathTooLongException

Der angegebene Pfad und/oder Dateiname überschreiten die vom System definierte maximale Länge.

SecurityException

Der Aufrufer verfügt nicht über die erforderliche Berechtigung.

UnauthorizedAccessException

Der Aufrufer verfügt nicht über die erforderliche Berechtigung.

Beispiele

Das folgende Beispiel zeigt, wie Sie alle Dateien in einem Verzeichnis abrufen und in ein neues Verzeichnis verschieben. Nachdem die Dateien verschoben wurden, sind sie nicht mehr im ursprünglichen Verzeichnis vorhanden.

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

Im folgenden Beispiel werden die Dateien im angegebenen Verzeichnis aufgelistet, jede Zeile der Datei gelesen und die Zeile angezeigt, wenn sie die Zeichenfolge "Europe" enthält.

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

Hinweise

Die zurückgegebene Sammlung wird nicht zwischengespeichert. Jeder Aufruf von für GetEnumerator die Auflistung startet eine neue Enumeration.

Gilt für:

EnumerateFiles(String, String)

Quelle:: Directory.cs

Quelle:: Directory.cs

Quelle:: Directory.cs

Gibt eine aufzählbare Sammlung von vollständigen Dateinamen zurück, die einem Suchmuster in einem angegebenen Pfad entsprechen.

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)

Parameter

path: String

Der relative oder absolute Pfad zum Verzeichnis, das durchsucht werden soll. Bei dieser Zeichenfolge wird die Groß-/Kleinschreibung nicht berücksichtigt.

searchPattern: String

Gibt zurück

IEnumerable<String>

Eine aufzählbare Auflistung der vollständigen Namen (einschließlich Pfade) für die Dateien im Verzeichnis, das von path angegebenen wird und dem angegebenen Suchmuster entsprechen.

Ausnahmen

ArgumentException

- oder -

searchPattern enthält kein gültiges Muster.

ArgumentNullException

path ist null.

- oder -

searchPattern ist null.

DirectoryNotFoundException

path ist ungültig (verweist z. B. auf ein nicht zugeordnetes Laufwerk).

IOException

path ist ein Dateiname.

PathTooLongException

Der angegebene Pfad und/oder Dateiname überschreiten die vom System definierte maximale Länge.

SecurityException

Der Aufrufer verfügt nicht über die erforderliche Berechtigung.

UnauthorizedAccessException

Der Aufrufer verfügt nicht über die erforderliche Berechtigung.

Beispiele

Das folgende Beispiel zeigt, wie Sie alle Textdateien in einem Verzeichnis abrufen und in ein neues Verzeichnis verschieben. Nachdem die Dateien verschoben wurden, sind sie nicht mehr im ursprünglichen Verzeichnis vorhanden.

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

Im folgenden Beispiel werden die Dateien im angegebenen Verzeichnis mit der Erweiterung ".txt" aufgelistet, jede Zeile der Datei gelesen und die Zeile angezeigt, wenn sie die Zeichenfolge "Europe" enthält.

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

Hinweise

searchPattern kann eine Kombination von Literal-und Platzhalterzeichen, jedoch werden reguläre Ausdrücke nicht unterstützt. Die folgenden Wildcard-Spezifizierer sind in searchPatternzulässig.

Wildcard-Spezifizierer	Treffer
* (Sternchen)	Null oder mehr Zeichen an dieser Position.
? (Fragezeichen)	Genau ein Zeichen in dieser Position.

Hinweis

Dateien im Verzeichnis	Suchmuster	.NET 5+ gibt zurück	.NET Framework gibt zurück
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 darf nicht mit zwei Punkten ("..") enden oder zwei Punkte ("..") gefolgt von DirectorySeparatorChar oder AltDirectorySeparatorCharenthalten, noch darf er ungültige Zeichen enthalten. Sie können Abfragen für ungültige Zeichen mithilfe der GetInvalidPathChars-Methode ausführen.

Sie können relative Pfadinformationen mit dem path -Parameter angeben. Relative Pfadinformationen werden als relativ zum aktuellen Arbeitsverzeichnis interpretiert, das Sie mithilfe der GetCurrentDirectory -Methode ermitteln können.

Die EnumerateFiles Methoden und GetFiles unterscheiden sich wie folgt: Wenn Sie verwenden EnumerateFiles, können Sie mit dem Aufzählen der Auflistung von Namen beginnen, bevor die gesamte Auflistung zurückgegeben wird. Wenn Sie verwenden GetFiles, müssen Sie warten, bis das gesamte Array von Namen zurückgegeben wird, bevor Sie auf das Array zugreifen können. Daher kann es effizienter sein, EnumerateFiles wenn Sie mit vielen Dateien und Verzeichnissen arbeiten.

Die zurückgegebene Auflistung wird nicht zwischengespeichert. Jeder Aufruf von für GetEnumerator die Auflistung startet eine neue Enumeration.

Gilt für:

Freigeben über

Directory.EnumerateFiles Methode

Definition

Überlädt

EnumerateFiles(String, String, SearchOption)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Gilt für:

EnumerateFiles(String, String, EnumerationOptions)

Parameter

Gibt zurück

Ausnahmen

Hinweise

Gilt für:

EnumerateFiles(String)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Gilt für:

EnumerateFiles(String, String)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Gilt für:

Zusätzliche Ressourcen