L’injection de dépendances en   est une bouée de sauvetage lors de l’organisation des dépendances, en particulier dans les applications ASP.NET Core plus complexes. Et si vous êtes déjà   ou si vous souhaitez simplement vous en tenir le plus possible aux offres DI déjà fournies,   est une grande amélioration. C# familier avec IServiceCollection Scrutor en C#  Dans cet article, je vais vous fournir un aperçu de haut niveau de l'injection de dépendances et de Scrutor en C#. Mais à partir de là, nous passons directement à 3 conseils que vous pouvez utiliser avec Scrutor et qui pourraient s'avérer très utiles dans votre candidature !  Qu’est-ce que Scrutor en C# ?  Scrutor est un puissant package NuGet en C# qui améliore l'injection de dépendances. Il simplifie l'enregistrement et la résolution des dépendances, ce qui vous permet de gérer et d'organiser plus facilement votre code.  L'injection de dépendances est une approche populaire pour configurer des applications qui favorise le couplage lâche et améliore la testabilité et la maintenabilité. Cela implique d’injecter des dépendances dans une classe plutôt que de les créer directement au sein de la classe. Cela signifie que la responsabilité de créer la dépendance n'appartient pas à la classe qui la nécessite, mais plutôt à quelqu'un au niveau de la pile d'appels. Finalement, cela pousse presque toutes les créations de dépendances au point d'entrée d'une application, ce qui la rend lourde. Cependant, les frameworks d'injection de dépendances aident   . à nettoyer et à organiser toute cette logique  Scrutor va encore plus loin dans ce concept en fournissant un moyen simple et intuitif d'enregistrer et de résoudre les dépendances. Avec Scrutor, vous n'avez plus besoin d'enregistrer manuellement chaque dépendance une par une. Au lieu de cela, vous pouvez utiliser des conventions et des attributs pour automatiser le processus.  1 – Utilisation de Scrator pour l’enregistrement et la résolution  Pour illustrer comment utiliser Scrutor en C# pour l'enregistrement et la résolution, considérons un scénario simple. Imaginez que nous ayons une application qui nécessite l'utilisation de différents référentiels de données, tels que UserRepository et ProductRepostiory.  Tout d’abord, nous devons installer le package Scrutor NuGet dans notre projet. Ouvrez la console du gestionnaire de packages et exécutez la commande suivante :   Install-Package Scrutor  Ensuite, nous devons définir nos référentiels et leurs interfaces correspondantes. Cet exemple est essentiellement vide, mais nous y ferons référence dans un instant :   public interface IUserRepository { // Interface methods } public class UserRepository : IUserRepository { // Implementation } public interface IProductRepository { // Interface methods } public class ProductRepository : IProductRepository { // Implementation }  Maintenant, connectons nos dépendances à l'aide de Scrutor. Dans votre code de démarrage (comme dans la méthode ConfigureServices dans ASP.NET Core), ajoutez le code suivant :   services.Scan(scan => scan .FromAssemblyOf<Startup>() .AddClasses(classes => classes.AssignableToAny( typeof(IUserRepository), typeof(IProductRepository))) .AsImplementedInterfaces() .WithScopedLifetime());  Ce code utilise la méthode Scan de Scrutor pour analyser l'assembly qui contient la classe Startup. Il filtre ensuite les classes attribuables aux interfaces IUserRepository ou IProductRepository. Enfin, il cartographie les implémentations de ces interfaces et les enregistre auprès de leurs interfaces respectives.  Maintenant, nous pouvons injecter ces dépendances dans nos classes. Par exemple, disons que nous avons une classe UserService qui nécessite IUserRepository :   public class UserService { private readonly IUserRepository _userRepository; public UserService(IUserRepository userRepository) { _userRepository = userRepository; } // Rest of the class implementation }  En déclarant IUserRepository comme dépendance dans le constructeur, Scrutor avec IServiceCollection résoudra et injectera automatiquement l'instance UserRepository pour nous.  2 – Le modèle Décorateur – Exemple de journalisation des services  Imaginez que vous ayez une interface de service   et une implémentation   . Vous souhaitez enregistrer l'entrée et la sortie de chaque appel de méthode dans   sans polluer sa logique métier avec des problèmes de journalisation. IService MyService MyService  Tout d’abord, définissez l’interface   et son implémentation : IService   public interface IService { void DoWork(); } public class MyService : IService { public void DoWork() { // Business logic here } }  Ensuite, créez une classe de décorateur   qui implémente   . Cette classe encapsulera le service réel et ajoutera une journalisation autour des appels de méthode délégués : LoggingDecorator IService   public class LoggingDecorator : IService { private readonly IService _decorated; private readonly ILogger<LoggingDecorator> _logger; public LoggingDecorator(IService decorated, ILogger<LoggingDecorator> logger) { _decorated = decorated; _logger = logger; } public void DoWork() { _logger.LogInformation("Starting work."); _decorated.DoWork(); _logger.LogInformation("Finished work."); } }  Maintenant, utilisez Scrutor pour enregistrer votre service et son décorateur dans   ou partout où vous configurez vos services : Startup.cs   public void ConfigureServices(IServiceCollection services) { // Register the base service services.AddScoped<IService, MyService>(); // Use Scrutor to apply the decorator services.Decorate<IService, LoggingDecorator>(); // Make sure to register the ILogger or ILogger<T> dependencies if not already done }  Cette configuration utilise Scrutor pour envelopper l'enregistrement   avec   . Lors de la résolution   , le conteneur DI fournira une instance de   , qui à son tour encapsule une instance de   . Cette approche permet de séparer les préoccupations en gardant la logique de journalisation en dehors de votre logique métier. IService LoggingDecorator IService LoggingDecorator MyService  3 – Basculement de fonctionnalité pour les implémentations de services  Lorsque nous construisons des systèmes complexes, il arrive souvent que nous souhaitions introduire quelque chose comme des indicateurs de fonctionnalités. Ceux-ci nous permettent d'emprunter différents chemins de code en fonction de la configuration et de ne pas avoir à recompiler et déployer une application entière. Dans certaines situations, il ne s'agit pas seulement de choisir un chemin de code différent, il s'agit d'échanger une implémentation entière de quelque chose !  Essayons ensemble un exemple ! Supposons que vous disposez d’une interface   avec plusieurs implémentations :   (une nouvelle fonctionnalité expérimentale) et   (la fonctionnalité actuelle et stable). Vous souhaitez basculer entre ces implémentations au moment de l'exécution en fonction d'un indicateur de configuration. IFeatureService NewFeatureService StandardFeatureService  Tout d’abord, définissez l’interface   et ses implémentations : IFeatureService   public interface IFeatureService { void ExecuteFeature(); } public class NewFeatureService : IFeatureService { public void ExecuteFeature() { // New feature logic } } public class StandardFeatureService : IFeatureService { public void ExecuteFeature() { // Standard feature logic } }  Ensuite, vous avez besoin d'un moyen de déterminer quelle implémentation utiliser en fonction d'un paramètre de basculement de fonctionnalité. Il peut s'agir d'une valeur dans   , d'un paramètre de base de données ou de toute autre source de configuration. appsettings.json  Maintenant, utilisez Scrutor pour enregistrer dynamiquement l'implémentation de service appropriée en fonction de la bascule de fonctionnalité :   public void ConfigureServices(IServiceCollection services) { // Assume GetFeatureToggleValue() retrieves the current feature toggle setting var useNewFeature = GetFeatureToggleValue("UseNewFeature"); // Dynamically register the appropriate implementation based on the feature toggle if (useNewFeature) { services.AddScoped<IFeatureService, NewFeatureService>(); } else { services.AddScoped<IFeatureService, StandardFeatureService>(); } // Optional: You could combine this with the previous example // to use the decorator pattern too! // services.Decorate<IFeatureService, FeatureServiceProxy>(); } private bool GetFeatureToggleValue(string featureName) { // This method would typically check your // configuration source to determine if the feature is enabled // For simplicity, this is just a placeholder return false; // or true based on actual configuration }  Adopter une approche comme celle-ci peut nous aider à :    : permet à l'application de basculer entre les implémentations de fonctionnalités sans avoir besoin de redéployer. Vous pouvez activer ou désactiver des fonctionnalités avec une simple modification de configuration. Flexibilité    : vous pouvez tester de nouvelles fonctionnalités dans un environnement de production avec un ensemble limité d'utilisateurs en activant la fonctionnalité pour ces utilisateurs. Tests en production    : aide au déploiement progressif des fonctionnalités pour surveiller l'impact et assurer la stabilité avant une version plus large. Déploiements progressifs    : revenez rapidement à l'ancienne implémentation si des problèmes surviennent avec la nouvelle fonctionnalité, minimisant ainsi les temps d'arrêt et l'impact sur les utilisateurs. Atténuation des risques  Conclusion de Scrutor en C#  Dans cet article, je vous ai fourni 3 conseils simples pour l'injection de dépendances avec Scrutor en C#. Après un bref aperçu de ce qu'est l'injection de dépendances et de la manière dont Scrutor s'y intègre, nous sommes passés directement à nos exemples. Nous avons pu voir l'analyse des assemblys, comment décorer les dépendances et même comment envisager de signaler des fonctionnalités d'implémentations entières !  L'injection de dépendances est quelque chose qui peut grandement simplifier vos applications à mesure qu'elles deviennent de plus en plus complexes, et Scrutor peut être d'une grande aide si vous souhaitez vous en tenir à l'   . Si vous avez trouvé cela utile et que vous recherchez davantage d'opportunités d'apprentissage, pensez à   et regardez mes   ! Rejoignez moi et les   ! offre IServiceCollection intégrée de Microsoft vous abonner à ma newsletter hebdomadaire gratuite sur le génie logiciel vidéos gratuites sur YouTube autres membres de la communauté sur Discord  Également publié  ici.

Walkthroughs, tutorials, guides, and tips. This story will teach you how to do something new or how to do something better.

Newsletter

Portfolio

Cet audio est produit dans la langue originale de l'histoire !

Trop long; Pour lire

Make resilience your competitive advantage

3 conseils simples pour l'injection de dépendances à l'aide de Scrutor en C#

About Author

COMMENTAIRES

ÉTIQUETTES

CET ARTICLE A ÉTÉ PARU DANS

Related Stories

HackerNoon Decoded: The Top 10 Countries Where HackerNoon Is the Most Active

Croissance des crypto-monnaies : créer des profils d'utilisateurs efficaces

Naviguer sur les eaux : développer des applications RAG de qualité production avec des lacs de données

Les couches invisibles : pourquoi les entretiens avec les utilisateurs sont un atout irremplaçable

HackerNoon Decoded: The Top 10 Countries Where HackerNoon Is the Most Active

Croissance des crypto-monnaies : créer des profils d'utilisateurs efficaces

Naviguer sur les eaux : développer des applications RAG de qualité production avec des lacs de données

Les couches invisibles : pourquoi les entretiens avec les utilisateurs sont un atout irremplaçable

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps