Injection de dépendance à l’aide de l’API .NET Core

Dans cet article, nous allons discuter de l’injection de dépendances, de son utilisation et de ses avantages. Nous discuterons également des différentes manières d’implémenter l’injection de dépendances.

Conditions préalables

Compréhension de base du langage de programmation C#.
Compréhension de la programmation orientée objet.
Compréhension de base de .NET Core.

Objectif du modèle de conception d’injection de dépendance

En termes simples, la dépendance signifie que l’objet dépend d’un autre objet pour effectuer un travail. En utilisant l’injection de dépendances, nous pouvons écrire des classes faiblement couplées et, à cause de cela, notre fonctionnalité actuelle d’une classe ne dépend pas directement d’une autre classe car nous pouvons facilement maintenir, modifier et tester correctement le code unitaire. Il respecte également le principe ouvert-fermé. En utilisant l’abstraction et l’interface, nous pouvons facilement apporter des modifications futures sans modifier les fonctionnalités existantes.

Injection de dépendance

L’injection de dépendance est utilisée pour injecter l’objet de la classe dans une autre classe, elle utilise également l’inversion de contrôle pour créer un objet en dehors de la classe et utilise cet objet de différentes manières, comme l’utilisation du conteneur de service, fourni par .NET Core.

Maintenant, nous examinons le problème auquel nous serons confrontés sans utiliser d’injection de dépendance.

Supposons que nous ayons une voiture de classe, et cela dépend de la classe BMW :

public class Car
{
    private BMW _bmw;
    public Car()
    {
        _bmw = new BMW();
    }
}
public class BMW
{
    public BMW()
    {
    }
}

Ici, dans cette classe d’exemple, Car dépend de la classe BMW, et parce qu’ils sont étroitement couplés, nous devons créer un objet de la classe BMW à chaque fois.

À l’avenir, supposons que nous voulions ajouter des paramètres au constructeur de la classe BMW, comme le nom du modèle, comme indiqué dans l’exemple ci-dessous :

public class Car
{
    private BMW _bmw;
    public Car()
    {
        _bmw = new BMW("BMW X1");
    }
}
public class BMW
{
    public BMW(string ModelName)
    {
    }
}

Donc, dans ce cas, nous devons ajouter le Model Name paramètre dans le Car class, et encore une fois, nous devons changer le constructeur et passer le paramètre. Ce n’est pas une bonne pratique dans le développement de logiciels, et à cause de cela, une dépendance dure est créée. Enfin, lorsque notre application est volumineuse, elle est difficile à maintenir.

Ce sont les défis auxquels nous sommes confrontés lors de la mise en œuvre de fonctionnalités sans injection de dépendance.

Utilisations de l’injection de dépendance dans .NET Core

.NET Core fournit un mécanisme tel qu’un conteneur IOC qui répondra pour prendre en charge les éléments suivants :

L’enregistrement des services avec le type et la classe dans un conteneur, ce qui nous permet d’injecter les services selon notre besoin.
Le conteneur IOC résout également les dépendances des classes de la classe requise.
Il gère également la durée de vie de l’objet.

Enregistrement de la durée de vie des services dans une classe de démarrage

Portée

Il créera une seule instance par étendue.
Il créera des instances de chaque demande.

Singleton

Il ne créera qu’une seule instance par requête et sera utilisé dans toute l’application.
Il a également partagé cette même instance dans toute l’application.

Transitoire

Il créera une nouvelle instance à chaque fois et ne partagera pas l’instance avec d’autres applications.
Il est utilisé pour des applications petites et légères.

Maintenant, nous allons créer une application de produit .NET Core en utilisant l’injection de dépendance une par une :

Ensuite, configurez le projet :

Fournissez des informations supplémentaires telles que la version .NET et une autre configuration :

Ensuite, installez les packages NuGet suivants, dont nous avons besoin pour Swagger, SQL Server, Migration et Database Update :

Microsoft.EntityFrameworkCore
Microsoft.EntityFrameworkCore.Design
Microsoft.EntityFrameworkCore.SqlServer
Microsoft.EntityFrameworkCore.Tools
Swashbuckle.AspNetCore

Ajoutez la chaîne de connexion à la base de données du serveur SQL dans le appsetting.json déposer:

using System.ComponentModel.DataAnnotations;
namespace Product.Model
{
    public class ProductDetail
    {
        [Key]
        public int Id { get; set; }
        public string Name { get; set; }
        public int Cost { get; set; }
        public int NoOfStock { get; set; }
    }
}

