Как работать с PDF в C#

// Низкоуровневый подход - прямой контроль над PDF-объектами
PdfReader reader = new PdfReader("input.pdf");
PdfStamper stamper = new PdfStamper(reader, new FileStream("output.pdf", FileMode.Create));
PdfContentByte canvas = stamper.GetOverContent(1); // Получаем канвас первой страницы
canvas.BeginText();
canvas.SetFontAndSize(BaseFont.CreateFont(), 12);
canvas.ShowTextAligned(Element.ALIGN_LEFT, "Текст поверх страницы", 36, 756, 0);
canvas.EndText();
stamper.Close();
reader.Close();
 
// Высокоуровневый подход - использование Document и его компонентов
Document document = new Document();
PdfWriter writer = PdfWriter.GetInstance(document, new FileStream("output.pdf", FileMode.Create));
document.Open();
document.Add(new Paragraph("Автоматически сгенерированный документ"));
document.Add(new Paragraph("Дата: " + DateTime.Now.ToString()));
document.Close();

// Создание подписанного документа
Document document = new Document();
string outputPath = "SignedDocument.pdf";
 
using (FileStream fs = new FileStream(outputPath, FileMode.Create))
{
    PdfWriter writer = PdfWriter.GetInstance(document, fs);
    document.Open();
    document.Add(new Paragraph("Документ, подлежащий подписанию"));
    
    // Добавляем видимую подпись
    PdfSignatureAppearance appearance = writer.SignatureAppearance;
    appearance.SetVisibleSignature(new Rectangle(100, 100, 300, 200), 1, "Signature1");
    appearance.SignatureRender = PdfSignatureAppearance.SignatureRender.NameAndDescription;
    appearance.SignatureCreator = "Иванов И.И.";
    appearance.Reason = "Я подтверждаю этот документ";
    appearance.Location = "Москва";
    
    // Применение цифровой подписи с использованием сертификата
    IExternalSignature signature = new X509Certificate2Signature(certificate, "SHA-256");
    MakeSignature.SignDetached(appearance, signature, new[] { CertificateChain }, null, null, null, 0, CryptoStandard.CMS);
}

// Заполнение существующей формы данными
PdfReader reader = new PdfReader("template_form.pdf");
PdfStamper stamper = new PdfStamper(reader, new FileStream("filled_form.pdf", FileMode.Create));
 
AcroFields form = stamper.AcroFields;
form.SetField("firstName", "Александр");
form.SetField("lastName", "Петров");
form.SetField("birthDate", "15.05.1985");
form.SetField("position", "Старший разработчик");
form.SetField("department", "IT отдел");
 
// Опционально - сделать форму неизменяемой после заполнения
stamper.FormFlattening = true;
stamper.Close();
reader.Close();

Document document = new Document();
using (var fs = new FileStream("optimized.pdf", FileMode.Create))
{
    PdfWriter writer = PdfWriter.GetInstance(document, fs);
    
    // Установка степени сжатия для всего документа
    writer.SetFullCompression();
    writer.CompressionLevel = PdfStream.BEST_COMPRESSION;
    
    document.Open();
    
    // Добавление изображения с настройкой сжатия
    Image img = Image.GetInstance("highres_photo.jpg");
    img.CompressionLevel = PdfStream.BEST_COMPRESSION;
    img.ScalePercent(80); // Уменьшаем размер
    
    // Снижаем качество JPEG для экономии места
    img.SetJpegQuality(70); // 0-100, где 100 - максимальное качество
    
    document.Add(img);
    document.Close();
}

Document document = new Document(PageSize.A4, 36, 36, 54, 36);
PdfWriter writer = PdfWriter.GetInstance(document, new FileStream("report.pdf", FileMode.Create));
document.Open();
 
// Добавление заголовка отчета
Paragraph header = new Paragraph("Ежемесячный отчет по продажам", 
                                 new Font(Font.FontFamily.HELVETICA, 18, Font.BOLD));
header.Alignment = Element.ALIGN_CENTER;
header.SpacingAfter = 20f;
document.Add(header);
 
// Создание таблицы с данными
PdfPTable table = new PdfPTable(4);
table.WidthPercentage = 100;
table.SetWidths(new float[] { 2f, 1.5f, 1.5f, 1.5f });
 
