Comment convertir un PDF en TIFF en C#

Comment commencer avec IronPDF ?

Ajoutez IronPDF à n'importe quel projet .NET 8 ou .NET 10 en quelques secondes grâce au gestionnaire de packages NuGet ou à l'interface de ligne de commande .NET . Aucune dépendance d'exécution supplémentaire ni aucun binaire natif ne sont requis sous Windows, Linux ou macOS.

dotnet add package IronPdf

Une fois le package installé, ajoutez using IronPdf; en haut de votre fichier C#. Une clé de licence valide déverrouille l'utilisation commerciale complète ; Une licence d'essai gratuite est disponible pour évaluation. Définissez votre clé avant d'appeler une API :

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

Avec le paquetage référencé et la licence configurée, chaque exemple de cet article fonctionnera sans modification. Le package NuGet IronPDF cible .NET Standard 2.0 et versions ultérieures, il fonctionne donc avec .NET Framework 4.6.2+, .NET Core et toutes les versions modernes de .NET .

Comment fonctionne le réordonnancement des pages en C# ?

Le processus pour réorganiser les pages dans un PDF en utilisant C# implique de charger le document source, de spécifier l'ordre de pages souhaité à travers une matrice d'index de pages, et de sauvegarder le fichier de sortie. IronPDF fournit la méthode CopyPages pour extraire et réordonner les pages d'un PDF dans un nouvel objet PdfDocument.

Le code suivant démontre comment réordonner les pages en créant un nouveau tableau int qui définit la séquence cible. Chaque valeur du tableau représente un index de page du document original, où les pages utilisent une indexation basée sur le zéro (la page 0 est la première page).

using IronPdf;

// Load the source document from file path
var pdf = PdfDocument.FromFile("quarterly-report.pdf");

// Define new page order: move page 3 to front, then pages 1, 2, 0
int[] pageOrder = new int[] { 3, 1, 2, 0 };

// Copy each requested page into its own PdfDocument
var pageDocs = new List<PdfDocument>();
foreach (var idx in pageOrder)
{
    // CopyPage returns a PdfDocument containing only that page
    var single = pdf.CopyPage(idx);
    pageDocs.Add(single);
}

// Merge the single-page docs into one ordered document
using var merged = PdfDocument.Merge(pageDocs.ToArray());

// Save the new ordered PDF
merged.SaveAs("report-reorganized.pdf");

using IronPdf;

// Load the source document from file path
var pdf = PdfDocument.FromFile("quarterly-report.pdf");

// Define new page order: move page 3 to front, then pages 1, 2, 0
int[] pageOrder = new int[] { 3, 1, 2, 0 };

// Copy each requested page into its own PdfDocument
var pageDocs = new List<PdfDocument>();
foreach (var idx in pageOrder)
{
    // CopyPage returns a PdfDocument containing only that page
    var single = pdf.CopyPage(idx);
    pageDocs.Add(single);
}

// Merge the single-page docs into one ordered document
using var merged = PdfDocument.Merge(pageDocs.ToArray());

// Save the new ordered PDF
merged.SaveAs("report-reorganized.pdf");

Imports IronPdf

' Load the source document from file path
Dim pdf As PdfDocument = PdfDocument.FromFile("quarterly-report.pdf")

' Define new page order: move page 3 to front, then pages 1, 2, 0
Dim pageOrder As Integer() = {3, 1, 2, 0}

' Copy each requested page into its own PdfDocument
Dim pageDocs As New List(Of PdfDocument)()
For Each idx In pageOrder
    ' CopyPage returns a PdfDocument containing only that page
    Dim single As PdfDocument = pdf.CopyPage(idx)
    pageDocs.Add(single)
Next

' Merge the single-page docs into one ordered document
Using merged As PdfDocument = PdfDocument.Merge(pageDocs.ToArray())
    ' Save the new ordered PDF
    merged.SaveAs("report-reorganized.pdf")
End Using

Comment réorganiser plusieurs pages à la fois ?

