Invoice Processing in C#: Generate, Extract, and Automate PDF Invoices with .NET

更新:2026年1月20日

Translated

View the article in English

using IronPDF 在 C# .NET 中處理發票，涵蓋完整的文件生命週期：從 HTML 範本生成專業的 PDF 發票、符合 ZUGFeRD 和 Factur-X 電子發票標準、透過文字解析和 AI 驅動的處理從收到的發票中提取結構化資料，以及建立可與 QuickBooks、Xero 和 SAP 等會計系統整合的批次自動化流程。

TL;DR：快速入門指南

本教學涵蓋在 C# .NET 中生成、擷取及自動化處理 PDF 發票的相關內容，包括電子發票合規性、AI 驅動的解析，以及會計系統整合。

適用對象：正在開發發票模組、應付帳款自動化或電子發票合規系統的 .NET 開發人員。
您將開發的內容：基於 HTML 範本的發票生成（含明細項目與稅額計算）、付款連結的 QR 碼、符合 ZUGFeRD/Factur-X 標準的 PDF/A-3 輸出、透過正規表達式進行文字擷取、AI 驅動的發票解析，以及與會計系統整合的批次處理功能。
執行環境：.NET 10、.NET 8 LTS、.NET Framework 4.6.2 以上版本，以及 .NET Standard 2.0。無需依賴任何外部服務。
適用情境：當您需要生成發票 PDF、符合歐盟電子發票法規，或從供應商發票中擷取數據以處理應付帳款時。
技術層面的重要性：IronPDF 能以像素級精準度將 HTML 渲染為 PDF，支援 PDF/A-3 格式以嵌入 XML，並提供文字擷取 API，可搭配正規表達式或 AI 技術，將非結構化發票轉化為結構化資料。

只需幾行程式碼，即可生成您的第一張 PDF 發票：

using NuGet 套件管理員安裝 https://www.nuget.org/packages/IronPdf
PM > Install-Package IronPdf

請複製並執行此程式碼片段。

var renderer = new IronPdf.ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Invoice #1001</h1><p>Total: $500.00</p>");
pdf.SaveAs("invoice.pdf");

部署至您的生產環境進行測試

立即透過免費試用，在您的專案中開始使用 IronPDF

購買 IronPDF 或註冊 30 天試用版後，請在應用程式啟動時輸入您的授權金鑰。

IronPdf.License.LicenseKey = "KEY";

IronPdf.License.LicenseKey = "KEY";

Imports IronPdf

IronPdf.License.LicenseKey = "KEY"

$vbLabelText $csharpLabel

立即透過免費試用，在您的專案中開始使用 IronPDF。

第一步：

透過 NuGet 安裝

請至 NuGet 查閱 https://www.nuget.org/packages/IronPdf 以快速安裝。該套件下載量已突破 1,000 萬次，正透過 C# 徹底改變 PDF 開發領域。您亦可下載 DLL 檔案或 Windows 安裝程式。

重點摘要：快速入門指南
- 快速概覽
生成 Professional PDF 發票
符合電子發票標準
從 PDF 發票中擷取資料
人工智慧驅動的發票處理
與會計系統整合
- QuickBooks、Xero 及 SAP 的整合模式
- 批次處理數百張發票

透過 NuGet 安裝

什麼是發票生命週期？為什麼 PDF 仍是標準格式？

在深入研究程式碼之前，先了解發票在現代企業系統中的完整流轉過程會有所幫助。發票生命週期包含五個明確的階段：生成、分發、收件、資料擷取以及會計整合。

發票流程始於生成階段。企業會建立包含明細項目、定價、稅金計算、付款條款及品牌資訊的發票。發票需呈現專業外觀，並符合所有法律要求。接下來是發送階段，發票將透過電子郵件、客戶入口網站或傳統郵件寄送給客戶。當客戶收到文件時，應付帳款團隊會將文件登錄系統並準備進行處理。資料擷取功能會從發票中提取關鍵資訊，例如供應商詳細資料、明細項目、總額及到期日，以便進行核對並與採購訂單進行比對。最後，透過會計整合功能，將這些資料匯入 QuickBooks、Xero 或 SAP 等財務系統，以進行付款及帳務記錄。

為何經過這麼多年，PDF 仍是最廣泛使用的格式？這歸結於一組獨特的優勢組合。無論您使用何種裝置或作業系統，PDF 都能確保您的發票格式保持一致。無論收件者是在 Windows、Mac 還是手機上開啟您的發票，其顯示效果都將完全符合您的設計。此外，PDF 檔案不易因誤操作而遭變更，因此相較於 WORD 或 Excel 等格式，更能有效保護文件的完整性。您可以添加數位簽章以確保真實性，並使用加密技術來保障安全性。最重要的是，PDF 已成為所有企業系統皆能識別與支援的通用標準。

當然，這其中存在著一項挑戰。 PDF 檔案的設計初衷是為了方便人類閱讀，而非供電腦處理。 PDF 並非將資訊儲存為結構化資料，而是根據其在頁面上的位置，儲存文字、線條、圖形及圖像。正因如此，像 IronPDF 這樣的工具才如此實用，它們能將人類易讀的文件轉化為軟體可處理的數據。

How to Generate Professional PDF Invoices in C

透過程式碼生成發票，需要將結構化資料（例如客戶資訊、明細項目及計算結果）轉換為格式完善的 PDF 文件。 IronPDF 透過運用 HTML 和 CSS 這兩項多數開發者已相當熟悉的技术，讓這項工作變得異常簡單。

在本教學中，我們將帶您了解實際應用中可能遇到的各種情境。您亦可由此處下載下方所示的專案。

如何建立發票 HTML 範本

IronPDF 生成發票的基礎是 HTML。您無需費心處理低階的 PDF 繪圖指令，只需使用標準的 HTML 和 CSS 設計發票，再由 IronPDF 基於 Chrome 的渲染引擎將其轉換為像素級精準的 PDF。

以下是一個展示此方法的基本發票範本：

:path=/static-assets/pdf/content-code-examples/tutorials/csharp-invoice-processing/basic-invoice-template.cs

using IronPdf;

// Define the HTML template for a basic invoice
// Uses inline CSS for styling headers, tables, and totals
string invoiceHtml = @"
E html>


