Autofac .NET 6 (Comment ça fonctionne pour les développeurs)

Comprendre Autofac .NET

Autofac est un conteneur IoC open-source pour .NET qui fournit un support complet pour l'injection de dépendances et l'enregistrement des composants dans les applications comme les API web. Développé par Nicholas Blumhardt et maintenu par une communauté dévouée, Autofac offre une solution robuste et flexible pour gérer la durée de vie des objets, résoudre les dépendances, et composer les composants des applications.

Pour plus d'informations sur comment Autofac améliore vos applications .NET, envisagez d'explorer les ressources fournies par la bibliothèque PDF .NET d'IronPDF, qui met en avant des fonctionnalités avancées pour la génération et la manipulation de PDF. Vous pouvez également vous plonger dans la bibliothèque de code-barres .NET d'IronBarcode pour voir des applications pratiques de l'injection de dépendances dans la génération de code-barres.

Engagez-vous avec des perspectives supplémentaires et des exemples pratiques en utilisant Autofac dans des scénarios réels en visitant la page officielle de IronSoftware, où vous trouverez une suite complète de produits comme IronOCR et IronXL qui s'intègrent parfaitement avec Autofac et améliorent votre processus de développement .NET.

Caractéristiques d'Autofac

1. Construction de Conteneur et Enregistrement de Composants : Vous pouvez construire des conteneurs en utilisant Autofac en enregistrant des composants dans la classe de démarrage. Vous pouvez enregistrer des composants en utilisant des lambdas, des types, ou des instances pré-construites.

   public class Startup
   {
       public void ConfigureContainer()
       {
           var builder = new ContainerBuilder(); // Create a new container builder
           builder.RegisterInstance(new TaskRepository()).As<ITaskRepository>(); // Register an instance for ITaskRepository
           builder.RegisterType<TaskController>(); // Register TaskController type
           builder.Register(c => new LogManager(DateTime.Now)).As<ILogger>(); // Use lambda expression to register ILogger
           // Scan an assembly for components and register them
           builder.RegisterAssemblyTypes(myAssembly).Where(t => t.Name.EndsWith("Repository")).AsImplementedInterfaces();
           var container = builder.Build(); // Build the container
       }
   }

   public class Startup
   {
       public void ConfigureContainer()
       {
           var builder = new ContainerBuilder(); // Create a new container builder
           builder.RegisterInstance(new TaskRepository()).As<ITaskRepository>(); // Register an instance for ITaskRepository
           builder.RegisterType<TaskController>(); // Register TaskController type
           builder.Register(c => new LogManager(DateTime.Now)).As<ILogger>(); // Use lambda expression to register ILogger
           // Scan an assembly for components and register them
           builder.RegisterAssemblyTypes(myAssembly).Where(t => t.Name.EndsWith("Repository")).AsImplementedInterfaces();
           var container = builder.Build(); // Build the container
       }
   }

   Public Class Startup
   	Public Sub ConfigureContainer()
   		Dim builder = New ContainerBuilder() ' Create a new container builder
   		builder.RegisterInstance(New TaskRepository()).As(Of ITaskRepository)() ' Register an instance for ITaskRepository
   		builder.RegisterType(Of TaskController)() ' Register TaskController type
   		builder.Register(Function(c) New LogManager(DateTime.Now)).As(Of ILogger)() ' Use lambda expression to register ILogger
   		' Scan an assembly for components and register them
   		builder.RegisterAssemblyTypes(myAssembly).Where(Function(t) t.Name.EndsWith("Repository")).AsImplementedInterfaces()
   		Dim container = builder.Build() ' Build the container
   	End Sub
   End Class

   $vbLabelText   $csharpLabel

2. Expressions des Dépendances : Autofac peut injecter des paramètres de constructeur, gérer l'injection de propriétés, et l'injection de méthodes.

   public class TaskController
   {
       private ITaskRepository _repository;
       private ILogger _logger;
   
       public TaskController(ITaskRepository repository, ILogger logger)
       {
           _repository = repository; // Assign injected repository to the local variable
           _logger = logger; // Assign injected logger to the local variable
       }
   }

   public class TaskController
   {
       private ITaskRepository _repository;
       private ILogger _logger;
   
       public TaskController(ITaskRepository repository, ILogger logger)
       {
           _repository = repository; // Assign injected repository to the local variable
           _logger = logger; // Assign injected logger to the local variable
       }
   }

   Public Class TaskController
   	Private _repository As ITaskRepository
   	Private _logger As ILogger
   
   	Public Sub New(ByVal repository As ITaskRepository, ByVal logger As ILogger)
   		_repository = repository ' Assign injected repository to the local variable
   		_logger = logger ' Assign injected logger to the local variable
   	End Sub
   End Class

   $vbLabelText   $csharpLabel

