Comment fusionner plusieurs fichiers pdf (générés en temps d'exécution)?

Si vous souhaitez fusionner les documents source à l'aide de la bibliothèque iText(Sharp), il y a deux situations de base:

1. Vous voulez vraiment fusionner les documents, d'en acquérir les pages dans leur format d'origine, le transfert d'un maximum de leur contenu et de leur interactif annotations que possible. Dans ce cas, vous devez utiliser une solution basée sur un membre de la Pdf*Copy* famille des classes.

2. Que vous voulez vraiment intégrer des pages à partir de la source des documents dans un nouveau document, mais que vous voulez le nouveau document de gouverner le format général et ne se soucient pas pour les fonctionnalités interactives (annotations...) dans les documents d'origine (ou même vouloir se débarrasser d'eux). Dans ce cas, vous devez utiliser une solution basée sur le PdfWriter classe.

Vous pouvez trouver plus de détails en chapitre 6 (en particulier l'article 6.4) de iText dans l'Action — 2e Édition. L'exemple de code Java peut être consulté ici et le C#identifiés versions ici.

Un simple échantillon à l'aide de PdfCopy est Concatenate.java /Les concaténer.cs. La pièce centrale de code est:

byte[] mergedPdf = null;
using (MemoryStream ms = new MemoryStream())
{
    using (Document document = new Document())
    {
        using (PdfCopy copy = new PdfCopy(document, ms))
        {
            document.Open();

            for (int i = 0; i < pdf.Count; ++i)
            {
                PdfReader reader = new PdfReader(pdf[i]);
                //loop over the pages in that document
                int n = reader.NumberOfPages;
                for (int page = 0; page < n; )
                {
                    copy.AddPage(copy.GetImportedPage(reader, ++page));
                }
            }
        }
    }
    mergedPdf = ms.ToArray();
}

Ici pdf peut être défini comme un List<byte[]> immédiatement contenant les documents sources (approprié pour votre cas d'utilisation de la fusion des intermédiaires en mémoire des documents) ou comme un List<String> contenant le nom de la source des fichiers de document (approprié si vous fusionnez des documents à partir du disque).

Un aperçu à la fin de l'référencé chapitre résume l'utilisation des classes visées:

• PdfCopy: Les Copies des pages d'un ou plusieurs documents PDF existants. Inconvénients majeurs: PdfCopy ne détecte pas redondant de contenu, et il échoue lors de la concaténation de formes.

• PdfCopyFields: Place les champs des différentes formes sur un seul formulaire. Peut être utilisé pour éviter les problèmes rencontrés avec les champs de formulaire lors de la concaténation de formulaires à l'aide de PdfCopy. L'utilisation de la mémoire peut être un problème.

• PdfSmartCopy: Les Copies des pages d'un ou plusieurs documents PDF existants. PdfSmartCopy est capable de détecter des contenus en double, mais il a besoin de plus de mémoire et de CPU que PdfCopy.

• PdfWriter: Génère des documents PDF à partir de zéro. Peut importer des pages à partir d'autres documents de PDF. L'inconvénient majeur est que toutes les fonctionnalités interactives de l'importation de la page (annotations, signets, les champs, et ainsi de suite) sont perdus dans le processus.

Voici un code que j'ai tirée d'un vieux projet que j'avais. C'était une application web, mais j'ai été en utilisant iTextSharp pour fusionner des fichiers pdf, puis les imprimer.

public static class PdfMerger
{
///<summary>
///Merge pdf files.
///</summary>
///<param name="sourceFiles">PDF files being merged.</param>
///<returns></returns>
public static byte[] MergeFiles(List<Stream> sourceFiles)
{
Document document = new Document();
MemoryStream output = new MemoryStream();
try
{
//Initialize pdf writer
PdfWriter writer = PdfWriter.GetInstance(document, output);
writer.PageEvent = new PdfPageEvents();
//Open document to write
document.Open();
PdfContentByte content = writer.DirectContent;
//Iterate through all pdf documents
for (int fileCounter = 0; fileCounter < sourceFiles.Count; fileCounter++)
{
//Create pdf reader
PdfReader reader = new PdfReader(sourceFiles[fileCounter]);
int numberOfPages = reader.NumberOfPages;
//Iterate through all pages
for (int currentPageIndex = 1; currentPageIndex <=
numberOfPages; currentPageIndex++)
{
//Determine page size for the current page
document.SetPageSize(
reader.GetPageSizeWithRotation(currentPageIndex));
//Create page
document.NewPage();
PdfImportedPage importedPage =
writer.GetImportedPage(reader, currentPageIndex);
//Determine page orientation
int pageOrientation = reader.GetPageRotation(currentPageIndex);
if ((pageOrientation == 90) || (pageOrientation == 270))
{
content.AddTemplate(importedPage, 0, -1f, 1f, 0, 0,
reader.GetPageSizeWithRotation(currentPageIndex).Height);
}
else
{
content.AddTemplate(importedPage, 1f, 0, 0, 1f, 0, 0);
}
}
}
}
catch (Exception exception)
{
throw new Exception("There has an unexpected exception" +
" occured during the pdf merging process.", exception);
}
finally
{
document.Close();
}
return output.GetBuffer();
}
}
///<summary>
///Implements custom page events.
///</summary>
internal class PdfPageEvents : IPdfPageEvent
{
#region members
private BaseFont _baseFont = null;
private PdfContentByte _content;
#endregion
#region IPdfPageEvent Members
public void OnOpenDocument(PdfWriter writer, Document document)
{
_baseFont = BaseFont.CreateFont(BaseFont.HELVETICA,
BaseFont.CP1252, BaseFont.NOT_EMBEDDED);
_content = writer.DirectContent;
}
public void OnStartPage(PdfWriter writer, Document document)
{ }
public void OnEndPage(PdfWriter writer, Document document)
{ }
public void OnCloseDocument(PdfWriter writer, Document document)
{ }
public void OnParagraph(PdfWriter writer,
Document document, float paragraphPosition)
{ }
public void OnParagraphEnd(PdfWriter writer,
Document document, float paragraphPosition)
{ }
public void OnChapter(PdfWriter writer, Document document,
float paragraphPosition, Paragraph title)
{ }
public void OnChapterEnd(PdfWriter writer,
Document document, float paragraphPosition)
{ }
public void OnSection(PdfWriter writer, Document document,
float paragraphPosition, int depth, Paragraph title)
{ }
public void OnSectionEnd(PdfWriter writer,
Document document, float paragraphPosition)
{ }
public void OnGenericTag(PdfWriter writer, Document document,
Rectangle rect, string text)
{ }
#endregion
private float GetCenterTextPosition(string text, PdfWriter writer)
{
return writer.PageSize.Width / 2 - _baseFont.GetWidthPoint(text, 8) / 2;
}
}

Je n'ai pas l'écrire, mais fait quelques modifications. Je ne me souviens pas où je l'ai trouvé. Après j'ai fusionné les fichiers Pdf que je voudrais appeler cette méthode pour insérer le javascript pour ouvrir la boîte de dialogue d'impression lorsque le fichier PDF est ouvert. Si vous modifiez bSilent est vraie, alors elle doit imprimer silencieusement à leur valeur par défaut de l'imprimante.

public Stream addPrintJStoPDF(Stream thePDF)
{
MemoryStream outPutStream = null;
PRStream finalStream = null;
PdfDictionary page = null;
string content = null;
//Open the stream with iTextSharp
var reader = new PdfReader(thePDF);
outPutStream = new MemoryStream(finalStream.GetBytes());
var stamper = new PdfStamper(reader, (MemoryStream)outPutStream);
var jsText = "var res = app.setTimeOut('this.print({bUI: true, bSilent: false, bShrinkToFit: false});', 200);";
//Add the javascript to the PDF
stamper.JavaScript = jsText;
stamper.FormFlattening = true;
stamper.Writer.CloseStream = false;
stamper.Close();
//Set the stream to the beginning
outPutStream.Position = 0;
return outPutStream;
}

Pas sûr de savoir comment bien le code ci-dessus est écrit depuis que je l'ai tiré de quelque part d'autre et je n'ai pas travaillé en profondeur avec iTextSharp mais je sais qu'il a fait un travail à la fusion de documents Pdf que j'étais la génération au moment de l'exécution.

Testé avec iTextSharp-LGPL 4.1.6:

    public static byte[] ConcatenatePdfs(IEnumerable<byte[]> documents)
{
using (var ms = new MemoryStream())
{
var outputDocument = new Document();
var writer = new PdfCopy(outputDocument, ms);
outputDocument.Open();
foreach (var doc in documents)
{
var reader = new PdfReader(doc);
for (var i = 1; i <= reader.NumberOfPages; i++)
{
writer.AddPage(writer.GetImportedPage(reader, i));
}
writer.FreeReader(reader);
reader.Close();
}
writer.Close();
outputDocument.Close();
var allPagesContent = ms.GetBuffer();
ms.Flush();
return allPagesContent;
}
}