Produkty Iron Software i Visual Studio 2026: Kompletne przewodnik po integracji

Install-Package IronPdf

dotnet add package IronPdf

using IronPdf;
using IronPdf.Signing;

// Open a PDF with form fields
var pdf = PdfDocument.FromFile("form.pdf");

// Fill form fields
pdf.Form.Fields["Name"].Value = "John Developer";
pdf.Form.Fields["Email"].Value = "john@example.com";

// Sign the PDF (using CSP-based certificates)
var signature = new PdfSignature("certificate.pfx", "password");
pdf.Sign(signature);

// Save the signed PDF
pdf.SaveAs("signed.pdf");

Imports IronPdf
Imports IronPdf.Signing

' Open a PDF with form fields
Dim pdf = PdfDocument.FromFile("form.pdf")

' Fill form fields
pdf.Form.Fields("Name").Value = "John Developer"
pdf.Form.Fields("Email").Value = "john@example.com"

' Sign the PDF (using CSP-based certificates)
Dim signature = New PdfSignature("certificate.pfx", "password")
pdf.Sign(signature)

' Save the signed PDF
pdf.SaveAs("signed.pdf")

Install-Package IronOcr

using IronOcr;

// Initialize with specific language
var ocr = new IronTesseract();
ocr.Language = OcrLanguage.Spanish;

// Add additional languages
ocr.AddSecondaryLanguage(OcrLanguage.French);

using (var input = new OcrInput())
{
    input.AddImage("multilingual-document.png");
    var result = ocr.Read(input);

    // Process multilingual text
    foreach (var page in result.Pages)
    {
        Console.WriteLine($"Page {page.PageNumber}: {page.Text}");
    }
}

Imports IronOcr

' Initialize with specific language
Dim ocr As New IronTesseract()
ocr.Language = OcrLanguage.Spanish

' Add additional languages
ocr.AddSecondaryLanguage(OcrLanguage.French)

Using input As New OcrInput()
    input.AddImage("multilingual-document.png")
    Dim result = ocr.Read(input)

    ' Process multilingual text
    For Each page In result.Pages
        Console.WriteLine($"Page {page.PageNumber}: {page.Text}")
    Next
End Using

using IronOcr;

var ocr = new IronTesseract();

using (var input = new OcrInput())
{
    // Add image with enhancement
    input.AddImage("poor-quality-scan.jpg");

    // Apply filters
    input.Deskew();
    input.DeNoise();
    input.Dilate();

    // Perform OCR
    var result = ocr.Read(input);
    Console.WriteLine(result.Text);
}

Imports IronOcr

Dim ocr As New IronTesseract()

Using input As New OcrInput()
    ' Add image with enhancement
    input.AddImage("poor-quality-scan.jpg")

    ' Apply filters
    input.Deskew()
    input.DeNoise()
    input.Dilate()

    ' Perform OCR
    Dim result = ocr.Read(input)
    Console.WriteLine(result.Text)
End Using

Install-Package IronBarcode

using IronBarCode;

// Configure barcode reader with ML detection
var options = new BarcodeReaderOptions
{
    ExpectMultipleBarcodes = true,
    ExpectBarcodeTypes = BarcodeEncoding.AllOneDimensional,
    CropArea = new System.Drawing.Rectangle(0, 0, 500, 500),
    UseCode39ExtendedMode = true
};

// Read barcodes with options
var results = BarcodeReader.Read("multi-barcode-image.png", options);

foreach (var barcode in results)
{
    Console.WriteLine($"Found: {barcode.BarcodeType} = {barcode.Value}");
}

Imports IronBarCode
Imports System.Drawing

' Configure barcode reader with ML detection
Dim options As New BarcodeReaderOptions With {
    .ExpectMultipleBarcodes = True,
    .ExpectBarcodeTypes = BarcodeEncoding.AllOneDimensional,
    .CropArea = New Rectangle(0, 0, 500, 500),
    .UseCode39ExtendedMode = True
}

' Read barcodes with options
Dim results = BarcodeReader.Read("multi-barcode-image.png", options)

