1. IronPDF
  2. IronPDF博客
  3. .NET 帮助
  4. Autofac .NET 6
.NET 帮助

Autofac .NET 6（它是如何为开发人员工作的）

Chipego
奇佩戈-卡琳达
2024年七月1日
分享:

在 .NET 开发领域，有效管理依赖关系对于构建可扩展、可维护和可测试的应用程序至关重要。 依赖注入（DI）容器通过促进控制反转（IoC）原则，在实现这些目标中发挥了关键作用。 在现有的大量通用托管机制库中，Autofac 脱颖而出，成为功能丰富、可扩展的 .NET Framework。

在本文中，我们将踏上探索 Autofac .NET 6 的旅程，揭开其功能和优点的神秘面纱，并展示其实际使用示例。 在本文的后面部分，我们将了解 IronPDF，这是 Iron Software 的一个功能强大的 PDF 生成库。 我们还将介绍一个 Autofac.NET 和 IronPDF 一起使用的案例。

了解 Autofac .NET

Autofac 是 .NET 的开源 IoC 容器，为 Web API 等应用程序中的依赖注入和组件注册提供全面支持。Autofac 由 Nicholas Blumhardt 开发，并由一个专门的社区负责维护，它为管理对象生命周期、解决依赖关系和组合应用程序组件提供了一个强大而灵活的解决方案。

欲了解有关 Autofac 如何增强您的 .NET 应用程序的更多信息，请考虑探索由IronPDF 的 .NET PDF 库 提供的资源，其中突出显示了 PDF 生成和处理的高级功能。 您还可以深入了解IronBarcode 的 .NET Barcode Library，了解依赖注入在条形码生成中的实际应用。

通过访问IronSoftware的官方网站，获取更多关于在实际场景中使用Autofac的深入见解和实践例子。在这里，您将找到包括IronOCR和IronXL在内的全套产品，这些产品与Autofac无缝集成，提升您的.NET开发过程。