// Добавляем заголовки колонок
table.AddCell(new PdfPCell(new Phrase("Продукт")) { BackgroundColor = BaseColor.LIGHT_GRAY });
table.AddCell(new PdfPCell(new Phrase("Продажи Q1")) { BackgroundColor = BaseColor.LIGHT_GRAY });
table.AddCell(new PdfPCell(new Phrase("Продажи Q2")) { BackgroundColor = BaseColor.LIGHT_GRAY });
table.AddCell(new PdfPCell(new Phrase("Изменение, %")) { BackgroundColor = BaseColor.LIGHT_GRAY });
 
// Добавляем данные
string[] products = { "Продукт A", "Продукт B", "Продукт C", "Продукт D" };
int[] q1Sales = { 125000, 87600, 145300, 65700 };
int[] q2Sales = { 156200, 92400, 138500, 95200 };
 
for (int i = 0; i < products.Length; i++)
{
    table.AddCell(products[i]);
    table.AddCell(q1Sales[i].ToString("N0"));
    table.AddCell(q2Sales[i].ToString("N0"));
    
    double change = ((double)q2Sales[i] / q1Sales[i] - 1) * 100;
    PdfPCell changeCell = new PdfPCell(new Phrase(change.ToString("F1") + "%"));
    
    if (change > 0) 
        changeCell.BackgroundColor = new BaseColor(230, 255, 230); // Светло-зеленый
    else if (change < 0)
        changeCell.BackgroundColor = new BaseColor(255, 230, 230); // Светло-красный
        
    table.AddCell(changeCell);
}
 
document.Add(table);
 
// Добавление графика (обычно использую стороннюю библиотеку для генерации изображения)
Image chartImage = Image.GetInstance(GenerateChartImage(products, q1Sales, q2Sales));
chartImage.ScaleToFit(500, 300);
chartImage.Alignment = Element.ALIGN_CENTER;
document.Add(chartImage);
 
document.Close();

// Этот код работает с iTextSharp 5.5.x (LGPL/MPL)
// и останется легальным для использования в коммерческих проектах
using iTextSharp.text;
using iTextSharp.text.pdf;
 
// Но для новых возможностей потребуется iText 7 (коммерческая лицензия)
// using iText.Kernel.Pdf;
// using iText.Layout;
// using iText.Layout.Element;

public interface IPdfService
{
    void CreateDocument(string outputPath, DocumentData data);
    void MergeDocuments(string[] inputPaths, string outputPath);
    string ExtractText(string inputPath);
    // Другие общие операции
}
 
public class ITextSharpPdfService : IPdfService
{
    // Реализация через iTextSharp
}
 
public class AlternativePdfLibraryService : IPdfService
{
    // Реализация через альтернативную библиотеку
}

// Извлечение страниц из документа и создание нового
string[] files = { "large_report.pdf" };
Document document = new Document();
PdfCopy copy = new PdfCopy(document, new FileStream("extracted_pages.pdf", FileMode.Create));
document.Open();
 
PdfReader reader = new PdfReader(files[0]);
// Извлекаем только четные страницы
for (int i = 2; i <= reader.NumberOfPages; i += 2)
{
    copy.AddPage(copy.GetImportedPage(reader, i));
}
document.Close();
reader.Close();

PdfReader reader = new PdfReader("input.pdf");
PdfStamper stamper = new PdfStamper(reader, new FileStream("output_with_metadata.pdf", FileMode.Create));
 
// Устанавливаем основные метаданные документа
Dictionary<string, string> info = reader.Info;
info["Title"] = "Ежеквартальный отчет отдела разработки";
info["Subject"] = "Финансовые показатели Q3 2023";
info["Keywords"] = "отчет, разработка, финансы, квартал";
info["Creator"] = "Система корпоративной отчетности v2.5";
info["Author"] = "Аналитический отдел";
 
// Добавляем кастомные метаданные
PdfDictionary catalog = reader.Catalog;
PdfDictionary metadata = new PdfDictionary();
metadata.Put(new PdfName("CompanyId"), new PdfString("AC-73892-X"));
metadata.Put(new PdfName("DepartmentCode"), new PdfString("DEV-15"));
metadata.Put(new PdfName("ConfidentialityLevel"), new PdfNumber(2));
catalog.Put(new PdfName("CustomMetadata"), metadata);
 
