Directory.EnumerateFiles Metod

Definition

Namnområde:: System.IO

Sammansättningar:: mscorlib.dll, System.IO.FileSystem.dll

Sammansättningar:: netstandard.dll, System.Runtime.dll

Sammansättningar:: netstandard.dll, System.IO.FileSystem.dll

Sammansättningar:: netstandard.dll, System.IO.FileSystem.dll, System.Runtime.dll

Sammansättning:: System.IO.FileSystem.dll

Sammansättning:: mscorlib.dll

Sammansättning:: netstandard.dll

Viktigt

En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.

Returnerar en uppräkningsbar samling med fullständiga filnamn som uppfyller angivna villkor.

Överlagringar

Name	Description
EnumerateFiles(String, String, SearchOption)	Returnerar en uppräkningsbar samling med fullständiga filnamn som matchar ett sökmönster i en angiven sökväg och söker eventuellt i underkataloger.
EnumerateFiles(String, String, EnumerationOptions)	Returnerar en uppräkningsbar samling med fullständiga filnamn som matchar ett sökmönster och uppräkningsalternativ i en angiven sökväg och söker eventuellt efter underkataloger.
EnumerateFiles(String)	Returnerar en uppräkningsbar samling med fullständiga filnamn i en angiven sökväg.
EnumerateFiles(String, String)	Returnerar en uppräkningsbar samling med fullständiga filnamn som matchar ett sökmönster i en angiven sökväg.

EnumerateFiles(String, String, SearchOption)

Källa:: Directory.cs

Källa:: Directory.cs

Källa:: Directory.cs

Källa:: Directory.cs

Källa:: Directory.cs

Returnerar en uppräkningsbar samling med fullständiga filnamn som matchar ett sökmönster i en angiven sökväg och söker eventuellt i underkataloger.

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)

Parametrar

path: String

Den relativa eller absoluta sökvägen till katalogen som ska sökas. Den här strängen är inte skiftlägeskänslig.

searchPattern: String

Söksträngen som ska matchas mot namnen på filerna i path. Den här parametern kan innehålla en kombination av giltiga teckensökväg och jokertecken (* och ?), men den stöder inte reguljära uttryck.

searchOption: SearchOption

Ett av uppräkningsvärdena som anger om sökåtgärden endast ska innehålla den aktuella katalogen eller ska innehålla alla underkataloger. Standardvärdet är TopDirectoryOnly.

Returer

IEnumerable<String>

En uppräkningsbar samling med fullständiga namn (inklusive sökvägar) för filerna i katalogen som anges av path och som matchar det angivna sökmönstret och sökalternativet.

Undantag

ArgumentException

.NET Framework- och .NET Core-versioner som är äldre än 2.1: path är en sträng med noll längd, innehåller endast tomt utrymme eller innehåller ogiltiga tecken. Du kan fråga efter ogiltiga tecken med hjälp GetInvalidPathChars() av metoden .

-eller-

searchPattern innehåller inget giltigt mönster.

ArgumentNullException

path är null.

-eller-

searchPattern är null.

ArgumentOutOfRangeException

searchOption är inte ett giltigt SearchOption värde.

DirectoryNotFoundException

path är ogiltigt, till exempel refererar till en ommappad enhet.

IOException

path är ett filnamn.

PathTooLongException

Den angivna sökvägen, filnamnet eller kombinerade överskrider den systemdefinierade maximala längden.

SecurityException

Anroparen har inte den behörighet som krävs.

UnauthorizedAccessException

Anroparen har inte den behörighet som krävs.

Exempel

I följande exempel visas hur du hämtar alla textfiler i en katalog och dess underkataloger och flyttar dem till en ny katalog. När filerna har flyttats finns de inte längre i de ursprungliga katalogerna.

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

Följande exempel räknar rekursivt upp alla filer som har tillägget .txt, läser varje rad i filen och visar raden om den innehåller strängen "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

Kommentarer

searchPattern kan vara en kombination av literaltecken och jokertecken, men det stöder inte reguljära uttryck. Följande jokerteckensspecificerare tillåts i searchPattern.

