如何在C#中将HTML转换为PDF？

你可以使用IronPDF的 RenderHtmlAsPdf 方法将HTML字符串转换为PDF。你还可以使用 RenderHtmlFileAsPdf 将HTML文件转换为PDF。

C# 中 volatile 关键字的目的是什么？

C# 中的 volatile 关键字用于指示字段可能会被并发执行的线程更新，从而确保内存访问不会被编译器优化掉，这可以防止多线程应用程序中的意外行为。

volatile 关键字如何提高 C# 中的数据一致性？

通过将字段标记为 volatile，可以强制内存屏障，确保内存操作不会在 volatile 访问之间重新排序。这可以保证字段的更改对所有线程立即可见，从而在并发环境中提高数据一致性。

C# 中 volatile 关键字的一些常见用途是什么？

volatile 关键字的常见用途包括多个线程在没有适当同步的情况下访问的字段，确保更改对所有线程立即可见，并防止缓存问题。

如何确保在 C# 中生成 PDF 时的线程安全？

using volatile 关键字来管理多线程应用程序中的共享状态，并依靠 IronPDF 的线程安全方法来处理 PDF 生成，以确保数据一致性和同步得到维护。

IronPDF 提供了哪些功能来处理 .NET 中的 PDF 文档？

IronPDF 提供诸如文本和图像注释、PDF 安全性、交互式表单填充、PDF 压缩和优化，以及与 .NET 应用程序的跨平台兼容性等功能。

如何在 Visual Studio 项目中安装 PDF 处理库？

您可以使用 NuGet 包管理器在 Visual Studio 项目中安装 IronPDF。在包管理器控制台中运行 Install-Package IronPDF 或在 NuGet 包管理器中搜索 IronPDF 并直接安装。

volatile 关键字如何与内存屏障一起工作？

volatile 中的内存屏障可以防止内存操作在 volatile 访问之间重新排序，确保所有线程以正确的顺序看到操作，从而保持数据一致性和线程安全。

什么是 C# 中的线程安全单例，以及如何通过 volatile 实现？

可以通过将实例变量标记为 volatile 并使用双重检查锁定机制来创建线程安全的单例，以确保即使在多线程上下文中也只创建一个实例。

在多线程应用程序中，为什么直接内存访问很重要？

直接内存访问确保从主内存读取和写入字段的最新值，防止由于缓存而导致的过时数据问题在多线程应用程序中出现。

C# PDF库

Explore IronPDF 免费试用

HTML到PDF

Online Demo 查看所有%s代码示例

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >Install-Package IronPdf

Install-Package IronPdf

开发者更新

C# Volatile（开发人员如何使用）

Jacob Mellor

Updated: 2026年4月23日

C#中的volatile关键字用于表示一个字段可能会被并发执行的线程更新。一个被标记为 volatile 的字段会提醒编译器和运行时，可能有并发线程或其他程序组件会在没有警告的情况下改变该字段的值。这保证了对该字段的内存访问不会被编译器优化掉，这可能会在[多线程应用程序](https://en.wikipedia.org/wiki/Multithreading_(computer_architecture)中导致意外行为。

一个受欢迎的用于创建和修改 PDF 文档的 C# 库被称为IronPDF - .NET PDF 库。了解如何适当地使用volatile关键字在处理多线程应用程序或使用IronPDF进行PDF创建或操控的程序时至关重要。这将有助于确保当多个线程访问数据时，数据被正确地同步和一致。

本教程将介绍使用IronPDF和volatile关键字创建可靠的多线程应用程序以生成或操控PDF的最佳方法。我们将讨论 volatile 字段的常见用途、如何正确声明和使用 volatile 字段，以及确保您的 IronPDF 支持的应用程序线程安全的推荐做法。现在让我们开始吧！

如何使用C#的Volatile

导入必要的库。
声明 Volatile 变量。
开始 PDF 生成任务。
在任务中设置 Volatile 变量。
检查 Volatile 变量。
等待 PDF 生成。
处理 PDF 完成。

什么是C#的Volatile？