stamper.Close();
reader.Close();

Document document = new Document();
MemoryStream ms = new MemoryStream();
PdfWriter writer = PdfWriter.GetInstance(document, ms);
 
// Настройка для соответствия PDF/A-1b
writer.PDFXConformance = PdfWriter.PDFA1B;
writer.CreateXmpMetadata();
 
document.Open();
 
// Добавляем ICC профиль (обязательно для PDF/A)
string colorProfilePath = Path.Combine(Environment.GetFolderPath(
                         Environment.SpecialFolder.System), "sRGB Color Space Profile.icm");
ICC_Profile icc = ICC_Profile.GetInstance(File.ReadAllBytes(colorProfilePath));
writer.SetOutputIntents("Custom", "", "http://www.color.org", "sRGB IEC61966-2.1", icc);
 
// Дальнейшее наполнение документа контентом
document.Add(new Paragraph("PDF/A-совместимый документ"));
document.Close();
 
// Сохраняем результат
File.WriteAllBytes("pdfa_document.pdf", ms.ToArray());

using (var document = PdfReader.Open("large_catalog.pdf"))
{
    // Даже большой документ занимает сравнительно мало памяти
    var processor = new CustomDocumentProcessor();
    
    foreach (PdfPage page in document.Pages)
    {
        processor.ProcessPage(page);
        // PdfSharp умно управляет ресурсами, освобождая память от обработанных страниц
    }
}

// Слияние нескольких PDF в один
PdfDocument targetDoc = new PdfDocument();
 
foreach (string file in sourceFiles)
{
    using (PdfDocument sourceDoc = PdfReader.Open(file, PdfDocumentOpenMode.Import))
    {
        for (int i = 0; i < sourceDoc.PageCount; i++)
        {
            targetDoc.AddPage(sourceDoc.Pages[i]);
        }
    }
}
 
targetDoc.Save("merged_document.pdf");

PdfDocument document = new PdfDocument();
PdfPage page = document.AddPage();
XGraphics gfx = XGraphics.FromPdfPage(page);
 
// Корректная работа с разными языками
XFont fontRussian = new XFont("Arial", 12);
XFont fontChinese = new XFont("SimSun", 12);
 
gfx.DrawString("Текст на русском языке", fontRussian, XBrushes.Black, 
               new XRect(0, 0, page.Width, 50), XStringFormats.TopLeft);
               
gfx.DrawString("中文文本", fontChinese, XBrushes.Black, 
               new XRect(0, 50, page.Width, 50), XStringFormats.TopLeft);
 
document.Save("multilingual.pdf");

public async Task<byte[]> MergeDocumentsAsync(List<string> filePaths)
{
    return await Task.Run(() => 
    {
        using (var mergedDocument = new PdfDocument())
        {
            foreach (var filePath in filePaths)
            {
                using (var document = PdfReader.Open(filePath, PdfDocumentOpenMode.Import))
                {
                    for (int i = 0; i < document.PageCount; i++)
                    {
                        mergedDocument.AddPage(document.Pages[i]);
                    }
                }
            }
            
            using (MemoryStream ms = new MemoryStream())
            {
                mergedDocument.Save(ms);
                return ms.ToArray();
            }
        }
    });
}

List<string> allFiles = Directory.GetFiles("path/to/documents", "*.pdf").ToList();
ConcurrentBag<byte[]> processedFiles = new ConcurrentBag<byte[]>();
 
Parallel.ForEach(allFiles, 
    new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount }, 
    filePath => 
    {
        using (var document = PdfReader.Open(filePath, PdfDocumentOpenMode.Modify))
        {
            // Выполняем какие-то операции с документом
            ApplyWatermark(document);
            
            using (MemoryStream ms = new MemoryStream())
            {
                document.Save(ms);
                processedFiles.Add(ms.ToArray());
            }
        }
    });

