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

Dans le domaine du développement .NET, la gestion efficace des dépendances est cruciale pour créer des applications évolutives, faciles à maintenir et à tester. Injection de dépendance (DI) les conteneurs jouent un rôle essentiel dans la réalisation de ces objectifs en facilitant l'inversion du contrôle (IoC) principe. Parmi la pléthore de bibliothèques de mécanismes d'hébergement génériques disponibles, Autofac se distingue comme un cadre riche en fonctionnalités et extensible pour .NET.

Dans cet article, nous allons partir à la découverte d'Autofac .NET 6, en décortiquant ses caractéristiques et ses avantages pour présenter des exemples pratiques de son utilisation. Dans la suite de cet article, nous découvrirons IronPDF, une bibliothèque de génération de PDF proposée par Iron Software. Nous présenterons également un cas d'utilisation où Autofac.NET et IronPDF sont utilisés conjointement.

Comprendre Autofac .NET

Autofac est un conteneur IoC open-source pour .NET qui offre une prise en charge complète de l'injection de dépendances et de l'enregistrement de composants dans des applications telles que 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 les durées de vie des objets, résoudre les dépendances et composer des composants d'application.

Caractéristiques d'Autofac

1. Construction de conteneurs et enregistrement de composants : Vous pouvez construire des conteneurs à l'aide d'Autofac en enregistrant des composants dans la classe de démarrage. Vous pouvez enregistrer des composants à l'aide de lambdas, de types ou d'instances préconstruites.

    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

2. Exprimer les dépendances : Autofac peut injecter des paramètres de construction, 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)
        {
            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

3. Système de modules flexibles : Les modules Autofac établissent un équilibre entre la configuration XML et les enregistrements basés sur des codes. Vous pouvez spécifier des enregistrements complexes dans le code ou modifier le comportement au moment du déploiement à l'aide de 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

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());
    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

Principales caractéristiques d'Autofac.NET

1. Enregistrement flexible des composants : Autofac permet aux développeurs d'enregistrer des composants à l'aide de diverses techniques d'enregistrement, notamment l'enregistrement manuel, le balayage d'assemblages et l'enregistrement basé sur les attributs. Cette flexibilité permet de contrôler finement l'instanciation et la configuration des composants.

2. Gestion de la durée de vie : Autofac prend en charge différentes durées de vie des objets, notamment le singleton, l'instance par dépendance, l'instance par durée de vie et l'instance par demande. Ce contrôle granulaire de la durée de vie des objets garantit une utilisation efficace des ressources et évite les fuites de mémoire dans les applications à long terme.

3. Résolution automatique des dépendances : Autofac résout automatiquement les dépendances sur la base des enregistrements de composants et de leurs dépendances. Ce câblage automatique simplifie la configuration de graphes d'objets complexes et favorise un couplage lâche entre les composants.

4. Composition de modules : Autofac permet aux développeurs d'organiser et d'encapsuler les enregistrements de composants à l'aide de modules. Les modules servent de conteneurs logiques pour les enregistrements connexes, ce qui facilite la gestion et la maintenance d'applications à grande échelle comportant plusieurs composants.

5. Interception et AOP : Autofac prend en charge l'interception et la programmation orientée aspect (AOP) par le biais de son extension d'interception. Grâce à 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 mise en œuvre.

6. Intégration d'ASP.NET Core et .NET Core : Autofac s'intègre de manière transparente à .NET Core et ASP.NET Core, offrant une prise en charge de premier ordre de l'injection de dépendances dans les applications web modernes et les microservices. Il tire parti de l'abstraction du fournisseur de services intégré pour garantir 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é la mise en œuvre pratique d'Autofac.NET pour l'injection de dépendances. De l'enregistrement manuel à la numérisation de l'assemblage 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 ainsi la maintenabilité et l'évolutivité.

Avantages de l'utilisation d'Autofac.NET

1. Simplicité et flexibilité : Autofac propose une API simple et intuitive pour l'enregistrement et la résolution des composants, ce qui facilite la mise en œuvre et la maintenance de l'injection de dépendances.

2. Testabilité et maintenabilité : En favorisant le couplage lâche et l'inversion des dépendances, Autofac améliore la testabilité et la maintenabilité des applications .NET, ce qui facilite les tests unitaires et le remaniement.

3. Performances et évolutivité : La légèreté et l'efficacité de l'exécution d'Autofac en font un outil adapté aux applications à haute performance et aux systèmes évolutifs comportant 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 par le biais de modules personnalisés, de sources d'enregistrement et de composants intergiciels, afin de répondre aux diverses exigences des applications.

5. Communauté et assistance : Avec une communauté active de développeurs et une documentation complète, Autofac fournit une excellente assistance et des ressources pour l'apprentissage, le dépannage et la contribution au cadre.

Licence Autofac

Autofac est livré avec une licence MIT qui est libre d'utilisation pour le développement et à des fins commerciales.

Présentation d'IronPDF d'Iron Software