le>
body { font-family: Arial, sans-serif; padding: 40px; }
.header { text-align: right; margin-bottom: 40px; }
.company-name { font-size: 24px; font-weight: bold; color: #333; }
.invoice-title { font-size: 32px; margin: 20px 0; }
.bill-to { margin: 20px 0; }
table { width: 100%; border-collapse: collapse; margin: 20px 0; }
th { background-color: #2A95D5; color: white; padding: 10px; text-align: left; }
td { padding: 10px; border-bottom: 1px solid #ddd; }
.total { text-align: right; font-size: 20px; font-weight: bold; margin-top: 20px; }
yle>


 class='header'>
<div class='company-name'>Your Company Name</div>
<div>123 Business Street</div>
<div>City, State 12345</div>
v>

 class='invoice-title'>INVOICE</div>

 class='bill-to'>
<strong>Bill To:</strong><br>
Customer Name<br>
456 Customer Avenue<br>
City, State 67890
v>

le>
<tr>
    <th>Description</th>
    <th>Quantity</th>
    <th>Price</th>
    <th>Total</th>
</tr>
<tr>
    <td>Web Development Services</td>
    <td>10 hours</td>
    <td>$100.00</td>
    <td>$1,000.00</td>
</tr>
<tr>
    <td>Consulting</td>
    <td>5 hours</td>
    <td>$150.00</td>
    <td>$750.00</td>
</tr>
ble>

 class='total'>Total: $1,750.00</div>

;

// Initialize the Chrome-based PDF renderer
var renderer = new ChromePdfRenderer();

// Convert the HTML string to a PDF document
var pdf = renderer.RenderHtmlAsPdf(invoiceHtml);

// Save the generated PDF to disk
pdf.SaveAs("basic-invoice.pdf");

Imports IronPdf

' Define the HTML template for a basic invoice
' Uses inline CSS for styling headers, tables, and totals
Dim invoiceHtml As String = "
<!DOCTYPE html>
<html>
<head>
<style>
body { font-family: Arial, sans-serif; padding: 40px; }
.header { text-align: right; margin-bottom: 40px; }
.company-name { font-size: 24px; font-weight: bold; color: #333; }
.invoice-title { font-size: 32px; margin: 20px 0; }
.bill-to { margin: 20px 0; }
table { width: 100%; border-collapse: collapse; margin: 20px 0; }
th { background-color: #2A95D5; color: white; padding: 10px; text-align: left; }
td { padding: 10px; border-bottom: 1px solid #ddd; }
.total { text-align: right; font-size: 20px; font-weight: bold; margin-top: 20px; }
</style>
</head>
<body>
<div class='header'>
    <div class='company-name'>Your Company Name</div>
    <div>123 Business Street</div>
    <div>City, State 12345</div>
</div>
<div class='invoice-title'>INVOICE</div>
<div class='bill-to'>
    <strong>Bill To:</strong><br>
    Customer Name<br>
    456 Customer Avenue<br>
    City, State 67890
</div>
<table>
    <tr>
        <th>Description</th>
        <th>Quantity</th>
        <th>Price</th>
        <th>Total</th>
    </tr>
    <tr>
        <td>Web Development Services</td>
        <td>10 hours</td>
        <td>$100.00</td>
        <td>$1,000.00</td>
    </tr>
    <tr>
        <td>Consulting</td>
        <td>5 hours</td>
        <td>$150.00</td>
        <td>$750.00</td>
    </tr>
</table>
<div class='total'>Total: $1,750.00</div>
</body>
</html>
"

' Initialize the Chrome-based PDF renderer
Dim renderer As New ChromePdfRenderer()

' Convert the HTML string to a PDF document
Dim pdf = renderer.RenderHtmlAsPdf(invoiceHtml)

' Save the generated PDF to disk
pdf.SaveAs("basic-invoice.pdf")

$vbLabelText $csharpLabel

翻譯範例

這種做法提供了極大的靈活性。任何在 Chrome 中有效的 CSS 樣式，在您的 PDF 中皆可正常運作，包括 flexbox、網格佈局及自訂字型等現代功能。您甚至可以透過引用 URL 或本機檔案路徑，使用外部樣式表和圖片。

如何新增動態明細項目並計算總額

真實的發票內容通常並非靜態。您需要從資料庫中填入明細項目、計算小計、套用稅率，並格式化貨幣數值。以下範例展示了一種適用於動態生成發票的生產就緒模式：

using IronPdf;
using System;
using System.Co/llections.Generic;
using System.Linq;

// Represents a single line item on an invoice
public class InvoiceLineItem
{
    public string Description { get; set; }
    public decimal Quantity { get; set; }
    public decimal UnitPrice { get; set; }

    // Auto-calculates line total from quantity and unit price
    public decimal Total => Quantity * UnitPrice;
}

// Represents a complete invoice with customer details and line items
public class Invoice
{
    public string InvoiceNumber { get; set; }
    public DateTime InvoiceDate { get; set; }
    public string CustomerName { get; set; }
    public string CustomerAddress { get; set; }
    public List<InvoiceLineItem> LineItems { get; set; }

    // Computed properties for invoice totals
    public decimal Subtotal => LineItems.Sum(item => item.Total);
    public decimal TaxRate { get; set; } = 0.08m;  // Default 8% tax rate
    public decimal Tax => Subtotal * TaxRate;
    public decimal Total => Subtotal + Tax;
}

// Generates PDF invoices from Invoice objects using HTML templates
public class InvoiceGenerator
{
    public PdfDocument GenerateInvoice(Invoice invoice)
    {
        // Build HTML table rows dynamically from line items
        string lineItemsHtml = string.Join("", invoice.LineItems.Select(item => $@"
            <tr>
                <td>{item.Description}</td>
                <td>{item.Quantity}</td>
                <td>${item.UnitPrice:F2}</td>
                <td>${item.Total:F2}</td>
            </tr>
        "));

        // Build the complete HTML invoice using string interpolation
        // All invoice data is injected into the template dynamically
        string invoiceHtml = $@"
<!DOCTYPE html>
<html>
<head>
    <style>
        body {{font-family: Arial, sans-serif; padding: 40px;}}
        .header {{text-align: right; margin-bottom: 40px;}}
        .company-name {{font-size: 24px; font-weight: bold; color: #333;}}
        .invoice-details {{margin: 20px 0;}}
        table {{width: 100%; border-collapse: collapse; margin: 20px 0;}}
        th {{background-color: #2A95D5; color: white; padding: 10px; text-align: left;}}
        td {{padding: 10px; border-bottom: 1px solid #ddd;}}
        .totals {{text-align: right; margin-top: 20px;}}
        .totals div {{margin: 5px 0;}}
        .grand-total {{font-size: 20px; font-weight: bold; color: #2A95D5;}}
    </style>
</head>
<body>
    <div class='header'>
        <div class='company-name'>Your Company Name</div>
    </div>

    <h1>INVOICE</h1>

    <div class='invoice-details'>
        <strong>Invoice Number:</strong> {invoice.InvoiceNumber}<br>
        <strong>Date:</strong> {invoice.InvoiceDate:MMM dd, yyyy}<br>
        <strong>Bill To:</strong> {invoice.CustomerName}<br>
        {invoice.CustomerAddress}
    </div>

    <table>
        <tr>
            <th>Description</th>
            <th>Quantity</th>
            <th>Unit Price</th>
            <th>Total</th>
        </tr>
        {lineItemsHtml}
    </table>

    <div class='totals'>
        <div>Subtotal: ${invoice.Subtotal:F2}</div>
        <div>Tax ({invoice.TaxRate:P0}): ${invoice.Tax:F2}</div>
        <div class='grand-total'>Total: ${invoice.Total:F2}</div>
    </div>
</body>
</html>";

        // Render HTML to PDF and return the document
        var renderer = new ChromePdfRenderer();
        return renderer.RenderHtmlAsPdf(invoiceHtml);
    }
}

using IronPdf;
using System;
using System.Co/llections.Generic;
using System.Linq;

// Represents a single line item on an invoice
public class InvoiceLineItem
{
    public string Description { get; set; }
    public decimal Quantity { get; set; }
    public decimal UnitPrice { get; set; }

    // Auto-calculates line total from quantity and unit price
    public decimal Total => Quantity * UnitPrice;
}

// Represents a complete invoice with customer details and line items
public class Invoice
{
    public string InvoiceNumber { get; set; }
    public DateTime InvoiceDate { get; set; }
    public string CustomerName { get; set; }
    public string CustomerAddress { get; set; }
    public List<InvoiceLineItem> LineItems { get; set; }

    // Computed properties for invoice totals
    public decimal Subtotal => LineItems.Sum(item => item.Total);
    public decimal TaxRate { get; set; } = 0.08m;  // Default 8% tax rate
    public decimal Tax => Subtotal * TaxRate;
    public decimal Total => Subtotal + Tax;
}

// Generates PDF invoices from Invoice objects using HTML templates
public class InvoiceGenerator
{
    public PdfDocument GenerateInvoice(Invoice invoice)
    {
        // Build HTML table rows dynamically from line items
        string lineItemsHtml = string.Join("", invoice.LineItems.Select(item => $@"
            <tr>
                <td>{item.Description}</td>
                <td>{item.Quantity}</td>
                <td>${item.UnitPrice:F2}</td>
                <td>${item.Total:F2}</td>
            </tr>
        "));

        // Build the complete HTML invoice using string interpolation
        // All invoice data is injected into the template dynamically
        string invoiceHtml = $@"
<!DOCTYPE html>
<html>
<head>
    <style>
        body {{font-family: Arial, sans-serif; padding: 40px;}}
        .header {{text-align: right; margin-bottom: 40px;}}
        .company-name {{font-size: 24px; font-weight: bold; color: #333;}}
        .invoice-details {{margin: 20px 0;}}
        table {{width: 100%; border-collapse: collapse; margin: 20px 0;}}
        th {{background-color: #2A95D5; color: white; padding: 10px; text-align: left;}}
        td {{padding: 10px; border-bottom: 1px solid #ddd;}}
        .totals {{text-align: right; margin-top: 20px;}}
        .totals div {{margin: 5px 0;}}
        .grand-total {{font-size: 20px; font-weight: bold; color: #2A95D5;}}
    </style>
</head>
<body>
    <div class='header'>
        <div class='company-name'>Your Company Name</div>
    </div>

    <h1>INVOICE</h1>

    <div class='invoice-details'>
        <strong>Invoice Number:</strong> {invoice.InvoiceNumber}<br>
        <strong>Date:</strong> {invoice.InvoiceDate:MMM dd, yyyy}<br>
        <strong>Bill To:</strong> {invoice.CustomerName}<br>
        {invoice.CustomerAddress}
    </div>

    <table>
        <tr>
            <th>Description</th>
            <th>Quantity</th>
            <th>Unit Price</th>
            <th>Total</th>
        </tr>
        {lineItemsHtml}
    </table>

    <div class='totals'>
        <div>Subtotal: ${invoice.Subtotal:F2}</div>
        <div>Tax ({invoice.TaxRate:P0}): ${invoice.Tax:F2}</div>
        <div class='grand-total'>Total: ${invoice.Total:F2}</div>
    </div>
</body>
</html>";

        // Render HTML to PDF and return the document
        var renderer = new ChromePdfRenderer();
        return renderer.RenderHtmlAsPdf(invoiceHtml);
    }
}

Imports IronPdf
Imports System
Imports System.Collections.Generic
Imports System.Linq

' Represents a single line item on an invoice
Public Class InvoiceLineItem
    Public Property Description As String
    Public Property Quantity As Decimal
    Public Property UnitPrice As Decimal

    ' Auto-calculates line total from quantity and unit price
    Public ReadOnly Property Total As Decimal
        Get
            Return Quantity * UnitPrice
        End Get
    End Property
End Class

' Represents a complete invoice with customer details and line items
Public Class Invoice
    Public Property InvoiceNumber As String
    Public Property InvoiceDate As DateTime
    Public Property CustomerName As String
    Public Property CustomerAddress As String
    Public Property LineItems As List(Of InvoiceLineItem)

    ' Computed properties for invoice totals
    Public ReadOnly Property Subtotal As Decimal
        Get
            Return LineItems.Sum(Function(item) item.Total)
        End Get
    End Property

    Public Property TaxRate As Decimal = 0.08D ' Default 8% tax rate

    Public ReadOnly Property Tax As Decimal
        Get
            Return Subtotal * TaxRate
        End Get
    End Property

    Public ReadOnly Property Total As Decimal
        Get
            Return Subtotal + Tax
        End Get
    End Property
End Class

' Generates PDF invoices from Invoice objects using HTML templates
Public Class InvoiceGenerator
    Public Function GenerateInvoice(invoice As Invoice) As PdfDocument
        ' Build HTML table rows dynamically from line items
        Dim lineItemsHtml As String = String.Join("", invoice.LineItems.Select(Function(item) $"
            <tr>
                <td>{item.Description}</td>
                <td>{item.Quantity}</td>
                <td>${item.UnitPrice:F2}</td>
                <td>${item.Total:F2}</td>
            </tr>
        "))

        ' Build the complete HTML invoice using string interpolation
        ' All invoice data is injected into the template dynamically
        Dim invoiceHtml As String = $"
<!DOCTYPE html>
<html>
<head>
    <style>
        body {{font-family: Arial, sans-serif; padding: 40px;}}
        .header {{text-align: right; margin-bottom: 40px;}}
        .company-name {{font-size: 24px; font-weight: bold; color: #333;}}
        .invoice-details {{margin: 20px 0;}}
        table {{width: 100%; border-collapse: collapse; margin: 20px 0;}}
        th {{background-color: #2A95D5; color: white; padding: 10px; text-align: left;}}
        td {{padding: 10px; border-bottom: 1px solid #ddd;}}
        .totals {{text-align: right; margin-top: 20px;}}
        .totals div {{margin: 5px 0;}}
        .grand-total {{font-size: 20px; font-weight: bold; color: #2A95D5;}}
    </style>
</head>
<body>
    <div class='header'>
        <div class='company-name'>Your Company Name</div>
    </div>

    <h1>INVOICE</h1>

    <div class='invoice-details'>
        <strong>Invoice Number:</strong> {invoice.InvoiceNumber}<br>
        <strong>Date:</strong> {invoice.InvoiceDate:MMM dd, yyyy}<br>
        <strong>Bill To:</strong> {invoice.CustomerName}<br>
        {invoice.CustomerAddress}
    </div>

    <table>
        <tr>
            <th>Description</th>
            <th>Quantity</th>
            <th>Unit Price</th>
            <th>Total</th>
        </tr>
        {lineItemsHtml}
    </table>

    <div class='totals'>
        <div>Subtotal: ${invoice.Subtotal:F2}</div>
        <div>Tax ({invoice.TaxRate:P0}): ${invoice.Tax:F2}</div>
        <div class='grand-total'>Total: ${invoice.Total:F2}</div>
    </div>
</body>
</html>"

        ' Render HTML to PDF and return the document
        Dim renderer As New ChromePdfRenderer()
        Return renderer.RenderHtmlAsPdf(invoiceHtml)
    End Function
End Class

$vbLabelText $csharpLabel

翻譯範例

Invoice 類別封裝了所有發票資料，並具備用於計算小計、稅金及總額的計算屬性。生成器會透過字串插值將此資料轉換為 HTML，然後渲染為 PDF。這種關注點的分離使程式碼更易於維護和測試。

如何在發票中加入公司品牌標識與浮水印

Professional發票需包含品牌元素，例如標誌，某些情況下還需水印以標示付款狀態。 IronPDF 同時支援 HTML 中的嵌入式圖片，以及渲染後的程式化浮水印功能。

:path=/static-assets/pdf/content-code-examples/tutorials/csharp-invoice-processing/branding-watermarks.cs
using IronPdf;

using IronPdf;

var renderer = new ChromePdfRenderer();

// Invoice HTML template with company logo embedded via URL
// Logo can also be Base64-encoded or a local file path
string htmlWithLogo = @"
E html>


le>
body { font-family: Arial, sans-serif; padding: 40px; }
.logo { width: 200px; margin-bottom: 20px; }
yle>


 style='text-align: center;'>
<img src='https://yourcompany.com/logo.png' alt='Company Logo' class='logo' />
v>
INVOICE</h1>
strong>Invoice Number:</strong> INV-2024-001</p>
strong>Total:</strong> $1,250.00</p>

;

// Render the HTML to PDF
var pdf = renderer.RenderHtmlAsPdf(htmlWithLogo);

// Apply a diagonal "UNPAID" watermark to mark invoice status
// 30% opacity keeps the content readable while the watermark is visible
pdf.ApplyWatermark("<h1 style='color: red;'>UNPAID</h1>",
    opacity: 30,
    rotation: 45,
    verticalAlignment: IronPdf.Editing.VerticalAlignment.Middle);

pdf.SaveAs("invoice-with-watermark.pdf");
using IronPdf;

Imports IronPdf

Dim renderer As New ChromePdfRenderer()

' Invoice HTML template with company logo embedded via URL
' Logo can also be Base64-encoded or a local file path
Dim htmlWithLogo As String = "
<!DOCTYPE html>
<html>
<head>
    <style>
        body { font-family: Arial, sans-serif; padding: 40px; }
        .logo { width: 200px; margin-bottom: 20px; }
    </style>
</head>
<body>
    <div style='text-align: center;'>
        <img src='https://yourcompany.com/logo.png' alt='Company Logo' class='logo' />
        <h1>INVOICE</h1>
        <p><strong>Invoice Number:</strong> INV-2024-001</p>
        <p><strong>Total:</strong> $1,250.00</p>
    </div>
</body>
</html>
"

' Render the HTML to PDF
Dim pdf = renderer.RenderHtmlAsPdf(htmlWithLogo)

' Apply a diagonal "UNPAID" watermark to mark invoice status
' 30% opacity keeps the content readable while the watermark is visible
pdf.ApplyWatermark("<h1 style='color: red;'>UNPAID</h1>",
                   opacity:=30,
                   rotation:=45,
                   verticalAlignment:=IronPdf.Editing.VerticalAlignment.Middle)

pdf.SaveAs("invoice-with-watermark.pdf")

$vbLabelText $csharpLabel

翻譯範例

ApplyWatermark 方法接受 HTML 內容，讓您能完全掌控浮水印的外觀。您可以調整不透明度、旋轉角度和位置，以精確呈現所需的外觀。這對於將發票標記為"已付款"、"草稿"或"已取消"特別有用，且無需重新生成整個文件。

如何嵌入支付連結的 QR 碼

現代發票通常會附有 QR 碼，客戶可透過掃描快速完成付款。雖然 IronPDF 專注於 PDF 生成，但它能與 IronQR 無縫協作以建立 BARCODE：

:path=/static-assets/pdf/content-code-examples/tutorials/csharp-invoice-processing/qr-code-payment.cs

using IronPdf;
using IronQr;
using IronSoftware.Drawing;

string invoiceNumber = "INV-2026-002";
decimal amount = 1500.00m;

// Create a payment URL with invoice details as query parameters
string paymentUrl = $"https://yourcompany.com/pay?invoice={invoiceNumber}&amount={amount}";

// Generate QR code from the payment URL using IronQR
QrCode qrCode = QrWriter.Write(paymentUrl);
AnyBitmap qrImage = qrCode.Save();
qrImage.SaveAs("payment-qr.png", AnyBitmap.ImageFormat.Png);

// Build invoice HTML with the QR code image embedded
// Customers can scan the QR to pay directly from their phone
string invoiceHtml = $@"
E html>


le>
body {{ font-family: Arial, sans-serif; padding: 40px; }}
.payment-section {{ margin-top: 40px; text-align: center;
                   border-top: 2px solid #eee; padding-top: 20px; }}
.qr-code {{ width: 150px; height: 150px; }}
yle>


INVOICE {invoiceNumber}</h1>
strong>Amount Due:</strong> ${amount:F2}</p>

 class='payment-section'>
<p><strong>Scan to Pay Instantly:</strong></p>
<img src='payment-qr.png' alt='Payment QR Code' class='qr-code' />
<p style='font-size: 12px; color: #666;'>
    Or visit: {paymentUrl}
</p>
v>

;

// Convert HTML to PDF and save
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(invoiceHtml);
pdf.SaveAs($"invoice-{invoiceNumber}.pdf");

Imports IronPdf
Imports IronQr
Imports IronSoftware.Drawing

Dim invoiceNumber As String = "INV-2026-002"
Dim amount As Decimal = 1500.00D

' Create a payment URL with invoice details as query parameters
Dim paymentUrl As String = $"https://yourcompany.com/pay?invoice={invoiceNumber}&amount={amount}"

' Generate QR code from the payment URL using IronQR
Dim qrCode As QrCode = QrWriter.Write(paymentUrl)
Dim qrImage As AnyBitmap = qrCode.Save()
qrImage.SaveAs("payment-qr.png", AnyBitmap.ImageFormat.Png)

' Build invoice HTML with the QR code image embedded
' Customers can scan the QR to pay directly from their phone
Dim invoiceHtml As String = $"
<!DOCTYPE html>
<html>
<head>
    <title>Invoice</title>
    <style>
        body {{ font-family: Arial, sans-serif; padding: 40px; }}
        .payment-section {{ margin-top: 40px; text-align: center; border-top: 2px solid #eee; padding-top: 20px; }}
        .qr-code {{ width: 150px; height: 150px; }}
    </style>
</head>
<body>
    <h1>INVOICE {invoiceNumber}</h1>
    <p><strong>Amount Due:</strong> ${amount:F2}</p>
    <div class='payment-section'>
        <p><strong>Scan to Pay Instantly:</strong></p>
        <img src='payment-qr.png' alt='Payment QR Code' class='qr-code' />
        <p style='font-size: 12px; color: #666;'>
            Or visit: {paymentUrl}
        </p>
    </div>
</body>
</html>"

' Convert HTML to PDF and save
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(invoiceHtml)
pdf.SaveAs($"invoice-{invoiceNumber}.pdf")

$vbLabelText $csharpLabel

翻譯範例

此 QR 碼會直接連結至付款頁面，減少客戶的支付障礙，並加速您的現金流。此模式適用於任何支援基於 URL 的付款啟動功能的支付服務供應商。

How to Comply with ZUGFeRD and Factur-X E-Invoicing Standards in C

電子發票制度正迅速在歐洲各地成為強制性規定。德國率先推出 ZUGFeRD，法國隨後推出 Factur-X。這些標準將機器可讀的 XML 資料嵌入 PDF 發票中，在維持文件可讀性的同時，實現自動化處理。對於在歐洲市場營運的企業而言，理解並落實這些標準已變得日益重要。

什麼是 ZUGFeRD？它是如何運作的？

ZUGFeRD（德國電子發票論壇中央使用者指南）是一項德國電子發票標準，其將發票資料作為 XML 檔案附件嵌入符合 PDF/A-3 標準的文件中。內嵌的 XML 可實現無需 OCR 或解析的自動資料擷取。

該標準定義了三個符合性等級，每個等級提供的結構化資料量皆逐級增加：

基本版：包含適用於簡單自動化處理的核心發票資料
Comfort：新增詳細資訊，實現完全自動化的發票處理
擴展版：包含適用於各產業複雜商業情境的全面性資料

此 XML 遵循 UN/CEFACT 跨產業發票 (CII) 架構，該架構已成為歐洲電子發票標準化的基礎。

什麼是 Factur-X？它與 ZUGFeRD 有何不同？

Factur-X 是基於相同底層標準的法國實作版本。 ZUGFeRD 2.0 與 Factur-X 在技術上完全相同。它們採用相同的 XML 架構，並基於歐洲標準 EN 16931 制定了相符性規範。兩者之間的差異僅在於地區性命名：根據 ZUGFeRD 規範建立的發票在 Factur-X 環境下同樣有效，反之亦然。

如何將 XML 資料嵌入 PDF/A-3 發票中

IronPDF 提供創建符合規範之電子發票所需的附件功能。此流程包含產生您的發票 PDF、依據 CII 架構建立 XML 資料，並將 XML 作為附件嵌入，同時遵循正確的命名規範：

using System;
using System.Xml.Linq;

// Generates ZUGFeRD-compliant invoices by embedding structured XML data
// ZUGFeRD allows automated processing while keeping a human-readable PDF
public class ZUGFeRDInvoiceGenerator
{
    public void GenerateZUGFeRDInvoice(Invoice invoice)
    {
        // First, create the visual PDF that humans will read
        var renderer = new ChromePdfRenderer();
        string invoiceHtml = BuildInvoiceHtml(invoice);
        var pdf = renderer.RenderHtmlAsPdf(invoiceHtml);

        // Define the UN/CEFACT namespaces required by the ZUGFeRD standard
        // These are mandatory for compliance with European e-invoicing regulations
        XNamespace rsm = "urn:un:unece:uncefact:data:standard:CrossIndustryInvoice:100";
        XNamespace ram = "urn:un:unece:uncefact:data:standard:ReusableAggregateBusinessInformationEntity:100";
        XNamespace udt = "urn:un:unece:uncefact:data:standard:UnqualifiedDataType:100";

        // Build the ZUGFeRD XML structure following the Cross-Industry Invoice schema
        var zugferdXml = new XDocument(
            new XDeclaration("1.0", "UTF-8", null),
            new XElement(rsm + "CrossIndustryInvoice",
                new XAttribute(XNamespace.Xmlns + "rsm", rsm.NamespaceName),
                new XAttribute(XNamespace.Xmlns + "ram", ram.NamespaceName),
                new XAttribute(XNamespace.Xmlns + "udt", udt.NamespaceName),

                // Document context identifies which e-invoicing guideline is being followed
                new XElement(rsm + "ExchangedDocumentContext",
                    new XElement(ram + "GuidelineSpecifiedDocumentContextParameter",
                        new XElement(ram + "ID", "urn:cen.eu:en16931:2017")
                    )
                ),

                // Core document identification: invoice number, type, and date
                new XElement(rsm + "ExchangedDocument",
                    new XElement(ram + "ID", invoice.InvoiceNumber),
                    new XElement(ram + "TypeCode", "380"), // 380 = Commercial Invoice per UN/CEFACT
                    new XElement(ram + "IssueDateTime",
                        new XElement(udt + "DateTimeString",
                            new XAttribute("format", "102"),
                            invoice.InvoiceDate.ToString("yyyyMMdd")
                        )
                    )
                ),

                // A complete implementation would include additional sections:
                // - Seller information (ram:SellerTradeParty)
                // - Buyer information (ram:BuyerTradeParty)
                // - Line items (ram:IncludedSupplyChainTradeLineItem)
                // - Payment terms (ram:SpecifiedTradePaymentTerms)
                // - Tax summaries (ram:ApplicableTradeTax)

                // Financial summary with all monetary totals
                new XElement(rsm + "SupplyChainTradeTransaction",
                    new XElement(ram + "ApplicableHeaderTradeSettlement",
                        new XElement(ram + "InvoiceCurrencyCode", "EUR"),
                        new XElement(ram + "SpecifiedTradeSettlementHeaderMonetarySummation",
                            new XElement(ram + "TaxBasisTotalAmount", invoice.Subtotal),
                            new XElement(ram + "TaxTotalAmount",
                                new XAttribute("currencyID", "EUR"),
                                invoice.Tax),
                            new XElement(ram + "GrandTotalAmount", invoice.Total),
                            new XElement(ram + "DuePayableAmount", invoice.Total)
                        )
                    )
                )
            )
        );

        // Save the XML to a temp file for embedding
        string xmlPath = $"zugferd-{invoice.InvoiceNumber}.xml";
        zugferdXml.Save(xmlPath);

        // Attach the XML to the PDF - filename must follow ZUGFeRD conventions
        pdf.Attachments.AddFile(xmlPath, "zugferd-invoice.xml", "ZUGFeRD Invoice Data");

        // Final PDF contains both visual invoice and machine-readable XML
        pdf.SaveAs($"invoice-{invoice.InvoiceNumber}-zugferd.pdf");
    }

    // Generates simple HTML for the visual portion of the invoice
    private string BuildInvoiceHtml(Invoice invoice)
    {
        return $@"
<!DOCTYPE html>
<html>
<head>
    <style>
        body {{font-family: Arial, sans-serif; padding: 40px;}}
        h1 {{color: #333;}}
        .zugferd-notice {{margin-top: 30px; padding: 10px; 
            background: #f0f0f0; font-size: 11px;}}
    </style>
</head>
<body>
    <h1>RECHNUNG / INVOICE</h1>
    <p><strong>Rechnungsnummer:</strong> {invoice.InvoiceNumber}</p>
    <p><strong>Datum:</strong> {invoice.InvoiceDate:dd.MM.yyyy}</p>
    <p><strong>Betrag:</strong> €{invoice.Total:F2}</p>

    <div class='zugferd-notice'>
        This invoice contains embedded ZUGFeRD data for automated processing.
    </div>
</body>
</html>";
    }
}

using System;
using System.Xml.Linq;

// Generates ZUGFeRD-compliant invoices by embedding structured XML data
// ZUGFeRD allows automated processing while keeping a human-readable PDF
public class ZUGFeRDInvoiceGenerator
{
    public void GenerateZUGFeRDInvoice(Invoice invoice)
    {
        // First, create the visual PDF that humans will read
        var renderer = new ChromePdfRenderer();
        string invoiceHtml = BuildInvoiceHtml(invoice);
        var pdf = renderer.RenderHtmlAsPdf(invoiceHtml);

        // Define the UN/CEFACT namespaces required by the ZUGFeRD standard
        // These are mandatory for compliance with European e-invoicing regulations
        XNamespace rsm = "urn:un:unece:uncefact:data:standard:CrossIndustryInvoice:100";
        XNamespace ram = "urn:un:unece:uncefact:data:standard:ReusableAggregateBusinessInformationEntity:100";
        XNamespace udt = "urn:un:unece:uncefact:data:standard:UnqualifiedDataType:100";

        // Build the ZUGFeRD XML structure following the Cross-Industry Invoice schema
        var zugferdXml = new XDocument(
            new XDeclaration("1.0", "UTF-8", null),
            new XElement(rsm + "CrossIndustryInvoice",
                new XAttribute(XNamespace.Xmlns + "rsm", rsm.NamespaceName),
                new XAttribute(XNamespace.Xmlns + "ram", ram.NamespaceName),
                new XAttribute(XNamespace.Xmlns + "udt", udt.NamespaceName),

                // Document context identifies which e-invoicing guideline is being followed
                new XElement(rsm + "ExchangedDocumentContext",
                    new XElement(ram + "GuidelineSpecifiedDocumentContextParameter",
                        new XElement(ram + "ID", "urn:cen.eu:en16931:2017")
                    )
                ),

                // Core document identification: invoice number, type, and date
                new XElement(rsm + "ExchangedDocument",
                    new XElement(ram + "ID", invoice.InvoiceNumber),
                    new XElement(ram + "TypeCode", "380"), // 380 = Commercial Invoice per UN/CEFACT
                    new XElement(ram + "IssueDateTime",
                        new XElement(udt + "DateTimeString",
                            new XAttribute("format", "102"),
                            invoice.InvoiceDate.ToString("yyyyMMdd")
                        )
                    )
                ),

                // A complete implementation would include additional sections:
                // - Seller information (ram:SellerTradeParty)
                // - Buyer information (ram:BuyerTradeParty)
                // - Line items (ram:IncludedSupplyChainTradeLineItem)
                // - Payment terms (ram:SpecifiedTradePaymentTerms)
                // - Tax summaries (ram:ApplicableTradeTax)

                // Financial summary with all monetary totals
                new XElement(rsm + "SupplyChainTradeTransaction",
                    new XElement(ram + "ApplicableHeaderTradeSettlement",
                        new XElement(ram + "InvoiceCurrencyCode", "EUR"),
                        new XElement(ram + "SpecifiedTradeSettlementHeaderMonetarySummation",
                            new XElement(ram + "TaxBasisTotalAmount", invoice.Subtotal),
                            new XElement(ram + "TaxTotalAmount",
                                new XAttribute("currencyID", "EUR"),
                                invoice.Tax),
                            new XElement(ram + "GrandTotalAmount", invoice.Total),
                            new XElement(ram + "DuePayableAmount", invoice.Total)
                        )
                    )
                )
            )
        );

        // Save the XML to a temp file for embedding
        string xmlPath = $"zugferd-{invoice.InvoiceNumber}.xml";
        zugferdXml.Save(xmlPath);

        // Attach the XML to the PDF - filename must follow ZUGFeRD conventions
        pdf.Attachments.AddFile(xmlPath, "zugferd-invoice.xml", "ZUGFeRD Invoice Data");

        // Final PDF contains both visual invoice and machine-readable XML
        pdf.SaveAs($"invoice-{invoice.InvoiceNumber}-zugferd.pdf");
    }

    // Generates simple HTML for the visual portion of the invoice
    private string BuildInvoiceHtml(Invoice invoice)
    {
        return $@"
<!DOCTYPE html>
<html>
<head>
    <style>
        body {{font-family: Arial, sans-serif; padding: 40px;}}
        h1 {{color: #333;}}
        .zugferd-notice {{margin-top: 30px; padding: 10px; 
            background: #f0f0f0; font-size: 11px;}}
    </style>
</head>
<body>
    <h1>RECHNUNG / INVOICE</h1>
    <p><strong>Rechnungsnummer:</strong> {invoice.InvoiceNumber}</p>
    <p><strong>Datum:</strong> {invoice.InvoiceDate:dd.MM.yyyy}</p>
    <p><strong>Betrag:</strong> €{invoice.Total:F2}</p>

    <div class='zugferd-notice'>
        This invoice contains embedded ZUGFeRD data for automated processing.
    </div>
</body>
</html>";
    }
}

Imports System
Imports System.Xml.Linq

' Generates ZUGFeRD-compliant invoices by embedding structured XML data
' ZUGFeRD allows automated processing while keeping a human-readable PDF
Public Class ZUGFeRDInvoiceGenerator
    Public Sub GenerateZUGFeRDInvoice(invoice As Invoice)
        ' First, create the visual PDF that humans will read
        Dim renderer As New ChromePdfRenderer()
        Dim invoiceHtml As String = BuildInvoiceHtml(invoice)
        Dim pdf = renderer.RenderHtmlAsPdf(invoiceHtml)

        ' Define the UN/CEFACT namespaces required by the ZUGFeRD standard
        ' These are mandatory for compliance with European e-invoicing regulations
        Dim rsm As XNamespace = "urn:un:unece:uncefact:data:standard:CrossIndustryInvoice:100"
        Dim ram As XNamespace = "urn:un:unece:uncefact:data:standard:ReusableAggregateBusinessInformationEntity:100"
        Dim udt As XNamespace = "urn:un:unece:uncefact:data:standard:UnqualifiedDataType:100"

        ' Build the ZUGFeRD XML structure following the Cross-Industry Invoice schema
        Dim zugferdXml As New XDocument(
            New XDeclaration("1.0", "UTF-8", Nothing),
            New XElement(rsm + "CrossIndustryInvoice",
                New XAttribute(XNamespace.Xmlns + "rsm", rsm.NamespaceName),
                New XAttribute(XNamespace.Xmlns + "ram", ram.NamespaceName),
                New XAttribute(XNamespace.Xmlns + "udt", udt.NamespaceName),

                ' Document context identifies which e-invoicing guideline is being followed
                New XElement(rsm + "ExchangedDocumentContext",
                    New XElement(ram + "GuidelineSpecifiedDocumentContextParameter",
                        New XElement(ram + "ID", "urn:cen.eu:en16931:2017")
                    )
                ),

                ' Core document identification: invoice number, type, and date
                New XElement(rsm + "ExchangedDocument",
                    New XElement(ram + "ID", invoice.InvoiceNumber),
                    New XElement(ram + "TypeCode", "380"), ' 380 = Commercial Invoice per UN/CEFACT
                    New XElement(ram + "IssueDateTime",
                        New XElement(udt + "DateTimeString",
                            New XAttribute("format", "102"),
                            invoice.InvoiceDate.ToString("yyyyMMdd")
                        )
                    )
                ),

                ' A complete implementation would include additional sections:
                ' - Seller information (ram:SellerTradeParty)
                ' - Buyer information (ram:BuyerTradeParty)
                ' - Line items (ram:IncludedSupplyChainTradeLineItem)
                ' - Payment terms (ram:SpecifiedTradePaymentTerms)
                ' - Tax summaries (ram:ApplicableTradeTax)

                ' Financial summary with all monetary totals
                New XElement(rsm + "SupplyChainTradeTransaction",
                    New XElement(ram + "ApplicableHeaderTradeSettlement",
                        New XElement(ram + "InvoiceCurrencyCode", "EUR"),
                        New XElement(ram + "SpecifiedTradeSettlementHeaderMonetarySummation",
                            New XElement(ram + "TaxBasisTotalAmount", invoice.Subtotal),
                            New XElement(ram + "TaxTotalAmount",
                                New XAttribute("currencyID", "EUR"),
                                invoice.Tax),
                            New XElement(ram + "GrandTotalAmount", invoice.Total),
                            New XElement(ram + "DuePayableAmount", invoice.Total)
                        )
                    )
                )
            )
        )

        ' Save the XML to a temp file for embedding
        Dim xmlPath As String = $"zugferd-{invoice.InvoiceNumber}.xml"
        zugferdXml.Save(xmlPath)

        ' Attach the XML to the PDF - filename must follow ZUGFeRD conventions
        pdf.Attachments.AddFile(xmlPath, "zugferd-invoice.xml", "ZUGFeRD Invoice Data")

        ' Final PDF contains both visual invoice and machine-readable XML
        pdf.SaveAs($"invoice-{invoice.InvoiceNumber}-zugferd.pdf")
    End Sub

    ' Generates simple HTML for the visual portion of the invoice
    Private Function BuildInvoiceHtml(invoice As Invoice) As String
        Return $"
<!DOCTYPE html>
<html>
<head>
    <style>
        body {{font-family: Arial, sans-serif; padding: 40px;}}
        h1 {{color: #333;}}
        .zugferd-notice {{margin-top: 30px; padding: 10px; 
            background: #f0f0f0; font-size: 11px;}}
    </style>
</head>
<body>
    <h1>RECHNUNG / INVOICE</h1>
    <p><strong>Rechnungsnummer:</strong> {invoice.InvoiceNumber}</p>
    <p><strong>Datum:</strong> {invoice.InvoiceDate:dd.MM.yyyy}</p>
    <p><strong>Betrag:</strong> €{invoice.Total:F2}</p>

    <div class='zugferd-notice'>
        This invoice contains embedded ZUGFeRD data for automated processing.
    </div>
</body>
</html>"
    End Function
End Class

$vbLabelText $csharpLabel

翻譯範例

合規性的關鍵要點在於使用正確的 XML 命名空間、遵循 CII 模式結構，以及以適當的檔案名稱嵌入 XML。 TypeCode"380"明確標示該文件為符合 UN/CEFACT 標準的商業發票。

如何讓發票符合歐盟法規要求

歐盟正逐步在各成員國推行電子發票制度。義大利已針對 B2B 交易實施此要求，法國將於 2026 年前逐步推行相關規範，而德國則宣布自 2025 年起強制實施 B2B 電子發票。現在即開始建置 ZUGFeRD/Factur-X 支援功能，將使您的系統為這些法規要求做好準備。

以下是一個符合規範的發票生成器範例，可針對不同標準進行調整：

using IronPdf;
using System;

// Enum representing supported European e-invoicing standards
public enum InvoiceStandard
{
    None,
    ZUGFeRD,    // German standard - uses CII XML format
    FacturX,    // French standard - technically identical to ZUGFeRD 2.0
    Peppol      // Pan-European standard - uses UBL XML format
}

// Factory class that generates invoices compliant with different e-invoicing standards
// Allows switching between standards without changing core invoice generation logic
public class CompliantInvoiceGenerator
{
    public PdfDocument GenerateCompliantInvoice(Invoice invoice, InvoiceStandard standard)
    {
        // Generate the base PDF from HTML
        var renderer = new ChromePdfRenderer();
        string html = BuildInvoiceHtml(invoice);
        var pdf = renderer.RenderHtmlAsPdf(html);

        // Attach the appropriate XML format based on target market/regulation
        switch (standard)
        {
            case InvoiceStandard.ZUGFeRD:
            case InvoiceStandard.FacturX:
                // Both use Cross-Industry Invoice format, just different filenames
                EmbedCIIXmlData(pdf, invoice, standard);
                break;
            case InvoiceStandard.Peppol:
                // Peppol uses Universal Business Language format
                EmbedUBLXmlData(pdf, invoice);
                break;
        }

        return pdf;
    }

    // Creates and embeds CII-format XML (used by ZUGFeRD and Factur-X)
    private void EmbedCIIXmlData(PdfDocument pdf, Invoice invoice, InvoiceStandard standard)
    {
        string xml = GenerateCIIXml(invoice);

        // Filename convention differs between German and French standards
        string filename = standard == InvoiceStandard.ZUGFeRD
            ? "zugferd-invoice.xml"
            : "factur-x.xml";

        System.IO.File.WriteAllText("temp-invoice.xml", xml);
        pdf.Attachments.AddFile("temp-invoice.xml", filename, $"{standard} Invoice Data");
    }

    // Creates and embeds UBL-format XML for Peppol network compliance
    private void EmbedUBLXmlData(PdfDocument pdf, Invoice invoice)
    {
        // UBL (Universal Business Language) is the Peppol standard format
        string xml = $@"<?xml version='1.0' encoding='UTF-8'?>
<Invoice xmlns='urn:oasis:names:specification:ubl:schema:xsd:Invoice-2'>
    <id>{invoice.InvoiceNumber}</id>
    <IssueDate>{invoice.InvoiceDate:yyyy-MM-dd}</IssueDate>
    <DocumentCurrencyCode>EUR</DocumentCurrencyCode>
    <LegalMonetaryTotal>
        <PayableAmount currencyID='EUR'>{invoice.Total}</PayableAmount>
    </LegalMonetaryTotal>
</Invoice>";

        System.IO.File.WriteAllText("peppol-invoice.xml", xml);
        pdf.Attachments.AddFile("peppol-invoice.xml", "invoice.xml", "Peppol UBL Invoice");
    }

    // Generates minimal CII XML structure for demonstration
    private string GenerateCIIXml(Invoice invoice)
    {
        return $@"<?xml version='1.0' encoding='UTF-8'?>
<rsm:CrossIndustryInvoice
    xmlns:rsm='urn:un:unece:uncefact:data:standard:CrossIndustryInvoice:100'
    xmlns:ram='urn:un:unece:uncefact:data:standard:ReusableAggregateBusinessInformationEntity:100'>
    <rsm:ExchangedDocument>
        <ram:ID>{invoice.InvoiceNumber}</ram:ID>
        <ram:TypeCode>380</ram:TypeCode>
    </rsm:ExchangedDocument>
</rsm:CrossIndustryInvoice>";
    }

    private string BuildInvoiceHtml(Invoice invoice)
    {
        return $"<html><body><h1>Invoice {invoice.InvoiceNumber}</h1></body></html>";
    }
}

using IronPdf;
using System;

// Enum representing supported European e-invoicing standards
public enum InvoiceStandard
{
    None,
    ZUGFeRD,    // German standard - uses CII XML format
    FacturX,    // French standard - technically identical to ZUGFeRD 2.0
    Peppol      // Pan-European standard - uses UBL XML format
}

// Factory class that generates invoices compliant with different e-invoicing standards
// Allows switching between standards without changing core invoice generation logic
public class CompliantInvoiceGenerator
{
    public PdfDocument GenerateCompliantInvoice(Invoice invoice, InvoiceStandard standard)
    {
        // Generate the base PDF from HTML
        var renderer = new ChromePdfRenderer();
        string html = BuildInvoiceHtml(invoice);
        var pdf = renderer.RenderHtmlAsPdf(html);

        // Attach the appropriate XML format based on target market/regulation
        switch (standard)
        {
            case InvoiceStandard.ZUGFeRD:
            case InvoiceStandard.FacturX:
                // Both use Cross-Industry Invoice format, just different filenames
                EmbedCIIXmlData(pdf, invoice, standard);
                break;
            case InvoiceStandard.Peppol:
                // Peppol uses Universal Business Language format
                EmbedUBLXmlData(pdf, invoice);
                break;
        }

        return pdf;
    }

    // Creates and embeds CII-format XML (used by ZUGFeRD and Factur-X)
    private void EmbedCIIXmlData(PdfDocument pdf, Invoice invoice, InvoiceStandard standard)
    {
        string xml = GenerateCIIXml(invoice);

        // Filename convention differs between German and French standards
        string filename = standard == InvoiceStandard.ZUGFeRD
            ? "zugferd-invoice.xml"
            : "factur-x.xml";

        System.IO.File.WriteAllText("temp-invoice.xml", xml);
        pdf.Attachments.AddFile("temp-invoice.xml", filename, $"{standard} Invoice Data");
    }

    // Creates and embeds UBL-format XML for Peppol network compliance
    private void EmbedUBLXmlData(PdfDocument pdf, Invoice invoice)
    {
        // UBL (Universal Business Language) is the Peppol standard format
        string xml = $@"<?xml version='1.0' encoding='UTF-8'?>
<Invoice xmlns='urn:oasis:names:specification:ubl:schema:xsd:Invoice-2'>
    <id>{invoice.InvoiceNumber}</id>
    <IssueDate>{invoice.InvoiceDate:yyyy-MM-dd}</IssueDate>
    <DocumentCurrencyCode>EUR</DocumentCurrencyCode>
    <LegalMonetaryTotal>
        <PayableAmount currencyID='EUR'>{invoice.Total}</PayableAmount>
    </LegalMonetaryTotal>
</Invoice>";

        System.IO.File.WriteAllText("peppol-invoice.xml", xml);
        pdf.Attachments.AddFile("peppol-invoice.xml", "invoice.xml", "Peppol UBL Invoice");
    }

    // Generates minimal CII XML structure for demonstration
    private string GenerateCIIXml(Invoice invoice)
    {
        return $@"<?xml version='1.0' encoding='UTF-8'?>
<rsm:CrossIndustryInvoice
    xmlns:rsm='urn:un:unece:uncefact:data:standard:CrossIndustryInvoice:100'
    xmlns:ram='urn:un:unece:uncefact:data:standard:ReusableAggregateBusinessInformationEntity:100'>
    <rsm:ExchangedDocument>
        <ram:ID>{invoice.InvoiceNumber}</ram:ID>
        <ram:TypeCode>380</ram:TypeCode>
    </rsm:ExchangedDocument>
</rsm:CrossIndustryInvoice>";
    }

    private string BuildInvoiceHtml(Invoice invoice)
    {
        return $"<html><body><h1>Invoice {invoice.InvoiceNumber}</h1></body></html>";
    }
}

Imports IronPdf
Imports System

' Enum representing supported European e-invoicing standards
Public Enum InvoiceStandard
    None
    ZUGFeRD    ' German standard - uses CII XML format
    FacturX    ' French standard - technically identical to ZUGFeRD 2.0
    Peppol     ' Pan-European standard - uses UBL XML format
End Enum

' Factory class that generates invoices compliant with different e-invoicing standards
' Allows switching between standards without changing core invoice generation logic
Public Class CompliantInvoiceGenerator
    Public Function GenerateCompliantInvoice(invoice As Invoice, standard As InvoiceStandard) As PdfDocument
        ' Generate the base PDF from HTML
        Dim renderer As New ChromePdfRenderer()
        Dim html As String = BuildInvoiceHtml(invoice)
        Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(html)

        ' Attach the appropriate XML format based on target market/regulation
        Select Case standard
            Case InvoiceStandard.ZUGFeRD, InvoiceStandard.FacturX
                ' Both use Cross-Industry Invoice format, just different filenames
                EmbedCIIXmlData(pdf, invoice, standard)
            Case InvoiceStandard.Peppol
                ' Peppol uses Universal Business Language format
                EmbedUBLXmlData(pdf, invoice)
        End Select

        Return pdf
    End Function

    ' Creates and embeds CII-format XML (used by ZUGFeRD and Factur-X)
    Private Sub EmbedCIIXmlData(pdf As PdfDocument, invoice As Invoice, standard As InvoiceStandard)
        Dim xml As String = GenerateCIIXml(invoice)

        ' Filename convention differs between German and French standards
        Dim filename As String = If(standard = InvoiceStandard.ZUGFeRD, "zugferd-invoice.xml", "factur_x.xml")

        System.IO.File.WriteAllText("temp-invoice.xml", xml)
        pdf.Attachments.AddFile("temp-invoice.xml", filename, $"{standard} Invoice Data")
    End Sub

    ' Creates and embeds UBL-format XML for Peppol network compliance
    Private Sub EmbedUBLXmlData(pdf As PdfDocument, invoice As Invoice)
        ' UBL (Universal Business Language) is the Peppol standard format
        Dim xml As String = $"<?xml version='1.0' encoding='UTF-8'?>
<Invoice xmlns='urn:oasis:names:specification:ubl:schema:xsd:Invoice-2'>
    <id>{invoice.InvoiceNumber}</id>
    <IssueDate>{invoice.InvoiceDate:yyyy-MM-dd}</IssueDate>
    <DocumentCurrencyCode>EUR</DocumentCurrencyCode>
    <LegalMonetaryTotal>
        <PayableAmount currencyID='EUR'>{invoice.Total}</PayableAmount>
    </LegalMonetaryTotal>
</Invoice>"

        System.IO.File.WriteAllText("peppol-invoice.xml", xml)
        pdf.Attachments.AddFile("peppol-invoice.xml", "invoice.xml", "Peppol UBL Invoice")
    End Sub

    ' Generates minimal CII XML structure for demonstration
    Private Function GenerateCIIXml(invoice As Invoice) As String
        Return $"<?xml version='1.0' encoding='UTF-8'?>
<rsm:CrossIndustryInvoice
    xmlns:rsm='urn:un:unece:uncefact:data:standard:CrossIndustryInvoice:100'
    xmlns:ram='urn:un:unece:uncefact:data:standard:ReusableAggregateBusinessInformationEntity:100'>
    <rsm:ExchangedDocument>
        <ram:ID>{invoice.InvoiceNumber}</ram:ID>
        <ram:TypeCode>380</ram:TypeCode>
    </rsm:ExchangedDocument>
</rsm:CrossIndustryInvoice>"
    End Function

    Private Function BuildInvoiceHtml(invoice As Invoice) As String
        Return $"<html><body><h1>Invoice {invoice.InvoiceNumber}</h1></body></html>"
    End Function
End Class

$vbLabelText $csharpLabel

此架構讓您能在新標準出現時直接加入，無需重新建構核心的發票生成邏輯。基於枚舉的作法，能讓使用者或設定輕鬆決定應採用哪種合規模式。

How to Extract Data from PDF Invoices in C

開立發票僅是整個流程的一半。大多數企業也會收到供應商開立的發票，並需要擷取資料以供處理。 IronPDF 提供強大的文字擷取功能，此功能為發票資料擷取奠定了基礎。

如何從 PDF 發票中擷取文字

最基本的擷取操作是從 PDF 中提取所有文字內容。 IronPDF 的 ExtractAllText 方法可處理 PDF 文字編碼與定位的複雜性：

using IronPdf;
using System;

// Extracts raw text content from PDF invoices for further processing
public class InvoiceTextExtractor
{
    // Extracts all text from a PDF in one operation
    // Best for single-page invoices or when you need the complete content
    public string ExtractInvoiceText(string pdfPath)
    {
        var pdf = PdfDocument.FromFile(pdfPath);

        // IronPDF handles the complexity of PDF text encoding and positioning
        string allText = pdf.ExtractAllText();
        Console.WriteLine("Full invoice text:");
        Console.WriteLine(allText);

        return allText;
    }

    // Extracts text page by page - useful for multi-page invoices
    // Allows you to process header info separately from line items
    public void ExtractTextByPage(string pdfPath)
    {
        var pdf = PdfDocument.FromFile(pdfPath);

        // Iterate through each page (0-indexed)
        for (int i = 0; i < pdf.PageCount; i++)
        {
            string pageText = pdf.ExtractTextFromPage(i);
            Console.WriteLine($"\n--- Page {i + 1} ---");
            Console.WriteLine(pageText);
        }
    }
}

using IronPdf;
using System;

// Extracts raw text content from PDF invoices for further processing
public class InvoiceTextExtractor
{
    // Extracts all text from a PDF in one operation
    // Best for single-page invoices or when you need the complete content
    public string ExtractInvoiceText(string pdfPath)
    {
        var pdf = PdfDocument.FromFile(pdfPath);

        // IronPDF handles the complexity of PDF text encoding and positioning
        string allText = pdf.ExtractAllText();
        Console.WriteLine("Full invoice text:");
        Console.WriteLine(allText);

        return allText;
    }

    // Extracts text page by page - useful for multi-page invoices
    // Allows you to process header info separately from line items
    public void ExtractTextByPage(string pdfPath)
    {
        var pdf = PdfDocument.FromFile(pdfPath);

        // Iterate through each page (0-indexed)
        for (int i = 0; i < pdf.PageCount; i++)
        {
            string pageText = pdf.ExtractTextFromPage(i);
            Console.WriteLine($"\n--- Page {i + 1} ---");
            Console.WriteLine(pageText);
        }
    }
}

Imports IronPdf
Imports System

' Extracts raw text content from PDF invoices for further processing
Public Class InvoiceTextExtractor
    ' Extracts all text from a PDF in one operation
    ' Best for single-page invoices or when you need the complete content
    Public Function ExtractInvoiceText(pdfPath As String) As String
        Dim pdf = PdfDocument.FromFile(pdfPath)

        ' IronPDF handles the complexity of PDF text encoding and positioning
        Dim allText As String = pdf.ExtractAllText()
        Console.WriteLine("Full invoice text:")
        Console.WriteLine(allText)

        Return allText
    End Function

    ' Extracts text page by page - useful for multi-page invoices
    ' Allows you to process header info separately from line items
    Public Sub ExtractTextByPage(pdfPath As String)
        Dim pdf = PdfDocument.FromFile(pdfPath)

        ' Iterate through each page (0-indexed)
        For i As Integer = 0 To pdf.PageCount - 1
            Dim pageText As String = pdf.ExtractTextFromPage(i)
            Console.WriteLine(vbCrLf & "--- Page " & (i + 1).ToString() & " ---")
            Console.WriteLine(pageText)
        Next
    End Sub
End Class

$vbLabelText $csharpLabel

逐頁擷取功能對於多頁發票特別有用，當您需要定位特定區段時（例如尋找橫跨多頁的明細項目，而頁首資訊僅出現在第一頁），此功能便能發揮作用。

如何擷取明細項目的表格資料

發票明細項目通常以表格格式呈現。 PDF 檔案本身不具備原生表格結構，但您可以擷取文字並進行解析，以重建表格資料：

using IronPdf;
using System;
using System.Co/llections.Generic;

// Data model for a single invoice line item
public class InvoiceLineItem
{
    public string Description { get; set; }
    public decimal Quantity { get; set; }
    public decimal UnitPrice { get; set; }
    public decimal Total { get; set; }
}

// Extracts tabular line item data from PDF invoices
// Note: PDFs don't have native table structure, so this uses text parsing
public class InvoiceTableExtractor
{
    public List<InvoiceLineItem> ExtractLineItems(string pdfPath)
    {
        var pdf = PdfDocument.FromFile(pdfPath);
        string text = pdf.ExtractAllText();

        var lineItems = new List<InvoiceLineItem>();
        string[] lines = text.Split('\n');

        foreach (string line in lines)
        {
            // Currency symbols indicate potential line items with amounts
            if (line.Co/ntains("$") || line.Co/ntains("€"))
            {
                Console.WriteLine($"Potential line item: {line.Trim()}");

                // Split on whitespace to separate columns
                // Actual parsing logic depends on your invoice format
                string[] parts = line.Split(new[] { '\t', ' ' },
                    StringSplitOptions.RemoveEmptyEntries);

                // Try to find numeric values that could be amounts
                foreach (string part in parts)
                {
                    string cleaned = part.Replace("$", "").Replace("€", "").Replace(",", "");
                    if (decimal.TryParse(cleaned, out decimal amount))
                    {
                        Console.WriteLine($"  Found amount: {amount:C}");
                    }
                }
            }
        }

        return lineItems;
    }
}

using IronPdf;
using System;
using System.Co/llections.Generic;

// Data model for a single invoice line item
public class InvoiceLineItem
{
    public string Description { get; set; }
    public decimal Quantity { get; set; }
    public decimal UnitPrice { get; set; }
    public decimal Total { get; set; }
}

// Extracts tabular line item data from PDF invoices
// Note: PDFs don't have native table structure, so this uses text parsing
public class InvoiceTableExtractor
{
    public List<InvoiceLineItem> ExtractLineItems(string pdfPath)
    {
        var pdf = PdfDocument.FromFile(pdfPath);
        string text = pdf.ExtractAllText();

        var lineItems = new List<InvoiceLineItem>();
        string[] lines = text.Split('\n');

        foreach (string line in lines)
        {
            // Currency symbols indicate potential line items with amounts
            if (line.Co/ntains("$") || line.Co/ntains("€"))
            {
                Console.WriteLine($"Potential line item: {line.Trim()}");

                // Split on whitespace to separate columns
                // Actual parsing logic depends on your invoice format
                string[] parts = line.Split(new[] { '\t', ' ' },
                    StringSplitOptions.RemoveEmptyEntries);

                // Try to find numeric values that could be amounts
                foreach (string part in parts)
                {
                    string cleaned = part.Replace("$", "").Replace("€", "").Replace(",", "");
                    if (decimal.TryParse(cleaned, out decimal amount))
                    {
                        Console.WriteLine($"  Found amount: {amount:C}");
                    }
                }
            }
        }

        return lineItems;
    }
}

Imports IronPdf
Imports System
Imports System.Collections.Generic

' Data model for a single invoice line item
Public Class InvoiceLineItem
    Public Property Description As String
    Public Property Quantity As Decimal
    Public Property UnitPrice As Decimal
    Public Property Total As Decimal
End Class

' Extracts tabular line item data from PDF invoices
' Note: PDFs don't have native table structure, so this uses text parsing
Public Class InvoiceTableExtractor
    Public Function ExtractLineItems(pdfPath As String) As List(Of InvoiceLineItem)
        Dim pdf = PdfDocument.FromFile(pdfPath)
        Dim text As String = pdf.ExtractAllText()

        Dim lineItems As New List(Of InvoiceLineItem)()
        Dim lines() As String = text.Split(ControlChars.Lf)

        For Each line As String In lines
            ' Currency symbols indicate potential line items with amounts
            If line.Contains("$") OrElse line.Contains("€") Then
                Console.WriteLine($"Potential line item: {line.Trim()}")

                ' Split on whitespace to separate columns
                ' Actual parsing logic depends on your invoice format
                Dim parts() As String = line.Split(New Char() {ControlChars.Tab, " "c}, StringSplitOptions.RemoveEmptyEntries)

                ' Try to find numeric values that could be amounts
                For Each part As String In parts
                    Dim cleaned As String = part.Replace("$", "").Replace("€", "").Replace(",", "")
                    Dim amount As Decimal
                    If Decimal.TryParse(cleaned, amount) Then
                        Console.WriteLine($"  Found amount: {amount:C}")
                    End If
                Next
            End If
        Next

        Return lineItems
    End Function
End Class

$vbLabelText $csharpLabel

解析邏輯將根據您的發票格式而有所不同。對於來自已知供應商且版面配置一致的發票，您可以建立特定格式的解析器。針對多種格式，請參考本文後段介紹的 AI 驅動提取功能。

如何運用模式比對處理發票編號、日期及總額

正規表達式對於從發票文字中提取特定數據點而言，具有不可或缺的重要性。發票編號、日期和總額等關鍵欄位通常遵循可辨識的模式：

using IronPdf;
using System;
using System.Text.RegularExpressions;

// Data model for extracted invoice information
public class InvoiceData
{
    public string InvoiceNumber { get; set; }
    public string InvoiceDate { get; set; }
    public decimal TotalAmount { get; set; }
    public string VendorName { get; set; }
}

// Extracts key invoice fields using regex pattern matching
// Multiple patterns handle variations across different vendors
public class InvoiceParser
{
    public InvoiceData ParseInvoice(string pdfPath)
    {
        var pdf = PdfDocument.FromFile(pdfPath);
        string text = pdf.ExtractAllText();

        var invoiceData = new InvoiceData();

        // Try multiple patterns to find invoice number
        // Handles: "Invoice #123", "INV-123", "Invoice Number: 123", German "Rechnungsnummer"
        string[] invoiceNumberPatterns = new[]
        {
            @"Invoice\s*#?\s*:?\s*([A-Z0-9-]+)",
            @"INV[-\s]?(\d+)",
            @"Invoice\s+Number\s*:?\s*([A-Z0-9-]+)",
            @"Rechnungsnummer\s*:?\s*([A-Z0-9-]+)"
        };

        foreach (string pattern in invoiceNumberPatterns)
        {
            var match = Regex.Match(text, pattern, RegexOptions.IgnoreCase);
            if (match.Success)
            {
                invoiceData.InvoiceNumber = match.Groups[1].Value;
                Console.WriteLine($"Found Invoice Number: {invoiceData.InvoiceNumber}");
                break;
            }
        }

        // Date patterns for US, European, and written formats
        string[] datePatterns = new[]
        {
            @"Date\s*:?\s*(\d{1,2}[/-]\d{1,2}[/-]\d{2,4})",
            @"Invoice\s+Date\s*:?\s*(\d{1,2}[/-]\d{1,2}[/-]\d{2,4})",
            @"(\d{1,2}\.\d{1,2}\.\d{4})",  // European: DD.MM.YYYY
            @"(\w+\s+\d{1,2},?\s+\d{4})"   // Written: January 15, 2024
        };

        foreach (string pattern in datePatterns)
        {
            var match = Regex.Match(text, pattern, RegexOptions.IgnoreCase);
            if (match.Success)
            {
                invoiceData.InvoiceDate = match.Groups[1].Value;
                Console.WriteLine($"Found Date: {invoiceData.InvoiceDate}");
                break;
            }
        }

        // Look for total amount with various labels
        string[] totalPatterns = new[]
        {
            @"Total\s*:?\s*[\$€]?\s*([\d,]+\.\d{2})",
            @"Amount\s+Due\s*:?\s*[\$€]?\s*([\d,]+\.\d{2})",
            @"Grand\s+Total\s*:?\s*[\$€]?\s*([\d,]+\.\d{2})",
            @"Balance\s+Due\s*:?\s*[\$€]?\s*([\d,]+\.\d{2})"
        };

        foreach (string pattern in totalPatterns)
        {
            var match = Regex.Match(text, pattern, RegexOptions.IgnoreCase);
            if (match.Success)
            {
                // Remove commas before parsing
                string amountStr = match.Groups[1].Value.Replace(",", "");
                if (decimal.TryParse(amountStr, out decimal amount))
                {
                    invoiceData.TotalAmount = amount;
                    Console.WriteLine($"Found Total: ${invoiceData.TotalAmount:F2}");
                    break;
                }
            }
        }

        return invoiceData;
    }
}

using IronPdf;
using System;
using System.Text.RegularExpressions;

// Data model for extracted invoice information
public class InvoiceData
{
    public string InvoiceNumber { get; set; }
    public string InvoiceDate { get; set; }
    public decimal TotalAmount { get; set; }
    public string VendorName { get; set; }
}

// Extracts key invoice fields using regex pattern matching
// Multiple patterns handle variations across different vendors
public class InvoiceParser
{
    public InvoiceData ParseInvoice(string pdfPath)
    {
        var pdf = PdfDocument.FromFile(pdfPath);
        string text = pdf.ExtractAllText();

        var invoiceData = new InvoiceData();

        // Try multiple patterns to find invoice number
        // Handles: "Invoice #123", "INV-123", "Invoice Number: 123", German "Rechnungsnummer"
        string[] invoiceNumberPatterns = new[]
        {
            @"Invoice\s*#?\s*:?\s*([A-Z0-9-]+)",
            @"INV[-\s]?(\d+)",
            @"Invoice\s+Number\s*:?\s*([A-Z0-9-]+)",
            @"Rechnungsnummer\s*:?\s*([A-Z0-9-]+)"
        };

        foreach (string pattern in invoiceNumberPatterns)
        {
            var match = Regex.Match(text, pattern, RegexOptions.IgnoreCase);
            if (match.Success)
            {
                invoiceData.InvoiceNumber = match.Groups[1].Value;
                Console.WriteLine($"Found Invoice Number: {invoiceData.InvoiceNumber}");
                break;
            }
        }

        // Date patterns for US, European, and written formats
        string[] datePatterns = new[]
        {
            @"Date\s*:?\s*(\d{1,2}[/-]\d{1,2}[/-]\d{2,4})",
            @"Invoice\s+Date\s*:?\s*(\d{1,2}[/-]\d{1,2}[/-]\d{2,4})",
            @"(\d{1,2}\.\d{1,2}\.\d{4})",  // European: DD.MM.YYYY
            @"(\w+\s+\d{1,2},?\s+\d{4})"   // Written: January 15, 2024
        };

        foreach (string pattern in datePatterns)
        {
            var match = Regex.Match(text, pattern, RegexOptions.IgnoreCase);
            if (match.Success)
            {
                invoiceData.InvoiceDate = match.Groups[1].Value;
                Console.WriteLine($"Found Date: {invoiceData.InvoiceDate}");
                break;
            }
        }

        // Look for total amount with various labels
        string[] totalPatterns = new[]
        {
            @"Total\s*:?\s*[\$€]?\s*([\d,]+\.\d{2})",
            @"Amount\s+Due\s*:?\s*[\$€]?\s*([\d,]+\.\d{2})",
            @"Grand\s+Total\s*:?\s*[\$€]?\s*([\d,]+\.\d{2})",
            @"Balance\s+Due\s*:?\s*[\$€]?\s*([\d,]+\.\d{2})"
        };

        foreach (string pattern in totalPatterns)
        {
            var match = Regex.Match(text, pattern, RegexOptions.IgnoreCase);
            if (match.Success)
            {
                // Remove commas before parsing
                string amountStr = match.Groups[1].Value.Replace(",", "");
                if (decimal.TryParse(amountStr, out decimal amount))
                {
                    invoiceData.TotalAmount = amount;
                    Console.WriteLine($"Found Total: ${invoiceData.TotalAmount:F2}");
                    break;
                }
            }
        }

        return invoiceData;
    }
}

Imports IronPdf
Imports System
Imports System.Text.RegularExpressions

' Data model for extracted invoice information
Public Class InvoiceData
    Public Property InvoiceNumber As String
    Public Property InvoiceDate As String
    Public Property TotalAmount As Decimal
    Public Property VendorName As String
End Class

' Extracts key invoice fields using regex pattern matching
' Multiple patterns handle variations across different vendors
Public Class InvoiceParser
    Public Function ParseInvoice(pdfPath As String) As InvoiceData
        Dim pdf = PdfDocument.FromFile(pdfPath)
        Dim text As String = pdf.ExtractAllText()

        Dim invoiceData As New InvoiceData()

        ' Try multiple patterns to find invoice number
        ' Handles: "Invoice #123", "INV-123", "Invoice Number: 123", German "Rechnungsnummer"
        Dim invoiceNumberPatterns As String() = {
            "Invoice\s*#?\s*:?\s*([A-Z0-9-]+)",
            "INV[-\s]?(\d+)",
            "Invoice\s+Number\s*:?\s*([A-Z0-9-]+)",
            "Rechnungsnummer\s*:?\s*([A-Z0-9-]+)"
        }

        For Each pattern As String In invoiceNumberPatterns
            Dim match = Regex.Match(text, pattern, RegexOptions.IgnoreCase)
            If match.Success Then
                invoiceData.InvoiceNumber = match.Groups(1).Value
                Console.WriteLine($"Found Invoice Number: {invoiceData.InvoiceNumber}")
                Exit For
            End If
        Next

        ' Date patterns for US, European, and written formats
        Dim datePatterns As String() = {
            "Date\s*:?\s*(\d{1,2}[/-]\d{1,2}[/-]\d{2,4})",
            "Invoice\s+Date\s*:?\s*(\d{1,2}[/-]\d{1,2}[/-]\d{2,4})",
            "(\d{1,2}\.\d{1,2}\.\d{4})",  ' European: DD.MM.YYYY
            "(\w+\s+\d{1,2},?\s+\d{4})"   ' Written: January 15, 2024
        }

        For Each pattern As String In datePatterns
            Dim match = Regex.Match(text, pattern, RegexOptions.IgnoreCase)
            If match.Success Then
                invoiceData.InvoiceDate = match.Groups(1).Value
                Console.WriteLine($"Found Date: {invoiceData.InvoiceDate}")
                Exit For
            End If
        Next

        ' Look for total amount with various labels
        Dim totalPatterns As String() = {
            "Total\s*:?\s*[\$€]?\s*([\d,]+\.\d{2})",
            "Amount\s+Due\s*:?\s*[\$€]?\s*([\d,]+\.\d{2})",
            "Grand\s+Total\s*:?\s*[\$€]?\s*([\d,]+\.\d{2})",
            "Balance\s+Due\s*:?\s*[\$€]?\s*([\d,]+\.\d{2})"
        }

        For Each pattern As String In totalPatterns
            Dim match = Regex.Match(text, pattern, RegexOptions.IgnoreCase)
            If match.Success Then
                ' Remove commas before parsing
                Dim amountStr As String = match.Groups(1).Value.Replace(",", "")
                Dim amount As Decimal
                If Decimal.TryParse(amountStr, amount) Then
                    invoiceData.TotalAmount = amount
                    Console.WriteLine($"Found Total: ${invoiceData.TotalAmount:F2}")
                    Exit For
                End If
            End If
        Next

        Return invoiceData
    End Function
End Class

$vbLabelText $csharpLabel

這種基於範式的做法對於格式可預測的發票非常有效。多種格式變體可處理不同供應商間常見的格式差異，例如"Invoice #"與"Invoice Number:"

至於掃描或圖像格式的發票呢？

上述文字擷取方法適用於包含內嵌文字的 PDF 檔案。然而，掃描文件和基於圖像的 PDF 檔案並無可提取的文字。它們本質上是發票的圖片。

請注意若要處理掃描過的發票，您將需要 OCR（光學字元辨識）功能。 IronOCR 作為 Iron Suite 的一部分，能與 IronPDF 無縫整合以應對這些情境。請造訪 https://ironsoftware.com/csharp/ocr/，進一步了解如何從掃描文件和圖片中擷取文字。）}]

如何在 .NET 中運用 AI 處理發票

傳統的模式比對對於標準化的發票效果良好，但現實中的應付帳款部門收到的文件格式卻五花八門。這正是 AI 驅動的資料擷取技術大顯身手之處。大型語言模型能夠理解發票的語義，即使面對不熟悉的版面配置，也能從中提取結構化資料。

如何整合 AI 進行發票解析

這套由 AI 驅動的發票處理模式，結合了 IronPDF 的文字擷取功能與 LLM API 呼叫。以下是一個適用於任何 OpenAI 相容 API 的通用實作範例：

using IronPdf;
using System;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

// Data model for extracted invoice information
public class InvoiceData
{
    public string InvoiceNumber { get; set; }
    public string InvoiceDate { get; set; }
    public string VendorName { get; set; }
    public decimal TotalAmount { get; set; }
}

// Leverages AI/LLM APIs to extract structured data from any invoice format
// Works with OpenAI or any compatible API endpoint
public class AIInvoiceParser
{
    private readonly HttpClient _httpClient;
    private readonly string _apiKey;
    private readonly string _apiUrl;

    public AIInvoiceParser(string apiKey, string apiUrl = "https://api.openai.com/v1/chat/completions")
    {
        _apiKey = apiKey;
        _apiUrl = apiUrl;
        _httpClient = new HttpClient();
        _httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {_apiKey}");
    }

    public async Task<InvoiceData> ParseInvoiceWithAI(string pdfPath)
    {
        // First extract raw text from the PDF using IronPDF
        var pdf = PdfDocument.FromFile(pdfPath);
        string invoiceText = pdf.ExtractAllText();

        // Construct a prompt that instructs the AI to return structured JSON
        // Being explicit about the format reduces parsing errors
        string prompt = $@"Extract the following information from this invoice text.
Return ONLY valid JSON with no additional text or markdown formatting.

Required fields:
- InvoiceNumber: The invoice or document number
- InvoiceDate: The invoice date in YYYY-MM-DD format
- VendorName: The company or person who sent the invoice
- TotalAmount: The total amount due as a number (no currency symbols)

Invoice text:
{invoiceText}

JSON response:";

        // Build the API request with a system prompt for context
        var requestBody = new
        {
            model = "gpt-4",
            messages = new[]
            {
                new {
                    role = "system",
                    content = "You are an invoice data extraction assistant. Extract structured data from invoices and return valid JSON only."
                },
                new { role = "user", content = prompt }
            },
            temperature = 0.1  // Low temperature ensures consistent, deterministic results
        };

        var json = JsonSerializer.Serialize(requestBody);
        var content = new StringContent(json, Encoding.UTF8, "application/json");

        var response = await _httpClient.PostAsync(_apiUrl, content);
        var responseJson = await response.Co/ntent.ReadAsStringAsync();

        // Navigate the API response structure to get the extracted content
        using var doc = JsonDocument.Parse(responseJson);
        var messageContent = doc.RootElement
            .GetProperty("choices")[0]
            .GetProperty("message")
            .GetProperty("content")
            .GetString();

        Console.WriteLine("AI Extracted Data:");
        Console.WriteLine(messageContent);

        // Deserialize the AI's JSON response into our data class
        var invoiceData = JsonSerializer.Deserialize<InvoiceData>(messageContent,
            new JsonSerializerOptions { PropertyNameCaseInsensitive = true });

        return invoiceData;
    }
}

using IronPdf;
using System;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

// Data model for extracted invoice information
public class InvoiceData
{
    public string InvoiceNumber { get; set; }
    public string InvoiceDate { get; set; }
    public string VendorName { get; set; }
    public decimal TotalAmount { get; set; }
}

// Leverages AI/LLM APIs to extract structured data from any invoice format
// Works with OpenAI or any compatible API endpoint
public class AIInvoiceParser
{
    private readonly HttpClient _httpClient;
    private readonly string _apiKey;
    private readonly string _apiUrl;

    public AIInvoiceParser(string apiKey, string apiUrl = "https://api.openai.com/v1/chat/completions")
    {
        _apiKey = apiKey;
        _apiUrl = apiUrl;
        _httpClient = new HttpClient();
        _httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {_apiKey}");
    }

    public async Task<InvoiceData> ParseInvoiceWithAI(string pdfPath)
    {
        // First extract raw text from the PDF using IronPDF
        var pdf = PdfDocument.FromFile(pdfPath);
        string invoiceText = pdf.ExtractAllText();

        // Construct a prompt that instructs the AI to return structured JSON
        // Being explicit about the format reduces parsing errors
        string prompt = $@"Extract the following information from this invoice text.
Return ONLY valid JSON with no additional text or markdown formatting.

Required fields:
- InvoiceNumber: The invoice or document number
- InvoiceDate: The invoice date in YYYY-MM-DD format
- VendorName: The company or person who sent the invoice
- TotalAmount: The total amount due as a number (no currency symbols)

Invoice text:
{invoiceText}

JSON response:";

        // Build the API request with a system prompt for context
        var requestBody = new
        {
            model = "gpt-4",
            messages = new[]
            {
                new {
                    role = "system",
                    content = "You are an invoice data extraction assistant. Extract structured data from invoices and return valid JSON only."
                },
                new { role = "user", content = prompt }
            },
            temperature = 0.1  // Low temperature ensures consistent, deterministic results
        };

        var json = JsonSerializer.Serialize(requestBody);
        var content = new StringContent(json, Encoding.UTF8, "application/json");

        var response = await _httpClient.PostAsync(_apiUrl, content);
        var responseJson = await response.Co/ntent.ReadAsStringAsync();

        // Navigate the API response structure to get the extracted content
        using var doc = JsonDocument.Parse(responseJson);
        var messageContent = doc.RootElement
            .GetProperty("choices")[0]
            .GetProperty("message")
            .GetProperty("content")
            .GetString();

        Console.WriteLine("AI Extracted Data:");
        Console.WriteLine(messageContent);

        // Deserialize the AI's JSON response into our data class
        var invoiceData = JsonSerializer.Deserialize<InvoiceData>(messageContent,
            new JsonSerializerOptions { PropertyNameCaseInsensitive = true });

        return invoiceData;
    }
}

Imports IronPdf
Imports System
Imports System.Net.Http
Imports System.Text
Imports System.Text.Json
Imports System.Threading.Tasks

' Data model for extracted invoice information
Public Class InvoiceData
    Public Property InvoiceNumber As String
    Public Property InvoiceDate As String
    Public Property VendorName As String
    Public Property TotalAmount As Decimal
End Class

' Leverages AI/LLM APIs to extract structured data from any invoice format
' Works with OpenAI or any compatible API endpoint
Public Class AIInvoiceParser
    Private ReadOnly _httpClient As HttpClient
    Private ReadOnly _apiKey As String
    Private ReadOnly _apiUrl As String

    Public Sub New(apiKey As String, Optional apiUrl As String = "https://api.openai.com/v1/chat/completions")
        _apiKey = apiKey
        _apiUrl = apiUrl
        _httpClient = New HttpClient()
        _httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {_apiKey}")
    End Sub

    Public Async Function ParseInvoiceWithAI(pdfPath As String) As Task(Of InvoiceData)
        ' First extract raw text from the PDF using IronPDF
        Dim pdf = PdfDocument.FromFile(pdfPath)
        Dim invoiceText As String = pdf.ExtractAllText()

        ' Construct a prompt that instructs the AI to return structured JSON
        ' Being explicit about the format reduces parsing errors
        Dim prompt As String = $"Extract the following information from this invoice text.
Return ONLY valid JSON with no additional text or markdown formatting.

Required fields:
- InvoiceNumber: The invoice or document number
- InvoiceDate: The invoice date in YYYY-MM-DD format
- VendorName: The company or person who sent the invoice
- TotalAmount: The total amount due as a number (no currency symbols)

Invoice text:
{invoiceText}

JSON response:"

        ' Build the API request with a system prompt for context
        Dim requestBody = New With {
            .model = "gpt-4",
            .messages = New Object() {
                New With {
                    .role = "system",
                    .content = "You are an invoice data extraction assistant. Extract structured data from invoices and return valid JSON only."
                },
                New With {
                    .role = "user",
                    .content = prompt
                }
            },
            .temperature = 0.1  ' Low temperature ensures consistent, deterministic results
        }

        Dim json As String = JsonSerializer.Serialize(requestBody)
        Dim content As New StringContent(json, Encoding.UTF8, "application/json")

        Dim response = Await _httpClient.PostAsync(_apiUrl, content)
        Dim responseJson As String = Await response.Content.ReadAsStringAsync()

        ' Navigate the API response structure to get the extracted content
        Using doc = JsonDocument.Parse(responseJson)
            Dim messageContent As String = doc.RootElement _
                .GetProperty("choices")(0) _
                .GetProperty("message") _
                .GetProperty("content") _
                .GetString()

            Console.WriteLine("AI Extracted Data:")
            Console.WriteLine(messageContent)

            ' Deserialize the AI's JSON response into our data class
            Dim invoiceData As InvoiceData = JsonSerializer.Deserialize(Of InvoiceData)(messageContent, New JsonSerializerOptions With {.PropertyNameCaseInsensitive = True})

            Return invoiceData
        End Using
    End Function
End Class

$vbLabelText $csharpLabel

較低的溫度設定（0.1）有助於產生確定性的輸出結果，這對於需要針對相同輸入獲得一致結果的資料擷取任務至關重要。

如何從發票中擷取結構化 JSON 資料

若需處理包含明細項目、供應商詳情及客戶資訊的較複雜發票，您可以要求採用更豐富的 JSON 結構：

using IronPdf;
using System;
using System.Co/llections.Generic;
using System.Text.Json;
using System.Threading.Tasks;

// Comprehensive invoice data model with all details
public class DetailedInvoiceData
{
    public string InvoiceNumber { get; set; }
    public DateTime InvoiceDate { get; set; }
    public DateTime DueDate { get; set; }
    public VendorInfo Vendor { get; set; }
    public CustomerInfo Customer { get; set; }
    public List<LineItem> LineItems { get; set; }
    public decimal Subtotal { get; set; }
    public decimal Tax { get; set; }
    public decimal Total { get; set; }
}

public class VendorInfo
{
    public string Name { get; set; }
    public string Address { get; set; }
    public string TaxId { get; set; }
}

public class CustomerInfo
{
    public string Name { get; set; }
    public string Address { get; set; }
}

public class LineItem
{
    public string Description { get; set; }
    public decimal Quantity { get; set; }
    public decimal UnitPrice { get; set; }
    public decimal Total { get; set; }
}

// Extracts comprehensive invoice data including line items and party details
public class StructuredInvoiceExtractor
{
    private readonly AIInvoiceParser _aiParser;

    public StructuredInvoiceExtractor(string apiKey)
    {
        _aiParser = new AIInvoiceParser(apiKey);
    }

    public async Task<DetailedInvoiceData> ExtractDetailedData(string pdfPath)
    {
        var pdf = PdfDocument.FromFile(pdfPath);
        string text = pdf.ExtractAllText();

        // Define the exact JSON structure we want the AI to return
        // This schema guides the AI to extract all relevant fields
        string jsonSchema = @"{
  ""InvoiceNumber"": ""string"",
  ""InvoiceDate"": ""YYYY-MM-DD"",
  ""DueDate"": ""YYYY-MM-DD"",
  ""Vendor"": {
    ""Name"": ""string"",
    ""Address"": ""string"",
    ""TaxId"": ""string or null""
  },
  ""Customer"": {
    ""Name"": ""string"",
    ""Address"": ""string""
  },
  ""LineItems"": [
    {
      ""Description"": ""string"",
      ""Quantity"": 0.0,
      ""UnitPrice"": 0.00,
      ""Total"": 0.00
    }
  ],
  ""Subtotal"": 0.00,
  ""Tax"": 0.00,
  ""Total"": 0.00
}";

        // Prompt includes both the schema and the extracted text
        string prompt = $@"Extract all invoice data and return it in this exact JSON structure:
{jsonSchema}

Invoice text:
{text}

Return only valid JSON, no markdown formatting or additional text.";

        // Call AI API and parse response (implementation as shown above)
        // Return deserialized DetailedInvoiceData

        return new DetailedInvoiceData(); // Placeholder
    }
}

using IronPdf;
using System;
using System.Co/llections.Generic;
using System.Text.Json;
using System.Threading.Tasks;

// Comprehensive invoice data model with all details
public class DetailedInvoiceData
{
    public string InvoiceNumber { get; set; }
    public DateTime InvoiceDate { get; set; }
    public DateTime DueDate { get; set; }
    public VendorInfo Vendor { get; set; }
    public CustomerInfo Customer { get; set; }
    public List<LineItem> LineItems { get; set; }
    public decimal Subtotal { get; set; }
    public decimal Tax { get; set; }
    public decimal Total { get; set; }
}

public class VendorInfo
{
    public string Name { get; set; }
    public string Address { get; set; }
    public string TaxId { get; set; }
}

public class CustomerInfo
{
    public string Name { get; set; }
    public string Address { get; set; }
}

public class LineItem
{
    public string Description { get; set; }
    public decimal Quantity { get; set; }
    public decimal UnitPrice { get; set; }
    public decimal Total { get; set; }
}

// Extracts comprehensive invoice data including line items and party details
public class StructuredInvoiceExtractor
{
    private readonly AIInvoiceParser _aiParser;

    public StructuredInvoiceExtractor(string apiKey)
    {
        _aiParser = new AIInvoiceParser(apiKey);
    }

    public async Task<DetailedInvoiceData> ExtractDetailedData(string pdfPath)
    {
        var pdf = PdfDocument.FromFile(pdfPath);
        string text = pdf.ExtractAllText();

        // Define the exact JSON structure we want the AI to return
        // This schema guides the AI to extract all relevant fields
        string jsonSchema = @"{
  ""InvoiceNumber"": ""string"",
  ""InvoiceDate"": ""YYYY-MM-DD"",
  ""DueDate"": ""YYYY-MM-DD"",
  ""Vendor"": {
    ""Name"": ""string"",
    ""Address"": ""string"",
    ""TaxId"": ""string or null""
  },
  ""Customer"": {
    ""Name"": ""string"",
    ""Address"": ""string""
  },
  ""LineItems"": [
    {
      ""Description"": ""string"",
      ""Quantity"": 0.0,
      ""UnitPrice"": 0.00,
      ""Total"": 0.00
    }
  ],
  ""Subtotal"": 0.00,
  ""Tax"": 0.00,
  ""Total"": 0.00
}";

        // Prompt includes both the schema and the extracted text
        string prompt = $@"Extract all invoice data and return it in this exact JSON structure:
{jsonSchema}

Invoice text:
{text}

Return only valid JSON, no markdown formatting or additional text.";

        // Call AI API and parse response (implementation as shown above)
        // Return deserialized DetailedInvoiceData

        return new DetailedInvoiceData(); // Placeholder
    }
}

Imports IronPdf
Imports System
Imports System.Collections.Generic
Imports System.Text.Json
Imports System.Threading.Tasks

' Comprehensive invoice data model with all details
Public Class DetailedInvoiceData
    Public Property InvoiceNumber As String
    Public Property InvoiceDate As DateTime
    Public Property DueDate As DateTime
    Public Property Vendor As VendorInfo
    Public Property Customer As CustomerInfo
    Public Property LineItems As List(Of LineItem)
    Public Property Subtotal As Decimal
    Public Property Tax As Decimal
    Public Property Total As Decimal
End Class

Public Class VendorInfo
    Public Property Name As String
    Public Property Address As String
    Public Property TaxId As String
End Class

Public Class CustomerInfo
    Public Property Name As String
    Public Property Address As String
End Class

Public Class LineItem
    Public Property Description As String
    Public Property Quantity As Decimal
    Public Property UnitPrice As Decimal
    Public Property Total As Decimal
End Class

' Extracts comprehensive invoice data including line items and party details
Public Class StructuredInvoiceExtractor
    Private ReadOnly _aiParser As AIInvoiceParser

    Public Sub New(apiKey As String)
        _aiParser = New AIInvoiceParser(apiKey)
    End Sub

    Public Async Function ExtractDetailedData(pdfPath As String) As Task(Of DetailedInvoiceData)
        Dim pdf = PdfDocument.FromFile(pdfPath)
        Dim text As String = pdf.ExtractAllText()

        ' Define the exact JSON structure we want the AI to return
        ' This schema guides the AI to extract all relevant fields
        Dim jsonSchema As String = "{
  ""InvoiceNumber"": ""string"",
  ""InvoiceDate"": ""YYYY-MM-DD"",
  ""DueDate"": ""YYYY-MM-DD"",
  ""Vendor"": {
    ""Name"": ""string"",
    ""Address"": ""string"",
    ""TaxId"": ""string or null""
  },
  ""Customer"": {
    ""Name"": ""string"",
    ""Address"": ""string""
  },
  ""LineItems"": [
    {
      ""Description"": ""string"",
      ""Quantity"": 0.0,
      ""UnitPrice"": 0.00,
      ""Total"": 0.00
    }
  ],
  ""Subtotal"": 0.00,
  ""Tax"": 0.00,
  ""Total"": 0.00
}"

        ' Prompt includes both the schema and the extracted text
        Dim prompt As String = $"
Extract all invoice data and return it in this exact JSON structure:
{jsonSchema}

Invoice text:
{text}

Return only valid JSON, no markdown formatting or additional text."

        ' Call AI API and parse response (implementation as shown above)
        ' Return deserialized DetailedInvoiceData

        Return New DetailedInvoiceData() ' Placeholder
    End Function
End Class

$vbLabelText $csharpLabel

如何處理不一致的發票格式

當處理來自多個供應商、且格式各異的發票時，AI 擷取功能的真正優勢便顯現出來。智慧型處理器可先嘗試基於模式的提取（速度更快且免費），僅在必要時才轉而使用 AI：

using IronPdf;
using System.Threading.Tasks;

// Hybrid processor that optimizes for cost and capability
// Tries fast regex patterns first, uses AI only when patterns fail
public class SmartInvoiceProcessor
{
    private readonly AIInvoiceParser _aiParser;

    public SmartInvoiceProcessor(string aiApiKey)
    {
        _aiParser = new AIInvoiceParser(aiApiKey);
    }

    public async Task<InvoiceData> ProcessAnyInvoice(string pdfPath)
    {
        var pdf = PdfDocument.FromFile(pdfPath);
        string text = pdf.ExtractAllText();

        // First attempt: regex patterns (fast and free)
        var patternParser = new InvoiceParser();
        var standardResult = patternParser.ParseInvoiceFromText(text);

        // If pattern matching found all required fields, use that result
        if (IsComplete(standardResult))
        {
            Console.WriteLine("Pattern extraction successful");
            return standardResult;
        }

        // Fallback: use AI for complex or unusual invoice formats
        // This costs money but handles any layout
        Console.WriteLine("Using AI extraction for complex invoice format");
        var aiResult = await _aiParser.ParseInvoiceWithAI(pdfPath);

        return aiResult;
    }

    // Validates that we have the minimum required fields
    private bool IsComplete(InvoiceData data)
    {
        return !string.IsNullOrEmpty(data.InvoiceNumber) &&
               !string.IsNullOrEmpty(data.InvoiceDate) &&
               data.TotalAmount > 0;
    }
}

using IronPdf;
using System.Threading.Tasks;

// Hybrid processor that optimizes for cost and capability
// Tries fast regex patterns first, uses AI only when patterns fail
public class SmartInvoiceProcessor
{
    private readonly AIInvoiceParser _aiParser;

    public SmartInvoiceProcessor(string aiApiKey)
    {
        _aiParser = new AIInvoiceParser(aiApiKey);
    }

    public async Task<InvoiceData> ProcessAnyInvoice(string pdfPath)
    {
        var pdf = PdfDocument.FromFile(pdfPath);
        string text = pdf.ExtractAllText();

        // First attempt: regex patterns (fast and free)
        var patternParser = new InvoiceParser();
        var standardResult = patternParser.ParseInvoiceFromText(text);

        // If pattern matching found all required fields, use that result
        if (IsComplete(standardResult))
        {
            Console.WriteLine("Pattern extraction successful");
            return standardResult;
        }

        // Fallback: use AI for complex or unusual invoice formats
        // This costs money but handles any layout
        Console.WriteLine("Using AI extraction for complex invoice format");
        var aiResult = await _aiParser.ParseInvoiceWithAI(pdfPath);

        return aiResult;
    }

    // Validates that we have the minimum required fields
    private bool IsComplete(InvoiceData data)
    {
        return !string.IsNullOrEmpty(data.InvoiceNumber) &&
               !string.IsNullOrEmpty(data.InvoiceDate) &&
               data.TotalAmount > 0;
    }
}

Imports IronPdf
Imports System.Threading.Tasks

' Hybrid processor that optimizes for cost and capability
' Tries fast regex patterns first, uses AI only when patterns fail
Public Class SmartInvoiceProcessor
    Private ReadOnly _aiParser As AIInvoiceParser

    Public Sub New(aiApiKey As String)
        _aiParser = New AIInvoiceParser(aiApiKey)
    End Sub

    Public Async Function ProcessAnyInvoice(pdfPath As String) As Task(Of InvoiceData)
        Dim pdf = PdfDocument.FromFile(pdfPath)
        Dim text As String = pdf.ExtractAllText()

        ' First attempt: regex patterns (fast and free)
        Dim patternParser = New InvoiceParser()
        Dim standardResult = patternParser.ParseInvoiceFromText(text)

        ' If pattern matching found all required fields, use that result
        If IsComplete(standardResult) Then
            Console.WriteLine("Pattern extraction successful")
            Return standardResult
        End If

        ' Fallback: use AI for complex or unusual invoice formats
        ' This costs money but handles any layout
        Console.WriteLine("Using AI extraction for complex invoice format")
        Dim aiResult = Await _aiParser.ParseInvoiceWithAI(pdfPath)

        Return aiResult
    End Function

    ' Validates that we have the minimum required fields
    Private Function IsComplete(data As InvoiceData) As Boolean
        Return Not String.IsNullOrEmpty(data.InvoiceNumber) AndAlso
               Not String.IsNullOrEmpty(data.InvoiceDate) AndAlso
               data.TotalAmount > 0
    End Function
End Class

$vbLabelText $csharpLabel

如何建立應付帳款自動化流程

綜合上述各項功能，以下是一套完整的自動化流程，可處理收到的發票、提取資料、進行驗證，並將資料準備好供您的會計系統使用：

using IronPdf;
using System;
using System.IO;
using System.Threading.Tasks;
using System.Co/llections.Generic;
using System.Linq;

// Tracks the outcome of processing each invoice
public class ProcessingResult
{
    public string FileName { get; set; }
    public bool Success { get; set; }
    public string InvoiceNumber { get; set; }
    public string ErrorMessage { get; set; }
}

// Complete automation pipeline for accounts payable
// Watches a folder, extracts data, validates, and routes to accounting system
public class InvoiceAutomationPipeline
{
    private readonly SmartInvoiceProcessor _processor;
    private readonly string _inputFolder;
    private readonly string _processedFolder;
    private readonly string _errorFolder;

    public InvoiceAutomationPipeline(string apiKey, string inputFolder)
    {
        _processor = new SmartInvoiceProcessor(apiKey);
        _inputFolder = inputFolder;
        _processedFolder = Path.Com/bine(inputFolder, "processed");
        _errorFolder = Path.Com/bine(inputFolder, "errors");

        // Create output directories if they don't exist
        Directory.CreateDirectory(_processedFolder);
        Directory.CreateDirectory(_errorFolder);
    }

    // Main entry point - processes all PDFs in the input folder
    public async Task<List<ProcessingResult>> ProcessInvoiceBatch()
    {
        string[] invoiceFiles = Directory.GetFiles(_inputFolder, "*.pdf");
        Console.WriteLine($"Found {invoiceFiles.Length} invoices to process");

        var results = new List<ProcessingResult>();

        foreach (string invoicePath in invoiceFiles)
        {
            string fileName = Path.GetFileName(invoicePath);

            try
            {
                Console.WriteLine($"Processing: {fileName}");

                // Extract data using smart processor (patterns first, then AI)
                var invoiceData = await _processor.ProcessAnyInvoice(invoicePath);

                // Ensure we have minimum required fields before proceeding
                if (ValidateInvoiceData(invoiceData))
                {
                    // Send to accounting system (QuickBooks, Xero, etc.)
                    await SaveToAccountingSystem(invoiceData);

                    // Archive successful invoices
                    string destPath = Path.Com/bine(_processedFolder, fileName);
                    File.Move(invoicePath, destPath, overwrite: true);

                    results.Add(new ProcessingResult
                    {
                        FileName = fileName,
                        Success = true,
                        InvoiceNumber = invoiceData.InvoiceNumber
                    });

                    Console.WriteLine($"✓ Processed: {invoiceData.InvoiceNumber}");
                }
                else
                {
                    throw new Exception("Validation failed - missing required fields");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"✗ Failed: {fileName} - {ex.Message}");

                // Quarantine failed invoices for manual review
                string destPath = Path.Com/bine(_errorFolder, fileName);
                File.Move(invoicePath, destPath, overwrite: true);

                results.Add(new ProcessingResult
                {
                    FileName = fileName,
                    Success = false,
                    ErrorMessage = ex.Message
                });
            }
        }

        GenerateReport(results);
        return results;
    }

    // Checks for minimum required fields
    private bool ValidateInvoiceData(InvoiceData data)
    {
        return !string.IsNullOrEmpty(data.InvoiceNumber) &&
               !string.IsNullOrEmpty(data.VendorName) &&
               data.TotalAmount > 0;
    }

    // Placeholder for accounting system integration
    private async Task SaveToAccountingSystem(InvoiceData data)
    {
        // Integrate with your accounting system here
        // Examples: QuickBooks API, Xero API, SAP, or database storage
        Console.WriteLine($"  Saved invoice {data.InvoiceNumber} to accounting system");
        await Task.Com/pletedTask;
    }

    // Outputs a summary of the batch processing results
    private void GenerateReport(List<ProcessingResult> results)
    {
        int successful = results.Co/unt(r => r.Success);
        int failed = results.Co/unt(r => !r.Success);

        Console.WriteLine($"\n========== Processing Complete ==========");
        Console.WriteLine($"Total Processed: {results.Co/unt}");
        Console.WriteLine($"Successful: {successful}");
        Console.WriteLine($"Failed: {failed}");

        if (failed > 0)
        {
            Console.WriteLine("\nFailed invoices requiring review:");
            foreach (var failure in results.Where(r => !r.Success))
            {
                Console.WriteLine($"  • {failure.FileName}: {failure.ErrorMessage}");
            }
        }
    }
}

using IronPdf;
using System;
using System.IO;
using System.Threading.Tasks;
using System.Co/llections.Generic;
using System.Linq;

// Tracks the outcome of processing each invoice
public class ProcessingResult
{
    public string FileName { get; set; }
    public bool Success { get; set; }
    public string InvoiceNumber { get; set; }
    public string ErrorMessage { get; set; }
}

// Complete automation pipeline for accounts payable
// Watches a folder, extracts data, validates, and routes to accounting system
public class InvoiceAutomationPipeline
{
    private readonly SmartInvoiceProcessor _processor;
    private readonly string _inputFolder;
    private readonly string _processedFolder;
    private readonly string _errorFolder;

    public InvoiceAutomationPipeline(string apiKey, string inputFolder)
    {
        _processor = new SmartInvoiceProcessor(apiKey);
        _inputFolder = inputFolder;
        _processedFolder = Path.Com/bine(inputFolder, "processed");
        _errorFolder = Path.Com/bine(inputFolder, "errors");

        // Create output directories if they don't exist
        Directory.CreateDirectory(_processedFolder);
        Directory.CreateDirectory(_errorFolder);
    }

    // Main entry point - processes all PDFs in the input folder
    public async Task<List<ProcessingResult>> ProcessInvoiceBatch()
    {
        string[] invoiceFiles = Directory.GetFiles(_inputFolder, "*.pdf");
        Console.WriteLine($"Found {invoiceFiles.Length} invoices to process");

        var results = new List<ProcessingResult>();

        foreach (string invoicePath in invoiceFiles)
        {
            string fileName = Path.GetFileName(invoicePath);

            try
            {
                Console.WriteLine($"Processing: {fileName}");

                // Extract data using smart processor (patterns first, then AI)
                var invoiceData = await _processor.ProcessAnyInvoice(invoicePath);

                // Ensure we have minimum required fields before proceeding
                if (ValidateInvoiceData(invoiceData))
                {
                    // Send to accounting system (QuickBooks, Xero, etc.)
                    await SaveToAccountingSystem(invoiceData);

                    // Archive successful invoices
                    string destPath = Path.Com/bine(_processedFolder, fileName);
                    File.Move(invoicePath, destPath, overwrite: true);

                    results.Add(new ProcessingResult
                    {
                        FileName = fileName,
                        Success = true,
                        InvoiceNumber = invoiceData.InvoiceNumber
                    });

                    Console.WriteLine($"✓ Processed: {invoiceData.InvoiceNumber}");
                }
                else
                {
                    throw new Exception("Validation failed - missing required fields");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"✗ Failed: {fileName} - {ex.Message}");

                // Quarantine failed invoices for manual review
                string destPath = Path.Com/bine(_errorFolder, fileName);
                File.Move(invoicePath, destPath, overwrite: true);

                results.Add(new ProcessingResult
                {
                    FileName = fileName,
                    Success = false,
                    ErrorMessage = ex.Message
                });
            }
        }

        GenerateReport(results);
        return results;
    }

    // Checks for minimum required fields
    private bool ValidateInvoiceData(InvoiceData data)
    {
        return !string.IsNullOrEmpty(data.InvoiceNumber) &&
               !string.IsNullOrEmpty(data.VendorName) &&
               data.TotalAmount > 0;
    }

    // Placeholder for accounting system integration
    private async Task SaveToAccountingSystem(InvoiceData data)
    {
        // Integrate with your accounting system here
        // Examples: QuickBooks API, Xero API, SAP, or database storage
        Console.WriteLine($"  Saved invoice {data.InvoiceNumber} to accounting system");
        await Task.Com/pletedTask;
    }

    // Outputs a summary of the batch processing results
    private void GenerateReport(List<ProcessingResult> results)
    {
        int successful = results.Co/unt(r => r.Success);
        int failed = results.Co/unt(r => !r.Success);

        Console.WriteLine($"\n========== Processing Complete ==========");
        Console.WriteLine($"Total Processed: {results.Co/unt}");
        Console.WriteLine($"Successful: {successful}");
        Console.WriteLine($"Failed: {failed}");

        if (failed > 0)
        {
            Console.WriteLine("\nFailed invoices requiring review:");
            foreach (var failure in results.Where(r => !r.Success))
            {
                Console.WriteLine($"  • {failure.FileName}: {failure.ErrorMessage}");
            }
        }
    }
}

Imports IronPdf
Imports System
Imports System.IO
Imports System.Threading.Tasks
Imports System.Collections.Generic
Imports System.Linq

' Tracks the outcome of processing each invoice
Public Class ProcessingResult
    Public Property FileName As String
    Public Property Success As Boolean
    Public Property InvoiceNumber As String
    Public Property ErrorMessage As String
End Class

' Complete automation pipeline for accounts payable
' Watches a folder, extracts data, validates, and routes to accounting system
Public Class InvoiceAutomationPipeline
    Private ReadOnly _processor As SmartInvoiceProcessor
    Private ReadOnly _inputFolder As String
    Private ReadOnly _processedFolder As String
    Private ReadOnly _errorFolder As String

    Public Sub New(apiKey As String, inputFolder As String)
        _processor = New SmartInvoiceProcessor(apiKey)
        _inputFolder = inputFolder
        _processedFolder = Path.Combine(inputFolder, "processed")
        _errorFolder = Path.Combine(inputFolder, "errors")

        ' Create output directories if they don't exist
        Directory.CreateDirectory(_processedFolder)
        Directory.CreateDirectory(_errorFolder)
    End Sub

    ' Main entry point - processes all PDFs in the input folder
    Public Async Function ProcessInvoiceBatch() As Task(Of List(Of ProcessingResult))
        Dim invoiceFiles As String() = Directory.GetFiles(_inputFolder, "*.pdf")
        Console.WriteLine($"Found {invoiceFiles.Length} invoices to process")

        Dim results As New List(Of ProcessingResult)()

        For Each invoicePath As String In invoiceFiles
            Dim fileName As String = Path.GetFileName(invoicePath)

            Try
                Console.WriteLine($"Processing: {fileName}")

                ' Extract data using smart processor (patterns first, then AI)
                Dim invoiceData = Await _processor.ProcessAnyInvoice(invoicePath)

                ' Ensure we have minimum required fields before proceeding
                If ValidateInvoiceData(invoiceData) Then
                    ' Send to accounting system (QuickBooks, Xero, etc.)
                    Await SaveToAccountingSystem(invoiceData)

                    ' Archive successful invoices
                    Dim destPath As String = Path.Combine(_processedFolder, fileName)
                    File.Move(invoicePath, destPath, overwrite:=True)

                    results.Add(New ProcessingResult With {
                        .FileName = fileName,
                        .Success = True,
                        .InvoiceNumber = invoiceData.InvoiceNumber
                    })

                    Console.WriteLine($"✓ Processed: {invoiceData.InvoiceNumber}")
                Else
                    Throw New Exception("Validation failed - missing required fields")
                End If
            Catch ex As Exception
                Console.WriteLine($"✗ Failed: {fileName} - {ex.Message}")

                ' Quarantine failed invoices for manual review
                Dim destPath As String = Path.Combine(_errorFolder, fileName)
                File.Move(invoicePath, destPath, overwrite:=True)

                results.Add(New ProcessingResult With {
                    .FileName = fileName,
                    .Success = False,
                    .ErrorMessage = ex.Message
                })
            End Try
        Next

        GenerateReport(results)
        Return results
    End Function

    ' Checks for minimum required fields
    Private Function ValidateInvoiceData(data As InvoiceData) As Boolean
        Return Not String.IsNullOrEmpty(data.InvoiceNumber) AndAlso
               Not String.IsNullOrEmpty(data.VendorName) AndAlso
               data.TotalAmount > 0
    End Function

    ' Placeholder for accounting system integration
    Private Async Function SaveToAccountingSystem(data As InvoiceData) As Task
        ' Integrate with your accounting system here
        ' Examples: QuickBooks API, Xero API, SAP, or database storage
        Console.WriteLine($"  Saved invoice {data.InvoiceNumber} to accounting system")
        Await Task.CompletedTask
    End Function

    ' Outputs a summary of the batch processing results
    Private Sub GenerateReport(results As List(Of ProcessingResult))
        Dim successful As Integer = results.Count(Function(r) r.Success)
        Dim failed As Integer = results.Count(Function(r) Not r.Success)

        Console.WriteLine(vbCrLf & "========== Processing Complete ==========")
        Console.WriteLine($"Total Processed: {results.Count}")
        Console.WriteLine($"Successful: {successful}")
        Console.WriteLine($"Failed: {failed}")

        If failed > 0 Then
            Console.WriteLine(vbCrLf & "Failed invoices requiring review:")
            For Each failure In results.Where(Function(r) Not r.Success)
                Console.WriteLine($"  • {failure.FileName}: {failure.ErrorMessage}")
            Next
        End If
    End Sub
End Class

$vbLabelText $csharpLabel

此流程實現了完整的作業流程：它會掃描資料夾以搜尋新進的 PDF 檔案，處理每個檔案，驗證擷取的資料，將擷取成功的資料導向您的會計系統，並將失敗的資料隔離以供人工審查。摘要報告可讓您清楚掌握處理結果。

How to Integrate C# Invoice Processing with Accounting Systems

提取的發票資料最終需匯入會計系統，以進行付款及記錄保存。具體細節雖因平台而異，但整合模式具有一致性。

QuickBooks、Xero 和 SAP 的常見整合模式有哪些？

大多數會計平台都提供 REST API，以便透過程式化方式建立帳單或發票。以下提供一個通用範本，您可以根據您的特定平台進行調整：

using System;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

// Generic integration layer for pushing invoice data to accounting systems
// Adapt the API calls based on your specific platform
public class AccountingSystemIntegration
{
    private readonly HttpClient _httpClient;
    private readonly string _apiKey;
    private readonly string _baseUrl;

    public AccountingSystemIntegration(string apiKey, string baseUrl)
    {
        _apiKey = apiKey;
        _baseUrl = baseUrl;
        _httpClient = new HttpClient();
        _httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {_apiKey}");
    }

    // Creates a Bill in QuickBooks (vendor invoices are called "Bills")
    public async Task SendToQuickBooks(InvoiceData invoice)
    {
        // QuickBooks Bill structure - see their API docs for full schema
        var bill = new
        {
            VendorRef = new { name = invoice.VendorName },
            TxnDate = invoice.InvoiceDate,
            DocNumber = invoice.InvoiceNumber,
            TotalAmt = invoice.TotalAmount,
            Line = new[]
            {
                new
                {
                    Amount = invoice.TotalAmount,
                    DetailType = "AccountBasedExpenseLineDetail",
                    AccountBasedExpenseLineDetail = new
                    {
                        AccountRef = new { name = "Accounts Payable" }
                    }
                }
            }
        };

        await PostToApi("/v3/company/{companyId}/bill", bill);
    }

    // Creates an accounts payable invoice in Xero
    public async Task SendToXero(InvoiceData invoice)
    {
        // ACCPAY type indicates this is a bill to pay (not a sales invoice)
        var bill = new
        {
            Type = "ACCPAY",
            Contact = new { Name = invoice.VendorName },
            Date = invoice.InvoiceDate,
            InvoiceNumber = invoice.InvoiceNumber,
            Total = invoice.TotalAmount
        };

        await PostToApi("/api.xro/2.0/Invoices", bill);
    }

    // Generic POST helper with error handling
    private async Task PostToApi(string endpoint, object payload)
    {
        string json = JsonSerializer.Serialize(payload);
        var content = new StringContent(json, Encoding.UTF8, "application/json");

        var response = await _httpClient.PostAsync($"{_baseUrl}{endpoint}", content);

        if (!response.IsSuccessStatusCode)
        {
            string error = await response.Co/ntent.ReadAsStringAsync();
            throw new Exception($"API Error: {response.StatusCode} - {error}");
        }

        Console.WriteLine($"Successfully posted to {endpoint}");
    }
}

using System;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

// Generic integration layer for pushing invoice data to accounting systems
// Adapt the API calls based on your specific platform
public class AccountingSystemIntegration
{
    private readonly HttpClient _httpClient;
    private readonly string _apiKey;
    private readonly string _baseUrl;

    public AccountingSystemIntegration(string apiKey, string baseUrl)
    {
        _apiKey = apiKey;
        _baseUrl = baseUrl;
        _httpClient = new HttpClient();
        _httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {_apiKey}");
    }

    // Creates a Bill in QuickBooks (vendor invoices are called "Bills")
    public async Task SendToQuickBooks(InvoiceData invoice)
    {
        // QuickBooks Bill structure - see their API docs for full schema
        var bill = new
        {
            VendorRef = new { name = invoice.VendorName },
            TxnDate = invoice.InvoiceDate,
            DocNumber = invoice.InvoiceNumber,
            TotalAmt = invoice.TotalAmount,
            Line = new[]
            {
                new
                {
                    Amount = invoice.TotalAmount,
                    DetailType = "AccountBasedExpenseLineDetail",
                    AccountBasedExpenseLineDetail = new
                    {
                        AccountRef = new { name = "Accounts Payable" }
                    }
                }
            }
        };

        await PostToApi("/v3/company/{companyId}/bill", bill);
    }

    // Creates an accounts payable invoice in Xero
    public async Task SendToXero(InvoiceData invoice)
    {
        // ACCPAY type indicates this is a bill to pay (not a sales invoice)
        var bill = new
        {
            Type = "ACCPAY",
            Contact = new { Name = invoice.VendorName },
            Date = invoice.InvoiceDate,
            InvoiceNumber = invoice.InvoiceNumber,
            Total = invoice.TotalAmount
        };

        await PostToApi("/api.xro/2.0/Invoices", bill);
    }

    // Generic POST helper with error handling
    private async Task PostToApi(string endpoint, object payload)
    {
        string json = JsonSerializer.Serialize(payload);
        var content = new StringContent(json, Encoding.UTF8, "application/json");

        var response = await _httpClient.PostAsync($"{_baseUrl}{endpoint}", content);

        if (!response.IsSuccessStatusCode)
        {
            string error = await response.Co/ntent.ReadAsStringAsync();
            throw new Exception($"API Error: {response.StatusCode} - {error}");
        }

        Console.WriteLine($"Successfully posted to {endpoint}");
    }
}

Imports System
Imports System.Net.Http
Imports System.Text
Imports System.Text.Json
Imports System.Threading.Tasks

' Generic integration layer for pushing invoice data to accounting systems
' Adapt the API calls based on your specific platform
Public Class AccountingSystemIntegration
    Private ReadOnly _httpClient As HttpClient
    Private ReadOnly _apiKey As String
    Private ReadOnly _baseUrl As String

    Public Sub New(apiKey As String, baseUrl As String)
        _apiKey = apiKey
        _baseUrl = baseUrl
        _httpClient = New HttpClient()
        _httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {_apiKey}")
    End Sub

    ' Creates a Bill in QuickBooks (vendor invoices are called "Bills")
    Public Async Function SendToQuickBooks(invoice As InvoiceData) As Task
        ' QuickBooks Bill structure - see their API docs for full schema
        Dim bill = New With {
            .VendorRef = New With {.name = invoice.VendorName},
            .TxnDate = invoice.InvoiceDate,
            .DocNumber = invoice.InvoiceNumber,
            .TotalAmt = invoice.TotalAmount,
            .Line = New Object() {
                New With {
                    .Amount = invoice.TotalAmount,
                    .DetailType = "AccountBasedExpenseLineDetail",
                    .AccountBasedExpenseLineDetail = New With {
                        .AccountRef = New With {.name = "Accounts Payable"}
                    }
                }
            }
        }

        Await PostToApi("/v3/company/{companyId}/bill", bill)
    End Function

    ' Creates an accounts payable invoice in Xero
    Public Async Function SendToXero(invoice As InvoiceData) As Task
        ' ACCPAY type indicates this is a bill to pay (not a sales invoice)
        Dim bill = New With {
            .Type = "ACCPAY",
            .Contact = New With {.Name = invoice.VendorName},
            .Date = invoice.InvoiceDate,
            .InvoiceNumber = invoice.InvoiceNumber,
            .Total = invoice.TotalAmount
        }

        Await PostToApi("/api.xro/2.0/Invoices", bill)
    End Function

    ' Generic POST helper with error handling
    Private Async Function PostToApi(endpoint As String, payload As Object) As Task
        Dim json As String = JsonSerializer.Serialize(payload)
        Dim content = New StringContent(json, Encoding.UTF8, "application/json")

        Dim response = Await _httpClient.PostAsync($"{_baseUrl}{endpoint}", content)

        If Not response.IsSuccessStatusCode Then
            Dim [error] As String = Await response.Content.ReadAsStringAsync()
            Throw New Exception($"API Error: {response.StatusCode} - {[error]}")
        End If

        Console.WriteLine($"Successfully posted to {endpoint}")
    End Function
End Class

$vbLabelText $csharpLabel

各平台皆有其專屬的驗證機制（QuickBooks 與 Xero 採用 OAuth，SAP 則有各種方法）、必填欄位及 API 規範。具體細節請參閱目標平台的文件，但將擷取的發票資料轉換為 API 有效載荷的模式保持一致。

如何批次處理數百張發票

大量發票處理需要特別注意並行處理與資源管理。以下是一個採用受控並發的平行處理範例：

using System;
using System.Co/llections.Concurrent;
using System.Co/llections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

// Tracks the result of processing a single invoice in a batch
public class BatchResult
{
    public string FilePath { get; set; }
    public bool Success { get; set; }
    public string InvoiceNumber { get; set; }
    public string Error { get; set; }
}

// High-volume invoice processor with controlled parallelism
// Prevents overwhelming APIs while maximizing throughput
public class BatchInvoiceProcessor
{
    private readonly SmartInvoiceProcessor _invoiceProcessor;
    private readonly AccountingSystemIntegration _accountingIntegration;
    private readonly int _maxConcurrency;

    public BatchInvoiceProcessor(string aiApiKey, string accountingApiKey,
        string accountingUrl, int maxConcurrency = 5)
    {
        _invoiceProcessor = new SmartInvoiceProcessor(aiApiKey);
        _accountingIntegration = new AccountingSystemIntegration(accountingApiKey, accountingUrl);
        _maxConcurrency = maxConcurrency;  // Adjust based on API rate limits
    }

    // Processes multiple invoices in parallel with controlled concurrency
    public async Task<List<BatchResult>> ProcessInvoiceBatch(List<string> invoicePaths)
    {
        // Thread-safe collection for gathering results from parallel tasks
        var results = new ConcurrentBag<BatchResult>();

        // Semaphore limits how many invoices process simultaneously
        var semaphore = new SemaphoreSlim(_maxConcurrency);

        // Create a task for each invoice
        var tasks = invoicePaths.Select(async path =>
        {
            // Wait for a slot to become available
            await semaphore.WaitAsync();
            try
            {
                var result = await ProcessSingleInvoice(path);
                results.Add(result);
            }
            finally
            {
                // Release slot for next invoice
                semaphore.Release();
            }
        });

        // Wait for all invoices to complete
        await Task.WhenAll(tasks);

        // Output summary statistics
        var resultList = results.ToList();
        int successful = resultList.Co/unt(r => r.Success);
        int failed = resultList.Co/unt(r => !r.Success);

        Console.WriteLine($"\nBatch Processing Complete:");
        Console.WriteLine($"  Total: {resultList.Co/unt}");
        Console.WriteLine($"  Successful: {successful}");
        Console.WriteLine($"  Failed: {failed}");

        return resultList;
    }

    // Processes one invoice: extract data and send to accounting system
    private async Task<BatchResult> ProcessSingleInvoice(string pdfPath)
    {
        try
        {
            Console.WriteLine($"Processing: {pdfPath}");

            var invoiceData = await _invoiceProcessor.ProcessAnyInvoice(pdfPath);
            await _accountingIntegration.SendToQuickBooks(invoiceData);

            Console.WriteLine($"✓ Completed: {invoiceData.InvoiceNumber}");

            return new BatchResult
            {
                FilePath = pdfPath,
                Success = true,
                InvoiceNumber = invoiceData.InvoiceNumber
            };
        }
        catch (Exception ex)
        {
            Console.WriteLine($"✗ Failed: {pdfPath}");

            return new BatchResult
            {
                FilePath = pdfPath,
                Success = false,
                Error = ex.Message
            };
        }
    }
}

using System;
using System.Co/llections.Concurrent;
using System.Co/llections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

// Tracks the result of processing a single invoice in a batch
public class BatchResult
{
    public string FilePath { get; set; }
    public bool Success { get; set; }
    public string InvoiceNumber { get; set; }
    public string Error { get; set; }
}

// High-volume invoice processor with controlled parallelism
// Prevents overwhelming APIs while maximizing throughput
public class BatchInvoiceProcessor
{
    private readonly SmartInvoiceProcessor _invoiceProcessor;
    private readonly AccountingSystemIntegration _accountingIntegration;
    private readonly int _maxConcurrency;

    public BatchInvoiceProcessor(string aiApiKey, string accountingApiKey,
        string accountingUrl, int maxConcurrency = 5)
    {
        _invoiceProcessor = new SmartInvoiceProcessor(aiApiKey);
        _accountingIntegration = new AccountingSystemIntegration(accountingApiKey, accountingUrl);
        _maxConcurrency = maxConcurrency;  // Adjust based on API rate limits
    }

    // Processes multiple invoices in parallel with controlled concurrency
    public async Task<List<BatchResult>> ProcessInvoiceBatch(List<string> invoicePaths)
    {
        // Thread-safe collection for gathering results from parallel tasks
        var results = new ConcurrentBag<BatchResult>();

        // Semaphore limits how many invoices process simultaneously
        var semaphore = new SemaphoreSlim(_maxConcurrency);

        // Create a task for each invoice
        var tasks = invoicePaths.Select(async path =>
        {
            // Wait for a slot to become available
            await semaphore.WaitAsync();
            try
            {
                var result = await ProcessSingleInvoice(path);
                results.Add(result);
            }
            finally
            {
                // Release slot for next invoice
                semaphore.Release();
            }
        });

        // Wait for all invoices to complete
        await Task.WhenAll(tasks);

        // Output summary statistics
        var resultList = results.ToList();
        int successful = resultList.Co/unt(r => r.Success);
        int failed = resultList.Co/unt(r => !r.Success);

        Console.WriteLine($"\nBatch Processing Complete:");
        Console.WriteLine($"  Total: {resultList.Co/unt}");
        Console.WriteLine($"  Successful: {successful}");
        Console.WriteLine($"  Failed: {failed}");

        return resultList;
    }

    // Processes one invoice: extract data and send to accounting system
    private async Task<BatchResult> ProcessSingleInvoice(string pdfPath)
    {
        try
        {
            Console.WriteLine($"Processing: {pdfPath}");

            var invoiceData = await _invoiceProcessor.ProcessAnyInvoice(pdfPath);
            await _accountingIntegration.SendToQuickBooks(invoiceData);

            Console.WriteLine($"✓ Completed: {invoiceData.InvoiceNumber}");

            return new BatchResult
            {
                FilePath = pdfPath,
                Success = true,
                InvoiceNumber = invoiceData.InvoiceNumber
            };
        }
        catch (Exception ex)
        {
            Console.WriteLine($"✗ Failed: {pdfPath}");

            return new BatchResult
            {
                FilePath = pdfPath,
                Success = false,
                Error = ex.Message
            };
        }
    }
}

Imports System
Imports System.Collections.Concurrent
Imports System.Collections.Generic
Imports System.Linq
Imports System.Threading
Imports System.Threading.Tasks

' Tracks the result of processing a single invoice in a batch
Public Class BatchResult
    Public Property FilePath As String
    Public Property Success As Boolean
    Public Property InvoiceNumber As String
    Public Property Error As String
End Class

' High-volume invoice processor with controlled parallelism
' Prevents overwhelming APIs while maximizing throughput
Public Class BatchInvoiceProcessor
    Private ReadOnly _invoiceProcessor As SmartInvoiceProcessor
    Private ReadOnly _accountingIntegration As AccountingSystemIntegration
    Private ReadOnly _maxConcurrency As Integer

    Public Sub New(aiApiKey As String, accountingApiKey As String, accountingUrl As String, Optional maxConcurrency As Integer = 5)
        _invoiceProcessor = New SmartInvoiceProcessor(aiApiKey)
        _accountingIntegration = New AccountingSystemIntegration(accountingApiKey, accountingUrl)
        _maxConcurrency = maxConcurrency ' Adjust based on API rate limits
    End Sub

    ' Processes multiple invoices in parallel with controlled concurrency
    Public Async Function ProcessInvoiceBatch(invoicePaths As List(Of String)) As Task(Of List(Of BatchResult))
        ' Thread-safe collection for gathering results from parallel tasks
        Dim results As New ConcurrentBag(Of BatchResult)()

        ' Semaphore limits how many invoices process simultaneously
        Dim semaphore As New SemaphoreSlim(_maxConcurrency)

        ' Create a task for each invoice
        Dim tasks = invoicePaths.Select(Async Function(path)
                                            ' Wait for a slot to become available
                                            Await semaphore.WaitAsync()
                                            Try
                                                Dim result = Await ProcessSingleInvoice(path)
                                                results.Add(result)
                                            Finally
                                                ' Release slot for next invoice
                                                semaphore.Release()
                                            End Try
                                        End Function)

        ' Wait for all invoices to complete
        Await Task.WhenAll(tasks)

        ' Output summary statistics
        Dim resultList = results.ToList()
        Dim successful = resultList.Count(Function(r) r.Success)
        Dim failed = resultList.Count(Function(r) Not r.Success)

        Console.WriteLine(vbCrLf & "Batch Processing Complete:")
        Console.WriteLine($"  Total: {resultList.Count}")
        Console.WriteLine($"  Successful: {successful}")
        Console.WriteLine($"  Failed: {failed}")

        Return resultList
    End Function

    ' Processes one invoice: extract data and send to accounting system
    Private Async Function ProcessSingleInvoice(pdfPath As String) As Task(Of BatchResult)
        Try
            Console.WriteLine($"Processing: {pdfPath}")

            Dim invoiceData = Await _invoiceProcessor.ProcessAnyInvoice(pdfPath)
            Await _accountingIntegration.SendToQuickBooks(invoiceData)

            Console.WriteLine($"✓ Completed: {invoiceData.InvoiceNumber}")

            Return New BatchResult With {
                .FilePath = pdfPath,
                .Success = True,
                .InvoiceNumber = invoiceData.InvoiceNumber
            }
        Catch ex As Exception
            Console.WriteLine($"✗ Failed: {pdfPath}")

            Return New BatchResult With {
                .FilePath = pdfPath,
                .Success = False,
                .Error = ex.Message
            }
        End Try
    End Function
End Class

$vbLabelText $csharpLabel

SemaphoreSlim 可確保您不會對外部 API 造成過大負擔，或耗盡系統資源。請根據您的 API 速率限制和伺服器容量調整 _maxConcurrency。 ConcurrentBag 可安全地彙整並行運算的結果。

後續步驟

發票自動化為減少人工作業、降低錯誤率並加速業務流程提供了重大契機。本指南已引導您完整走過整個生命週期：從 HTML 範本生成 Professional 發票、符合 ZUGFeRD 和 Factur-X 電子發票標準、透過模式比對與 AI 驅動的處理從收到的發票中提取資料，以及建立可擴展的自動化流程。

IronPDF 是這些功能的核心基礎，提供強大的 HTML 轉 PDF 渲染、可靠的文字擷取，以及符合 PDF/A-3 電子發票規範所需的附件功能。其基於 Chrome 的渲染引擎可確保您的發票呈現效果與設計完全一致，同時其擷取方法能自動處理 PDF 文字編碼的複雜性。

此處展示的範例僅供參考。實際部署時，需根據您的特定發票格式、會計系統及業務規則進行調整。針對高負載情境，批次處理教學指南涵蓋了具受控並發性的平行執行及錯誤復原機制。

準備開始建置了嗎？下載 IronPDF 並透過免費試用版體驗其功能。此函式庫包含免費開發授權，因此您可在決定購買正式授權前，充分評估其發票生成、資料擷取及 PDF 報表功能。若您對發票自動化或會計系統整合有任何疑問，歡迎聯繫我們的工程支援團隊。

常見問題

在 C# 發票處理中，IronPDF 用於什麼用途？

IronPDF 用於 C# 發票處理，可生成專業的 PDF 發票、擷取結構化資料，並自動化發票工作流程，同時確保符合 ZUGFeRD 和 Factur-X 等標準。

如何使用 C# 透過 IronPDF 產生 PDF 發票？

您可以透過 C# 運用 IronPDF 的 API，以程式化方式建立並自訂 PDF 文件，藉此產生 PDF 發票。這包括加入構成發票的元素，例如文字、表格和圖片。

什麼是 ZUGFeRD 和 Factur-X？IronPDF 如何支援它們？

ZUGFeRD 和 Factur-X 是電子發票標準，可確保發票既能供人閱讀，也能供機器讀取。IronPDF 支援這些標準，讓您能夠產生符合這些規範的 PDF 發票。

IronPDF 如何協助自動化應付帳款流程？

IronPDF 可透過從發票中擷取結構化資料並與自動化流程整合，來自動化應付帳款流程，從而減少人工資料輸入並提升效率。

IronPDF 能否從現有的 PDF 發票中擷取資料？

是的，IronPDF 能夠從現有的 PDF 發票中擷取結構化資料，使發票資訊的自動處理與分析更加容易。

在 C# 中使用 IronPDF 處理發票有哪些好處？

在 C# 環境中使用 IronPDF 處理發票的優勢包括：簡化發票生成流程、符合國際發票標準、高效提取資料，以及強化自動化功能。

是否可以使用 IronPDF 自訂 PDF 發票的外觀？

是的，IronPDF 允許您透過添加各種設計元素（例如標誌、文字格式及版面調整）來自訂 PDF 發票的外觀，以符合品牌規範。

using IronPDF 自動化處理發票的典型步驟有哪些？

若要使用 IronPDF 自動化處理發票，通常需先生成發票、擷取必要資料，並與其他系統或自動化工具整合，以簡化工作流程。

IronPDF 如何處理不同的發票格式？

IronPDF 透過提供生成、處理及讀取 PDF 文件的工具，能處理各種發票格式，確保與常見的電子發票標準相容。

Curtis Chau

立即與工程團隊聯繫

技術撰稿人

Curtis Chau 擁有卡爾頓大學（Carleton University）的電腦科學學士學位，專精於前端開發，並精通 Node.js、TypeScript、JavaScript 及 React。他熱衷於打造直觀且美觀的用戶介面，喜歡運用現代框架，並創建結構完善、視覺上吸引人的手冊。

除了開發工作之外，Curtis 對物聯網（IoT）抱有濃厚興趣，致力於探索整合硬體與軟體的創新方法。閒暇時，他喜歡玩遊戲和開發 Discord 機器人，將對科技的熱愛與創意相結合。

準備開始了嗎？

Nuget 下載 18,926,724 | 版本： 2026.5 just released

檢視授權

還在往下捲動嗎？

想要快速確認成果嗎？ PM > Install-Package IronPdf
執行範例觀看您的 HTML 轉為 PDF。

檢視授權

立即開始 30天試用

本頁內容

Invoice Processing in C#: Generate, Extract, and Automate PDF Invoices with .NET

using NuGet 套件管理員安裝 https://www.nuget.org/packages/IronPdf

請複製並執行此程式碼片段。

部署至您的生產環境進行測試

什麼是發票生命週期？為什麼 PDF 仍是標準格式？

How to Generate Professional PDF Invoices in C

如何建立發票 HTML 範本

翻譯範例

如何新增動態明細項目並計算總額

翻譯範例

如何在發票中加入公司品牌標識與浮水印

翻譯範例

如何嵌入支付連結的 QR 碼

翻譯範例

How to Comply with ZUGFeRD and Factur-X E-Invoicing Standards in C

什麼是 ZUGFeRD？它是如何運作的？

什麼是 Factur-X？它與 ZUGFeRD 有何不同？

如何將 XML 資料嵌入 PDF/A-3 發票中

翻譯範例

如何讓發票符合歐盟法規要求

How to Extract Data from PDF Invoices in C

如何從 PDF 發票中擷取文字

如何擷取明細項目的表格資料

如何運用模式比對處理發票編號、日期及總額

至於掃描或圖像格式的發票呢？

如何在 .NET 中運用 AI 處理發票

如何整合 AI 進行發票解析

如何從發票中擷取結構化 JSON 資料

如何處理不一致的發票格式

如何建立應付帳款自動化流程

How to Integrate C# Invoice Processing with Accounting Systems

QuickBooks、Xero 和 SAP 的常見整合模式有哪些？

如何批次處理數百張發票

後續步驟

常見問題

在 C# 發票處理中，IronPDF 用於什麼用途？

如何使用 C# 透過 IronPDF 產生 PDF 發票？

什麼是 ZUGFeRD 和 Factur-X？IronPDF 如何支援它們？

IronPDF 如何協助自動化應付帳款流程？

IronPDF 能否從現有的 PDF 發票中擷取資料？

在 C# 中使用 IronPDF 處理發票有哪些好處？

是否可以使用 IronPDF 自訂 PDF 發票的外觀？

using IronPDF 自動化處理發票的典型步驟有哪些？

IronPDF 如何處理不同的發票格式？

還在往下捲動嗎？

下一步：開始 30天試用

Thank You

下一步：開始 30天試用

Want to deploy IronSuite to a live project for FREE?

What’s included?

獲得全球數百萬工程師的信賴

鋼鐵支援團隊