public class DocumentNumberingService
{
    public void ApplyPageNumbering(string inputPath, string outputPath, string format = "Страница {0} из {1}")
    {
        PdfDocument document = PdfReader.Open(inputPath);
        XFont font = new XFont("Times New Roman", 9);
        
        int totalPages = document.PageCount;
        
        for (int i = 0; i < totalPages; i++)
        {
            PdfPage page = document.Pages[i];
            XGraphics gfx = XGraphics.FromPdfPage(page, XGraphicsPdfPageOptions.Append);
            
            string pageNumberText = string.Format(format, i + 1, totalPages);
            
            // Рассчитываем позицию для номера в нижнем колонтитуле
            XSize size = gfx.MeasureString(pageNumberText, font);
            XPoint position = new XPoint(
                (page.Width - size.Width) / 2,
                page.Height - 20);
                
            gfx.DrawString(pageNumberText, font, XBrushes.Black, position);
        }
        
        document.Save(outputPath);
    }
}

PdfDocument document = PdfReader.Open("input.pdf");
 
// Чтение метаданных
string title = document.Info.Title;
string author = document.Info.Author;
string subject = document.Info.Subject;
 
// Изменение метаданных
document.Info.Title = "Ежегодный отчет 2023";
document.Info.Author = "Финансовый департамент";
document.Info.Subject = "Финансовые показатели за 2023 год";
document.Info.Keywords = "отчет, финансы, годовой, 2023";
document.Info.Creator = "PdfSharp Custom Reporting Tool";
 
// Можно добавлять и кастомные метаданные
document.Info.Elements.Add(new KeyValuePair<string, PdfItem>("/CompanyID", new PdfString("ABC-12345")));
document.Info.Elements.Add(new KeyValuePair<string, PdfItem>("/Department", new PdfString("Finance")));
 
document.Save("output.pdf");

// Подход к рисованию, знакомый Windows Forms разработчикам
PdfDocument document = new PdfDocument();
PdfPage page = document.AddPage();
XGraphics gfx = XGraphics.FromPdfPage(page);
 
// Рисуем как в обычной WinForms-графике
gfx.DrawRectangle(XPens.Black, XBrushes.LightGray, new XRect(50, 50, 200, 100));
gfx.DrawEllipse(XPens.Red, new XRect(300, 50, 100, 100));
gfx.DrawLine(XPens.DarkBlue, 50, 200, 550, 200);
 
document.Save("graphics_example.pdf");

// Генерация PDF для веб-приложения
[HttpGet("report")]
public IActionResult GenerateReport()
{
    using (MemoryStream ms = new MemoryStream())
    {
        PdfDocument document = new PdfDocument();
        PdfPage page = document.AddPage();
        
        XGraphics gfx = XGraphics.FromPdfPage(page);
        XFont font = new XFont("Arial", 12);
        
        gfx.DrawString("Отчет сгенерирован: " + DateTime.Now.ToString(), 
                     font, XBrushes.Black, 20, 50);
        
        // Наполняем отчет данными
        PopulateReport(document, gfx);
        
        document.Save(ms);
        return File(ms.ToArray(), "application/pdf", "report.pdf");
    }
}

PdfDocument document = new PdfDocument();
PdfOutline outline = document.Outlines;
 
// Добавляем страницу с разделом
PdfPage page1 = document.AddPage();
XGraphics gfx1 = XGraphics.FromPdfPage(page1);
gfx1.DrawString("Раздел 1: Введение", new XFont("Verdana", 16), XBrushes.Black, 20, 50);
 
// Создаем закладку на этот раздел
PdfOutline section1 = outline.Outlines.Add("Раздел 1: Введение", page1, true);
 
// Добавляем подразделы
PdfPage page1_1 = document.AddPage();
XGraphics gfx1_1 = XGraphics.FromPdfPage(page1_1);
gfx1_1.DrawString("1.1. Цели и задачи", new XFont("Verdana", 14), XBrushes.Black, 20, 50);
 
// Вложеная закладка
section1.Outlines.Add("1.1. Цели и задачи", page1_1, true);
 
document.Save("document_with_bookmarks.pdf");

public class ReportingService
{
    private readonly ITemplateProvider _templateProvider;
    private readonly IDataService _dataService;
    
    public ReportingService(ITemplateProvider templateProvider, IDataService dataService)
    {
        _templateProvider = templateProvider;
        _dataService = dataService;
    }
    
    public byte[] GenerateReport(ReportType type, int entityId)
    {
        byte[] templateBytes = _templateProvider.GetTemplate(type);
        var data = _dataService.GetReportData(type, entityId);
        
        using (MemoryStream ms = new MemoryStream())
        {
            using (PdfDocument document = PdfReader.Open(new MemoryStream(templateBytes)))
            {
                // Заполняем шаблон данными
                ApplyDataToTemplate(document, data);
                document.Save(ms);
                return ms.ToArray();
            }
        }
    }
}

