.NET 帮助

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

雷根·彭

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 库该译文将重点介绍.NET、Java、Python 或 Node.js 的高级功能。您还可以深入研究IronBarcode 的 .NET 条码库以了解依赖注入在 BarCode 生成中的实际应用。

请访问以下网站，了解在现实世界中使用 Autofac 的更多见解和实际案例IronSoftware 官方网页如果您想了解更多关于 IronOcr for .NET 的信息，请访问我们的网站：IronOcr for .NET ，在这里您可以找到 IronOCR 和 IronXL 等全面的产品套件，它们可与 Autofac 无缝集成，并增强您的 .NET 开发流程。

Autofac 的功能

容器构建和组件注册：通过在启动类中注册组件，您可以使用 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

表达依赖关系：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

灵活的模块系统：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

简单扩展点：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

Autofac.NET 的主要功能

灵活的组件注册：Autofac 允许开发人员使用多种注册技术注册组件，包括手动注册、程序集扫描和基于属性的注册。这种灵活性可实现对组件实例化和配置的细粒度控制。
生命周期管理：Autofac 支持各种对象生命周期范围，包括单例、每个依赖的实例、每个生命周期范围的实例以及每个请求的实例。这种对对象生命周期的细粒度控制可确保资源的有效利用，并防止长期运行的应用程序出现内存泄露。
自动解决依赖关系：Autofac 可根据已注册的组件注册及其依赖关系自动解析依赖关系。这种自动布线简化了复杂对象图的配置，促进了组件之间的松散耦合。
模块组成：Autofac 允许开发人员使用模块组织和封装组件注册。模块可作为相关注册表的逻辑容器，使管理和维护包含多个组件的大型应用程序变得更加容易。
拦截和 AOP：Autofac 支持拦截和面向方面的编程(AOP)通过其拦截扩展。有了拦截功能，开发人员可以将日志、缓存和安全等跨领域问题应用到组件中，而无需修改其实现。
ASP.NET Core 和 .NET Core 集成：Autofac 与 .NET Core 和 ASP.NET Core 无缝集成，为现代网络应用程序和微服务中的依赖注入提供一流的支持。它利用内置的服务提供商抽象来确保与 .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

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

有关 Iron Software 的产品如何与您的 .NET 应用程序集成以进一步简化和增强功能的更多信息，请浏览IronPDF 文档如需了解如何以编程方式生成和编辑 PDF 文档，请访问我们的网站Iron Software 的网站您将发现各种功能强大的 .NET 库，如用于读写条形码的 IronBarcode 和用于高级光学字符识别的 IronOCR。

使用 Autofac.NET 的好处

简单灵活：Autofac 为注册和解析组件提供了简单直观的应用程序接口（API），使依赖注入易于实施和维护。
可测试性和可维护性：通过促进松散耦合和依赖反转，Autofac 增强了 .NET 应用程序的可测试性和可维护性，使单元测试和重构变得更加容易。
性能和可扩展性：Autofac 的轻量级和高效运行性能使其适用于高性能应用程序和具有大型对象图的可扩展系统。
可扩展性和定制：Autofac 的可扩展架构允许开发人员通过自定义模块、注册源和中间件组件扩展和定制 Autofac 的行为，以满足不同的应用需求。
社区和支持：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 管理：IronPdf 具有 50 多种功能，可让您对 PDF 进行签名、编辑和提取内容，使数字签名和修改变得简单。
跨平台支持：IronPDF 兼容 C#、F# 和 VB.NET，可在各种 .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 与 IronPDF)桌面(WPF 和 MAUI)和控制台应用程序。
应用环境：兼容 Windows、Linux、Mac、Docker、Azure、AWS 等。
设计：无缝集成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

代码解释

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

ChromePdfRenderer 设置：
- 代码初始化一个 ChromePdfRenderer 实例，用于从 HTML 内容渲染 PDF，这是IronPDF.
HTML 内容准备：
- 内容 "变量是用于生成 PDF 的 HTML 字符串。
- 其中包括一个标题为 "使用 IronPDF 演示 Autofac "的 <h1> 标签。
设置 Autofac 容器：
- 代码会创建一个名为 builder 的 ContainerBuilder 实例。
- 这是为依赖注入设置 Autofac 容器的第一步。
手动注册类型：
- 它将类型 MyService 注册为 IMyService 接口的实现。
- 这使 Autofac 能够在需要时解决依赖性问题。
使用程序集扫描注册类型：
- 它扫描了包含 AutoFac 类型的程序集。
- 将名称以 "Repository "结尾的类型注册为相应接口的实现。
注册模块：
- 它注册了一个名为 "MyModule "的模块。
- 模块允许对相关注册进行分组。
构建容器：
- 容器是通过使用 `builder.Build()方法。
解决依赖关系：
- 终生范围内(使用(var scope = container.BeginLifetimeScope())`)在".NET "中，它解析了一个 "IMyService "实例。
- 在已解析的服务上调用 DoSomething 方法。
PDF 生成：
- 使用 ChromePdfRenderer 从内容中创建 PDF。
- 生成的 PDF 文件保存为 "autofac.pdf"。

输出

Autofac .NET 6（如何为开发人员工作）：图 6 - 上一代码示例的 PDF 输出结果

IronPDF 许可证

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

{
  "IronPdf.License.LicenseKey": "The Key Here"
}

雷根·彭

立即与工程团队聊天

软件工程师

Regan毕业于雷丁大学，拥有电子工程学士学位。在加入Iron Software之前，他的前工作职位要求他专注于单一任务；他在Iron Software最喜欢的是能进行多种工作，无论是增加销售价值、技术支持、产品开发还是营销。他喜欢了解开发人员如何使用Iron Software的库，并利用这些知识不断改进文档和开发产品。

< 前一页
OpenTelemetry .NET（如何为开发者工作）

下一步 >
Papercut SMTP C# (开发者如何使用)