C# Directory.GetFiles (Comment ça fonctionne : Un guide pour les développeurs)

Introduction

Paramètre out en C#. En associant cette fonctionnalité à IronPDF, les développeurs peuvent automatiser les flux de travail PDF à grande échelle. Par exemple, vous pouvez utiliser Directory.GetFiles pour localiser tous les fichiers PDF dans un dossier, puis les traiter en masse en utilisantIronPDFpour des tâches telles que la fusion, l'ajout d'annotations, ou la génération de rapports. Cette combinaison permet des opérations rationalisées, surtout lorsqu'il s'agit de traiter de nombreux fichiers dans le système de fichiers.

Qu'est-ce qu'IronPDF ?

IronPDFest une bibliothèque .NET robuste qui fournit aux développeurs des outils pour travailler de manière transparente avec les fichiers PDF. Avec IronPDF, vous pouvez créer, modifier, fusionner, diviser et manipuler des PDFs en utilisant des méthodes simples et intuitives. Il comprend des fonctionnalités puissantes telles queConversion de HTML en PDF, style avancé et gestion des métadonnées. Pour les développeurs .NET travaillant sur des applications nécessitant un traitement PDF, IronPDF est un outil inestimable qui rationalise les flux de travail et améliore la productivité.

Pour commencer

Installation d'IronPDF

Installation du package NuGet

Pour commencer, ajoutez IronPDF à votre projet via NuGet :

1. Ouvrez votre projet dans Visual Studio.

2. Accédez au menu Outils et sélectionnez Gestionnaire de packages NuGet > Gérer les packages NuGet pour la solution.

   3. Recherchez IronPDF dans le gestionnaire de packages NuGet.

   

3. Installez la dernière version d'IronPDF.

   Alternativement, utilisez la console du gestionnaire de packages NuGet :

Install-Package IronPdf

Install-Package IronPdf

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

Notions de base de Directory.GetFiles en C

La méthode Directory.GetFiles fait partie de l'espace de noms System.IO et est utilisée pour récupérer les noms de fichiers d'un système de fichiers. Cette méthode, un membre public statique de type string de la classe Directory, simplifie l'accès aux chemins de fichiers. Par exemple :

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")

Ce extrait de code récupère tous les fichiers PDF dans le répertoire actuel. En combinant cette méthode avec IronPDF, vous pouvez créer des solutions automatisées pour traiter plusieurs fichiers à la fois. Vous pouvez également appliquer un modèle de recherche spécifié, défini comme un modèle de chaîne, pour filtrer les fichiers en fonction de leurs extensions ou de leurs noms.

Vous pouvez affiner davantage votre logique de récupération de fichiers en spécifiant des options de recherche, telles que l'inclusion des sous-répertoires de recherche :

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)

Cela garantit que les fichiers dans les dossiers imbriqués sont également inclus, récupérant le chemin absolu de chaque fichier et rendant l'approche polyvalente pour divers scénarios.

Cas d'utilisation pratiques

Récupération et traitement des fichiers PDF d'un répertoire

Exemple : Chargement de tous les fichiers PDF pour le traitement

En utilisant Directory.GetFiles, vous pouvez parcourir tous les fichiers PDF dans un répertoire et les traiter avec 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

Cet exemple montre comment charger plusieurs PDF à partir d'un répertoire pour les traiter. Une fois chargé, vous pouvez effectuer une variété d'opérations, telles que l'extraction de texte, l'ajout d'annotations ou la génération de nouveaux PDF basés sur leur contenu.

Filtrer les fichiers à l'aide de motifs de recherche

Exemple : Sélection des fichiers PDF par nom ou par date

Vous pouvez combiner Directory.GetFiles avec LINQ pour filtrer les fichiers selon des critères tels que la date de création ou de modification :

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

Cette approche garantit que seuls les fichiers pertinents sont traités, ce qui permet de gagner du temps et des ressources informatiques. Par exemple, vous pouvez utiliser cette méthode pour traiter uniquement les dernières factures ou rapports générés au cours de la dernière semaine.