Autofac 的功能

  1. 容器构建和组件注册：您可以通过在启动类中注册组件，使用Autofac构建容器。 您可以使用 lambdas、类型或预建实例注册组件。
    public class Startup
    {
        public void ConfigureContainer()
        {
            var builder = new ContainerBuilder(); // host sub property builder
            builder.RegisterInstance(new TaskRepository()).As<ITaskRepository>();
            builder.RegisterType<TaskController>();
            builder.Register(c => new LogManager(DateTime.Now)).As<ILogger>();
            // Scan an assembly for components
            builder.RegisterAssemblyTypes(myAssembly).Where(t => t.Name.EndsWith("Repository")).AsImplementedInterfaces();
            var container = builder.Build();
        }
    }
    public class Startup
    {
        public void ConfigureContainer()
        {
            var builder = new ContainerBuilder(); // host sub property builder
            builder.RegisterInstance(new TaskRepository()).As<ITaskRepository>();
            builder.RegisterType<TaskController>();
            builder.Register(c => new LogManager(DateTime.Now)).As<ILogger>();
            // Scan an assembly for components
            builder.RegisterAssemblyTypes(myAssembly).Where(t => t.Name.EndsWith("Repository")).AsImplementedInterfaces();
            var container = builder.Build();
        }
    }
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel
  1. 表达依赖关系：Autofac 可以注入构造函数参数，处理属性注入和方法注入。
    public class TaskController
    {
        private ITaskRepository _repository;
        private ILogger _logger;

        public TaskController(ITaskRepository repository, ILogger logger)
        {
            this._repository = repository;
            this._logger = logger;
        }
    }
    public class TaskController
    {
        private ITaskRepository _repository;
        private ILogger _logger;

        public TaskController(ITaskRepository repository, ILogger logger)
        {
            this._repository = repository;
            this._logger = logger;
        }
    }
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel
  1. 灵活的模块系统：Autofac 模块在 XML 配置和基于代码的注册之间取得了平衡。 您可以在代码中指定复杂的注册，或使用 XML 更改部署时的行为。
    public class CarTransportModule : Module
    {
        public bool ObeySpeedLimit { get; set; }

        protected override void Load(ContainerBuilder builder)
        {
            builder.RegisterType<Car>().As<IVehicle>();
            if (ObeySpeedLimit)
                builder.RegisterType<SaneDriver>().As<IDriver>();
            else
                builder.RegisterType<CrazyDriver>().As<IDriver>();
        }
    }
    public class CarTransportModule : Module
    {
        public bool ObeySpeedLimit { get; set; }

        protected override void Load(ContainerBuilder builder)
        {
            builder.RegisterType<Car>().As<IVehicle>();
            if (ObeySpeedLimit)
                builder.RegisterType<SaneDriver>().As<IDriver>();
            else
                builder.RegisterType<CrazyDriver>().As<IDriver>();
        }
    }
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel
  1. 简单扩展点：Autofac提供激活事件以自定义组件的激活或释放。
    var builder = new ContainerBuilder();
    builder.RegisterType<Listener>().As<IListener>().OnActivated(e => e.Instance.StartListening());
    builder.RegisterType<Processor>().OnActivating(e => e.Instance.Initialize());
    var container = builder.Build();
    var builder = new ContainerBuilder();
    builder.RegisterType<Listener>().As<IListener>().OnActivated(e => e.Instance.StartListening());
    builder.RegisterType<Processor>().OnActivating(e => e.Instance.Initialize());
    var container = builder.Build();
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Autofac.NET 的主要功能

  1. 灵活的组件注册：Autofac允许开发人员使用多种注册技术来注册组件，包括手动注册、程序集扫描和基于属性的注册。 这种灵活性可实现对组件实例化和配置的细粒度控制。

  2. 生命周期管理：Autofac 支持多种对象生命周期范围，包括单例、每次依赖实例、每个生命周期范围实例和每个请求实例。这种对对象生命周期的细粒度控制确保了资源的高效利用，并防止在长时间运行的应用程序中出现内存泄漏。

  3. 自动依赖解析：Autofac根据注册的组件注册和它们的依赖关系自动解析依赖。 这种自动布线简化了复杂对象图的配置，促进了组件之间的松散耦合。

  4. 模块组成：Autofac 允许开发人员使用模块来组织和封装组件注册。 模块可作为相关注册表的逻辑容器，使管理和维护包含多个组件的大型应用程序变得更加容易。

  5. 拦截和AOP：Autofac通过其拦截扩展提供对拦截和面向方面编程（AOP）的支持。 有了拦截功能，开发人员可以将日志、缓存和安全等跨领域问题应用到组件中，而无需修改其实现。

  6. ASP.NET Core 和 .NET Core 集成：Autofac 无缝集成到 .NET Core 和 ASP.NET Core 中，为现代 web 应用程序和微服务中的依赖注入提供一流支持。 它利用内置的服务提供商抽象来确保与 .NET 生态系统的兼容性和互操作性。

使用 Autofac.NET 的实用示例

让我们通过一些实际例子来说明 Autofac.NET 的用法：

public class Program
{
    public static void Main()
    {
        // Setting up Autofac container
        var builder = new ContainerBuilder();

        // Registering types manually
        builder.RegisterType<MyService>().As<IMyService>();

        // Registering types using assembly scanning
        builder.RegisterAssemblyTypes(typeof(MyAssembly).Assembly)
            .Where(t => t.Name.EndsWith("Repository"))
            .AsImplementedInterfaces();

        // Registering modules
        builder.RegisterModule(new MyModule());

        // Building the container
        var container = builder.Build();

        // Resolving dependencies
        using (var scope = container.BeginLifetimeScope())
        {
            var service = scope.Resolve<IMyService>();
            service.DoSomething();
        }
    }
}
public class Program
{
    public static void Main()
    {
        // Setting up Autofac container
        var builder = new ContainerBuilder();

        // Registering types manually
        builder.RegisterType<MyService>().As<IMyService>();

        // Registering types using assembly scanning
        builder.RegisterAssemblyTypes(typeof(MyAssembly).Assembly)
            .Where(t => t.Name.EndsWith("Repository"))
            .AsImplementedInterfaces();

        // Registering modules
        builder.RegisterModule(new MyModule());

        // Building the container
        var container = builder.Build();

        // Resolving dependencies
        using (var scope = container.BeginLifetimeScope())
        {
            var service = scope.Resolve<IMyService>();
            service.DoSomething();
        }
    }
}
Public Class Program
	Public Shared Sub Main()
		' Setting up Autofac container
		Dim builder = New ContainerBuilder()

		' Registering types manually
		builder.RegisterType(Of MyService)().As(Of IMyService)()

		' Registering types using assembly scanning
		builder.RegisterAssemblyTypes(GetType(MyAssembly).Assembly).Where(Function(t) t.Name.EndsWith("Repository")).AsImplementedInterfaces()

		' Registering modules
		builder.RegisterModule(New MyModule())

		' Building the container
		Dim container = builder.Build()

		' Resolving dependencies
		Using scope = container.BeginLifetimeScope()
			Dim service = scope.Resolve(Of IMyService)()
			service.DoSomething()
		End Using
	End Sub