// Конвертация Word документа в PDF
using Syncfusion.DocIO;
using Syncfusion.DocIO.DLS;
using Syncfusion.DocToPDFConverter;
using Syncfusion.Pdf;
 
WordDocument wordDocument = new WordDocument("source.docx");
PdfDocument pdfDocument = new PdfDocument();
DocToPDFConverter converter = new DocToPDFConverter();
 
// Настройка конвертации
converter.Settings.EmbedFonts = true;
converter.Settings.PreserveFormFields = true;
 
pdfDocument = converter.ConvertToPDF(wordDocument);
pdfDocument.Save("converted_document.pdf");
wordDocument.Close();
pdfDocument.Close();

// Конвертация PDF в Excel
using Syncfusion.Pdf;
using Syncfusion.Pdf.Parsing;
using Syncfusion.XlsIO;
 
PdfLoadedDocument loadedPDF = new PdfLoadedDocument("source.pdf");
ExcelEngine excelEngine = new ExcelEngine();
IApplication application = excelEngine.Excel;
IWorkbook workbook = application.Workbooks.Create(1);
 
// Настройка опций экспорта
PdfExcelConverter converter = new PdfExcelConverter();
converter.PreserveFormFields = true;
converter.PreserveImages = true;
 
// Выполняем конвертацию
converter.Convert(loadedPDF, workbook);
workbook.SaveAs("converted_document.xlsx");
 
loadedPDF.Close();
workbook.Close();
excelEngine.Dispose();

// Работа с PDF в Azure Blob Storage
using Syncfusion.Pdf;
using Syncfusion.Pdf.Parsing;
using Microsoft.Azure.Storage;
using Microsoft.Azure.Storage.Blob;
 
// Соединение с хранилищем
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(connectionString);
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
CloudBlobContainer container = blobClient.GetContainerReference("documents");
 
// Загрузка PDF из хранилища
CloudBlockBlob blockBlob = container.GetBlockBlobReference("document.pdf");
using (MemoryStream ms = new MemoryStream())
{
    blockBlob.DownloadToStream(ms);
    ms.Position = 0;
    
    // Открываем PDF из потока
    PdfLoadedDocument loadedPDF = new PdfLoadedDocument(ms);
    
    // Выполняем какие-то операции
    // ...
    
    // Сохраняем обратно в хранилище
    ms.SetLength(0);
    loadedPDF.Save(ms);
    ms.Position = 0;
    
    CloudBlockBlob newBlob = container.GetBlockBlobReference("processed_document.pdf");
    newBlob.UploadFromStream(ms);
    
    loadedPDF.Close();
}

// Использование OCR для извлечения текста из сканированного PDF
using Syncfusion.Pdf;
using Syncfusion.Pdf.Parsing;
using Syncfusion.OCRProcessor;
 
// Инициализируем OCR процессор
OCRProcessor processor = new OCRProcessor();
processor.Settings.Language = Languages.English;
 
// Загружаем сканированный PDF
PdfLoadedDocument loadedDocument = new PdfLoadedDocument("scanned_document.pdf");
 
// Распознаем текст со всех страниц
string extractedText = processor.PerformOCR(loadedDocument);
 
Console.WriteLine(extractedText);
 
// Также можно создать PDF с поисковым слоем
PdfLoadedDocument searchableDocument = processor.PerformOCR(loadedDocument, false);
searchableDocument.Save("searchable_document.pdf");
 
loadedDocument.Close();
searchableDocument.Close();

// Создание интерактивной формы
using Syncfusion.Pdf;
using Syncfusion.Pdf.Interactive;
 
PdfDocument document = new PdfDocument();
PdfPage page = document.Pages.Add();
 
// Создаем текстовое поле
PdfTextBoxField textBoxField = new PdfTextBoxField(page, "employeeName");
textBoxField.Bounds = new RectangleF(100, 100, 200, 20);
textBoxField.ToolTip = "Введите имя сотрудника";
textBoxField.BorderWidth = 1;
textBoxField.BorderStyle = PdfBorderStyle.Solid;
 