3. Système de Module Flexible : Les modules d'Autofac trouvent un équilibre entre la configuration XML et les enregistrements basés sur le code. Vous pouvez spécifier des enregistrements complexes dans le code ou modifier le comportement au moment du déploiement en utilisant XML.

   public class CarTransportModule : Module
   {
       public bool ObeySpeedLimit { get; set; }
   
       protected override void Load(ContainerBuilder builder)
       {
           builder.RegisterType<Car>().As<IVehicle>(); // Register Car as IVehicle
           if (ObeySpeedLimit)
               builder.RegisterType<SaneDriver>().As<IDriver>(); // Register SaneDriver if speed limit is to be obeyed
           else
               builder.RegisterType<CrazyDriver>().As<IDriver>(); // Register CrazyDriver otherwise
       }
   }

   public class CarTransportModule : Module
   {
       public bool ObeySpeedLimit { get; set; }
   
       protected override void Load(ContainerBuilder builder)
       {
           builder.RegisterType<Car>().As<IVehicle>(); // Register Car as IVehicle
           if (ObeySpeedLimit)
               builder.RegisterType<SaneDriver>().As<IDriver>(); // Register SaneDriver if speed limit is to be obeyed
           else
               builder.RegisterType<CrazyDriver>().As<IDriver>(); // Register CrazyDriver otherwise
       }
   }

   Public Class CarTransportModule
   	Inherits Module
   
   	Public Property ObeySpeedLimit() As Boolean
   
   	Protected Overrides Sub Load(ByVal builder As ContainerBuilder)
   		builder.RegisterType(Of Car)().As(Of IVehicle)() ' Register Car as IVehicle
   		If ObeySpeedLimit Then
   			builder.RegisterType(Of SaneDriver)().As(Of IDriver)() ' Register SaneDriver if speed limit is to be obeyed
   		Else
   			builder.RegisterType(Of CrazyDriver)().As(Of IDriver)() ' Register CrazyDriver otherwise
   		End If
   	End Sub
   End Class

   $vbLabelText   $csharpLabel

4. Points d'Extension Simples : Autofac fournit des événements d'activation pour personnaliser l'activation ou la libération des composants.

   var builder = new ContainerBuilder();
   builder.RegisterType<Listener>().As<IListener>().OnActivated(e => e.Instance.StartListening()); // Setup activation event
   builder.RegisterType<Processor>().OnActivating(e => e.Instance.Initialize()); // Setup activating event
   var container = builder.Build();

   var builder = new ContainerBuilder();
   builder.RegisterType<Listener>().As<IListener>().OnActivated(e => e.Instance.StartListening()); // Setup activation event
   builder.RegisterType<Processor>().OnActivating(e => e.Instance.Initialize()); // Setup activating event
   var container = builder.Build();

   Dim builder = New ContainerBuilder()
   builder.RegisterType(Of Listener)().As(Of IListener)().OnActivated(Function(e) e.Instance.StartListening()) ' Setup activation event
   builder.RegisterType(Of Processor)().OnActivating(Function(e) e.Instance.Initialize()) ' Setup activating event
   Dim container = builder.Build()

   $vbLabelText   $csharpLabel

Fonctionnalités Clés d'Autofac.NET

1. Enregistrement de Composant Flexible : Autofac permet aux développeurs d'enregistrer des composants en utilisant une variété de techniques d'enregistrement, y compris l'enregistrement manuel, la numérisation d'assemblée, et l'enregistrement basé sur les attributs. Cette flexibilité permet un contrôle précis sur l'instanciation et la configuration des composants.

2. Gestion de Durée de Vie : Autofac prend en charge divers portées de durée de vie des objets, y compris le singleton, l'instance par dépendance, l'instance par portée de durée de vie, et l'instance par requête. Ce contrôle granulaire sur les durées de vie des objets assure une utilisation efficace des ressources et prévient les fuites de mémoire dans les applications à long terme.

3. Résolution Automatique des Dépendances : Autofac résout automatiquement les dépendances basées sur les enregistrements de composants enregistrés et leurs dépendances. Cette interconnexion automatique simplifie la configuration des graphes d'objets complexes et promeut le couplage lâche entre les composants.