IronPDF est une bibliothèque PDF C# robuste conçue pour fournir une solution complète de gestion des PDF 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 possède les outils dont vous avez besoin. Voici quelques-unes de ses caractéristiques et applications les plus remarquables :

Caractéristiques principales

• Conversion de HTML en PDF : Convertissez sans effort du contenu HTML en PDF. Générer des PDF à partir de HTML, MVC, ASPX et d'images.
• Gestion des PDF : Avec plus de 50 fonctionnalités, IronPDF vous permet de signer, d'éditer et d'extraire le contenu des PDF, facilitant ainsi les signatures et les modifications numériques.
• Prise en charge multiplateforme : Compatible avec C#, F# et VB.NET, IronPDF fonctionne sur différentes versions de .NET, notamment .NET Core, .NET Standard et .NET Framework. Il est également disponible pour Java, Node.js et Python.

Compatibilité et environnements

• Versions .NET : Prend en charge C#, VB.NET et F#.
• Types de projets : Convient pour le web (Blazor et WebForms), bureau (WPF ET MAUI)et les applications sur console.
• Environnements d'application : Compatible avec Windows, Linux, Mac, Docker, Azure, AWS, etc.
• IDEs : Intégration transparente avec Microsoft Visual Studio et JetBrains Rider.
• OS et processeurs : Fonctionne sous Windows, Mac et Linux (x64, x86, ARM).

Normes et édition PDF

• Compatibilité : Prise en charge de diverses versions de PDF (1.2 - 1.7)pDF/UA et PDF/A.
• Personnalisation : Définissez les propriétés, la sécurité et la compression des fichiers PDF.
• Métadonnées et structure : Modifier les métadonnées, l'historique des révisions et la structure du document.
• Modèles et paramètres : Appliquer des modèles de page, des en-têtes, des pieds de page et des paramètres de page.

Optimisation des performances

• Efficacité : Prise en charge complète du multithreading et de l'asynchronisme pour une génération PDF efficace.

• Priorité : L'accent est mis sur la précision, la facilité d'utilisation et la rapidité.

  Voyons maintenant un exemple pratique avec ces deux bibliothèques.

Générer un document PDF à l'aide d'Autofac.NET et IronPDF for .NET

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

Indiquer le nom et la localisation du projet.

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

Installez ensuite la bibliothèque IronPDF à partir de NuGet Package dans le Visual Studio Package Manager

Installer Autofac à partir d'un paquet NuGet dans le gestionnaire de paquets de Visual Studio

Exemple de code : Autofac et 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

Explication du code

Décortiquons l'extrait de code que vous avez fourni :

1. ChromePdfRenderer Setup :

   • Le code initialise une instance de ChromePdfRenderer pour le rendu des PDF.

2. Préparation du contenu HTML :

   • La variable content est une chaîne HTML qui sera utilisée pour générer le PDF.

   • Il comprend une balise <h1> dont le titre est "Demonstrate Autofac with IronPDF" (Démonstration d'Autofac avec IronPDF).

3. Mise en place du conteneur Autofac :

   • Le code crée une instance de ContainerBuilder nommée builder.

   • C'est la première étape de la mise en place d'un conteneur Autofac pour l'injection de dépendances.

4. Enregistrement manuel des types :

   • Il enregistre un type MyService en tant qu'implémentation de l'interface IMyService.

   • Cela permet à Autofac de résoudre les dépendances si nécessaire.

5. Enregistrement des types à l'aide de l'analyse d'assemblage :

   • Il analyse l'assemblage contenant le type AutoFac.

   • Enregistre les types dont les noms se terminent par "Repository" en tant qu'implémentations de leurs interfaces correspondantes.

6. Enregistrement des modules :

   • Il enregistre un module appelé MyModule.

   • Les modules permettent de regrouper des enregistrements connexes.

7. Construction du conteneur :

   • Le conteneur est construit à partir des composants enregistrés à l'aide de la fonction builder.Build() méthode.

8. Résoudre les dépendances :

   • À l'intérieur d'un champ d'application à vie (utilisation (var scope = container.BeginLifetimeScope()))il résout une instance de IMyService.

   • La méthode DoSomething est appelée sur le service résolu.

9. Génération de PDF :

   • Un PDF est créé à partir du contenu à l'aide de ChromePdfRenderer.

   • Le PDF résultant est enregistré sous le nom de "autofac.pdf".

Sortie

Licence d'IronPDF

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

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

Conclusion

En conclusion, Autofac.NET est un conteneur d'injection de dépendances robuste et riche en fonctionnalités pour .NET, qui permet aux développeurs de créer des applications modulaires, faciles à maintenir et extensibles. Que vous développiez des applications de bureau, des services web ou des solutions cloud-natives, Autofac offre une base fiable pour gérer les dépendances et promouvoir les meilleures pratiques en matière de développement .NET.

IronPDF est une bibliothèque polyvalente et riche en fonctionnalités qui permet de générer, d'éditer et de lire des documents PDF. Avec la bibliothèque IronPDF d'Iron Software, qui permet de lire et de générer des documents PDF, les développeurs peuvent acquérir des compétences avancées pour mettre au point des applications modernes.