Opérations par lots avec IronPDF et Directory.GetFiles

Exemple : Ajout de plusieurs PDF

Vous pouvez ajouter plusieurs PDF d'un répertoire dans un seul fichier :

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!")

Cette approche est particulièrement utile pour créer des rapports consolidés, archiver plusieurs documents ou préparer des présentations. En automatisant ce processus, vous pouvez gérer de grandes collections de fichiers sans effort.

Mise en œuvre étape par étape

Mise en place du projet

Extrait de code : Initialisation de IronPDF et travail avec les fichiers PDF

Le code suivant démontre comment IronPDF peut être utilisé avec Directory.GetFiles pour charger et travailler avec des documents PDF.

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

Sortie de la console

Explication

Ce code démontre comment ajouter une annotation texte à tous les fichiers PDF dans un répertoire spécifié en utilisant IronPDF en C#. Le programme commence par récupérer tous les chemins de fichiers PDF du dossier fourni en utilisant la méthode Directory.GetFiles, qui repose sur un chemin de type chaîne pour spécifier le répertoire et permet de filtrer par extension de fichier. qui renvoie un tableau de chaînes de caractères contenant les chemins de tous les fichiers PDF avec l'extension de fichier ".pdf".

Ensuite, le code initialise un objet PdfDocument(pdfAppend)avec des dimensions de 200x200, bien que cette instance spécifique ne soit pas utilisée directement dans la boucle. Il crée ensuite une TextAnnotation avec le texte "Processed by IronPDF" positionné aux coordonnées(10, 10). Cette annotation sera ajoutée à chaque fichier PDF.

Dans la boucle foreach, le programme parcourt chaque chemin de fichier dans le tableau pdfFiles. Pour chaque fichier, il charge le PDF en utilisant PdfDocument.FromFile(fichier), ajoute l'annotation précédemment créée à la collection d'annotations du PDF, puis enregistre le PDF mis à jour à son chemin absolu en utilisant pdf.SaveAs(fichier).

Ce processus garantit que chaque PDF dans le répertoire spécifié reçoit la même annotation et est enregistré avec l'annotation incluse.

Conseils de performance et meilleures pratiques

Optimisation de la récupération de fichiers avec Directory.GetFiles

Utilisez des méthodes asynchrones comme Directory.EnumerateFiles pour de meilleures performances avec de grands répertoires.

Gérer efficacement un grand nombre de fichiers

Traitez les fichiers par petits lots pour réduire la consommation de mémoire :

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

Gestion des erreurs dans le traitement des fichiers et la génération de PDF

Enveloppez le traitement de fichiers dans un bloc try-catch pour gérer les 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

En combinant la puissance de Directory.GetFiles avec IronPDF, les développeurs peuvent gérer et traiter efficacement des fichiers PDF à grande échelle. Avec cette approche, des tâches telles que le traitement par lots, la fusion, le filtrage et la transformation des PDF deviennent sans effort, réduisant considérablement l'effort manuel et améliorant la productivité. En tirant parti des capacités avancées d'IronPDF, y compris l'ajout d'en-têtes, de métadonnées et de styles, les développeurs peuvent créer des documents PDF de haute qualité et professionnels adaptés à leurs exigences.

Tout au long de ce guide, nous avons exploré comment utiliser Directory.GetFiles pour récupérer et manipuler des PDF avec IronPDF. De la mise en place d'un projet à la mise en œuvre de cas d'utilisation pratiques, nous avons couvert les techniques essentielles qui peuvent être appliquées à des scénarios réels. Que vous travailliez sur l'automatisation des flux de travail de documents ou sur l'amélioration des fonctionnalités de vos applications .NET, cette combinaison offre une solution robuste et évolutive.

Si vous êtes prêt à plonger plus profondément dans IronPDF et à explorer des fonctionnalités avancées, ledocumentation officielle, vous permettant de tester la bibliothèque dans vos propres projets avant de vous engager à un achat.