End Class
$vbLabelText   $csharpLabel

在本节中，我们演示了 Autofac.NET 在依赖注入方面的实际应用。 从手动注册到程序集扫描和基于模块的注册，我们展示了 Autofac 在管理依赖关系方面提供的灵活性。 利用这些技术，开发人员可以简化应用程序的依赖注入过程，提高可维护性和可扩展性。

欲了解更多有关Iron Software的产品如何与您的.NET应用程序集成，以进一步简化和增强功能的信息，请浏览IronPDF文档，您可以在此学习如何以编程方式生成和编辑PDF文档，或者访问Iron Software的网站，发掘广泛强大的.NET库，例如用于读取和写入条形码的IronBarcode，以及用于高级光学字符识别的IronOCR。

使用 Autofac.NET 的好处

  1. 简单性和灵活性：Autofac 提供一个简单而直观的 API 用于注册和解析组件，使得依赖注入易于实现和维护。

  2. 可测试性与可维护性：通过促进松耦合和依赖倒置，Autofac 增强了 .NET 应用程序的可测试性和可维护性，使单元测试和重构变得更加容易。

  3. 性能和可扩展性：Autofac 的轻量级和高效运行时性能使其适用于高性能应用程序和具有大型对象图的可扩展系统。

  4. 可扩展性和自定义：Autofac 的可扩展架构允许开发人员通过自定义模块、注册源和中间件组件扩展和自定义 Autofac 的行为，以满足不同的应用需求。

  5. 社区和支持：Autofac 拥有活跃的开发者社区和全面的文档，为学习、故障排除和对框架的贡献提供了出色的支持和资源。

Autofac 许可证

Autofac 采用 MIT 许可，可免费用于开发和商业目的。

介绍 Iron Software 的 IronPDF

Autofac .NET 6（它如何为开发人员工作）：图1 - IronPDF网页

IronPDF 是一个强大的 C# PDF 库，旨在为 .NET 项目中的 PDF 管理提供全面的解决方案。 无论您需要创建、编辑、导出、保护、加载或操作 PDF 文档，IronPDF 都能满足您的需求。 以下是一些突出的功能和应用：

主要功能

  • HTML 转换为 PDF：轻松将 HTML 内容转换为 PDF。 从 HTML、MVC、ASPX 和图像生成 PDF。
  • PDF 管理：拥有超过 50 项功能，IronPDF 使您可以签署、编辑和提取 PDF 中的内容，使数字签名和修改变得简单。

  • 跨平台支持：兼容 C#、F# 和 VB.NET，IronPDF 能够在多个 .NET 版本上运行，包括 .NET Core、.NET Standard 和 .NET Framework。 它还可用于 Java、Node.js 和 Python。

    要了解更多关于如何将IronPDF的PDF功能集成到您的项目中，请访问IronPDF产品页面。

    如需全面了解Iron Software的产品，包括IronBarcode、IronOCR等，请访问Iron Software主页。

兼容性和环境

  • .NET 版本：支持 C#、VB.NET 和 F#。
  • 项目类型：适用于网络（Blazor 和 WebForms with IronPDF）、桌面（WPF 和 MAUI）及控制台应用程序。
  • 应用环境：兼容 Windows、Linux、Mac、Docker、Azure、AWS 等。
  • 集成开发环境 (IDEs)：可无缝集成到Microsoft Visual Studio 和 JetBrains Rider 中。
  • 操作系统和处理器：适用于 Windows、Mac 和 Linux（x64、x86、ARM）。

PDF 标准和编辑

  • 兼容性：支持各种PDF版本（1.2 - 1.7）、PDF/UA和PDF/A。
  • 自定义：设置PDF文件的属性、安全性和压缩。
  • 元数据和结构：编辑元数据、修订历史和文档结构。

  • 模板和设置：应用页面模板、页眉、页脚和页面设置。

    有关这些功能的更多信息以及如何实现它们，请访问 IronPDF 官方网站上的详细 PDF 生成和操作指南。

