.NET HELP

C# Directory.GetFiles (How It Works: A Guide for Developers)

Published February 19, 2025

Introduction

C# out parameter. By pairing this functionality with IronPDF, developers can automate PDF workflows at scale. For example, you can use Directory.GetFiles to locate all PDF files in a folder, then process them in bulk using IronPDF for tasks such as merging, adding annotations, or generating reports. This combination allows for streamlined operations, especially when dealing with many files in the file system.

What is IronPDF?

IronPDF is a robust .NET library that provides developers with tools to work seamlessly with PDF files. With IronPDF, you can create, edit, merge, split, and manipulate PDFs using straightforward, intuitive methods. It includes powerful features such as HTML-to-PDF conversion, advanced styling, and metadata handling. For .NET developers working on applications that require PDF processing, IronPDF is an invaluable tool that streamlines workflows and enhances productivity.

Getting Started

Installing IronPDF

NuGet Package Installation

To begin, add IronPDF to your project via NuGet:

Open your project in Visual Studio.
Go to the Tools menu and select NuGet Package Manager > Manage NuGet Packages for Solution.
1. Search for IronPDF in the NuGet package manager.

C# Directory.GetFiles (How It Works: A Guide for Developers): Figure 1

Install the latest version of IronPDF.

Alternatively, use the NuGet Package Manager Console:

Install-Package IronPdf

Install-Package IronPdf

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'Install-Package IronPdf

Basics of Directory.GetFiles in C#

The Directory.GetFiles method is part of the System.IO namespace and is used to retrieve file names from a file system. This method, a public static string member of the Directory class, simplifies accessing file paths. For instance:

string[] pdfFiles = Directory.GetFiles("C:\\Documents\\PDFs", "*.pdf");

string[] pdfFiles = Directory.GetFiles("C:\\Documents\\PDFs", "*.pdf");

Dim pdfFiles() As String = Directory.GetFiles("C:\Documents\PDFs", "*.pdf")

This snippet retrieves all PDF files within the current directory. By combining this method with IronPDF, you can create automated solutions for processing multiple files at once. You can also apply a specified search pattern, defined as a string pattern, to filter files based on their extensions or names.

You can further refine your file retrieval logic by specifying search options, such as including searchsubdirectories:

string[] pdfFiles = Directory.GetFiles("C:\\Documents\\PDFs", "*.pdf", SearchOption.AllDirectories);

string[] pdfFiles = Directory.GetFiles("C:\\Documents\\PDFs", "*.pdf", SearchOption.AllDirectories);

Dim pdfFiles() As String = Directory.GetFiles("C:\Documents\PDFs", "*.pdf", SearchOption.AllDirectories)

This ensures that files in nested folders are also included, retrieving each file's absolute path and making the approach versatile for various scenarios.

Practical Use Cases

Fetching and Processing PDF Files from a Directory

Example: Loading All PDF Files for Processing

Using Directory.GetFiles, you can iterate over all PDF files in a directory and process them with IronPDF:

string[] pdfFiles = Directory.GetFiles("C:\\Documents\\PDFs", "*.pdf");
foreach (string file in pdfFiles)
{
    // Load the PDF with IronPDF
    var pdf = PdfDocument.FromFile(file);
    Console.WriteLine($"Processing file: {Path.GetFileName(file)}");
}

string[] pdfFiles = Directory.GetFiles("C:\\Documents\\PDFs", "*.pdf");
foreach (string file in pdfFiles)
{
    // Load the PDF with IronPDF
    var pdf = PdfDocument.FromFile(file);
    Console.WriteLine($"Processing file: {Path.GetFileName(file)}");
}

Dim pdfFiles() As String = Directory.GetFiles("C:\Documents\PDFs", "*.pdf")
For Each file As String In pdfFiles
	' Load the PDF with IronPDF
	Dim pdf = PdfDocument.FromFile(file)
	Console.WriteLine($"Processing file: {Path.GetFileName(file)}")
Next file

C# Directory.GetFiles (How It Works: A Guide for Developers): Figure 2

This example demonstrates how to load multiple PDFs from a directory for processing. Once loaded, you can perform a variety of operations, such as extracting text, adding annotations, or generating new PDFs based on their content.

Filtering Files Using Search Patterns

Example: Selecting PDFs by Name or Date

You can combine Directory.GetFiles with LINQ to filter files based on criteria such as creation or modification date:

