Lezen in het Engels

Delen via


Procedure: Mappen en bestanden opsommen

Enumerable verzamelingen bieden betere prestaties dan matrices wanneer u met grote verzamelingen mappen en bestanden werkt. Als u mappen en bestanden wilt inventariseren, gebruikt u methoden die een inventariserbare verzameling map- of bestandsnamen, of hun DirectoryInfo, FileInfoof FileSystemInfo objecten retourneren.

Als u alleen de namen van mappen of bestanden wilt zoeken en retourneren, gebruikt u de opsommingsmethoden van de Directory klasse. Als u andere eigenschappen van mappen of bestanden wilt zoeken en retourneren, gebruikt u de DirectoryInfo en FileSystemInfo klassen.

U kunt op deze methoden opsommingsbare verzamelingen gebruiken als de IEnumerable<T> parameter voor constructors van verzamelingsklassen, zoals List<T>.

De volgende tabel bevat een overzicht van de methoden die inventariserbare verzamelingen bestanden en mappen retourneren:

Zoeken en retourneren Methode gebruiken
Mapnamen Directory.EnumerateDirectories
Adreslijstgegevens (DirectoryInfo) DirectoryInfo.EnumerateDirectories
Bestandsnamen Directory.EnumerateFiles
Bestandsinformatie (FileInfo) DirectoryInfo.EnumerateFiles
Namen van bestandssysteemvermeldingen Directory.EnumerateFileSystemEntries
Informatie over het invoeren van het bestandssysteem (FileSystemInfo) DirectoryInfo.EnumerateFileSystemInfos
Map- en bestandsnamen Directory.EnumerateFileSystemEntries

Notitie

Hoewel u alle bestanden in de submappen van een bovenliggende map onmiddellijk kunt inventariseren met behulp van de AllDirectories optie van de optionele SearchOption opsomming, UnauthorizedAccessException kunnen fouten de opsomming onvolledig maken. U kunt deze uitzonderingen ondervangen door eerst mappen op te sommen en vervolgens bestanden op te sommen.

Voorbeelden: De mapklasse gebruiken

In het volgende voorbeeld wordt de Directory.EnumerateDirectories(String) methode gebruikt om een lijst op te halen met de mapnamen op het hoogste niveau in een opgegeven pad.

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

class Program
{
    private static void Main(string[] args)
    {
        try
        {
            // Set a variable to the My Documents path.
            string docPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);

            List<string> dirs = new List<string>(Directory.EnumerateDirectories(docPath));

            foreach (var dir in dirs)
            {
                Console.WriteLine($"{dir.Substring(dir.LastIndexOf(Path.DirectorySeparatorChar) + 1)}");
            }
            Console.WriteLine($"{dirs.Count} directories found.");
        }
        catch (UnauthorizedAccessException ex)
        {
            Console.WriteLine(ex.Message);
        }
        catch (PathTooLongException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}

In het volgende voorbeeld wordt de Directory.EnumerateFiles(String, String, SearchOption) methode gebruikt voor het recursief inventariseren van alle bestandsnamen in een map en submappen die overeenkomen met een bepaald patroon. Vervolgens wordt elke regel van elk bestand gelezen en worden de regels weergegeven die een opgegeven tekenreeks bevatten, met hun bestandsnamen en paden.

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);
        }
    }
}

Voorbeelden: De klasse DirectoryInfo gebruiken

In het volgende voorbeeld wordt de DirectoryInfo.EnumerateDirectories methode gebruikt om een verzameling mappen op het hoogste niveau weer te geven waarvan CreationTimeUtc de waarde eerder is dan een bepaalde DateTime waarde.

using System;
using System.IO;

namespace EnumDir
{
    class Program
    {
        static void Main(string[] args)
        {
            // Set a variable to the Documents path.
            string docPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);

            DirectoryInfo dirPrograms = new DirectoryInfo(docPath);
            DateTime StartOf2009 = new DateTime(2009, 01, 01);

            var dirs = from dir in dirPrograms.EnumerateDirectories()
            where dir.CreationTimeUtc > StartOf2009
            select new
            {
                ProgDir = dir,
            };

            foreach (var di in dirs)
            {
                Console.WriteLine($"{di.ProgDir.Name}");
            }
        }
    }
}
// </Snippet1>

In het volgende voorbeeld wordt de DirectoryInfo.EnumerateFiles methode gebruikt om alle bestanden weer te geven waarvan Length de 10 MB overschrijdt. In dit voorbeeld worden eerst de mappen op het hoogste niveau opgesomd om mogelijke uitzonderingen voor onbevoegde toegang te ondervangen en vervolgens de bestanden op te sommen.

using System;
using System.IO;

class Program
{
    static void Main(string[] args)
    {
        // Set a variable to the My Documents path.
        string docPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);

        DirectoryInfo diTop = new DirectoryInfo(docPath);

        try
        {
            foreach (var fi in diTop.EnumerateFiles())
            {
                try
                {
                    // Display each file over 10 MB;
                    if (fi.Length > 10000000)
                    {
                        Console.WriteLine($"{fi.FullName}\t\t{fi.Length.ToString("N0")}");
                    }
                }
                catch (UnauthorizedAccessException unAuthTop)
                {
                    Console.WriteLine($"{unAuthTop.Message}");
                }
            }

            foreach (var di in diTop.EnumerateDirectories("*"))
            {
                try
                {
                    foreach (var fi in di.EnumerateFiles("*", SearchOption.AllDirectories))
                    {
                        try
                        {
                            // Display each file over 10 MB;
                            if (fi.Length > 10000000)
                            {
                                Console.WriteLine($"{fi.FullName}\t\t{fi.Length.ToString("N0")}");
                            }
                        }
                        catch (UnauthorizedAccessException unAuthFile)
                        {
                            Console.WriteLine($"unAuthFile: {unAuthFile.Message}");
                        }
                    }
                }
                catch (UnauthorizedAccessException unAuthSubDir)
                {
                    Console.WriteLine($"unAuthSubDir: {unAuthSubDir.Message}");
                }
            }
        }
        catch (DirectoryNotFoundException dirNotFound)
        {
            Console.WriteLine($"{dirNotFound.Message}");
        }
        catch (UnauthorizedAccessException unAuthDir)
        {
            Console.WriteLine($"unAuthDir: {unAuthDir.Message}");
        }
        catch (PathTooLongException longPath)
        {
            Console.WriteLine($"{longPath.Message}");
        }
    }
}

Zie ook