4. Composition de Module : Autofac permet aux développeurs d'organiser et d'encapsuler des enregistrements de composants en utilisant des modules. Les modules servent de conteneurs logiques pour les enregistrements associés, rendant plus facile la gestion et la maintenance d'applications à grande échelle avec plusieurs composants.

5. Interception et AOP : Autofac fournit un support pour l'interception et la programmation orientée aspect (AOP) à travers son extension d'interception. Avec l'interception, les développeurs peuvent appliquer des préoccupations transversales telles que la journalisation, la mise en cache, et la sécurité aux composants sans modifier leur implémentation.

6. Intégration avec ASP.NET Core et .NET Core : Autofac s'intègre parfaitement avec .NET Core et ASP.NET Core, fournissant un support de première classe pour l'injection de dépendances dans les applications web modernes et les microservices. Il exploite l'abstraction du fournisseur de services intégré pour assurer la compatibilité et l'interopérabilité avec l'écosystème .NET.

Exemples Pratiques avec Autofac.NET

Explorons quelques exemples pratiques pour illustrer l'utilisation d'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

Dans cette section, nous avons démontré l'implémentation pratique d'Autofac.NET pour l'injection de dépendances. Depuis l'enregistrement manuel jusqu'à la numérisation d'assemblée et l'enregistrement basé sur les modules, nous avons montré la flexibilité qu'offre Autofac dans la gestion des dépendances. En utilisant ces techniques, les développeurs peuvent rationaliser le processus d'injection de dépendances de leur application, améliorant sa maintenabilité et sa scalabilité.

For more information on how Iron Software's products can integrate with your .NET applications to further streamline and enhance functionality, explore the IronPDF documentation where you can learn how to generate and edit PDF documents programmatically, or visit Iron Software's website to discover a wide range of powerful .NET libraries like IronBarcode for reading and writing barcodes, and IronOCR for advanced optical character recognition.

Avantages de l'Utilisation d'Autofac.NET

1. Simplicité et Flexibilité : Autofac offre une API simple et intuitive pour enregistrer et résoudre des composants, rendant l'injection de dépendances facile à mettre en œuvre et à maintenir.

2. Testabilité et Maintenabilité : En promouvant le couplage lâche et l'inversion de dépendances, Autofac améliore la testabilité et la maintenabilité des applications .NET, permettant le test unitaire et le refactoring avec facilité.

3. Performance et Scalabilité : La performance d'exécution légère et efficace d'Autofac le rend adapté aux applications à haute performance et aux systèmes scalables avec de grands graphes d'objets.

4. Extensibilité et Personnalisation : L'architecture extensible d'Autofac permet aux développeurs d'étendre et de personnaliser le comportement d'Autofac à travers des modules personnalisés, des sources d'enregistrement, et des composants de middleware, répondant à des exigences d'application diversifiées.

5. Communauté et Support : Avec une communauté active de développeurs et une documentation complète, Autofac fournit un excellent support et des ressources pour apprendre, résoudre des problèmes, et contribuer au cadre.

Présentation d'IronPDF de Iron Software

IronPDF est une bibliothèque PDF C# robuste conçue pour fournir une solution complète pour gérer les PDFs dans les projets .NET. Que vos besoins concernent la création, l'édition, l'exportation, la sécurisation, le chargement, ou la manipulation de documents PDF, IronPDF dispose des outils dont vous avez besoin. Voici certaines de ses fonctionnalités et applications remarquables :

• En savoir plus sur la création de PDFs avec IronPDF
• Découvrez comment éditer des PDFs efficacement avec IronPDF
• Explorez les fonctionnalités de sécurité d'IronPDF
• Visitez le site Web de Iron Software pour plus de détails
• Consultez la documentation IronPDF pour un guide détaillé

Générer un Document PDF en Utilisant Autofac.NET et IronPDF

Tout d'abord, créons une application console Visual Studio

Fournissez le nom et l'emplacement du projet.

Pour l'étape suivante, sélectionnez la version .NET requise et cliquez sur Créer.

Ensuite, installez la bibliothèque IronPDF depuis NuGet Package à partir de Visual Studio Package Manager

Visitez la documentation d'IronPDF pour plus d'informations sur l'installation et l'utilisation de la bibliothèque IronPDF.

Installez Autofac depuis NuGet Package à partir de Visual Studio Package Manager

En savoir plus sur Autofac en visitant la page de documentation d'Autofac.

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

Licence IronPDF

IronPDF nécessite une clé de licence. Placez la clé de licence dans le fichier appSettings.json comme montré ci-dessous.

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