Creación de servicios

Jorge García Delgado

student•

Al minuto 7:42, cuando estamos verificando la categoría actual, es preferible seguir la estrategia guard. Consiste básicamente en realizar validaciones y romper/interrumpir la ejecución antes de la lógica principal:

if(categoriaActual == null)
{
	return NotFound();
}
// Resto de la lógica

De esta manera evitamos el uso de else y el código es más legible.

Nelson Alejandro Rivas Mendoza

student•

¡Totalmente de acuerdo!

Fue lo primero que percibí cuando escribió la lógica del update.

Jeronimo Suquilvide

student•

Creo que de eso se debería de encargar el controlador...

Antonio Bermúdez

student•

En el servicio de categoría hay un error al hacer el Update, se están actualizando los datos de categoria con categoría. Y deberían actualizarse categoriaActual con los datos de categoria.

Adjunto mi clase Update de Categoria.

    public async Task Update(Guid id, Categoria categoria)
    {
        var categoriaActual = context.Categorias.Find(id);
        if (categoriaActual != null)
        {
            categoriaActual.Nombre = categoria.Nombre;
            categoriaActual.Descripcion = categoria.Descripcion;
            categoriaActual.Peso = categoria.Peso;

            await context.SaveChangesAsync();
        }

    }

Juan Sebastian Viazzo Perrone

student•

Acabo de ver lo mismo! necesitaba chequearlo con alguien, dudas hasta de tu propio conocimiento con estas cosas jaja. Gracias!

Leandro Barbera

student•

Para ser mas precisos, en el condicional if, al asignar los valores encontrados se debería actualizar la variable categoriaActual de la siguiente forma:

categoriaActual.Nombre = categoria.Nombre; //en categ categoriaActual.Descripcion = categoria.Descripcion; //(estaba mal en video) categoriaActual.Peso = categoria.Peso; //(estaba mal en video)

Hector Hugo Luna Miranda

student•

1 - En proyetos grandes, ¿es conveniente tener archivos y carpeta separada para las interfaces? 2 - Al hacer la eliminación (D_E_L_E_T_E) de las categorias, si las categorias tienen tareas relacionadas, ¿se eliminan las tareas relacionadas o se bloquea la eliminación?

Miguel Teheran

teacher•

Si el proyecto es muy grande si, pero tener monolitos gigantes ya no es una buena practica la idea es usar microservicios o arquitecturas orientadas a servicios para eso

2- Eso se conoce como delete en cascada por defecto esto no viene habilitado, osea que si intentas eliminar la categoria va salir error. Si deseas habilitarlo debes especificarlo en la configuración de fluente API:

modelBuilder.Entity<Profile>() .HasOptional(c => c.ProfileImages) .WithOptionalDependent() ** .WillCascadeOnDelete(true);. **

Hector Hugo Luna Miranda

student•

Muchas gracias

Carlos Gomez

student•

Mi TareaService 😊

using webapi.Models;
namespace webapi.Services;


public class TareasService : ITareasService
{

    TareasContext context;
    public TareasService(TareasContext dbcontext)
    {
        context = dbcontext;
    }

    public IEnumerable<Tarea> Get()
    {
        return context.Tareas;
    }
    public async Task Save(Tarea tarea)
    {
        context.Add(tarea);
        await context.SaveChangesAsync();
    }

    public async Task Update(Guid id, Tarea tarea)
    {
        var tareaActual = context.Tareas.Find(id);
        if (tareaActual != null)
        {
            tareaActual.CategoriaId = tarea.CategoriaId;
            tareaActual.Titulo = tarea.Titulo;
            tareaActual.Descripcion = tarea.Descripcion;
            tareaActual.PrioridadTarea = tarea.PrioridadTarea;
            tareaActual.FechaCreacion = tarea.FechaCreacion;
            tareaActual.Categoria = tarea.Categoria;
            await context.SaveChangesAsync();
        }
    }

    public async Task Delete(Guid id)
    {
        var tareaActual = context.Tareas.Find(id);
        if (tareaActual != null)
        {
            context.Remove(tareaActual);
            await context.SaveChangesAsync();
        }
    }
}

