L'injection de dépendance dans un contr?leur permet au cadre de fournir des services requis, d'améliorer la testabilité et la maintenabilité. 1. Utilisez l'injection du constructeur en déclarant les dépendances dans les paramètres du constructeur. 2. Enregistrez les services dans des fichiers de démarrage comme Program.cs avec des durées de vie appropriées telles que AddScoped. 3. évitez l'injection de propriété à moins que cela ne soit nécessaire car elle obscurcit les dépendances. 4. Utilisez des fonctionnalités DI intégrées pour la journalisation et la configuration, en maintenant Focus sur la gestion des demandes HTTP dans les contr?leurs.

Lorsque vous travaillez avec un contr?leur dans un cadre comme ASP.NET Core ou Spring, l'utilisation de l'injection de dépendance (DI) est un moyen propre d'obtenir les services dont votre contr?leur a besoin sans les codant dur. Vous déclarez simplement les dépendances dont vous avez besoin dans le constructeur, et le framework gère les créations et les transmettre pour vous.

Voici comment le faire correctement et éviter les pièges courants.

Comprendre quelle est l'injection de dépendance dans un contr?leur

En termes simples, l'injection de dépendance dans un contr?leur signifie laisser quelqu'un d'autre (le conteneur DI du cadre) vous donne les outils (services, référentiels, etc.) dont vous avez besoin au lieu de les créer vous-même à l'intérieur du contr?leur.

Cela maintient votre code testable, maintenable et couplé de manière lache.

Par exemple:

• Votre contr?leur peut avoir besoin d'un service qui récupère les données utilisateur d'une base de données.
• Au lieu d'instaurer ce service manuellement, vous le demandez simplement dans le constructeur.
• Le cadre injectera ensuite automatiquement une instance.

Utilisez l'injection du constructeur (la méthode préférée)

La plupart des cadres modernes comme ASP.NET Core et Spring MVC recommandent l'injection de constructeur. Voici comment cela fonctionne:

Vous définissez un constructeur de votre contr?leur qui prend une ou plusieurs interfaces ou types de béton comme paramètres. Le cadre résout ces dépendances lorsqu'il crée le contr?leur.

 classe publique UserController: ControllerBase
{
    Private Readonly iuserservice _userservice;

    public UserController (iUserService UserService)
    {
        _UserService = userService;
    }

    [Httpget ("{id}")]
    tache asynchrone publique <IActionResult> GetUser (int id)
    {
        var user = attendre _userservice.getUserByIdasync (id);
        return ok (utilisateur);
    }
}

Que se passe-t-il ici:

• IUserService est une interface que vous avez définie ailleurs.
• L'implémentation réelle (comme UserService ) est enregistrée auprès du conteneur DI.
• Lorsqu'une demande frappe ce contr?leur, le framework sait quel service en béton transmettre.

Cette approche est préférée car:

• Il rend les dépendances explicites.
• Il facilite les tests unitaires - vous pouvez passer des objets simulés directement dans le constructeur pendant les tests.

Enregistrer les services correctement en démarrage

Le simple fait de déclarer les dépendances dans le contr?leur ne suffit pas. Vous devez également les enregistrer dans le démarrage de l'application afin que le système DI sache comment les résoudre.

Dans ASP.NET Core, cela se produit généralement dans le fichier Startup.cs ou dans Program.cs si vous utilisez .net 6.

 // dans programme.cs (.net 6)
var builder = webApplication.CreateBuilder (args);

// Enregistrer les services ici
builder.services.addscoped <iUserService, userService> ();

var app = builder.build ();

Points clés:

• Assurez-vous que la durée de vie correspond à votre cas d'utilisation: AddTransient , AddScoped ou AddSingleton .
• N'oubliez pas d'enregistrer à la fois l'interface et l'implémentation.
• Si vous sautez cette étape, vous obtiendrez des erreurs d'exécution sur le fait de ne pas pouvoir résoudre le service.

évitez l'injection de propriétés sauf si nécessaire

Certains cadres prennent en charge l'injection de propriété, où vous décorez une propriété avec un attribut comme [Inject] ou [Autowired] . Bien que cela puisse fonctionner, il est généralement découragé à moins que vous ayez une raison spécifique.

Pourquoi?

• Il cache des dépendances - quelqu'un lisant votre code ne verra pas ce qui est nécessaire en regardant le constructeur.
• Cela rend les tests plus difficiles car vous ne pouvez pas facilement fournir ces dépendances lorsque vous instanciez manuellement le contr?leur.

Restez à l'injection de constructeur, sauf si vous avez affaire à des systèmes hérités ou à des composants tiers qui forcent l'injection de propriété.

Conseil bonus: utilisez une journalisation ou une configuration intégrée via DI

Vous n'avez pas toujours à créer vos propres services pour utiliser DI. La plupart des frameworks offrent déjà des cadres utiles hors de la bo?te.

Par exemple, dans ASP.Net Core, vous pouvez injecter directement ILogger<T> :

 Private ReadOnly Ilogger <UserController> _Logger;

public UserController (iUserService UserService, ILogger <UserController> Enregistreur)
{
    _UserService = userService;
    _Logger = Logger;
}

Ou injecter des options de configuration comme celle-ci:

 Public UserController (paramètres IOPTIONS <Pisettings>)
{
    var timeout = settings.value.defaultTimeout;
}

Ce sont d'excellents exemples de la fa?on dont DI aide à garder vos contr?leurs concentrés sur la gestion des demandes HTTP plut?t que sur la gestion de la logique ou de la configuration interne.

C'est essentiellement ainsi que vous utilisez l'injection de dépendance dans un contr?leur. Il est simple une fois que vous comprenez comment cabler les choses dans le démarrage et structurez correctement votre constructeur.

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!