For Each barcode In results
    Console.WriteLine($"Found: {barcode.BarcodeType} = {barcode.Value}")
Next

using IronPdf;
using System.Diagnostics;

public class PdfProcessor
{
    public void ProcessDocument(string htmlContent, string outputPath)
    {
        // Visual Studio 2026 shows inline values here
        var renderer = new ChromePdfRenderer();

        // Inline if-statement debugging shows evaluation results
        if (string.IsNullOrEmpty(htmlContent))
        {
            throw new ArgumentException("HTML content cannot be empty");
        }

        // Inline post-return values show the PDF object immediately
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);

        // Copilot can analyze unexpected results
        var pageCount = pdf.PageCount;
        Debug.WriteLine($"Generated PDF with {pageCount} pages");

        pdf.SaveAs(outputPath);
    }
}

Imports IronPdf
Imports System.Diagnostics

Public Class PdfProcessor
    Public Sub ProcessDocument(htmlContent As String, outputPath As String)
        ' Visual Studio 2026 shows inline values here
        Dim renderer = New ChromePdfRenderer()

        ' Inline if-statement debugging shows evaluation results
        If String.IsNullOrEmpty(htmlContent) Then
            Throw New ArgumentException("HTML content cannot be empty")
        End If

        ' Inline post-return values show the PDF object immediately
        Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)

        ' Copilot can analyze unexpected results
        Dim pageCount = pdf.PageCount
        Debug.WriteLine($"Generated PDF with {pageCount} pages")

        pdf.SaveAs(outputPath)
    End Sub
End Class

using IronPdf;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

[MemoryDiagnoser]
public class PdfBenchmarks
{
    private const string SampleHtml = "<html><body><h1>Test Document</h1></body></html>";

    [Benchmark]
    public void RenderSimplePdf()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(SampleHtml);
    }

    [Benchmark]
    public void RenderComplexPdf()
    {
        var renderer = new ChromePdfRenderer();
        var complexHtml = GenerateComplexHtml();
        var pdf = renderer.RenderHtmlAsPdf(complexHtml);
    }

    private string GenerateComplexHtml()
    {
        // Generate HTML with tables, images, etc.
        return "<html><body><table>...</table></body></html>";
    }
}

partial class Program
{
    static void Main(string[] args)
    {
        var summary = BenchmarkRunner.Run<PdfBenchmarks>();
    }
}

Imports IronPdf
Imports BenchmarkDotNet.Attributes
Imports BenchmarkDotNet.Running

<MemoryDiagnoser>
Public Class PdfBenchmarks
    Private Const SampleHtml As String = "<html><body><h1>Test Document</h1></body></html>"

    <Benchmark>
    Public Sub RenderSimplePdf()
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf(SampleHtml)
    End Sub

    <Benchmark>
    Public Sub RenderComplexPdf()
        Dim renderer = New ChromePdfRenderer()
        Dim complexHtml = GenerateComplexHtml()
        Dim pdf = renderer.RenderHtmlAsPdf(complexHtml)
    End Sub

    Private Function GenerateComplexHtml() As String
        ' Generate HTML with tables, images, etc.
        Return "<html><body><table>...</table></body></html>"
    End Function
End Class

Partial Class Program
    Shared Sub Main(ByVal args As String())
        Dim summary = BenchmarkRunner.Run(Of PdfBenchmarks)()
    End Sub
End Class

using Microsoft.Azure.Functions;
using IronPdf;
using IronOcr;