Lorsqu'un document PDF contient de nombreuses pages, vous pouvez réorganiser toute sa structure en une seule opération. Le code ci-dessous montre comment inverser toutes les pages ou créer une séquence personnalisée en calculant le tableau d'index par programmation.

using IronPdf;

// Load PDF document with several pages
var doc = PdfDocument.FromFile("quarterly-report.pdf");
int count = doc.PageCount;

// Build reversed single-page PDFs
var pages = new List<PdfDocument>();
for (int i = count - 1; i >= 0; i--)
{
    // Copy a single page as a standalone PdfDocument
    pages.Add(doc.CopyPage(i));
}

// Merge all the reversed single-page PDFs
using var reversed = PdfDocument.Merge(pages.ToArray());

// Save to a new filename
reversed.SaveAs("report-reversed.pdf");

using IronPdf;

// Load PDF document with several pages
var doc = PdfDocument.FromFile("quarterly-report.pdf");
int count = doc.PageCount;

// Build reversed single-page PDFs
var pages = new List<PdfDocument>();
for (int i = count - 1; i >= 0; i--)
{
    // Copy a single page as a standalone PdfDocument
    pages.Add(doc.CopyPage(i));
}

// Merge all the reversed single-page PDFs
using var reversed = PdfDocument.Merge(pages.ToArray());

// Save to a new filename
reversed.SaveAs("report-reversed.pdf");

Imports IronPdf

' Load PDF document with several pages
Dim doc = PdfDocument.FromFile("quarterly-report.pdf")
Dim count As Integer = doc.PageCount

' Build reversed single-page PDFs
Dim pages As New List(Of PdfDocument)()
For i As Integer = count - 1 To 0 Step -1
    ' Copy a single page as a standalone PdfDocument
    pages.Add(doc.CopyPage(i))
Next

' Merge all the reversed single-page PDFs
Using reversed = PdfDocument.Merge(pages.ToArray())
    ' Save to a new filename
    reversed.SaveAs("report-reversed.pdf")
End Using

Comment déplacer une seule page vers un nouvel emplacement ?

Déplacer une page à un autre emplacement nécessite de combiner une copie, un retrait et une insertion. La méthode InsertPdf place un PdfDocument à n'importe quel index dans le document cible.

using IronPdf;

// Load the input PDF file
var pdf = PdfDocument.FromFile("presentation.pdf");
int sourceIndex = 1;   // page to move
int targetIndex = 3;   // destination position

// Track direction to handle index shift after removal
bool movingForward = targetIndex > sourceIndex;

// 1. Copy the page to move (produces a one-page PdfDocument)
var pageDoc = pdf.CopyPage(sourceIndex);

// 2. Remove the original page from its current position
pdf.RemovePage(sourceIndex);

// 3. Adjust target index if moving forward (removal shifts remaining pages left)
if (movingForward)
    targetIndex--;

// 4. Insert the copied page at the target position
pdf.InsertPdf(pageDoc, targetIndex);

// Save the result
pdf.SaveAs("presentation-reordered.pdf");

using IronPdf;

// Load the input PDF file
var pdf = PdfDocument.FromFile("presentation.pdf");
int sourceIndex = 1;   // page to move
int targetIndex = 3;   // destination position

// Track direction to handle index shift after removal
bool movingForward = targetIndex > sourceIndex;

// 1. Copy the page to move (produces a one-page PdfDocument)
var pageDoc = pdf.CopyPage(sourceIndex);

// 2. Remove the original page from its current position
pdf.RemovePage(sourceIndex);

// 3. Adjust target index if moving forward (removal shifts remaining pages left)
if (movingForward)
    targetIndex--;

// 4. Insert the copied page at the target position
pdf.InsertPdf(pageDoc, targetIndex);

// Save the result
pdf.SaveAs("presentation-reordered.pdf");

Imports IronPdf

' Load the input PDF file
Dim pdf = PdfDocument.FromFile("presentation.pdf")
Dim sourceIndex As Integer = 1   ' page to move
Dim targetIndex As Integer = 3   ' destination position

' Track direction to handle index shift after removal
Dim movingForward As Boolean = targetIndex > sourceIndex

