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

Comprendre Autofac .NET

Autofac est un conteneur IoC open-source for .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 Iron Software, 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 conteneurs 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
       }
   }

   $vbLabelText   $csharpLabel

2. Exprimer les dépendances : Autofac peut injecter des paramètres de constructeur, gérer l'injection de propriétés et l'injection de méthode.

   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
       }
   }

   $vbLabelText   $csharpLabel

3. Système de module flexible : Les modules Autofac établissent un équilibre entre configuration XML et 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
       }
   }

   $vbLabelText   $csharpLabel

4. Points d'extension simples : Autofac fournit des événements d'activation pour personnaliser l'activation ou la libération de 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();

   $vbLabelText   $csharpLabel

Fonctionnalités Clés d'Autofac.NET

1. Enregistrement de composants flexible : Autofac permet aux développeurs d'enregistrer des composants en utilisant diverses techniques d'enregistrement, y compris l'enregistrement manuel, le balayage d'assemblage 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 du cycle de vie : Autofac prend en charge divers scopes de cycle de vie des objets, y compris singleton, instance par dépendance, instance par scope de cycle de vie, et instance par requête. Ce contrôle granulaire sur les cycles de vie des objets assure une utilisation efficace des ressources et évite les fuites de mémoire dans les applications de longue durée.

3. Résolution automatique des dépendances : Autofac résout automatiquement les dépendances en fonction des enregistrements de composants enregistrés et de 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 les 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 offre un support pour l'interception et la programmation orientée aspect (AOP) via 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 ASP.NET Core et .NET Core : Autofac s'intègre parfaitement avec .NET Core et ASP.NET Core, offrant 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();
        }
    }
}

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é.

Pour plus d'informations sur la façon dont les produits d'Iron Software peuvent s'intégrer à vos applications .NET pour rationaliser davantage et améliorer les fonctionnalités, explorez la documentation d'IronPDF où vous pouvez apprendre à générer et éditer des documents PDF par programmation, ou visitez le site Web de Iron Software pour découvrir une large gamme de bibliothèques .NET puissantes comme IronBarcode pour lire et écrire des codes-barres, et IronOCR pour la reconnaissance optique de caractères avancée.

Avantages de l'Utilisation d'Autofac.NET

1. Simplicité et flexibilité : Autofac propose une API simple et intuitive pour enregistrer et résoudre les composants, rendant l'injection de dépendances facile à implémenter et à maintenir.

2. Testabilité et maintenabilité : En promouvant le découplage et l'inversion de dépendance, Autofac améliore la testabilité et la maintenabilité des applications .NET, permettant des tests unitaires et des refactorings aisés.

3. Performance et évolutivité : Les performances légères et efficaces d'Autofac le rendent adapté aux applications à haute performance et aux systèmes évolutifs 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 via des modules personnalisés, des sources d'enregistrement et des composants middleware, répondant à diverses exigences applicatives.

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

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");
        }
    }
}

Licence 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"
}