通过使用volatile关键字声明可能会被多个同时运行的线程更改的字段。当一个字段被标记为 volatile 时，它提醒编译器和运行时警惕其他程序组件（包括并发线程）可能未经警告修改其值。因此，对 volatile 字段的读写始终直接在主内存中进行。

volatile关键字通过强制内存屏障解决与重新排序内存操作相关的问题。内存屏障确保内存操作不会跨越 volatile 访问重排序，从而防止在多线程场景中意外行为的发生。

通过在自愿读操作之前和之后或在自愿写操作期间隐式采用内存屏障，volatile确保内存操作的正确顺序，从而相较于使用非自愿对象可能出现的问题，增强并发环境中的线程安全和数据一致性。

Volatile 关键字的目的

C#中的volatile关键字主要用于处理多个线程不正确同步以访问和修改共享数据内存位置的情况。在多线程环境中，如果不存在 volatile 修饰符，编译器可能会优化内存访问，从而导致不可预见的行为。

通过将字段标记为 volatile，开发人员可以向编译器表明，该字段的值可能会异步更改，而数据完整性需要直接内存访问。

Volatile 关键字的行为

编译器和运行时确保每一次对标记为 volatile 的字段的内存读写操作都不会使用任何可能的缓存方法。这表示，即使一个线程缓存了一个 volatile 字段的值，随后的访问总是从主内存中提取该值，而不是依赖于已经缓存的同一值。同样，由于对 volatile 字段的写入是立即传播到内存的，因此一个线程的修改对于所有其他访问同一字段的线程都是可见的。

使用 Volatile 处理共享状态

让我们用一些代码示例来演示如何使用volatile关键字。

using System;
using System.Threading;

class SharedStateExample
{
    private volatile bool _isRunning = true;

    public void Run()
    {
        Thread thread1 = new Thread(ChangeState);
        Thread thread2 = new Thread(ReadState);
        thread1.Start();
        thread2.Start();
    }
    
    private void ChangeState()
    {
        while (_isRunning)
        {
            Console.WriteLine("Changing state...");
            Thread.Sleep(1000);
            _isRunning = false;
        }
    }

    private void ReadState()
    {
        while (_isRunning)
        {
            Console.WriteLine("Reading state...");
            Thread.Sleep(500);
        }
        Console.WriteLine("State is no longer running.");
    }
}

class Program
{
    static void Main(string[] args)
    {
        SharedStateExample example = new SharedStateExample();
        example.Run();
    }
}

using System;
using System.Threading;

class SharedStateExample
{
    private volatile bool _isRunning = true;

    public void Run()
    {
        Thread thread1 = new Thread(ChangeState);
        Thread thread2 = new Thread(ReadState);
        thread1.Start();
        thread2.Start();
    }
    
    private void ChangeState()
    {
        while (_isRunning)
        {
            Console.WriteLine("Changing state...");
            Thread.Sleep(1000);
            _isRunning = false;
        }
    }

    private void ReadState()
    {
        while (_isRunning)
        {
            Console.WriteLine("Reading state...");
            Thread.Sleep(500);
        }
        Console.WriteLine("State is no longer running.");
    }
}

class Program
{
    static void Main(string[] args)
    {
        SharedStateExample example = new SharedStateExample();
        example.Run();
    }
}

Imports System
Imports System.Threading

Class SharedStateExample
    Private _isRunning As volatile Boolean = True

    Public Sub Run()
        Dim thread1 As New Thread(AddressOf ChangeState)
        Dim thread2 As New Thread(AddressOf ReadState)
        thread1.Start()
        thread2.Start()
    End Sub

    Private Sub ChangeState()
        While _isRunning
            Console.WriteLine("Changing state...")
            Thread.Sleep(1000)
            _isRunning = False
        End While
    End Sub

    Private Sub ReadState()
        While _isRunning
            Console.WriteLine("Reading state...")
            Thread.Sleep(500)
        End While
        Console.WriteLine("State is no longer running.")
    End Sub
End Class

Module Program
    Sub Main(args As String())
        Dim example As New SharedStateExample()
        example.Run()
    End Sub
End Module

Imports System
Imports System.Threading

