Sería más oportuno para el curso explicar con gráficos o imágenes representativas de lo que significa las tres formas de inyección de dependencia como Freddy lo hace en las clases de programación para tener una representación visual más clara del alcance que tiene cada una.
Introducción a API en .NET
Domina las API con .NET
Prerrequisitos
¿Qué es una API?
¿Qué es REST?
Creando tu primera API con .NET
Funcionamiento de una API en .NET
Consumiendo API desde Postman
Análisis del template para APIs de .NET
Atributos para verbos HTTP
Manejo de rutas
Minimal API vs. Web API
Arquitectura y configuración
¿Qué son los middlewares?
Creando un nuevo middleware
Inyección de dependencias
Agregando Logging a API
Documentando API con Swagger
Manipulación de datos con Entity Framework
Agregando librerías para Entity Framework
Configuración de Entity framework y clases base
Creación de servicios
Inyectando servicios como dependencia
Creando controladores
Probando API con una base de datos SQL server
Outro
Retrospectiva: APIs con .NET
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
Inyección de dependencias
13/22Recursos
Aportes 16
Preguntas 17
Ordenar por:
-AddScoped crea una instancia por cada request del cliente
-AddTransient crea una instancia por cada controlador
-AddSingelton crea una sola instancia para todo lo que dure la ejecución de la API.
Transient vs Scoped vs Singleton
Les dejo una explicación muy interesante 😄
https://www.youtube.com/watch?v=srPGwwMwAoA&ab_channel=hdeleon.net
Inyección de Dependencias
Nos permite utilizar diferentes tipos abstractos y configurar nuestras dependencias utilizando un inyector sin tener que crear un nuevo objeto o una nueva referencia del componente cada vez que lo necesitemos, sino que el inyector se encarga de pasarnos esa dependencia y la podemos utilizar directamente.
Configuración del inyector: Para la configuración del inyector tenemos las siguientes opciones:
- Usando
builder.Services.addscop<>();: De esta manera estamos creando una nueva instancia de la dependencia que estamos usando, pero a nivel de controlador o a nivel de clase, es decir que no importa si estamos inyectando varias veces y en diferentes partes esta dependencia dentro de todo el contexto del controlador o todo el contexto de la clase, se va a inyectar exactamente la misma instancia que se creo para todo ese elemento.
(También podemos usarbuilder.Services.addTrasient) - Usando
builder.Services.addsingleton: De esta manera estamos creando UNA ÚNICA implementación o instancia de esa dependencia EN TODA LA API (no es recomendable usar singleton porque hacemos que nuestras dependencias se creen en memoria lo que podría causar un problema, además la tendencia es implementar APIS que sean stateless que no manejen ningún tipo de estado sino que con cada request se cree una nueva implementación o instancia de la dependencia configurada.)
Estoy haciendo el curso usando NET 5 y si hay sus cositas diferentes en el startup.cs
Creo que lo que entendei de AddScoped y AddSingleton
es que AddSingleton crea 1 contexto para todos los controladores y el AddScoped crea un contexto para cada uno de los controladores.
Y cuando dice que una api tienes que ser State Less, quiere decir que las peticiones HTTP no deberian compartir informacion y que cada peticion HTTP sea decentralizada. Es decir, que si manejo un estado en /users ese estado no debe estar en /products
La inyección de dependencias puede entenderse de mejor manera si se conocen los principios SOLID. También es necesario saber manejar interfaces.
Si tienen dudas sobre de clase, les recomendaría que acudan a estudiarlos.
# **Dependency Injection**
Dependency injection is a fundamental concept in object-oriented programming (OOP) languages. It allows us to manage dependencies in our code effectively, making it easier to maintain and test. Let's dive into how it works and how to implement it in C#.
## **Understanding Dependency Injection**
Dependency injection is all about decoupling components in your codebase. Instead of directly creating instances of dependencies within a class or controller, we rely on an injector to provide these dependencies when needed. This promotes a more modular and flexible code structure.
## **Implementation Steps**
### **1. Create a Service**
Start by creating a service class that encapsulates the functionality you need. This service should implement an interface, which defines the contract for how the service can be used.
namespace apidotnet.Services
{
// Define the interface
public interface IHelloWorldService
{
string GetHelloWorld();
}
// Implement the service
public class HelloWorldService : IHelloWorldService
{
public string GetHelloWorld()
{
return "Hello world";
}
}
}
### **2. Configure Dependency Injection**
Next, configure the dependency injection container to associate the interface with its corresponding implementation.
using apidotnet.Services;
using Microsoft.Extensions.DependencyInjection;
// Configure services in Program.cs
public class Program
{
public static void Main(string\[] args)
{
var builder = WebApplication.CreateBuilder(args);
// Configure dependency injection
builder.Services.AddScoped\<IHelloWorldService, HelloWorldService>();
var app = builder.Build();
// Additional setup...
app.Run();
}
}
### **3. Utilize Dependency in Controller**
Now, let's create a controller that utilizes the dependency injected through its constructor.
using apidotnet.Services;
using Microsoft.AspNetCore.Mvc;
namespace apidotnet.Controllers
{
\[ApiController]
\[Route("\[controller]")]
public class HelloWorldController : ControllerBase
{
private readonly IHelloWorldService \_helloWorldService;
// Inject the service through constructor
public HelloWorldController(IHelloWorldService helloWorldService)
{
\_helloWorldService = helloWorldService;
}
// Endpoint to get hello world message
\[HttpGet]
public IActionResult Get()
{
return Ok(\_helloWorldService.GetHelloWorld());
}
}
}
## **Conclusion**
And there you have it! By implementing dependency injection, we've achieved a more modular and maintainable codebase. Remember, dependency injection is a powerful tool in your programming arsenal, so use it wisely to improve the structure and flexibility of your applications.
Inyección de dependencias y la vida util del servicio.
La vida util o tiempo de vida del servicio describe por cuanto tiempo la instancia de cualquier clase persistirá.
AddSingleton: Crea solamente una instancia cuando el servicio hace un request por primera vez y entonces la misma instancia sera compartida por todos los diferentes http requests siguientes.
AddScoped: Crea una sola instancia por cada request. Para cada diferente http request se creará una diferente instancia.
AddTransient: Esta instancia no sera compartida, cada vez que se realice un request se creará una nueva instancia.
Por fin entendí la inyección de dependencias, gracias Miguel!
Esta pagina me parece interesante para entender un poco mas los metodos mensionados:
<https://medium.com/@pablo.tejgar/transient-scoped-o-singleton-net-core-como-si-estuvieras-en-1%C2%BA-514db9877684>
Estoy un poco perdido en cuanto a INTERFACES y CONSTRUCTOR, algún curso que refuerce estos conceptos?
¡Saludos!
lo que dices en el minuto 14:00 no es nada claro y podria ser hasta erroneo, muy decepcionado de este curso
hay una serie de videos que no estan funcionando, incluido este.
CReo que la palabra correcta para la interfaz es multiples definciones de metodos que pueden ser implementados cuando se implementa en una clase
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?