// Создаем флажок
PdfCheckBoxField checkBoxField = new PdfCheckBoxField(page, "isManager");
checkBoxField.Bounds = new RectangleF(100, 150, 20, 20);
checkBoxField.ToolTip = "Отметьте, если сотрудник является менеджером";
 
// Создаем выпадающий список
PdfComboBoxField comboBoxField = new PdfComboBoxField(page, "department");
comboBoxField.Bounds = new RectangleF(100, 200, 200, 20);
comboBoxField.Items.Add("ИТ отдел");
comboBoxField.Items.Add("Бухгалтерия");
comboBoxField.Items.Add("Маркетинг");
comboBoxField.Items.Add("Служба поддержки");
 
// Добавляем поля формы в документ
document.Form.Fields.Add(textBoxField);
document.Form.Fields.Add(checkBoxField);
document.Form.Fields.Add(comboBoxField);
 
// Опционально - добавляем кнопку отправки формы
PdfButtonField submitButton = new PdfButtonField(page, "submitBtn");
submitButton.Bounds = new RectangleF(150, 250, 100, 25);
submitButton.Text = "Отправить";
document.Form.Fields.Add(submitButton);
 
document.Save("interactive_form.pdf");
document.Close();

// Пример организации пакетной обработки документов
public class BatchProcessor
{
private readonly ConcurrentQueue<DocumentTask> _tasksQueue = new ConcurrentQueue<DocumentTask>();
private readonly int _maxConcurrentTasks;
private readonly SemaphoreSlim _semaphore;
private readonly CancellationTokenSource _cts = new CancellationTokenSource();
 
public BatchProcessor(int maxConcurrentTasks = 4)
{
    _maxConcurrentTasks = maxConcurrentTasks;
    _semaphore = new SemaphoreSlim(maxConcurrentTasks);
}
 
public void EnqueueTask(DocumentTask task)
{
    _tasksQueue.Enqueue(task);
}
 
public async Task StartProcessingAsync()
{
    List<Task> runningTasks = new List<Task>();
    
    while (!_tasksQueue.IsEmpty || runningTasks.Count > 0)
    {
        if (_tasksQueue.TryDequeue(out DocumentTask task) && !_cts.Token.IsCancellationRequested)
        {
            await _semaphore.WaitAsync();
            
            var processTask = Task.Run(async () => 
            {
                try 
                {
                    using (PdfLoadedDocument document = new PdfLoadedDocument(task.InputPath))
                    {
                        // Выполняем обработку в зависимости от типа задачи
                        switch (task.TaskType)
                        {
                            case TaskType.AddWatermark:
                                AddWatermark(document, task.Parameters["watermarkText"]);
                                break;
                            case TaskType.ApplySecurity:
                                ApplySecurity(document, task.Parameters["password"]);
                                break;
                            // Другие типы задач...
                        }
                        
                        document.Save(task.OutputPath);
                    }
                    
                    task.CompletionCallback?.Invoke(task, true, null);
                }
                catch (Exception ex)
                {
                    task.CompletionCallback?.Invoke(task, false, ex);
                }
                finally
                {
                    _semaphore.Release();
                }
            }, _cts.Token);
            
            runningTasks.Add(processTask);
        }
        
        if (runningTasks.Count > 0)
        {
            Task completed = await Task.WhenAny(runningTasks);
            runningTasks.Remove(completed);
        }
    }
}
}

// Пример интеграции с SharePoint
public async Task<List<DocumentInfo>> GetSharePointDocumentsAsync(string siteUrl, string libraryName)
{
    using (ClientContext context = new ClientContext(siteUrl))
    {
        context.Credentials = new SharePointOnlineCredentials(username, securePassword);
        Web web = context.Web;
        List documentLibrary = web.Lists.GetByTitle(libraryName);
        
        CamlQuery query = CamlQuery.CreateAllItemsQuery();
        ListItemCollection items = documentLibrary.GetItems(query);
        
        context.Load(items, 
            includes => includes.Include(
                item => item.Id,
                item => item["Title"],
                item => item["FileLeafRef"],
                item => item["Modified"]));
                
        await context.ExecuteQueryAsync();
        
        List<DocumentInfo> documents = new List<DocumentInfo>();
        
        foreach (ListItem item in items)
        {
            // Загружаем PDF документ
            Microsoft.SharePoint.Client.File file = item.File;
            context.Load(file);
            await context.ExecuteQueryAsync();
            
            ClientResult<Stream> streamResult = file.OpenBinaryStream();
            await context.ExecuteQueryAsync();
            
            using (Stream stream = streamResult.Value)
            using (MemoryStream ms = new MemoryStream())
            {
                stream.CopyTo(ms);
                ms.Position = 0;
                
                // Обрабатываем документ с Syncfusion
                using (PdfLoadedDocument doc = new PdfLoadedDocument(ms))
                {
                    DocumentInfo docInfo = new DocumentInfo
                    {
                        Id = item.Id,
                        Title = item["Title"]?.ToString(),
                        FileName = item["FileLeafRef"]?.ToString(),
                        ModifiedDate = (DateTime)item["Modified"],
                        PageCount = doc.Pages.Count,
                        HasSignature = HasDigitalSignature(doc)
                    };
                    
                    documents.Add(docInfo);
                }
            }
        }
        
        return documents;
    }
}