性能优化

  • 效率：支持完整的多线程和异步，提供高效的PDF生成。

  • 优先级：注重准确性、易用性和速度。

    现在，让我们用这两个库来看一个实际例子。

使用 Autofac.NET 和 IronPDF 生成 PDF 文档

首先，让我们创建一个 Visual Studio 控制台应用程序

Autofac .NET 6（它如何为开发人员工作）：图2 - 创建一个 Visual Studio 控制台应用程序

提供项目名称和地点。

Autofac .NET 6（开发者如何使用）：图 3 - 配置项目详细信息

下一步，选择所需的 .NET 版本，然后单击 "创建"。

然后从 Visual Studio 软件包管理器中的 NuGet 软件包安装 IronPdf 库

Autofac .NET 6（开发者如何使用）：图4 - 安装必要的 IronPDF 包

访问IronPDF文档以获取有关安装和使用IronPDF库的更多信息。

从 Visual Studio 软件包管理器中的 NuGet 软件包安装 Autofac

Autofac .NET 6（开发人员如何使用）：图 5 - 安装必要的 Autofac 包

通过访问Autofac 文档页面了解更多关于 Autofac 的信息。

代码示例：Autofac 和 IronPDF

using Autofac;
using CacheManager.Core;
using IronPdf;
using System.Reflection;

namespace IronPdfDemos
{
    public class AutoFac
    {
        public static void Execute()
        {
            // Instantiate Cache and ChromePdfRenderer
            var renderer = new ChromePdfRenderer();
            var cache = CacheFactory.Build("ironPdfAutofac", settings =>
            {
                settings.WithDictionaryHandle();
            });

            // Prepare HTML content
            var content = "<h1>Demonstrate Autofac with IronPDF</h1>";
            content += "<p>This is an illustration of using Autofac for dependency injection and IronPDF for generating PDF documents.</p>";
            content += "<h2>Setting up Autofac container</h2>";

            // Setting up Autofac container
            var builder = new ContainerBuilder();
            content += "<p>var builder = new ContainerBuilder();</p>";

            content += "<h2>Registering types manually</h2>";
            // Registering types manually
            builder.RegisterType<MyService>().As<IMyService>();
            content += "<p>builder.RegisterType<MyService>().As<IMyService();</p>";

            content += "<h2>Registering types using assembly scanning</h2>";
            // Registering types using assembly scanning
            builder.RegisterAssemblyTypes(typeof(AutoFac).Assembly)
                .Where(t => t.Name.EndsWith("Repository"))
                .AsImplementedInterfaces();
            content += "<p>builder.RegisterAssemblyTypes(typeof(AutoFac).Assembly).Where(t => t.Name.EndsWith(\"Repository\")).AsImplementedInterfaces();</p>";

            content += "<h2>Registering modules</h2>";
            // Registering modules
            builder.RegisterModule(new MyModule());
            content += "<p>builder.RegisterModule(new MyModule());</p>";

            content += "<h2>Building the container</h2>";
            // Building the container
            var container = builder.Build();
            content += "<p>var container = builder.Build();</p>";

            content += "<h2>Resolving dependencies</h2>";
            // Resolving dependencies
            using (var scope = container.BeginLifetimeScope())
            {
                var service = scope.Resolve<IMyService>();
                service.DoSomething();
            }
            content += "<p>var service = scope.Resolve<IMyService();</p>";

            // Create a PDF from the HTML string using C#
            var pdf = renderer.RenderHtmlAsPdf(content);
            // Export to a file or Stream
            pdf.SaveAs("autofac.pdf");
            Console.WriteLine("We are done...");
            Console.ReadKey();
        }
    }

    internal interface IMyService
    {
        void DoSomething();
    }

    internal class MyModule : Module
    {
        protected override void Load(ContainerBuilder builder)
        {
            // Register module dependencies here
        }
    }

    internal class MyService : IMyService
    {
        public void DoSomething()
        {
            Console.WriteLine("DoSomething");
        }
    }
}
using Autofac;
using CacheManager.Core;
using IronPdf;
using System.Reflection;