public interface ITareasService
{
    IEnumerable<Tarea> Get();
    Task Save(Tarea tarea);
    Task Update(Guid id, Tarea tarea);
    Task Delete(Guid id);
}

Jorge Luis Chan Chan

student•

En el método Update de categoría no logro entender porque solo usan una vez la variable "categoriaActual" y asignarle el valor a la propiedad nombre. ¿Por qué se hace así?

Miguel Teheran

teacher•

Hola Jorge es un error, se le debe asignar el valor a categoriaActual para que el valor se vea reflejado en la base de datos

Efrel Armando López Cáceres

student•

Asi es Jorge es un error como lo como lo menciona el Profe, te deberia quedar asi:

Sergio Sanchez

student•

Noté que hay dos tipos de metodos, Sync y Async. El Async, utiliza un tipo "Task" mientras que el Sync, es void.

Basado en esto, que ventajas tiene usar uno u otro?
Qué es "Task"?
Cuando el tipo del metodo es "Task" no se retorna nada, se deberia retornar algo de tipo Task?

        public void Save(Category c)
        {
            context.Add(c);
            context.SaveChanges();
        }

Save Async

        public async Task Save(Category c) 
        {
            await context.SaveChangesAsync(); 
        }

Miguel Teheran

teacher•

Async significa que es asincrono lo cual permite que se creen nuevos hilos durante la ejecución y de esta manera la API responda mucho mejor antes una alta demanda de request.

Hans González

student•

Excelente clase

Leandro Andres Suarez Vece

student•

Aquí dejo mi codigo, al cual comence usando la palabra reservada Task para tarea. Aprendan de los errores ajenos no hagan estas cosas sino tendran que estar asi igual que yo

using EF.Models;

namespace API.Service;
public class TaskService : ITaskService
{
    TaskContext context;

    public TaskService(TaskContext dbcontext)
    {
        context = dbcontext;
    }

    public IEnumerable<EF.Models.Task> Get()
    {
        return context.Tasks;
    }

    //Esta es la razon por la que no debemos usar palabras recervadas.
    public async System.Threading.Tasks.Task Save(EF.Models.Task Task)
    {
        context.Add(Task);
        await context.SaveChangesAsync();
    }

    public async System.Threading.Tasks.Task update(Guid id, EF.Models.Task Task)
    {
        var TaskPresent = context.Tasks.Find(id);
        if (TaskPresent != null)
        {
            TaskPresent.Title = Task.Title;
            TaskPresent.Description = Task.Description;
            TaskPresent.Date = Task.Date;
            TaskPresent.PriorityTask = Task.PriorityTask;

            await context.SaveChangesAsync();
        }
    }

    public async System.Threading.Tasks.Task Delete(Guid id)
    {
        var TaskPresent = context.Categoties.Find(id);
        if (TaskPresent != null)
        {
            context.Remove(TaskPresent);
            await context.SaveChangesAsync();
        }
    }

}

public interface ITaskService
{
    IEnumerable<EF.Models.Task> Get();
    System.Threading.Tasks.Task Delete(Guid id);
    System.Threading.Tasks.Task update(Guid id, EF.Models.Task Task);
    System.Threading.Tasks.Task Save(EF.Models.Task Task);

}

JUAN PABLO MAYORGA MENDIETA

student•

En el contexto de una API desarrollada con ASP.NET Core, un "servicio" se refiere a una clase o componente que encapsula la lógica de negocio o funcionalidad específica de la aplicación. Estos servicios están diseñados para realizar tareas específicas y proporcionar funcionalidades reutilizables que pueden ser utilizadas por diferentes partes de la aplicación.

En ASP.NET Core, la arquitectura típica sigue el patrón de Inyección de Dependencias (Dependency Injection). Esto significa que los servicios necesarios para una operación específica se inyectan en lugar de ser instanciados directamente dentro de una clase. La Inyección de Dependencias facilita la gestión de las dependencias y la modularidad del código.

Aquí hay algunas características clave de los servicios en el contexto de una API ASP.NET Core:

Encapsulación de Lógica de Negocio: Los servicios se utilizan para encapsular y organizar la lógica de negocio de la aplicación. Por ejemplo, un servicio puede encargarse de la autenticación, otro de la persistencia de datos en una base de datos, y otro de la lógica de negocio específica de un controlador.
Reutilización de Código: Al dividir la lógica de la aplicación en servicios, se fomenta la reutilización de código. Varios controladores o componentes pueden utilizar el mismo servicio para realizar operaciones similares.
Inyección de Dependencias: En ASP.NET Core, los servicios se registran en el contenedor de inversión de control (IoC) y se inyectan en las clases que los necesitan. Esto facilita la gestión de dependencias y mejora la modularidad del código.
Testabilidad: La división de la lógica en servicios facilita la prueba unitaria. Puedes escribir pruebas unitarias para cada servicio de forma independiente, lo que ayuda a garantizar que cada componente de la aplicación funcione correctamente.

Un ejemplo práctico sería un servicio de gestión de usuarios. Este servicio podría contener métodos para crear usuarios, autenticar usuarios, recuperar información de usuario, etc. Luego, estos métodos pueden ser utilizados por los controladores de la API para realizar operaciones relacionadas con usuarios.

En resumen, en el contexto de una API ASP.NET Core, un servicio es un componente que encapsula la lógica de negocio, promoviendo la reutilización de código, la inyección de dependencias y la testabilidad.

Jhon Alex Ojeda Theran

student•

Buenas, Tengo este error al intentar crear el save, ¿alguien tiene idea a que se debe?

Daniel Andres Lobo Moncada

student•

te hace falta el await

Hans González

student•

Vengo de algun futuro, para quien empiece a ver arquitectura limpia, esto es base para entender cuando se hablan de repositorio e interfaces , ademas esto esta en el mismo curso de miguel de programacion deobjetos, sobre las clases abstractas , saludos

JUAN DAVID MARTINEZ GONZALEZ

student•

Aporte de Tareas