string[] pdfFiles = Directory.GetFiles("C:\\Documents\\PDFs", "*.pdf");
var recentFiles = pdfFiles.Where(file => File.GetLastWriteTime(file) > DateTime.Now.AddDays(-7));
foreach (string file in recentFiles)
{
    Console.WriteLine($"Recent file: {Path.GetFileName(file)}");
}

string[] pdfFiles = Directory.GetFiles("C:\\Documents\\PDFs", "*.pdf");
var recentFiles = pdfFiles.Where(file => File.GetLastWriteTime(file) > DateTime.Now.AddDays(-7));
foreach (string file in recentFiles)
{
    Console.WriteLine($"Recent file: {Path.GetFileName(file)}");
}

Dim pdfFiles() As String = Directory.GetFiles("C:\Documents\PDFs", "*.pdf")
Dim recentFiles = pdfFiles.Where(Function(file) File.GetLastWriteTime(file) > DateTime.Now.AddDays(-7))
For Each file As String In recentFiles
	Console.WriteLine($"Recent file: {Path.GetFileName(file)}")
Next file

C# Directory.GetFiles (How It Works: A Guide for Developers): Figure 3

This approach ensures that only relevant files are processed, saving time and computational resources. For example, you might use this method to process only the latest invoices or reports generated within the last week.

Batch Operations with IronPDF and Directory.GetFiles

Example: Appending Multiple PDFs

You can append multiple PDFs from a directory into a single file:

string[] pdfFiles = Directory.GetFiles("C:\\Documents\\PDFs", "*.pdf");
var pdfAppend = new PdfDocument(200, 200);
foreach (string file in pdfFiles)
{
    var pdf = PdfDocument.FromFile(file);
    pdfAppend.AppendPdf(pdf);
}
pdfAppend.SaveAs("LargePdf.pdf");
Console.WriteLine("PDFs Appended successfully!");

string[] pdfFiles = Directory.GetFiles("C:\\Documents\\PDFs", "*.pdf");
var pdfAppend = new PdfDocument(200, 200);
foreach (string file in pdfFiles)
{
    var pdf = PdfDocument.FromFile(file);
    pdfAppend.AppendPdf(pdf);
}
pdfAppend.SaveAs("LargePdf.pdf");
Console.WriteLine("PDFs Appended successfully!");

Dim pdfFiles() As String = Directory.GetFiles("C:\Documents\PDFs", "*.pdf")
Dim pdfAppend = New PdfDocument(200, 200)
For Each file As String In pdfFiles
	Dim pdf = PdfDocument.FromFile(file)
	pdfAppend.AppendPdf(pdf)
Next file
pdfAppend.SaveAs("LargePdf.pdf")
Console.WriteLine("PDFs Appended successfully!")

C# Directory.GetFiles (How It Works: A Guide for Developers): Figure 4

This approach is particularly useful for creating consolidated reports, archiving multiple documents, or preparing presentations. By automating this process, you can handle large collections of files effortlessly.

Step-by-Step Implementation

Setting Up the Project

Code Snippet: Initializing IronPDF and Working with PDF Files

The following code demonstrates how IronPDF can be used alongside Directory.GetFiles to load and work with PDF documents.

using IronPdf;
using System;
using System.IO;
class Program
{
    static void Main()
    {
        string[] pdfFiles = Directory.GetFiles("C:\\Users\\kyess\\Documents\\PDFs", "*.pdf");
    var pdfAppend = new PdfDocument(200, 200);
    TextAnnotation annotation = new TextAnnotation(0)
    {
            Contents = "Processed by IronPDF",
            X = 50,
            Y = 50,
    };
    foreach (string file in pdfFiles)
    {
        var pdf = PdfDocument.FromFile(file);
            pdf.Annotations.Add(annotation);
            pdf.SaveAs(file);
    }
    }
}

using IronPdf;
using System;
using System.IO;
class Program
{
    static void Main()
    {
        string[] pdfFiles = Directory.GetFiles("C:\\Users\\kyess\\Documents\\PDFs", "*.pdf");
    var pdfAppend = new PdfDocument(200, 200);
    TextAnnotation annotation = new TextAnnotation(0)
    {
            Contents = "Processed by IronPDF",
            X = 50,
            Y = 50,
    };
    foreach (string file in pdfFiles)
    {
        var pdf = PdfDocument.FromFile(file);
            pdf.Annotations.Add(annotation);
            pdf.SaveAs(file);
    }
    }
}

