.NET ヘルプ

Autofac .NET 6（開発者向けの動作方法）

Name: IronPDF
Brand: Iron Software
Availability: InStock
Rating: 4.87 (307 reviews)

チペゴ・カリンダ

2024年7月1日

共有:

.NET開発の分野では、依存関係を効率的に管理することが、スケーラブルで保守可能、かつテストしやすいアプリケーションを構築する上で非常に重要です。依存性注入（DI）コンテナは、制御の反転（IoC）原則を促進することによって、これらの目標を達成する上で重要な役割を果たします。多数の一般的なホスティングメカニズムライブラリが利用可能である中で、Autofacは.NETのための機能豊富で拡張可能なフレームワークとして際立っています。

この記事では、Autofac .NET 6を探求する旅に出かけ、その特徴と利点を解き明かしながら、実際の使用例を紹介します。この記事の後半では、Iron Softwareの強力なPDF生成ライブラリであるIronPDFについて学びます。 Autofac.NETとIronPDFを一緒に使用するユースケースも紹介します。

Autofac .NETを理解する

Autofacは、.NET向けのオープンソースのIoCコンテナで、ウェブAPIのようなアプリにおける依存関係注入とコンポーネント登録の包括的なサポートを提供します。Nicholas Blumhardtによって開発され、献身的なコミュニティによって維持されているAutofacは、オブジェクトのライフタイムを管理し、依存関係を解決し、アプリケーションコンポーネントを構築するための堅牢かつ柔軟なソリューションを提供します。

Autofacが.NETアプリケーションをどのように強化するかについての詳細な情報は、PDF生成と操作における高度な機能を強調するIronPDFの.NET PDFライブラリが提供するリソースを探索することを検討してください。また、IronBarcodeの.NETバーコードライブラリを調べて、バーコード生成における依存性注入の実用的な応用を見ることもできます。

現実のシナリオでAutofacを使用する追加の洞察と実用的な例に触れるには、IronSoftwareの公式ページを訪問してください。そこではAutofacとシームレスに統合し、.NETの開発プロセスを強化するIronOCRやIronXLのような包括的な製品スイートを見つけることができます。

Autofacの特徴

コンテナの構築とコンポーネントの登録：スタートアップクラスでコンポーネントを登録することにより、Autofacを使用してコンテナを構築できます。コンポーネントは、ラムダ、型、または事前構築されたインスタンスを使用して登録できます。

    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

依存関係の表現: 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

柔軟なモジュールシステム：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

シンプルな拡張ポイント: 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 の主な機能

柔軟なコンポーネント登録: 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

$vbLabelText $csharpLabel

このセクションでは、依存性注入のためのAutofac.NETの実用的な実装を示しました。手動登録からアセンブリスキャンおよびモジュールベースの登録に至るまで、Autofac が依存関係の管理に提供する柔軟性を示しました。これらの技術を活用することで、開発者はアプリケーションの依存性注入プロセスを効率化し、保守性とスケーラビリティを向上させることができます。

Iron Softwareの製品がどのようにして.NETアプリケーションと統合し、機能をさらに合理化および強化できるかについての詳細は、IronPDF ドキュメントを参照してください。ここでは、PDFドキュメントをプログラムで生成および編集する方法を学ぶことができます。また、Iron Softwareのウェブサイトを訪れて、バーコードの読み取りと書き込みのためのIronBarcodeや、高度な光学文字認識のためのIronOCRのような強力な.NETライブラリの幅広い選択肢を発見してください。

Autofac.NETの使用のメリット

シンプルさと柔軟性: Autofacは、コンポーネントの登録と解決のためのシンプルで直感的なAPIを提供し、依存性の注入を簡単に実装および維持できるようにします。
テスタビリティとメンテナビリティ: Autofacは、疎結合と依存関係の逆転を促進することにより、.NETアプリケーションのテスタビリティとメンテナビリティを向上させ、ユニットテストやリファクタリングを容易にします。
パフォーマンスとスケーラビリティ: Autofacの軽量で効率的なランタイムパフォーマンスは、高性能アプリケーションや大規模なオブジェクトグラフを持つスケーラブルなシステムに適しています。
拡張性とカスタマイズ: Autofac の拡張可能なアーキテクチャにより、開発者はカスタムモジュール、登録ソース、およびミドルウェアコンポーネントを使用して Autofac の動作を拡張およびカスタマイズでき、さまざまなアプリケーション要件に対応します。
コミュニティとサポート: 開発者の活発なコミュニティと包括的なドキュメントにより、Autofacはフレームワークの学習、トラブルシューティング、および貢献に対する優れたサポートとリソースを提供します。

Autofac ライセンス

Autofacは、開発および商業目的で無料で使用できるMITライセンスが付属しています。

Iron SoftwareからのIronPDFをご紹介します。

Autofac .NET 6 (開発者向けの仕組み): 図1 - IronPDFウェブページ

IronPDFは、.NETプロジェクトでPDFを管理するための包括的なソリューションを提供するように設計された堅牢なC# PDFライブラリです。 PDFドキュメントの作成、編集、エクスポート、セキュリティ、ロード、または操作が必要な場合でも、IronPDFには必要なツールが揃っています。以下はその際立った機能と応用例です：