public class DocumentProcessor
{
    [FunctionName("ConvertHtmlToPdf")]
    public async Task<IActionResult> ConvertToPdf(
        [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequest req)
    {
        string html = await new StreamReader(req.Body).ReadToEndAsync();

        // Configure IronPDF for Azure
        License.LicenseKey = Environment.GetEnvironmentVariable("IRONPDF_LICENSE");

        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(html);

        return new FileContentResult(pdf.BinaryData, "application/pdf")
        {
            FileDownloadName = "document.pdf"
        };
    }

    [FunctionName("ExtractTextFromImage")]
    public async Task<IActionResult> ExtractText(
        [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequest req)
    {
        var imageBytes = await ReadImageBytes(req);

        License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE");

        var ocr = new IronTesseract();
        using (var input = new OcrInput())
        {
            input.AddImage(imageBytes);
            var result = ocr.Read(input);

            return new OkObjectResult(new { text = result.Text });
        }
    }
}

Imports Microsoft.Azure.Functions
Imports IronPdf
Imports IronOcr
Imports System.IO
Imports Microsoft.AspNetCore.Mvc
Imports Microsoft.AspNetCore.Http
Imports System.Threading.Tasks

Public Class DocumentProcessor

    <FunctionName("ConvertHtmlToPdf")>
    Public Async Function ConvertToPdf(
        <HttpTrigger(AuthorizationLevel.Function, "post")> req As HttpRequest) As Task(Of IActionResult)

        Dim html As String = Await New StreamReader(req.Body).ReadToEndAsync()

        ' Configure IronPDF for Azure
        License.LicenseKey = Environment.GetEnvironmentVariable("IRONPDF_LICENSE")

        Dim renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf(html)

        Return New FileContentResult(pdf.BinaryData, "application/pdf") With {
            .FileDownloadName = "document.pdf"
        }
    End Function

    <FunctionName("ExtractTextFromImage")>
    Public Async Function ExtractText(
        <HttpTrigger(AuthorizationLevel.Function, "post")> req As HttpRequest) As Task(Of IActionResult)

        Dim imageBytes = Await ReadImageBytes(req)

        License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE")

        Dim ocr As New IronTesseract()
        Using input As New OcrInput()
            input.AddImage(imageBytes)
            Dim result = ocr.Read(input)

            Return New OkObjectResult(New With {.text = result.Text})
        End Using
    End Function

    Private Async Function ReadImageBytes(req As HttpRequest) As Task(Of Byte())
        Using memoryStream As New MemoryStream()
            Await req.Body.CopyToAsync(memoryStream)
            Return memoryStream.ToArray()
        End Using
    End Function

End Class

using Microsoft.VisualStudio.TestTools.UnitTesting;
using IronPdf;
using System.IO;

[TestClass]
public class PdfGenerationTests
{
    [TestMethod]
    public void TestSimpleHtmlToPdf()
    {
        // Arrange
        var renderer = new ChromePdfRenderer();
        var html = "<h1>Test</h1>";

        // Act
        var pdf = renderer.RenderHtmlAsPdf(html);

        // Assert
        Assert.IsNotNull(pdf);
        Assert.IsTrue(pdf.PageCount > 0);
        Assert.IsTrue(pdf.BinaryData.Length > 0);
    }

    [TestMethod]
    public void TestPdfExtraction()
    {
        // Arrange
        var html = "<html><body><p>Sample text for extraction</p></body></html>";
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(html);

        // Act
        var extractedText = pdf.ExtractAllText();

        // Assert
        Assert.IsTrue(extractedText.Contains("Sample text"));
    }

    [TestMethod]
    [DataRow("document1.html")]
    [DataRow("document2.html")]
    [DataRow("document3.html")]
    public void TestBatchPdfGeneration(string filename)
    {
        // Arrange
        var html = File.ReadAllText(filename);
        var renderer = new ChromePdfRenderer();

        // Act
        var pdf = renderer.RenderHtmlAsPdf(html);

        // Assert
        Assert.IsNotNull(pdf);
        Assert.IsTrue(pdf.PageCount > 0);
    }
}

Imports Microsoft.VisualStudio.TestTools.UnitTesting
Imports IronPdf
Imports System.IO

<TestClass>
Public Class PdfGenerationTests

    <TestMethod>
    Public Sub TestSimpleHtmlToPdf()
        ' Arrange
        Dim renderer As New ChromePdfRenderer()
        Dim html As String = "<h1>Test</h1>"

        ' Act
        Dim pdf = renderer.RenderHtmlAsPdf(html)

        ' Assert
        Assert.IsNotNull(pdf)
        Assert.IsTrue(pdf.PageCount > 0)
        Assert.IsTrue(pdf.BinaryData.Length > 0)
    End Sub

    <TestMethod>
    Public Sub TestPdfExtraction()
        ' Arrange
        Dim html As String = "<html><body><p>Sample text for extraction</p></body></html>"
        Dim renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf(html)

        ' Act
        Dim extractedText As String = pdf.ExtractAllText()

        ' Assert
        Assert.IsTrue(extractedText.Contains("Sample text"))
    End Sub

    <TestMethod>
    <DataRow("document1.html")>
    <DataRow("document2.html")>
    <DataRow("document3.html")>
    Public Sub TestBatchPdfGeneration(filename As String)
        ' Arrange
        Dim html As String = File.ReadAllText(filename)
        Dim renderer As New ChromePdfRenderer()

        ' Act
        Dim pdf = renderer.RenderHtmlAsPdf(html)

        ' Assert
        Assert.IsNotNull(pdf)
        Assert.IsTrue(pdf.PageCount > 0)
    End Sub

End Class

using Microsoft.VisualStudio.TestTools.UnitTesting;
using IronPdf;
using IronOcr;
using IronBarCode;

[TestClass]
public class DocumentWorkflowTests
{
    [TestMethod]
    public void TestCompleteDocumentWorkflow()
    {
        // Step 1: Generate PDF with barcode
        var renderer = new ChromePdfRenderer();
        var barcode = BarcodeWriter.CreateBarcode("DOC-12345", BarcodeEncoding.QRCode);

        var html = $@"
            <html>
            <body>
                <h1>Document #DOC-12345</h1>
                <img src='{barcode.ToDataUrl()}' />
                <p>This is a test document with a QR code.</p>
            </body>
            </html>";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("test-document.pdf");

        // Step 2: Convert PDF to image
        pdf.RasterizeToImageFiles("test-page-*.png");

        // Step 3: Read barcode from image
        var barcodeResults = BarcodeReader.Read("test-page-1.png");

        // Step 4: Verify barcode content
        Assert.IsTrue(barcodeResults.Any());
        Assert.AreEqual("DOC-12345", barcodeResults.First().Value);

        // Step 5: OCR the document
        var ocr = new IronTesseract();
        using (var input = new OcrInput())
        {
            input.AddImage("test-page-1.png");
            var ocrResult = ocr.Read(input);

            Assert.IsTrue(ocrResult.Text.Contains("Document"));
        }
    }
}

Imports Microsoft.VisualStudio.TestTools.UnitTesting
Imports IronPdf
Imports IronOcr
Imports IronBarCode

<TestClass>
Public Class DocumentWorkflowTests

    <TestMethod>
    Public Sub TestCompleteDocumentWorkflow()
        ' Step 1: Generate PDF with barcode
        Dim renderer As New ChromePdfRenderer()
        Dim barcode = BarcodeWriter.CreateBarcode("DOC-12345", BarcodeEncoding.QRCode)

        Dim html As String = $"
            <html>
            <body>
                <h1>Document #DOC-12345</h1>
                <img src='{barcode.ToDataUrl()}' />
                <p>This is a test document with a QR code.</p>
            </body>
            </html>"

        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("test-document.pdf")

        ' Step 2: Convert PDF to image
        pdf.RasterizeToImageFiles("test-page-*.png")

        ' Step 3: Read barcode from image
        Dim barcodeResults = BarcodeReader.Read("test-page-1.png")

        ' Step 4: Verify barcode content
        Assert.IsTrue(barcodeResults.Any())
        Assert.AreEqual("DOC-12345", barcodeResults.First().Value)

        ' Step 5: OCR the document
        Dim ocr As New IronTesseract()
        Using input As New OcrInput()
            input.AddImage("test-page-1.png")
            Dim ocrResult = ocr.Read(input)

            Assert.IsTrue(ocrResult.Text.Contains("Document"))
        End Using
    End Sub

End Class

using Microsoft.Extensions.DependencyInjection;
using IronPdf;
using IronOcr;

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // Configure IronPDF
        services.AddSingleton<ChromePdfRenderer>();

        // Configure IronOCR
        services.AddSingleton<IronTesseract>();

        // Add other services
        services.AddLogging();
    }
}