![](

Andre Huaman Yovera

student•

Si alguien quiere que le aparezca estas ayudas, solo instalece IntelliCode en su VS Code. . .

JUAN SEBASTIAN ORTIZ

student•

using webapi.Models;

namespace webapi.Services;

public class TareaService : ITareaService

{

TareasContext context;

public TareaService(TareasContext dbContext)

{

context = dbContext;

}

public IEnumerable<Tarea> Get()

{

return context.Tareas;

}

public async Task Save(Tarea tarea)

{

context.Add(tarea);

await context.SaveChangesAsync();

}

public async Task Update(Guid id, Tarea tarea)

{

var tareaActual = context.Tareas.Find(id);

if (tareaActual != null)

{

tareaActual.Titulo = tarea.Titulo;

tareaActual.Descripcion = tarea.Descripcion;

tareaActual.PrioridadTarea = tarea.PrioridadTarea;

tareaActual.CategoriaId = tarea.CategoriaId;

await context.SaveChangesAsync();

}

public async Task Delete(Guid id)

{

var tareaActual = context.Tareas.Find(id);

if (tareaActual != null)

{

context.Remove(tareaActual);

await context.SaveChangesAsync();

}

public interface ITareaService

{

IEnumerable<Tarea> Get();

Task Save(Tarea tarea);

Task Update(Guid id, Tarea tarea);

Task Delete(Guid id);

}

Douglas Isturiz

student•

¿La base de datos ya debería estar creada de antemano o la vamos a crear en este curso también?

Mauricio Zárate

student•

Saludos Douglas, la base de datos la creará Entity Framework automáticamente.

Esa es la ventaja de utilizar los frameworks, específicamente el elemento llamado ORM. La creación de las tablas de la base de datos a partir de los modelos.

Carlos Rafael Padilla Ramirez

student•

Porque el Conext se puede inyectar sin necesidad de hacer la inyeccion en el program.cs?

Miguel Teheran

teacher•

Si esta la inyeccion donde se configura el servicio se genera el objeto para cuando se solicite en cualquiera de las dependencias

Arturo Ventura Martínez

student•

realmente es bueno crear la interface en la misma clase de servicio? o seria mejor en un archivo aparte?

Miguel Teheran

teacher•

Es mejor aparte, solamente si el proyecto es muy muy pequeño se hace así

Jhan Carlos Bacca

student•

lo correcto sería que las interfaces también tuvieran sus archivos individuales ?

Miguel Teheran

teacher•

Si correcto

Sergio Sanchez

student•

Una Solucion tiene uno o varios projectos.

Basado en eso, es posible separar en mas projectos, los servicios, modelos y controllers?

En que casos es conveniente hacerlo?

Miguel Teheran

teacher•

Solamente cuando estas trabajando con una aplicación monolitica super grande es conviente hacer la separación o por que aplicar arquitecturas limpias o clean code. Para proyectos pequeños o arquitecutras de microservicios o serverless no es recomendable.

Dilan de Jesús Lucio Sustaita

student•

Aqui mi aporte de la clase TareaService.cs

using API.Models;

namespace API.Services;


public class TareaService : ITareaService
{
    TareasContext context;

    public TareaService(TareasContext dbcontext)
    {
        context = dbcontext;


    }

    public IEnumerable<Tarea> Get()
    {
        return context.Tareas;
    }

    public async Task Save(Tarea Tarea)
    {
        context.Add(Tarea);
       await context.SaveChangesAsync();
    }

    public async Task Update(Guid id, Tarea Tarea)
    {
        var TareaActual = context.Tareas.Find(id);


        if (TareaActual != null)
        {
            TareaActual.Titulo = Tarea.Titulo;
            TareaActual.Descripcion = Tarea.Descripcion;
           await context.SaveChangesAsync();
        }
    }

    public async Task Delete(Guid id)
    {
        var TareaActual = context.Tareas.Find(id);

        if (TareaActual != null)
        {
            context.Remove(TareaActual);

            await context.SaveChangesAsync();
        }
    }
}



public interface ITareaService

{
   public IEnumerable<Tarea> Get();
   Task Save(Tarea Tarea);
   Task Update(Guid id, Tarea Tarea);
   Task Delete(Guid id);    
}
```using API.Models;
namespace API.Services;

public class TareaService : ITareaService{    TareasContext context;
    public TareaService(TareasContext dbcontext)    {        context = dbcontext;

    }
    public IEnumerable\<Tarea> Get()    {        return context.Tareas;    }
    public async Task Save(Tarea Tarea)    {        context.Add(Tarea);       await context.SaveChangesAsync();    }
    public async Task Update(Guid id, Tarea Tarea)    {        var TareaActual = context.Tareas.Find(id);

        if (TareaActual != null)        {            TareaActual.Titulo = Tarea.Titulo;            TareaActual.Descripcion = Tarea.Descripcion;           await context.SaveChangesAsync();        }    }
    public async Task Delete(Guid id)    {        var TareaActual = context.Tareas.Find(id);
        if (TareaActual != null)        {            context.Remove(TareaActual);
            await context.SaveChangesAsync();        }    }}


public interface ITareaService
{   public IEnumerable\<Tarea> Get();   Task Save(Tarea Tarea);   Task Update(Guid id, Tarea Tarea);   Task Delete(Guid id);    }

    public async Task Update(Guid id, Categoria categoria)
    {
        var categoriaActual = context.Categorias.Find(id);
        if (categoriaActual != null)
        {
            categoriaActual.Nombre = categoria.Nombre;
            categoriaActual.Descripcion = categoria.Descripcion;
            categoriaActual.Peso = categoria.Peso;

            await context.SaveChangesAsync();
        }

    }

using webapi.Models;
namespace webapi.Services;


public class TareasService : ITareasService
{

    TareasContext context;
    public TareasService(TareasContext dbcontext)
    {
        context = dbcontext;
    }

    public IEnumerable<Tarea> Get()
    {
        return context.Tareas;
    }
    public async Task Save(Tarea tarea)
    {
        context.Add(tarea);
        await context.SaveChangesAsync();
    }

    public async Task Update(Guid id, Tarea tarea)
    {
        var tareaActual = context.Tareas.Find(id);
        if (tareaActual != null)
        {
            tareaActual.CategoriaId = tarea.CategoriaId;
            tareaActual.Titulo = tarea.Titulo;
            tareaActual.Descripcion = tarea.Descripcion;
            tareaActual.PrioridadTarea = tarea.PrioridadTarea;
            tareaActual.FechaCreacion = tarea.FechaCreacion;
            tareaActual.Categoria = tarea.Categoria;
            await context.SaveChangesAsync();
        }
    }

    public async Task Delete(Guid id)
    {
        var tareaActual = context.Tareas.Find(id);
        if (tareaActual != null)
        {
            context.Remove(tareaActual);
            await context.SaveChangesAsync();
        }
    }
}

public interface ITareasService
{
    IEnumerable<Tarea> Get();
    Task Save(Tarea tarea);
    Task Update(Guid id, Tarea tarea);
    Task Delete(Guid id);
}

using EF.Models;

namespace API.Service;
public class TaskService : ITaskService
{
    TaskContext context;

    public TaskService(TaskContext dbcontext)
    {
        context = dbcontext;
    }

    public IEnumerable<EF.Models.Task> Get()
    {
        return context.Tasks;
    }

    //Esta es la razon por la que no debemos usar palabras recervadas.
    public async System.Threading.Tasks.Task Save(EF.Models.Task Task)
    {
        context.Add(Task);
        await context.SaveChangesAsync();
    }

    public async System.Threading.Tasks.Task update(Guid id, EF.Models.Task Task)
    {
        var TaskPresent = context.Tasks.Find(id);
        if (TaskPresent != null)
        {
            TaskPresent.Title = Task.Title;
            TaskPresent.Description = Task.Description;
            TaskPresent.Date = Task.Date;
            TaskPresent.PriorityTask = Task.PriorityTask;

            await context.SaveChangesAsync();
        }
    }

    public async System.Threading.Tasks.Task Delete(Guid id)
    {
        var TaskPresent = context.Categoties.Find(id);
        if (TaskPresent != null)
        {
            context.Remove(TaskPresent);
            await context.SaveChangesAsync();
        }
    }

}

public interface ITaskService
{
    IEnumerable<EF.Models.Task> Get();
    System.Threading.Tasks.Task Delete(Guid id);
    System.Threading.Tasks.Task update(Guid id, EF.Models.Task Task);
    System.Threading.Tasks.Task Save(EF.Models.Task Task);

}

using API.Models;

namespace API.Services;


public class TareaService : ITareaService
{
    TareasContext context;

    public TareaService(TareasContext dbcontext)
    {
        context = dbcontext;


    }

    public IEnumerable<Tarea> Get()
    {
        return context.Tareas;
    }

    public async Task Save(Tarea Tarea)
    {
        context.Add(Tarea);
       await context.SaveChangesAsync();
    }

    public async Task Update(Guid id, Tarea Tarea)
    {
        var TareaActual = context.Tareas.Find(id);


        if (TareaActual != null)
        {
            TareaActual.Titulo = Tarea.Titulo;
            TareaActual.Descripcion = Tarea.Descripcion;
           await context.SaveChangesAsync();
        }
    }

    public async Task Delete(Guid id)
    {
        var TareaActual = context.Tareas.Find(id);

        if (TareaActual != null)
        {
            context.Remove(TareaActual);

            await context.SaveChangesAsync();
        }
    }
}



public interface ITareaService

{
   public IEnumerable<Tarea> Get();
   Task Save(Tarea Tarea);
   Task Update(Guid id, Tarea Tarea);
   Task Delete(Guid id);    
}
```using API.Models;
namespace API.Services;

public class TareaService : ITareaService{    TareasContext context;
    public TareaService(TareasContext dbcontext)    {        context = dbcontext;

    }
    public IEnumerable\<Tarea> Get()    {        return context.Tareas;    }
    public async Task Save(Tarea Tarea)    {        context.Add(Tarea);       await context.SaveChangesAsync();    }
    public async Task Update(Guid id, Tarea Tarea)    {        var TareaActual = context.Tareas.Find(id);

        if (TareaActual != null)        {            TareaActual.Titulo = Tarea.Titulo;            TareaActual.Descripcion = Tarea.Descripcion;           await context.SaveChangesAsync();        }    }
    public async Task Delete(Guid id)    {        var TareaActual = context.Tareas.Find(id);
        if (TareaActual != null)        {            context.Remove(TareaActual);
            await context.SaveChangesAsync();        }    }}


public interface ITareaService
{   public IEnumerable\<Tarea> Get();   Task Save(Tarea Tarea);   Task Update(Guid id, Tarea Tarea);   Task Delete(Guid id);    }

Creación de servicios

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