主な機能

HTMLからPDFへの変換: HTMLコンテンツを簡単にPDFに変換します。 HTML、MVC、ASPX、および画像からPDFを生成。
PDF管理: IronPDFは50以上の機能を備えており、PDFに署名、編集、コンテンツの抽出が可能です。これにより、デジタル署名や修正が簡単になります。
クロスプラットフォームサポート: C#、F#、VB.NETと互換性があり、IronPDFは.NET Core、.NET Standard、.NET Frameworkを含むさまざまな.NETバージョンで動作します。それはJava、Node.js、およびPythonでも利用可能です。

IronPDFがどのようにしてあなたのプロジェクトにPDF機能を統合できるかを知るためには、IronPDF製品ページをご覧ください。

IronBarcode、IronOCRなどを含むIron Softwareの製品概要については、Iron Softwareホームページをご覧ください。

互換性と環境

.NETバージョン: C#、VB.NET、およびF#をサポートします。
プロジェクトタイプ: Web(Blazor & WebForms with IronPDF)、デスクトップ(WPF & MAUI)、コンソールアプリケーションに適しています。
アプリ環境: Windows、Linux、Mac、Docker、Azure、AWSなどに対応。
IDEs: Microsoft Visual Studio および JetBrains Rider とシームレスに統合されます。
OS & プロセッサ: Windows、Mac、Linux (x64、x86、ARM)で動作します。

PDFの標準と編集

互換性: さまざまなPDFバージョン（1.2 - 1.7）、PDF/UA、およびPDF/Aをサポートしています。
カスタマイズ: PDFファイルのプロパティ、セキュリティ、および圧縮を設定します。
メタデータと構造：メタデータ、改訂履歴、文書構造を編集します。
テンプレートと設定: ページテンプレート、ヘッダー、フッター、およびページ設定を適用します。

これらの機能の詳細および実装方法については、IronPDFの公式サイトにある詳細なPDF生成と操作ガイドをご覧ください。

パフォーマンス最適化

効率: 効率的なPDF生成のための完全なマルチスレッドと非同期サポート。
優先事項: 正確さ、使いやすさ、速度に焦点を当てています。

では、これらの2つのライブラリを使用した実際の例を見てみましょう。

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

コードの説明

では、提供していただいたコードスニペットを分解してみましょう。

ChromePdfRenderer セットアップ:
- このコードは、HTMLコンテンツからPDFをレンダリングするためのChromePdfRendererインスタンスを初期化します。これはIronPDFの重要な機能です。
HTMLコンテンツの準備：
- content 変数は、PDF を生成するために使用される HTML 文字列です。
- それには、「IronPDFでAutofacを実演する」というタイトルの<h1>タグが含まれています。
Autofacコンテナの設定：
- そのコードはContainerBuilderのインスタンスをbuilderという名前で生成します。
- これは依存性注入のためにAutofacコンテナを設定する最初のステップです。
タイプを手動で登録する：
- これは、MyService 型を IMyService インターフェースの実装として登録します。
- これにより、Autofacは必要に応じて依存関係を解決することができます。
アセンブリスキャンを使用したタイプの登録
- それは、AutoFac型を含むアセンブリをスキャンします。
- "Repository"で終わる名前を持つ型を、それに対応するインターフェースの実装として登録します。
モジュールの登録:
- モジュールMyModuleを登録します。
- モジュールは関連する登録をグループ化することを可能にします。
コンテナの構築：
- コンテナは、builder.Build() メソッドを使用して登録されたコンポーネントから構築されます。
依存関係の解決:
- ライフタイムスコープ内 (using (var scope = container.BeginLifetimeScope())) で、IMyService のインスタンスを解決します。
- 解決されたサービスでDoSomethingメソッドが呼び出されます。
PDF生成：
- コンテンツから ChromePdfRenderer を使用してPDFが作成されます。
- 結果として生成されたPDFは「autofac.pdf」として保存されます。

出力

Autofac .NET 6（開発者向け：動作の仕組み）: 図6 - 前のコード例から出力されたPDF

IronPDFライセンス

IronPDFにはライセンスキーが必要です。 appSettings.jsonファイルにライセンスキーを以下のように配置してください。

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

チペゴ・カリンダ

今すぐエンジニアリングチームとチャット

ソフトウェアエンジニア

チペゴは優れた傾聴能力を持ち、それが顧客の問題を理解し、賢明な解決策を提供する助けとなっています。彼は情報技術の学士号を取得後、2023年にIron Softwareチームに加わりました。現在、彼はIronPDFとIronOCRの2つの製品に注力していますが、顧客をサポートする新しい方法を見つけるにつれて、他の製品に関する知識も日々成長しています。Iron Softwareでの協力的な生活を楽しんでおり、さまざまな経験を持つチームメンバーが集まり、効果的で革新的な解決策を提供することに貢献しています。チペゴがデスクを離れているときは、良い本を楽しんだり、サッカーをしていることが多いです。

< 以前
OpenTelemetry .NET（開発者向けの仕組み）

次へ >
Papercut SMTP C#（開発者向けの動作方法）