Imports Microsoft.Extensions.DependencyInjection
Imports IronPdf
Imports IronOcr

Public Class Startup
    Public Sub ConfigureServices(services As IServiceCollection)
        ' Configure IronPDF
        services.AddSingleton(Of ChromePdfRenderer)()

        ' Configure IronOCR
        services.AddSingleton(Of IronTesseract)()

        ' Add other services
        services.AddLogging()
    End Sub
End Class

name: Build and Test

on: [push, pull_request]

jobs:
  build:
    runs-on: windows-latest

    steps:
    - uses: actions/checkout@v2

    - name: Setup .NET 10
      uses: actions/setup-dotnet@v1
      with:
        dotnet-version: '10.0.x'

    - name: Restore dependencies
      run: dotnet restore

    - name: Build
      run: dotnet build --configuration Release

    - name: Run unit tests
      run: dotnet test --configuration Release --logger trunit

    - name: Run code coverage
      run: dotnet test --collect:"XPlat Code Coverage"

using IronPdf;
using System;

public class OptimizedPdfProcessor
{
    public void ProcessLargeDocument(string htmlPath)
    {
        // Use using statements for proper disposal
        using var renderer = new ChromePdfRenderer();

        // Configure for memory efficiency
        renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;

        // Process in chunks if possible
        var html = File.ReadAllText(htmlPath);
        using var pdf = renderer.RenderHtmlAsPdf(html);

        // Save immediately to free memory
        pdf.SaveAs("output.pdf");

        // PDF is disposed automatically
    }
}

