Dependency Injector ou injeção de dependência

Olá pessoal, meu nome é Mauricio Junior e hoje eu vou falar um pouco sobre Dependency Injector usando .NET Core e a linguagem C# da Microsoft. Você pode usar qualquer ferramenta mas eu usei esses aqui:

• Ferramenta: Visual Studio
• Linguagem: C#
• Framework: .NETCore ou .NET 6

Explicando

Antigamente nós precisávamos criar instâncias como Class class = new Class() para acessar os métodos dentro da instância gerada como class.Method(parameter) mas agora a praticidade é melhor e o sistema sabe gerenciar as instâncias necessárias; e por isso agora você pode deixar preparado no sistema web, api ou desktop variáveis que vão ter a possibilidade de uso através do construtor e caso ela não seja usada, nenhum endereço de memória será criado, é criado apenas no momento de uso e é reutilizado caso use mais de uma vez.

Antigamente nós tinhamos sistemas que geravam instâncias new Class() que acabavam não sendo usadas e assim consumindo memória no servidor de forma desnecessária.

Como fazer?

Com o .NET Core e .NET 6, podemos usar dependency injector através da configuração do sistema e confirmando o uso através do construtor da classe. Eu quero dizer que, no momento que quiser acessar algum método da classe, basta usar o nome da variável colocada no construtor e acessar o método disponível.

É necessário ter uma interface da classe sempre.

Vamos para o código?

Na configuração do sistema você pode usar o AddScoped, o Singleton e o Transient por exemplo. Vou explicar de forma simples cada um deles:

• AddScoped: os objetos são os mesmos para cada objeto e para cada requisição
• Singleton: os objetos são os mesmos dentro da mesma requisição e são diferentes em diferentes chamadas
• Transient: os objetos são sempre diferentes, e uma nova instância é criada para todo o controlador e todo serviço.

Você escolhe baseado no que for melhor para você.

Dentro da classe Startup.cs do projeto, existe o método ConfigureServices(IServiceCollection services) e é aqui que vou adicionar as classes no meu escopo. Veja o código 1.1

Código 1.1 - Adicionando classe ao escopo

public void ConfigureServices(IServiceCollection services)
{
    services.AddScoped<IClassService, ClasseService>();
}

Eu adicionei aqui uma classe de serviço chamada ClassService mas eu posso colocar outras classes também como demonstro no código 1.2.

Código 1.2 - Adicionando várias classes no escopo

public void ConfigureServices(IServiceCollection services)
{
    //add services
    services.AddScoped<IUserService, UserService>();
    services.AddScoped<IUserTypeService, UserTypeService>();

    //add repository
    services.AddScoped<IUserRepository, UserRepository>();
    services.AddScoped<IUserTypeRepository, UserTypeRepository>();
}

No código 1.2 eu já mostro quatro classes diferentes adicionadas no escopo e que podem ser usadas em qualquer momento no código. Uma instância será criada apenas quando o construtor da classe implementar. Vamos para o construtor?

Construtor da uma classe

Código 1.3 - Construtor da classe

public class UserController : ControllerBase 
{
    //variável privada
    private readonly IUserService _userService;

    //construtor
    public UserController(IUserService userService)}
    {
        _userService = userService;
    }
}

Note que no código 1.3 eu adicionei uma variável privada com o nome da Interface adicionada no escopo, a IUserService. No construtor do método que é o nome da classe, eu adicionei uma variável e fiz a atribuição.

Para os próximos métodos, basta colocar o nome da variável e chamar os métodos disponíveis através dela, veja o código 1.4 de exemplo.

Código 1.4 - Chamando métodos.

public ActionResult<List<UserModel>> GetAllUsers()
{
    return _userService.GetAll();
}

Note que no código 1.4 eu criei um método que retorna uma lista de usuários e para chamar o método responsável não foi necessário criar uma instância para acessar o método GetAll().

Espero que tenha gostado e qualquer dúvida pode entrar em contato comigo pelo site Mauricio Junior - www.mauriciojunior.net.