namespace IronPdfDemos
{
    public class AutoFac
    {
        public static void Execute()
        {
            // Instantiate Cache and ChromePdfRenderer
            var renderer = new ChromePdfRenderer();
            var cache = CacheFactory.Build("ironPdfAutofac", settings =>
            {
                settings.WithDictionaryHandle();
            });

            // Prepare HTML content
            var content = "<h1>Demonstrate Autofac with IronPDF</h1>";
            content += "<p>This is an illustration of using Autofac for dependency injection and IronPDF for generating PDF documents.</p>";
            content += "<h2>Setting up Autofac container</h2>";

            // Setting up Autofac container
            var builder = new ContainerBuilder();
            content += "<p>var builder = new ContainerBuilder();</p>";

            content += "<h2>Registering types manually</h2>";
            // Registering types manually
            builder.RegisterType<MyService>().As<IMyService>();
            content += "<p>builder.RegisterType<MyService>().As<IMyService();</p>";

            content += "<h2>Registering types using assembly scanning</h2>";
            // Registering types using assembly scanning
            builder.RegisterAssemblyTypes(typeof(AutoFac).Assembly)
                .Where(t => t.Name.EndsWith("Repository"))
                .AsImplementedInterfaces();
            content += "<p>builder.RegisterAssemblyTypes(typeof(AutoFac).Assembly).Where(t => t.Name.EndsWith(\"Repository\")).AsImplementedInterfaces();</p>";

            content += "<h2>Registering modules</h2>";
            // Registering modules
            builder.RegisterModule(new MyModule());
            content += "<p>builder.RegisterModule(new MyModule());</p>";

            content += "<h2>Building the container</h2>";
            // Building the container
            var container = builder.Build();
            content += "<p>var container = builder.Build();</p>";

            content += "<h2>Resolving dependencies</h2>";
            // Resolving dependencies
            using (var scope = container.BeginLifetimeScope())
            {
                var service = scope.Resolve<IMyService>();
                service.DoSomething();
            }
            content += "<p>var service = scope.Resolve<IMyService();</p>";

            // Create a PDF from the HTML string using C#
            var pdf = renderer.RenderHtmlAsPdf(content);
            // Export to a file or Stream
            pdf.SaveAs("autofac.pdf");
            Console.WriteLine("We are done...");
            Console.ReadKey();
        }
    }

    internal interface IMyService
    {
        void DoSomething();
    }

    internal class MyModule : Module
    {
        protected override void Load(ContainerBuilder builder)
        {
            // Register module dependencies here
        }
    }

    internal class MyService : IMyService
    {
        public void DoSomething()
        {
            Console.WriteLine("DoSomething");
        }
    }
}
Imports Autofac
Imports CacheManager.Core
Imports IronPdf
Imports System.Reflection

Namespace IronPdfDemos
	Public Class AutoFac
		Public Shared Sub Execute()
			' Instantiate Cache and ChromePdfRenderer
			Dim renderer = New ChromePdfRenderer()
			Dim cache = CacheFactory.Build("ironPdfAutofac", Sub(settings)
				settings.WithDictionaryHandle()
			End Sub)

			' Prepare HTML content
			Dim content = "<h1>Demonstrate Autofac with IronPDF</h1>"
			content &= "<p>This is an illustration of using Autofac for dependency injection and IronPDF for generating PDF documents.</p>"
			content &= "<h2>Setting up Autofac container</h2>"

			' Setting up Autofac container
			Dim builder = New ContainerBuilder()
			content &= "<p>var builder = new ContainerBuilder();</p>"

			content &= "<h2>Registering types manually</h2>"
			' Registering types manually
			builder.RegisterType(Of MyService)().As(Of IMyService)()
			content &= "<p>builder.RegisterType<MyService>().As<IMyService();</p>"

			content &= "<h2>Registering types using assembly scanning</h2>"
			' Registering types using assembly scanning
			builder.RegisterAssemblyTypes(GetType(AutoFac).Assembly).Where(Function(t) t.Name.EndsWith("Repository")).AsImplementedInterfaces()
			content &= "<p>builder.RegisterAssemblyTypes(typeof(AutoFac).Assembly).Where(t => t.Name.EndsWith(""Repository"")).AsImplementedInterfaces();</p>"

			content &= "<h2>Registering modules</h2>"
			' Registering modules
			builder.RegisterModule(New MyModule())
			content &= "<p>builder.RegisterModule(new MyModule());</p>"

			content &= "<h2>Building the container</h2>"
			' Building the container
			Dim container = builder.Build()
			content &= "<p>var container = builder.Build();</p>"

			content &= "<h2>Resolving dependencies</h2>"
			' Resolving dependencies
			Using scope = container.BeginLifetimeScope()
				Dim service = scope.Resolve(Of IMyService)()
				service.DoSomething()
			End Using
			content &= "<p>var service = scope.Resolve<IMyService();</p>"

			' Create a PDF from the HTML string using C#
			Dim pdf = renderer.RenderHtmlAsPdf(content)
			' Export to a file or Stream
			pdf.SaveAs("autofac.pdf")
			Console.WriteLine("We are done...")
			Console.ReadKey()
		End Sub
	End Class

	Friend Interface IMyService
		Sub DoSomething()
	End Interface

	Friend Class MyModule
		Inherits Module

		Protected Overrides Sub Load(ByVal builder As ContainerBuilder)
			' Register module dependencies here
		End Sub
	End Class

	Friend Class MyService
		Implements IMyService

		Public Sub DoSomething() Implements IMyService.DoSomething
			Console.WriteLine("DoSomething")
		End Sub
	End Class