' 1. Copy the page to move (produces a one-page PdfDocument)
Dim pageDoc = pdf.CopyPage(sourceIndex)

' 2. Remove the original page from its current position
pdf.RemovePage(sourceIndex)

' 3. Adjust target index if moving forward (removal shifts remaining pages left)
If movingForward Then
    targetIndex -= 1
End If

' 4. Insert the copied page at the target position
pdf.InsertPdf(pageDoc, targetIndex)

' Save the result
pdf.SaveAs("presentation-reordered.pdf")

Comment supprimer des pages et les réorganiser à l'aide de MemoryStream ?

Les applications qui automatisent les flux de travail PDF ont parfois besoin de manipuler des documents sans écrire de fichiers intermédiaires sur le disque. Charger à partir d'un tableau d'octets et exporter vers un MemoryStream garde tout le traitement en mémoire, ce qui est plus rapide pour les opérations transitoires et évite les problèmes de permissions du système de fichiers dans des environnements conteneurisés ou sans serveur.

using IronPdf;
using System.IO;

// Load PDF from byte array (simulating input from a database or API response)
byte[] pdfBytes = File.ReadAllBytes("report-with-blank.pdf");
var pdf = new PdfDocument(pdfBytes);

// Delete the blank page at index 2 (zero-based)
pdf.RemovePage(2);

// Reorder remaining pages: new sequence from a four-page document
var reorderedPdf = pdf.CopyPages(new int[] { 1, 0, 2, 3 });

// Export to MemoryStream for further processing (e.g., HTTP response body)
MemoryStream outputStream = reorderedPdf.Stream;

// Or save directly using the BinaryData property
File.WriteAllBytes("cleaned-report.pdf", reorderedPdf.BinaryData);

using IronPdf;
using System.IO;

// Load PDF from byte array (simulating input from a database or API response)
byte[] pdfBytes = File.ReadAllBytes("report-with-blank.pdf");
var pdf = new PdfDocument(pdfBytes);

// Delete the blank page at index 2 (zero-based)
pdf.RemovePage(2);

// Reorder remaining pages: new sequence from a four-page document
var reorderedPdf = pdf.CopyPages(new int[] { 1, 0, 2, 3 });

// Export to MemoryStream for further processing (e.g., HTTP response body)
MemoryStream outputStream = reorderedPdf.Stream;

// Or save directly using the BinaryData property
File.WriteAllBytes("cleaned-report.pdf", reorderedPdf.BinaryData);

Imports IronPdf
Imports System.IO

' Load PDF from byte array (simulating input from a database or API response)
Dim pdfBytes As Byte() = File.ReadAllBytes("report-with-blank.pdf")
Dim pdf As New PdfDocument(pdfBytes)

' Delete the blank page at index 2 (zero-based)
pdf.RemovePage(2)

' Reorder remaining pages: new sequence from a four-page document
Dim reorderedPdf = pdf.CopyPages(New Integer() {1, 0, 2, 3})

' Export to MemoryStream for further processing (e.g., HTTP response body)
Dim outputStream As MemoryStream = reorderedPdf.Stream

' Or save directly using the BinaryData property
File.WriteAllBytes("cleaned-report.pdf", reorderedPdf.BinaryData)

Le constructeur PdfDocument accepte un byte[] directement, et la propriété Stream retourne le PDF résultant comme un MemoryStream. Ce modèle convient aux contrôleurs ASP.NET Core qui renvoient des réponses de type fichier, aux Azure Functions qui lisent et écrivent dans le stockage Blob, et aux services d'arrière-plan qui traitent des lots de PDF à partir d'une file d'attente de messages. La bibliothèque gère efficacement la mémoire, même pour les documents volumineux contenant des images intégrées.

Consultez la documentation de l'API PdfDocument pour découvrir l'ensemble des méthodes d'opération sur les pages, notamment la rotation, l'extraction et l'estampillage.

