L'injection de dépendance (DI) en C # est un modèle de conception qui améliore la modularité, la testabilité et la maintenabilité en permettant aux classes de recevoir des dépendances à l'extérieur. 1. Di favorise le couplage lache en découplant la création d'objets à partir de l'utilisation. 2. Il simplifie les tests par l'injection d'objets simulés. 3. Les composants deviennent plus réutilisables entre les applications. 4. Les modifications des dépendances ne nécessitent pas de modifications de code généralisées. Dans ASP.NET Core, DI est intégré dans le cadre, en utilisant principalement l'injection de constructeur. Les services sont enregistrés dans programme.cs ou startup.cs, par exemple: builder.services.addtransient ();. Ensuite, ils sont injectés dans des classes via des constructeurs. ASP.NET Core prend en charge trois durées de vie: 5. Transient - créé à chaque fois qu'ils sont demandés. 6. Scoped - créé une fois par demande, idéal pour les contextes de base de données. 7. Singleton - Créé une fois et réutilisé. Choisir la bonne durée de vie est crucial pour éviter des problèmes comme le partage d'état. Par exemple, les DBContexts du cadre d'entité doivent être étendus pour éviter les problèmes de concurrence. Bien que le conteneur DI intégré soit suffisant pour de nombreux scénarios, en particulier dans les petits projets, il manque de fonctionnalités avancées telles que l'injection de propriété et l'interception. Dans de tels cas, les développeurs peuvent opter pour des conteneurs tiers comme Autofac ou Unity. Dans l'ensemble, DI dans ASP.NET Core permet une gestion de la dépendance propre, mais nécessite une manipulation minutieuse des vies et des modèles d'enregistrement pour assurer la stabilité et les performances des applications.

L'injection de dépendance (DI) est un modèle de conception qui aide à rendre les applications plus modulaires, testables et maintenables. à la base, DI permet aux classes de recevoir leurs dépendances d'une source externe plut?t que de les créer en interne. Cela facilite l'échange d'implémentations, d'écrire des tests unitaires et de gérer des graphiques d'objets complexes.

En C #, en particulier dans le noyau ASP.NET, DI est intégré dans le cadre et utilisé de manière approfondie tout au long du cycle de vie de l'application.

Pourquoi utiliser l'injection de dépendance?

Il y a quelques raisons solides pour lesquelles DI est devenu une pratique aussi standard:

• Accouplement lache : Vos cours n'ont pas besoin de savoir comment créer ou gérer leurs propres dépendances.
• Test plus facile : vous pouvez injecter des objets simulés lors des tests au lieu de réels.
• Réutilisabilité : les composants peuvent être réutilisés dans différentes parties de l'application ou même différents projets.
• Maintenabilité : Si quelque chose change dans une dépendance, vous n'avez pas à réécrire tous les endroits où elle est utilisée.

Par exemple, si vous travaillez avec un service qui enregistre les données dans une base de données, en utilisant DI signifie vous basculer entre la journalisation vers SQL Server, MongoDB ou même un fichier sans modifier votre logique principale - simplement en échangeant l'implémentation injectée.

Comment fonctionne DI intégrée dans ASP.NET Core?

ASP.NET Core est livré avec un conteneur DI léger intégré. Il prend en charge l'injection de constructeur hors de la bo?te, ce qui est le moyen le plus courant d'utiliser DI dans le cadre.

Vous enregistrez généralement des services dans le fichier Startup.cs ou Program.cs selon que vous utilisez les modèles de projet plus anciens ou plus récents.

Voici comment vous enregistrez un service:

 // dans programme.cs (pour .NET 6 API minimales)
var builder = webApplication.CreateBuilder (args);

// Enregistrer les services ici
builder.services.addTransient <iMyService, myService> ();

Ensuite, vous pouvez l'utiliser dans un contr?leur comme celui-ci:

 classe publique MyController: ControllerBase
{
    Private ReadOnly ImyService _MyService;

    public MyController (Imyservice MyService)
    {
        _MyService = myService;
    }

    [Httpget]
    public iActionResult get ()
    {
        var result = _myService.doSomething ();
        return ok (résultat);
    }
}

Le framework gère la résolution de l'instance correcte d' IMyService au moment de l'exécution en fonction de la fa?on dont vous l'avez enregistré.

LIFE DES SERVICE: transitoire, portée, singleton

Lors de l'enregistrement des services, vous choisissez également combien de temps ils vivent. Les trois principales options sont:

• Transient : créé à chaque fois qu'ils sont demandés. Meilleur pour les services sans état légers.
• Scoped : créé une fois par demande client (demande HTTP dans les applications Web). Bon pour des choses comme les contextes de base de données.
• Singleton : créé la première fois qu'ils sont demandés puis réutilisés pour toutes les demandes suivantes.

Choisir la bonne vie est importante. Par exemple, l'injection d'un service transitoire dans un singleton pourrait causer des problèmes car le transitoire pourrait transporter un état qui ne devrait pas être partagé.

Disons que vous utilisez le noyau du framework Entity. Vous enregistreriez normalement votre DbContext en tant que portée:

 builder.services.adddbcontext <ppdbContext> (Options =>
    options.USESQLSERVER (builder.configuration.getConnectionString ("DefaultConnection")));

Cela garantit que le contexte ne vit que pour la durée de la demande HTTP et évite les problèmes de concurrence.

Quand ne pas utiliser le conteneur DI intégré

Bien que le DI intégré fonctionne bien pour la plupart des scénarios, ce n'est pas le conteneur le plus riche en fonctionnalités du marché. Si vous avez besoin de fonctionnalités avancées comme:

• Injection de biens
• Inscription automatique
• Interception ou décorateurs

Vous pourriez envisager de le remplacer par un conteneur tiers comme Autofac, Unity ou Microsoft.Extensions.DenpendencyInjection avec quelques extensions.

Mais pour de nombreux projets - en particulier les plus petits à moyennes - le système intégré est parfaitement bien.

Ainsi, en gros, Di dans C # via ASP.NET Core vous donne un moyen propre de gérer les dépendances sans couplage serré. Vous enregistrez les services, les injectez en cas de besoin et laissez le cadre gérer le reste. Ce n'est pas trop complexe, mais cela nécessite une compréhension des vies et comment le conteneur résout les types.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!