Class SharedStateExample
    Private _isRunning As volatile Boolean = True

    Public Sub Run()
        Dim thread1 As New Thread(AddressOf ChangeState)
        Dim thread2 As New Thread(AddressOf ReadState)
        thread1.Start()
        thread2.Start()
    End Sub

    Private Sub ChangeState()
        While _isRunning
            Console.WriteLine("Changing state...")
            Thread.Sleep(1000)
            _isRunning = False
        End While
    End Sub

    Private Sub ReadState()
        While _isRunning
            Console.WriteLine("Reading state...")
            Thread.Sleep(500)
        End While
        Console.WriteLine("State is no longer running.")
    End Sub
End Class

Module Program
    Sub Main(args As String())
        Dim example As New SharedStateExample()
        example.Run()
    End Sub
End Module

此示例中的 SharedStateExample 类具有一个被标记为 volatile 对象的 _isRunning 字段。一个 ChangeState 方法用于更改状态，而一个 ReadState 方法建立一个 volatile 读取操作。

当 ReadState 方法连续检查 _isRunning 的值时，ChangeState 方法延迟然后将 _isRunning 设置为 false。由于 _isRunning 的 volatility，仅由一个线程完成的更改对于另一个线程立即可见。

使用 Volatile 进行双重检查锁定

using System;

class Singleton
{
    private static volatile Singleton _instance;
    private static readonly object _lock = new object();
    
    private Singleton() { }
    
    public static Singleton GetInstance()
    {
        if (_instance == null)
        {
            lock (_lock)
            {
                if (_instance == null)
                {
                    _instance = new Singleton();
                }
            }
        }
        return _instance;
    }
}

class Program
{
    static void Main(string[] args)
    {
        Singleton instance1 = Singleton.GetInstance();
        Singleton instance2 = Singleton.GetInstance();
        Console.WriteLine("Are instances equal? " + (instance1 == instance2));
    }
}

using System;

class Singleton
{
    private static volatile Singleton _instance;
    private static readonly object _lock = new object();
    
    private Singleton() { }
    
    public static Singleton GetInstance()
    {
        if (_instance == null)
        {
            lock (_lock)
            {
                if (_instance == null)
                {
                    _instance = new Singleton();
                }
            }
        }
        return _instance;
    }
}

class Program
{
    static void Main(string[] args)
    {
        Singleton instance1 = Singleton.GetInstance();
        Singleton instance2 = Singleton.GetInstance();
        Console.WriteLine("Are instances equal? " + (instance1 == instance2));
    }
}

Imports System

Class Singleton
    Private Shared _instance As Singleton
    Private Shared ReadOnly _lock As New Object()

    Private Sub New()
    End Sub

    Public Shared Function GetInstance() As Singleton
        If _instance Is Nothing Then
            SyncLock _lock
                If _instance Is Nothing Then
                    _instance = New Singleton()
                End If
            End SyncLock
        End If
        Return _instance
    End Function
End Class

Class Program
    Shared Sub Main(args As String())
        Dim instance1 As Singleton = Singleton.GetInstance()
        Dim instance2 As Singleton = Singleton.GetInstance()
        Console.WriteLine("Are instances equal? " & (instance1 Is instance2))
    End Sub
End Class

Imports System

Class Singleton
    Private Shared _instance As Singleton
    Private Shared ReadOnly _lock As New Object()

    Private Sub New()
    End Sub

    Public Shared Function GetInstance() As Singleton
        If _instance Is Nothing Then
            SyncLock _lock
                If _instance Is Nothing Then
                    _instance = New Singleton()
                End If
            End SyncLock
        End If
        Return _instance
    End Function
End Class

Class Program
    Shared Sub Main(args As String())
        Dim instance1 As Singleton = Singleton.GetInstance()
        Dim instance2 As Singleton = Singleton.GetInstance()
        Console.WriteLine("Are instances equal? " & (instance1 Is instance2))
    End Sub
End Class

在这个示例中，我们使用双重检查锁定机制来构建一个线程安全的 Singleton 设计。为了确保多个线程之间的修改是最新的和可见的，_instance字段被指定为自愿的。这避免了单个线程仅注意到一个半初始化的Singleton实例的情况。即使在多线程上下文中，双重检查锁定机制也保证只生成 Singleton 的一个实例。

什么是 IronPDF？

C# 库IronPDF - PDF 生成和编辑允许程序员在 .NET 应用程序中创建、修改和渲染 PDF 文档。其丰富的功能集使得处理 PDF 文件变得简单。已存在的 PDF 文档可以被编辑、分割和合并。 PDF 文档可以以 HTML、图像和其他形式创建。 PDF 上可以添加文本、照片和其他数据作为注释。

IronPDF的功能

文本和图像注释

using IronPDF，您可以通过编程方式在 PDF 文档上添加注释，包括文本、图片和其他数据。使用这个工具，您可以在 PDF 文件上添加签名、印章和评论。

PDF 安全

IronPDF 允许您设置不同的权限，包括打印、复制、编辑文档，也可以用密码加密 PDF 文档。这有助于控制谁可以访问 PDF 文件和保护机密信息。

填写交互式 PDF 表单

using IronPDF，可以程序化地填写交互式 PDF 表单。这个功能对根据用户输入创建个性化文档和自动提交表单很有帮助。

PDF 压缩和优化

IronPDF 提供 PDF 文件优化和压缩选项，可以在不影响质量的情况下减少大小。因此，PDF 文档需求更少的存储空间，并以更高效率运行。

跨平台兼容性

IronPDF 被设计为可以在多种操作系统上与 .NET 程序完美结合，包括 Windows、Linux 和 macOS。它与常用的 .NET Framework如 ASP.NET、.NET Core 和 Xamarin 集成。

创建新的Visual Studio项目

在 Visual Studio 中创建一个控制台项目是一个简单的过程。要启动一个控制台应用程序，请在 Visual Studio 环境中遵循以下简单步骤：

在使用 Visual Studio 之前，确认它已经安装在您的计算机上。

启动新项目

选择文件，然后选择新建，最后选择项目。

C# Volatile（对开发者的工作原理）：图1

在"创建新项目"框中，从左侧的列表中选择您喜欢的编程语言（例如 C#）。

以下项目模板参考列表中有"控制台应用"或"控制台应用（.NET Core）"模板可供选择。

在"名称"字段中为您的项目提供名称。

C# Volatile（对开发者的工作原理）：图2

选择项目将被保存的位置。

点击"创建"将开始控制台应用程序项目。

C# Volatile（对开发者的工作原理）：图3

安装 IronPDF

Visual Studio 工具菜单项下的工具中包含 Visual 命令行界面。选择 NuGet 包管理器。在包管理终端选项卡上，您必须键入以下命令。

PM > Install-Package IronPdf

Install-Package IronPdf

或者，您可以使用 Package Manager。使用 NuGet 包管理器选项可以将包直接安装到解决方案中。使用NuGet 管理器网站的搜索框查找包。下面的示例截图显示了在包管理器中搜索"IronPDF"的简便性：

C# Volatile（对开发者的工作原理）：图4 - 从NuGet包管理器安装IronPDF

相关的搜索结果显示在上图中。请做以下更改，以便软件在您的机器上更容易安装。

下载并安装包之后，我们现在可以在进行中的项目中使用它。

使用C# Volatile和IronPDF确保PDF生成的线程安全性

现在我们在C#程序中一起使用IronPDF和volatile关键字。一个受欢迎的用于创建和修改 PDF 文档的 C# 库被称为 IronPDF。在使用 IronPDF 进行 PDF 创建或处理的多线程应用程序中，必须保持线程安全性。

这是一个示例，展示如何在多线程环境中利用 IronPDF 的 volatile 关键字来创建 PDF 文档。

using IronPdf;
using System;
using System.Threading;

class PdfGenerator
{
    private volatile bool _isRunning = true;
    private readonly object _lock = new object();
    
    public void GeneratePdf(string filePath)
    {
        Thread thread = new Thread(() =>
        {
            while (_isRunning)
            {
                // Generate PDF document
                GenerateDocument(filePath);
                // Sleep for some time
                Thread.Sleep(5000);
            }
        });
        thread.Start();
    }
    
    public void StopPdfGeneration()
    {
        lock (_lock)
        {
            _isRunning = false;
        }
    }
    
    private void GenerateDocument(string filePath)
    {
        // Load HTML content
        string htmlContent = "<html><body><h1>Hello, IronPDF!</h1></body></html>";
        // Convert HTML to PDF
        var renderer = new ChromePdfRenderer();
        var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);
        // Save PDF to file
        pdfDocument.SaveAs(filePath);
        // Output status
        Console.WriteLine($"PDF generated and saved to {filePath}");
    }
}

class Program
{
    static void Main(string[] args)
    {
        PdfGenerator pdfGenerator = new PdfGenerator();
        // Start PDF generation
        pdfGenerator.GeneratePdf("output.pdf");
        // Wait for user input to stop PDF generation
        Console.WriteLine("Press any key to stop PDF generation...");
        Console.ReadKey();
        // Stop PDF generation
        pdfGenerator.StopPdfGeneration();
    }
}

using IronPdf;
using System;
using System.Threading;

class PdfGenerator
{
    private volatile bool _isRunning = true;
    private readonly object _lock = new object();
    
    public void GeneratePdf(string filePath)
    {
        Thread thread = new Thread(() =>
        {
            while (_isRunning)
            {
                // Generate PDF document
                GenerateDocument(filePath);
                // Sleep for some time
                Thread.Sleep(5000);
            }
        });
        thread.Start();
    }
    
    public void StopPdfGeneration()
    {
        lock (_lock)
        {
            _isRunning = false;
        }
    }
    
    private void GenerateDocument(string filePath)
    {
        // Load HTML content
        string htmlContent = "<html><body><h1>Hello, IronPDF!</h1></body></html>";
        // Convert HTML to PDF
        var renderer = new ChromePdfRenderer();
        var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);
        // Save PDF to file
        pdfDocument.SaveAs(filePath);
        // Output status
        Console.WriteLine($"PDF generated and saved to {filePath}");
    }
}

class Program
{
    static void Main(string[] args)
    {
        PdfGenerator pdfGenerator = new PdfGenerator();
        // Start PDF generation
        pdfGenerator.GeneratePdf("output.pdf");
        // Wait for user input to stop PDF generation
        Console.WriteLine("Press any key to stop PDF generation...");
        Console.ReadKey();
        // Stop PDF generation
        pdfGenerator.StopPdfGeneration();
    }
}

Imports IronPdf
Imports System
Imports System.Threading

Class PdfGenerator
    Private _isRunning As Boolean = True
    Private ReadOnly _lock As New Object()

    Public Sub GeneratePdf(filePath As String)
        Dim thread As New Thread(Sub()
                                     While _isRunning
                                         ' Generate PDF document
                                         GenerateDocument(filePath)
                                         ' Sleep for some time
                                         Thread.Sleep(5000)
                                     End While
                                 End Sub)
        thread.Start()
    End Sub

    Public Sub StopPdfGeneration()
        SyncLock _lock
            _isRunning = False
        End SyncLock
    End Sub

    Private Sub GenerateDocument(filePath As String)
        ' Load HTML content
        Dim htmlContent As String = "<html><body><h1>Hello, IronPDF!</h1></body></html>"
        ' Convert HTML to PDF
        Dim renderer As New ChromePdfRenderer()
        Dim pdfDocument = renderer.RenderHtmlAsPdf(htmlContent)
        ' Save PDF to file
        pdfDocument.SaveAs(filePath)
        ' Output status
        Console.WriteLine($"PDF generated and saved to {filePath}")
    End Sub
End Class

Module Program
    Sub Main(args As String())
        Dim pdfGenerator As New PdfGenerator()
        ' Start PDF generation
        pdfGenerator.GeneratePdf("output.pdf")
        ' Wait for user input to stop PDF generation
        Console.WriteLine("Press any key to stop PDF generation...")
        Console.ReadKey()
        ' Stop PDF generation
        pdfGenerator.StopPdfGeneration()
    End Sub
End Module

Imports IronPdf
Imports System
Imports System.Threading