using IronPdf;
using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api/pdf")]
public class PdfController : ControllerBase
{
    [HttpPost("reorder")]
    public IActionResult Reorder(IFormFile file, [FromQuery] string order)
    {
        // Parse comma-separated page indexes from query string
        var indexes = order.Split(',').Select(int.Parse).ToArray();

        using var stream = file.OpenReadStream();
        using var ms = new System.IO.MemoryStream();
        stream.CopyTo(ms);

        var pdf = new PdfDocument(ms.ToArray());
        var reordered = pdf.CopyPages(indexes);

        // Return the reordered PDF as a downloadable file
        return File(reordered.BinaryData, "application/pdf", "reordered.pdf");
    }
}

using IronPdf;
using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api/pdf")]
public class PdfController : ControllerBase
{
    [HttpPost("reorder")]
    public IActionResult Reorder(IFormFile file, [FromQuery] string order)
    {
        // Parse comma-separated page indexes from query string
        var indexes = order.Split(',').Select(int.Parse).ToArray();

        using var stream = file.OpenReadStream();
        using var ms = new System.IO.MemoryStream();
        stream.CopyTo(ms);

        var pdf = new PdfDocument(ms.ToArray());
        var reordered = pdf.CopyPages(indexes);

        // Return the reordered PDF as a downloadable file
        return File(reordered.BinaryData, "application/pdf", "reordered.pdf");
    }
}

Imports IronPdf
Imports Microsoft.AspNetCore.Mvc
Imports System.IO

<ApiController>
<Route("api/pdf")>
Public Class PdfController
    Inherits ControllerBase

    <HttpPost("reorder")>
    Public Function Reorder(file As IFormFile, <FromQuery> order As String) As IActionResult
        ' Parse comma-separated page indexes from query string
        Dim indexes = order.Split(","c).Select(Function(s) Integer.Parse(s)).ToArray()

        Using stream = file.OpenReadStream()
            Using ms = New MemoryStream()
                stream.CopyTo(ms)

                Dim pdf = New PdfDocument(ms.ToArray())
                Dim reordered = pdf.CopyPages(indexes)

                ' Return the reordered PDF as a downloadable file
                Return File(reordered.BinaryData, "application/pdf", "reordered.pdf")
            End Using
        End Using
    End Function
End Class

Comment fusionner des fichiers PDF après les avoir réorganisés ?

Le réarrangement des pages va souvent de pair avec la combinaison de contenu provenant de plusieurs fichiers sources. La méthode PdfDocument.Merge de IronPDF accepte un tableau d'objets PdfDocument et les joint dans l'ordre fourni, ce qui se marie naturellement avec les techniques de copie de pages montrées ci-dessus.

using IronPdf;

// Load two separate PDF files
var docA = PdfDocument.FromFile("section-a.pdf");
var docB = PdfDocument.FromFile("section-b.pdf");

// Reorder pages within each source document
var reorderedA = docA.CopyPages(new int[] { 1, 0, 2 });
var reorderedB = docB.CopyPages(new int[] { 0, 2, 1 });

// Merge into a single output document
using var combined = PdfDocument.Merge(reorderedA, reorderedB);
combined.SaveAs("combined-report.pdf");

using IronPdf;

// Load two separate PDF files
var docA = PdfDocument.FromFile("section-a.pdf");
var docB = PdfDocument.FromFile("section-b.pdf");

// Reorder pages within each source document
var reorderedA = docA.CopyPages(new int[] { 1, 0, 2 });
var reorderedB = docB.CopyPages(new int[] { 0, 2, 1 });

// Merge into a single output document
using var combined = PdfDocument.Merge(reorderedA, reorderedB);
combined.SaveAs("combined-report.pdf");

Imports IronPdf

' Load two separate PDF files
Dim docA = PdfDocument.FromFile("section-a.pdf")
Dim docB = PdfDocument.FromFile("section-b.pdf")

' Reorder pages within each source document
Dim reorderedA = docA.CopyPages(New Integer() {1, 0, 2})
Dim reorderedB = docB.CopyPages(New Integer() {0, 2, 1})

' Merge into a single output document
Using combined = PdfDocument.Merge(reorderedA, reorderedB)
    combined.SaveAs("combined-report.pdf")
End Using