Imports IronPdf
Imports System
Imports System.IO
Friend Class Program
	Shared Sub Main()
		Dim pdfFiles() As String = Directory.GetFiles("C:\Users\kyess\Documents\PDFs", "*.pdf")
	Dim pdfAppend = New PdfDocument(200, 200)
	Dim annotation As New TextAnnotation(0) With {
		.Contents = "Processed by IronPDF",
		.X = 50,
		.Y = 50
	}
	For Each file As String In pdfFiles
		Dim pdf = PdfDocument.FromFile(file)
			pdf.Annotations.Add(annotation)
			pdf.SaveAs(file)
	Next file
	End Sub
End Class

Console Output

C# Directory.GetFiles (How It Works: A Guide for Developers): Figure 5

Explanation

This code demonstrates how to add a text annotation to all PDF files in a specified directory using IronPDF in C#. The program begins by retrieving all PDF file paths from the folder provided using the Directory.GetFiles method, which relies on a string path to specify the directory and supports filtering by file extension. which returns an array of string filename containing the paths of all PDF files with the ".pdf" file extension.

Next, the code initializes a PdfDocument object (pdfAppend) with dimensions 200x200, although this specific instance isn't used directly in the loop. It then creates a TextAnnotation with the text "Processed by IronPDF" positioned at coordinates (10, 10). This annotation will be added to each PDF file.

In the foreach loop, the program iterates through each file path in the pdfFiles array. For each file, it loads the PDF using PdfDocument.FromFile(file), adds the previously created annotation to the PDF's Annotations collection, and then saves the updated PDF back to its absolute path using pdf.SaveAs(file).

This process ensures that every PDF in the specified directory receives the same annotation and is saved with the annotation included.

Performance Tips and Best Practices

Optimizing File Retrieval with Directory.GetFiles

Use asynchronous methods like Directory.EnumerateFiles for better performance with large directories.

Managing Large Numbers of Files Efficiently

Process files in smaller batches to reduce memory consumption:

foreach (var batch in pdfFiles.Batch(10))
{
    foreach (string file in batch)
    {
        var pdf = PdfDocument.FromFile(file);
        // Process PDF
    }
}

foreach (var batch in pdfFiles.Batch(10))
{
    foreach (string file in batch)
    {
        var pdf = PdfDocument.FromFile(file);
        // Process PDF
    }
}

For Each batch In pdfFiles.Batch(10)
	For Each file As String In batch
		Dim pdf = PdfDocument.FromFile(file)
		' Process PDF
	Next file
Next batch

Error Handling in File Processing and PDF Generation

Wrap file processing in a try-catch block to handle exceptions:

try
{
    var pdf = PdfDocument.FromFile(file);
    // Process PDF
}
catch (Exception ex)
{
    Console.WriteLine($"Error processing {file}: {ex.Message}");
}

try
{
    var pdf = PdfDocument.FromFile(file);
    // Process PDF
}
catch (Exception ex)
{
    Console.WriteLine($"Error processing {file}: {ex.Message}");
}

Try
	Dim pdf = PdfDocument.FromFile(file)
	' Process PDF
Catch ex As Exception
	Console.WriteLine($"Error processing {file}: {ex.Message}")
End Try

Conclusion

Combining the power of Directory.GetFiles with IronPDF allows developers to efficiently manage and process PDF files at scale. With this approach, tasks such as batch processing, merging, filtering, and transforming PDFs become seamless, significantly reducing manual effort and improving productivity. By leveraging the advanced capabilities of IronPDF, including adding headers, metadata, and styling, developers can create high-quality, professional PDF documents tailored to their requirements.

Throughout this guide, we’ve explored how to use Directory.GetFiles to retrieve and manipulate PDFs with IronPDF. From setting up a project to implementing practical use cases, we covered essential techniques that can be applied to real-world scenarios. Whether you are working on automating document workflows or enhancing the functionality of your .NET applications, this combination provides a robust and scalable solution.

If you're ready to dive deeper into IronPDF and explore advanced features, the official documentation, allowing you to test the library in your own projects before committing to a purchase.

Kannapat Udonpant

Software Engineer

LinkedIn

Before becoming a Software Engineer, Kannapat completed a Environmental Resources PhD from Hokkaido University in Japan. While pursuing his degree, Kannapat also became a member of the Vehicle Robotics Laboratory, which is part of the Department of Bioproduction Engineering. In 2022, he leveraged his C# skills to join Iron Software's engineering team, where he focuses on IronPDF. Kannapat values his job because he learns directly from the developer who writes most of the code used in IronPDF. In addition to peer learning, Kannapat enjoys the social aspect of working at Iron Software. When he's not writing code or documentation, Kannapat can usually be found gaming on his PS5 or rewatching The Last of Us.

NEXT >
C# Out Parameter (How It Works: A Guide for Developers)