// Применение шифрования и защиты документа
PdfDocument document = new PdfDocument();
PdfPage page = document.Pages.Add();
PdfGraphics graphics = page.Graphics;
 
graphics.DrawString("Конфиденциальная информация", new PdfStandardFont(PdfFontFamily.Helvetica, 14), 
                  PdfBrushes.Black, new PointF(10, 10));
 
// Настройка шифрования
PdfSecurity security = document.Security;
// Используем 256-битный AES (самый надежный алгоритм для PDF)
security.Algorithm = PdfEncryptionAlgorithm.AES;
security.KeySize = PdfEncryptionKeySize.Key256Bit;
 
// Устанавливаем пароли
security.OwnerPassword = "СложныйПарольВладельца123!";
security.UserPassword = "ПарольПользователя456";
 
// Управление разрешениями
security.Permissions = PdfPermissionsFlags.Print | PdfPermissionsFlags.CopyContent;
// Запрещаем редактирование, добавление/удаление страниц и аннотаций
security.Permissions &= ~(PdfPermissionsFlags.EditContent | 
                          PdfPermissionsFlags.AssembleDocument | 
                          PdfPermissionsFlags.ModifyAnnotations);
 
document.Save("secured_document.pdf");
document.Close();

// Защита на основе сертификатов
PdfDocument document = new PdfDocument();
// Добавляем содержимое...
 
// Применяем защиту на основе сертификата
X509Certificate2 certificate = new X509Certificate2("certificate.pfx", "password");
document.Security.Certificate = certificate;
 
// Настраиваем разрешения для получателей
PdfCertificate pdfCertificate = new PdfCertificate(certificate);
PdfCertificatePermissions permissions = new PdfCertificatePermissions();
permissions.AccessPermission = PdfAccessPermission.ContentExtraction | PdfAccessPermission.Printing;
document.Security.AddRecipient(pdfCertificate, permissions);
 
document.Save("certificate_secured.pdf");
document.Close();

// Добавление цифровой подписи с временными метками
public void SignDocumentWithTimestamp(string inputPath, string outputPath, X509Certificate2 certificate)
{
    PdfLoadedDocument document = new PdfLoadedDocument(inputPath);
    
    // Создаем поле для подписи
    PdfLoadedForm form = document.Form;
    PdfSignatureField signatureField = new PdfSignatureField(document.Pages[0], "signature");
    signatureField.Bounds = new RectangleF(300, 100, 200, 100);
    form.Fields.Add(signatureField);
    
    // Настраиваем внешний вид подписи
    PdfSignature signature = new PdfSignature(document, document.Pages[0], null, "Signature");
    signature.Bounds = new RectangleF(300, 100, 200, 100);
    
    // Добавляем визуальное представление подписи
    PdfSignatureAppearance appearance = signature.Appearance;
    appearance.Normal.Graphics.DrawRectangle(PdfPens.Black, PdfBrushes.White, 
                                            new RectangleF(0, 0, 200, 100));
    appearance.Normal.Graphics.DrawString("Подписано: " + certificate.SubjectName.Name, 
                                         new PdfStandardFont(PdfFontFamily.Helvetica, 7),
                                         PdfBrushes.Black, new PointF(5, 10));
    
    // Добавляем временную метку
    signature.Settings.TimeStampServer = new Uri("http://timestamp.digicert.com");
    
    // Применяем цифровую подпись
    signature.Certificate = certificate;
    document.Save(outputPath);
    document.Close();
}