End Namespace
$vbLabelText   $csharpLabel

代码解释

让我们来分析一下您提供的代码片段：

  1. ChromePdfRenderer 设置：

    • 该代码初始化了一个ChromePdfRenderer实例，用于从HTML内容渲染PDF，这是IronPDF的一个关键功能。

  2. HTML 内容准备：

    • content变量是一个HTML字符串，将用于生成PDF。

    • 它包含一个<h1>标签，标题为“Demonstrate Autofac with IronPDF”。

  3. 设置Autofac容器：

    • 代码创建了一个名为builder的ContainerBuilder实例。

    • 这是为依赖注入设置 Autofac 容器的第一步。

  4. 手动注册类型：

    • 它将类型MyService注册为IMyService接口的实现。

    • 这使 Autofac 能够在需要时解决依赖性问题。

  5. 使用程序集扫描注册类型：

    • 它扫描包含AutoFac类型的程序集。

    • 将名称以 "Repository "结尾的类型注册为相应接口的实现。

  6. 注册模块：

    • 它注册了一个名为MyModule的模块。

    • 模块允许对相关注册进行分组。

  7. 构建容器：

    • 容器是使用builder.Build()方法从已注册的组件构建的。

  8. 解决依赖关系：

    • 在生命周期范围内（using (var scope = container.BeginLifetimeScope())），它解析出一个IMyService的实例。

    • 在解析的服务上调用 DoSomething 方法。

  9. PDF生成：

    • 使用ChromePdfRenderer从内容创建PDF。

    • 生成的 PDF 文件保存为 "autofac.pdf"。

输出

Autofac .NET 6（开发者指南）：图6 - 从前面的代码示例输出的PDF

IronPDF 许可证

IronPDF需要许可证密钥。 将许可证密钥放置在appSettings.json文件中，如下所示。

{
  "IronPdf.License.LicenseKey": "The Key Here"
}
Chipego
奇佩戈-卡琳达
  立即与工程团队聊天
软件工程师
Chipego 拥有出色的倾听技巧，这帮助他理解客户问题并提供智能解决方案。他在 2023 年加入 Iron Software 团队，此前他获得了信息技术学士学位。IronPDF 和 IronOCR 是 Chipego 主要专注的两个产品，但他对所有产品的了解每天都在增长，因为他不断找到支持客户的新方法。他喜欢 Iron Software 的合作氛围，公司各地的团队成员贡献他们丰富的经验，以提供有效的创新解决方案。当 Chipego 离开办公桌时，你经常可以发现他在看书或踢足球。
< 前一页
OpenTelemetry .NET（如何为开发者工作）
下一步 >
Papercut SMTP C# (开发者如何使用)

报告问题

准备开始了吗？ 版本： 2025.5 刚刚发布

免费开始
NuGet 下载 DLL 下载 Windows 安装程序 开始免费试用
查看许可证 >
Experience the full power of IronPDF 开始免费试用
Textlogo Iron Suite related to Autofac .NET 6（它是如何为开发人员工作的）

IronPDF 是 IRON 的一部分套装

10 个 .NET API 产品用于您的办公文档

以2个产品的价格获取10个产品   开始免费试用