Imports IronPdf
Imports System
Imports System.IO

Public Class OptimizedPdfProcessor
    Public Sub ProcessLargeDocument(htmlPath As String)
        ' Use Using blocks for proper disposal
        Using renderer As New ChromePdfRenderer()

            ' Configure for memory efficiency
            renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print
            renderer.RenderingOptions.PaperSize = PdfPaperSize.A4

            ' Process in chunks if possible
            Dim html As String = File.ReadAllText(htmlPath)
            Using pdf = renderer.RenderHtmlAsPdf(html)

                ' Save immediately to free memory
                pdf.SaveAs("output.pdf")

                ' PDF is disposed automatically
            End Using
        End Using
    End Sub
End Class

using IronPdf;
using System.Collections.Concurrent;
using System.Threading.Tasks;

public class BatchProcessor
{
    public async Task ProcessDocumentsBatch(IEnumerable<string> filePaths)
    {
        var options = new ParallelOptions
        {
            MaxDegreeOfParallelism = Environment.ProcessorCount
        };

        await Parallel.ForEachAsync(filePaths, options, async (path, ct) =>
        {
            using var renderer = new ChromePdfRenderer();
            var html = await File.ReadAllTextAsync(path, ct);
            var pdf = renderer.RenderHtmlAsPdf(html);

            var outputPath = Path.ChangeExtension(path, ".pdf");
            pdf.SaveAs(outputPath);
        });
    }
}

Imports IronPdf
Imports System.Collections.Concurrent
Imports System.Threading.Tasks

Public Class BatchProcessor
    Public Async Function ProcessDocumentsBatch(filePaths As IEnumerable(Of String)) As Task
        Dim options As New ParallelOptions With {
            .MaxDegreeOfParallelism = Environment.ProcessorCount
        }

        Await Parallel.ForEachAsync(filePaths, options, Async Function(path, ct)
            Using renderer As New ChromePdfRenderer()
                Dim html As String = Await File.ReadAllTextAsync(path, ct)
                Dim pdf = renderer.RenderHtmlAsPdf(html)

                Dim outputPath As String = Path.ChangeExtension(path, ".pdf")
                pdf.SaveAs(outputPath)
            End Using
        End Function)
    End Function
End Class