Après la fusion, le document résultant contient toutes les pages de reorderedA suivies de toutes les pages de reorderedB. Vous pouvez enchaîner des appels Merge supplémentaires ou passer davantage de documents pour combiner tout nombre de sources. La documentation IronPDF sur la fusion et la division explique comment diviser des documents en sections individuelles, ce qui est l'opération inverse.

Pour une analyse plus approfondie de la fusion de tableaux d'octets et de documents en mémoire, le guide sur la fusion de PDF à partir de tableaux d'octets en C# décrit les flux de travail basés sur une base de données où les documents sont stockés sous forme de blobs binaires plutôt que de chemins de fichiers.

Quelles sont les meilleures pratiques pour la gestion des pages PDF ?

Les bonnes pratiques de programmation permettent d'éviter les bugs subtils et les défaillances de production lors de la manipulation à grande échelle de pages PDF. L'application systématique de ces pratiques facilite le test et la maintenance du code de réorganisation des pages.

Validez toujours les index de pages contre PdfDocument.PageCount avant de les passer à CopyPages ou RemovePage. Un index qui tombe en dehors de [0, PageCount - 1] soulève un ArgumentOutOfRangeException à l'exécution. Une vérification de garde en une ligne élimine entièrement cette catégorie de défaillance.

Privilégiez la surcharge CopyPages(IEnumerable<int>) par rapport à la boucle manuelle à travers CopyPage lorsque vous travaillez avec des réorganisations multipages. Le traitement par lots traite la séquence complète en une seule passe, réduisant ainsi les allocations et le temps d'exécution. Réservez le modèle de boucle par page aux cas où vous devez appliquer des transformations page par page, comme la rotation de pages individuelles avant la fusion.

Encadrez les objets intermédiaires PdfDocument dans les instructions using pour garantir que leurs ressources non gérées soient libérées immédiatement après utilisation. Ceci est particulièrement important dans les gestionnaires de requêtes Web et les tâches en arrière-plan, où de nombreux documents peuvent s'accumuler en mémoire si les objets intermédiaires ne sont pas supprimés rapidement. Le guide de dépannage IronPDF couvre en détail les problèmes courants de mémoire et de performances.

Lors de la conception de pipelines d'automatisation de documents, il est conseillé de séparer la logique de réorganisation des entrées/sorties de fichiers. Acceptez et retournez byte[] ou MemoryStream dans votre couche de service pour garder les tests unitaires rapides et éviter les dépendances au système de fichiers. Les exemples IronPDF pour les opérations sur les pages PDF présentent côte à côte des modèles pour les flux de travail par chemin de fichier et en mémoire.

Quelles sont vos prochaines étapes ?

Réorganiser les pages PDF en C# avec IronPDF réduit une tâche complexe de manipulation de documents à quelques appels de méthode. Les techniques de base couvertes dans cet article incluent la réorganisation des pages avec un tableau d'index utilisant CopyPages, l'inversion de toutes les pages par programmation avec une boucle, le déplacement d'une seule page en combinant CopyPage, RemovePage, et InsertPdf, la suppression des pages indésirables avant réorganisation, et le traitement des documents entièrement en mémoire en utilisant des tableaux d'octets et MemoryStream.

Chacun de ces modèles s'intègre au reste des fonctionnalités IronPDF . Après avoir réorganisé les pages, vous pouvez ajouter un filigrane ou un tampon , rogner certaines pages ou ajouter des numéros de page avant de livrer le document final. Les guides pratiques IronPDF fournissent des exemples de code pour chacune de ces opérations de suivi.

Commencez par une licence d'essai gratuite pour tester le réarrangement des pages et toutes les autres fonctionnalités IronPDF dans votre propre environnement. Lorsque vous serez prêt à déployer votre solution, consultez les options de licence IronPDF pour trouver le niveau qui correspond aux exigences de votre projet. La IronPDF et le référentiel d'objets d'IronPDF sont disponibles chaque fois que vous souhaitez explorer des scénarios avancés tels que les signatures numériques, la conformité PDF/A et le balisage d'accessibilité.