// Создание документа в соответствии с PDF/A-3b (для архивного хранения)
PdfDocument document = new PdfDocument(PdfConformanceLevel.Pdf_A3B);
document.DocumentInformation.Author = "Отдел автоматизации";
document.DocumentInformation.Title = "Архивный документ";
document.DocumentInformation.Subject = "Долгосрочное хранение";
document.DocumentInformation.Keywords = "PDF/A, архив, соответствие";
 
// Обязательно для PDF/A - встраиваем ICC профиль
PdfStream stream = new PdfStream(File.OpenRead("sRGB Color Space Profile.icm"));
PdfName colorProfile = new PdfName("ICCProfile");
document.DocumentInformation.ConformanceOptions.AddColorProfile(colorProfile, stream);
 
// Настраиваем метаданные XMP
document.DocumentInformation.XmpMetadata = XmpMetadata.CreateXmpMetadata();
 
// Добавляем содержимое
PdfPage page = document.Pages.Add();
PdfGraphics graphics = page.Graphics;
graphics.DrawString("PDF/A-3B совместимый документ", 
                  new PdfStandardFont(PdfFontFamily.Helvetica, 14, PdfFontStyle.Bold),
                  PdfBrushes.Black, new PointF(10, 10));
 
document.Save("pdfa3b_document.pdf");
document.Close();

// Пример простого сценария с PdfSharp
public byte[] GenerateSimpleReport(ReportData data)
{
    using (PdfDocument document = new PdfDocument())
    {
        PdfPage page = document.AddPage();
        XGraphics gfx = XGraphics.FromPdfPage(page);
        XFont titleFont = new XFont("Arial", 16, XFontStyle.Bold);
        XFont normalFont = new XFont("Arial", 11);
        
        // Заголовок отчета
        gfx.DrawString(data.Title, titleFont, XBrushes.Black, 
                     new XRect(0, 30, page.Width, 20), XStringFormats.Center);
        
        // Основная информация
        gfx.DrawString($"Дата: {data.Date.ToShortDateString()}", normalFont, 
                     XBrushes.Black, 50, 80);
        gfx.DrawString($"Подготовил: {data.Author}", normalFont, 
                     XBrushes.Black, 50, 100);
        
        // Основной контент
        float yPosition = 150;
        foreach (var item in data.Items)
        {
            gfx.DrawString(item.Description, normalFont, 
                         XBrushes.Black, 50, yPosition);
            yPosition += 20;
        }
        
        using (MemoryStream ms = new MemoryStream())
        {
            document.Save(ms);
            return ms.ToArray();
        }
    }
}

// Пример абстракции, позволяющей в будущем менять библиотеки
public interface IPdfGenerator
{
    Task<byte[]> GenerateInvoiceAsync(InvoiceData data);
    Task<byte[]> MergeDocumentsAsync(IEnumerable<byte[]> documents);
    Task<DocumentMetadata> ExtractMetadataAsync(byte[] document);
}
 
// Реализация для PdfSharp
public class PdfSharpGenerator : IPdfGenerator
{
    // Реализация методов
}
 
// Реализация для iTextSharp
public class ITextSharpGenerator : IPdfGenerator
{
    // Реализация методов
}
 
// Реализация для Syncfusion
public class SyncfusionGenerator : IPdfGenerator
{
    // Реализация методов
}
 
// Фабрика для выбора подходящей реализации
public static class PdfGeneratorFactory
{
    public static IPdfGenerator Create(PdfLibraryType type)
    {
        switch (type)
        {
            case PdfLibraryType.PdfSharp:
                return new PdfSharpGenerator();
            case PdfLibraryType.ITextSharp:
                return new ITextSharpGenerator();
            case PdfLibraryType.Syncfusion:
                return new SyncfusionGenerator();
            default:
                throw new ArgumentException("Неизвестный тип библиотеки");
        }
    }
}

// Безопасно для коммерческого использования (LGPL/MPL)
// iTextSharp 4.x или 5.x до 5.5.x
using iTextSharp.text;
using iTextSharp.text.pdf;
 
// Требует коммерческой лицензии для закрытого кода
// iText 7.x
using iText.Kernel;
using iText.Layout;