Plus tard, créez le DBContextClass pour le fonctionnement lié à la base de données du cadre d’entité :

using Microsoft.EntityFrameworkCore;
using Product.Model;
namespace Product.Data
{
    public class DBContextClass : DbContext
    {
        public DBContextClass(DbContextOptions<DBContextClass> options) : base(options)
        {
        }
        public DbSet<ProductDetail> Products { get; set; }
    }
}

Ajoutez la chaîne de connexion à la base de données du serveur SQL dans le appsetting.json déposer:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*",
  "ConnectionStrings": {
    "DefaultConnection": "Data Source=ServerName;Initial Catalog=ProductData;User Id=Test;Password=database@123;"
  }
}

Créer le ProductService et le IProductService cours à l’intérieur du « Dossier de services” pour la manipulation de données à l’aide de l’injection de dépendance :

using Product.Model;
using System.Collections.Generic;
namespace Product.Service
{
    public interface IProductService
    {
        ProductDetail AddProduct(ProductDetail employee);
        List<ProductDetail> GetProducts();
        void UpdateProduct(ProductDetail employee);
        void DeleteProduct(int Id);
        ProductDetail GetProduct(int Id);
    }
}

Maintenant, créez le ProductService classe:

using Product.Data;
using Product.Model;
using System.Collections.Generic;
using System.Linq;
namespace Product.Service
{
    public class ProductService : IProductService
    {
        private readonly DBContextClass _context;
public ProductService(DBContextClass context)
        {
            _context = context;
        }
        public ProductDetail AddProduct(ProductDetail product)
        {
            _context.Products.Add(product);
            _context.SaveChanges();
            return product;
        }
public void DeleteProduct(int Id)
        {
            var product = _context.Products.FirstOrDefault(x => x.Id == Id);
            if (product != null)
            {
                _context.Remove(product);
                _context.SaveChanges();
            }
        }
public ProductDetail GetProduct(int Id)
        {
            return _context.Products.FirstOrDefault(x => x.Id == Id);
        }
public List<ProductDetail> GetProducts()
        {
            return _context.Products.OrderBy(a => a.Name).ToList();
        }
public void UpdateProduct(ProductDetail product)
        {
            _context.Products.Update(product);
            _context.SaveChanges();
        }
    }
}

Après cela, créez un contrôleur de produit, et à l’intérieur de celui-ci, vous pouvez voir que nous injectons facilement le service produit dans le constructeur sans être étroitement couplé. Cela permet d’étendre les fonctionnalités du produit sans modifier les fonctionnalités existantes :

using Microsoft.AspNetCore.Mvc;
using Product.Model;
using Product.Service;
using System.Collections.Generic;
namespace Product.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class ProductController : ControllerBase
    {
        private readonly IProductService productService;
        public ProductController(IProductService _productService)
        {
            productService = _productService;
        }
        [HttpGet]
        [Route("api/Product/GetProducts")]
        public IEnumerable<ProductDetail> GetProducts()
        {
            return productService.GetProducts();
        }
        [HttpPost]
        [Route("api/Product/AddProduct")]
        public IActionResult AddProduct(ProductDetail product)
        {
            productService.AddProduct(product);
            return Ok();
        }
        [HttpPut]
        [Route("api/Product/UpdateProduct")]
        public IActionResult UpdateProduct(ProductDetail product)
        {
            productService.UpdateProduct(product);
            return Ok();
        }
        [HttpDelete]
        [Route("api/Product/DeleteProduct")]
        public IActionResult DeleteProduct(int id)
        {
            var existingProduct = productService.GetProduct(id);
            if (existingProduct != null)
            {
                productService.DeleteProduct(existingProduct.Id);
                return Ok();
            }
            return NotFound($"Product Not Found with ID : {existingProduct.Id}");
        }
        [HttpGet]
        [Route("GetProduct")]
        public ProductDetail GetProduct(int id)
        {
            return productService.GetProduct(id);
        }
    }
}

Enfin, enregistrez le service dans la méthode « Configurer les services », ajoutez le fournisseur de base de données et configurez la chaîne de connexion à la base de données, que nous mettons dans les paramètres de l’application :

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.OpenApi.Models;
using Product.Data;
using Product.Service;
namespace Product
{
    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }
        public IConfiguration Configuration { get; }
        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers();
            //DBContext Configuration
            services.AddDbContext<DBContextClass>(options =>
           options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
            //Register the ProductService for DI purpose
           ...