Jokerteckensspecificerare	Matcher
* (asterisk)	Noll eller fler tecken i den positionen.
? (frågetecken)	Exakt ett tecken i den positionen.

Andra tecken än jokertecknet är literaltecken. Strängen searchPattern "*t" söker till exempel efter alla namn som path slutar med bokstaven "t". Strängen searchPattern "s*" söker efter alla namn från path och med bokstaven "s".

Note

.NET Framework only: När du använder jokertecknet asterisk i searchPattern och du anger ett filnamnstillägg med tre tecken, till exempel "*.txt", returnerar den här metoden även filer med tillägg som begin med det angivna tillägget. Sökmönstret "*.xls" returnerar till exempel både "book.xls" och "book.xlsx". Det här beteendet inträffar bara om en asterisk används i sökmönstret och filnamnstillägget är exakt tre tecken. Om du använder jokertecknet för frågetecknet någonstans i sökmönstret returnerar den här metoden endast filer som matchar det angivna filnamnstillägget exakt. Följande tabell visar den här avvikelsen i .NET Framework.

Filer i katalogen	Sökmönster	.NET 5+ returer	.NET Framework returnerar
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 kan inte sluta i två perioder ("..") eller innehålla två punkter ("..") följt av DirectorySeparatorChar eller AltDirectorySeparatorChar, och kan inte heller innehålla ogiltiga tecken. Du kan fråga efter ogiltiga tecken med hjälp GetInvalidPathChars av metoden .

Du kan ange relativ sökvägsinformation med parametern path . Relativ sökvägsinformation tolkas som relativ till den aktuella arbetskatalogen, vilket du kan avgöra med hjälp GetCurrentDirectory av metoden.

Metoderna EnumerateFiles och GetFiles skiljer sig åt på följande sätt: När du använder EnumerateFileskan du börja räkna upp namnsamlingen innan hela samlingen returneras. När du använder GetFilesmåste du vänta tills hela matrisen med namn returneras innan du kan komma åt matrisen. Därför kan det vara mer effektivt när du arbetar med många filer och kataloger EnumerateFiles .

Den returnerade samlingen cachelagras inte. Varje anrop till GetEnumerator i samlingen startar en ny uppräkning.

Gäller för

EnumerateFiles(String, String, EnumerationOptions)

Källa:: Directory.cs

Källa:: Directory.cs

Källa:: Directory.cs

Källa:: Directory.cs

Källa:: Directory.cs

Returnerar en uppräkningsbar samling med fullständiga filnamn som matchar ett sökmönster och uppräkningsalternativ i en angiven sökväg och söker eventuellt efter underkataloger.

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)

Parametrar

path: String

Den relativa eller absoluta sökvägen till katalogen som ska sökas. Den här strängen är inte skiftlägeskänslig.

searchPattern: String

enumerationOptions: EnumerationOptions

Ett objekt som beskriver den sök- och uppräkningskonfiguration som ska användas.

Returer

IEnumerable<String>

En uppräkningsbar samling med fullständiga namn (inklusive sökvägar) för filerna i katalogen som anges av path och som matchar det angivna sökmönstret och uppräkningsalternativen.

Undantag

ArgumentException

-eller-

searchPattern innehåller inget giltigt mönster.

ArgumentNullException

path är null.

-eller-

searchPattern är null.

DirectoryNotFoundException

path är ogiltigt, till exempel refererar till en ommappad enhet.

IOException

path är ett filnamn.

PathTooLongException

Den angivna sökvägen, filnamnet eller kombinerade överskrider den systemdefinierade maximala längden.

UnauthorizedAccessException

Anroparen har inte den behörighet som krävs.

Exempel

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

Följande exempel räknar rekursivt upp alla filer med .txt tillägget och ignorerar otillgängliga kataloger och filer. Den läser varje rad i filen och visar raden om den innehåller strängen "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

Kommentarer

searchPattern kan vara en kombination av literaltecken och jokertecken, men det stöder inte reguljära uttryck. Följande jokerteckensspecificerare tillåts i searchPattern.

Jokerteckensspecificerare	Matcher
* (asterisk)	Noll eller fler tecken i den positionen.
? (frågetecken)	Exakt ett tecken i den positionen.

Note

Filer i katalogen	Sökmönster	.NET 5+ returer	.NET Framework returnerar
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

Den returnerade samlingen cachelagras inte. Varje anrop till GetEnumerator i samlingen startar en ny uppräkning.

Gäller för

EnumerateFiles(String)

Källa:: Directory.cs

Källa:: Directory.cs

Källa:: Directory.cs

Källa:: Directory.cs

Källa:: Directory.cs

Returnerar en uppräkningsbar samling med fullständiga filnamn i en angiven sökväg.

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)

Parametrar

path: String

Den relativa eller absoluta sökvägen till katalogen som ska sökas. Den här strängen är inte skiftlägeskänslig.

Returer

IEnumerable<String>

En uppräkningsbar samling med fullständiga namn (inklusive sökvägar) för filerna i katalogen som anges av path.

Undantag

ArgumentException

ArgumentNullException

path är null.

DirectoryNotFoundException

path är ogiltigt, till exempel refererar till en ommappad enhet.

IOException

path är ett filnamn.

PathTooLongException

Den angivna sökvägen, filnamnet eller kombinerade överskrider den systemdefinierade maximala längden.

SecurityException

Anroparen har inte den behörighet som krävs.

UnauthorizedAccessException

Anroparen har inte den behörighet som krävs.

Exempel

I följande exempel visas hur du hämtar alla filer i en katalog och flyttar dem till en ny katalog. När filerna har flyttats finns de inte längre i den ursprungliga katalogen.

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

I följande exempel räknas filerna upp i den angivna katalogen, varje rad i filen läses och raden visas om den innehåller strängen "Europa".

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

Kommentarer

Den returnerade samlingen cachelagras inte. varje anrop till GetEnumerator i samlingen startar en ny uppräkning.

Gäller för

EnumerateFiles(String, String)

Källa:: Directory.cs

Källa:: Directory.cs

Källa:: Directory.cs

Källa:: Directory.cs

Källa:: Directory.cs

Returnerar en uppräkningsbar samling med fullständiga filnamn som matchar ett sökmönster i en angiven sökväg.

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)

Parametrar

path: String

Den relativa eller absoluta sökvägen till katalogen som ska sökas. Den här strängen är inte skiftlägeskänslig.

searchPattern: String

Returer

IEnumerable<String>

En uppräkningsbar samling med fullständiga namn (inklusive sökvägar) för filerna i katalogen som anges av path och som matchar det angivna sökmönstret.

Undantag

ArgumentException

-eller-

searchPattern innehåller inget giltigt mönster.

ArgumentNullException

path är null.

-eller-

searchPattern är null.

DirectoryNotFoundException

path är ogiltigt, till exempel refererar till en ommappad enhet.

IOException

path är ett filnamn.

PathTooLongException

Den angivna sökvägen, filnamnet eller kombinerade överskrider den systemdefinierade maximala längden.

SecurityException

Anroparen har inte den behörighet som krävs.

UnauthorizedAccessException

Anroparen har inte den behörighet som krävs.

Exempel

I följande exempel visas hur du hämtar alla textfiler i en katalog och flyttar dem till en ny katalog. När filerna har flyttats finns de inte längre i den ursprungliga katalogen.

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

I följande exempel räknas filerna upp i den angivna katalogen som har tillägget ".txt", läser varje rad i filen och visar raden om den innehåller strängen "Europa".

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

Kommentarer

searchPattern kan vara en kombination av literaltecken och jokertecken, men det stöder inte reguljära uttryck. Följande jokerteckensspecificerare tillåts i searchPattern.

Jokerteckensspecificerare	Matcher
* (asterisk)	Noll eller fler tecken i den positionen.
? (frågetecken)	Exakt ett tecken i den positionen.

Note

Filer i katalogen	Sökmönster	.NET 5+ returer	.NET Framework returnerar
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

Den returnerade samlingen cachelagras inte. Varje anrop till GetEnumerator i samlingen startar en ny uppräkning.

Gäller för

Feedback

Var den här sidan till hjälp?