Class PdfGenerator
    Private _isRunning As Boolean = True
    Private ReadOnly _lock As New Object()

    Public Sub GeneratePdf(filePath As String)
        Dim thread As New Thread(Sub()
                                     While _isRunning
                                         ' Generate PDF document
                                         GenerateDocument(filePath)
                                         ' Sleep for some time
                                         Thread.Sleep(5000)
                                     End While
                                 End Sub)
        thread.Start()
    End Sub

    Public Sub StopPdfGeneration()
        SyncLock _lock
            _isRunning = False
        End SyncLock
    End Sub

    Private Sub GenerateDocument(filePath As String)
        ' Load HTML content
        Dim htmlContent As String = "<html><body><h1>Hello, IronPDF!</h1></body></html>"
        ' Convert HTML to PDF
        Dim renderer As New ChromePdfRenderer()
        Dim pdfDocument = renderer.RenderHtmlAsPdf(htmlContent)
        ' Save PDF to file
        pdfDocument.SaveAs(filePath)
        ' Output status
        Console.WriteLine($"PDF generated and saved to {filePath}")
    End Sub
End Class

Module Program
    Sub Main(args As String())
        Dim pdfGenerator As New PdfGenerator()
        ' Start PDF generation
        pdfGenerator.GeneratePdf("output.pdf")
        ' Wait for user input to stop PDF generation
        Console.WriteLine("Press any key to stop PDF generation...")
        Console.ReadKey()
        ' Stop PDF generation
        pdfGenerator.StopPdfGeneration()
    End Sub
End Module

volatile bool isRunning: 我们将一个_isRunning字段指定为自愿变量，以表示有可能有多个线程对此进行更改。 PDF 文档生成由此字段管理。 PDF创建在_isRunning为true时继续；如果不是，则退出。

**GeneratePdf(string filePath):**此函数启动一个新线程，按计划创建 PDF 文档。我们在主线程中持续检查_isRunning标志。如果是这样，我们使用 IronPDF 创建一个 PDF 文档并将其保存到指定的文件目录。

**StopPdfGeneration():**此函数可以停止创建 PDF 文件。为了在更改_lock的私有对象。

**GenerateDocument(string filePath):**此函数包含使用 IronPDF 创建 PDF 文档所需的代码。创建了ChromePdfRenderer的一个实例，加载HTML内容，将其转换为PDF文档，然后将PDF保存到指定的文件目录中。

Main(string[] args): 实例化PdfGenerator类，开始PDF生成，并在Main方法中提示用户按下任意键停止PDF生成。

C# Volatile（对开发者的工作原理）：图5

这个示例展示了如何在使用IronPDF和volatile关键字的多线程环境中可靠地生成PDF文档。我们通过使用_isRunning标志的更改在各个线程之间立即可见。我们还使用锁在保持工作线程安全的情况下访问和修改_isRunning标志。

C# Volatile（对开发者的工作原理）：图6

结论

总之，将volatile关键字集成到IronPDF中提供了一种强有力的方法，以确保在多线程C#程序中创建PDF时的线程安全。通过将共享控制标志标记为 volatile，我们确保改变的及时感知和正确同步，并提供了对 PDF 生产过程的有效控制。

通过确保控制标志的更改被即时广播到所有线程，使用volatile来避免冲突并促进PDF创建过程中涉及的进程的高效协调。

由于此方法提高了在并发上下文中 PDF 生成的可扩展性和可靠性，应用程序可以同时有效地管理多个 PDF 生成过程而不会面临数据损坏或竞争状况的风险。

最后，通过包含 IronPDF 和轻松探索 Iron Software 库的全部潜力，您可以高效地处理条形码，创建 PDF，执行 OCR，并连接到 Excel。 Iron Software 无缝结合其多功能套件的性能、兼容性和易用性，以提供增强的应用程序功能和更有效的开发。

如果有明确的许可证选项，针对项目的特定需求量身打造，开发人员可以有信心选择最佳模型。这些优势让开发人员得以高效且透明地应对各种挑战。

Jacob Mellor

立即与工程团队聊天

首席技术官

Jacob Mellor 是 Iron Software 的首席技术官，也是一位开创 C# PDF 技术的有远见的工程师。作为 Iron Software 核心代码库的原始开发者，他从公司成立之初就开始塑造公司的产品架构，与首席执行官 Cameron Rimington 一起将公司转变为一家拥有 50 多名员工的公司，为 NASA、特斯拉和全球政府机构提供服务。