Projet ASP.NET Core Web API sur Visual Studio : Repository

Comment ajouter un Repository à l’entité User :
1- Créer le dossier ‘Repository’
2- Ajouter la classe ‘UserRepository’
3- Ajouter la dépendance au contexte de la base de données avec la gestion de dépendance ASP.NET
4- Créer le dossier ‘Repositories.Interface’
5- Créer l’interface ‘IUserRepository’
6- Ajouter une méthode “Get”
7- Méthode asynchrone
8- Exemple de méthodes CRUD

1- Créer le dossier ‘Repository’
Si ce n’est pas déjà fait créer le dossier ‘Repositories’.

2- Ajouter la classe ‘UserRepository’
Dans le dossier ajouter une classe ‘UserRepository.cs’

3- Ajouter la dépendance au contexte de la base de données avec la gestion de dépendance ASP.NET
Créer le contexte ‘context’ avec son construteur comme ceci :

public class UserRepository : IUserRepository
    {
    LootManagerLiteContext context;
    public UserRepository(LootManagerLiteContext context, ILogger logger)
    {
        this.context = context;
    }

Déclarer le LootManagerLiteContext en ajoutant dans Program.cs le builder :

builder.Services.AddDbContext();

Le contexte ‘context’ peut être maintenant utilisé dans les méthodes.

4- Créer le dossier ‘Repositories.Interface’
Dans le dossier du projet ajouter le dossier ‘Repositories.Interfaces’. L’on peut aussi le nommer : Repositories.Contracts ou IRepositories.

5- Créer l’interface ‘IUserRepository’
Dans le dossier Repositories.Interfaces ajouter l’interface ‘IUserRepositories.cs’

6- Ajouter une méthode “Get”
La méthode doit être déclarée dans ‘IUserRepositories.cs’ comme ceci :

    namespace LootManagerLite.Repositories.Interfaces
{
    public interface IUserRepository
    {
        User GetAllUsers();
    }
}

Ajouter l’héritage à ‘IUserRepository’ à ‘UserRepository’ :

using LootManagerLite.Repositories.Interfaces;
using Microsoft.EntityFrameworkCore;

namespace LootManagerLite.Repositories
{
    public class UserRepository : IUserRepository
...

Ajouter la méthode correspondante dans ‘UserRepositories.cs’

    public User GetAllUsers()
    {
        return context.Users.ToList();
    }

La méthode utilise l’injection de dépendance du contexte pour obtenir la liste des Users.

7- Méthode asynchrone
Une méthode asynchrone est une méthode qui peut être exécutée de manière asynchrone sans bloquer le thread appelant, en utilisant le mot-clé ‘async' et en retournant un objet 'Task'. Elle est couramment utilisée pour améliorer les performances et gérer les opérations d’entrée-sortie.
Modifier la méthode comme ceci pour quelle soit asynchrone :

// Dans IUserRepository

        Task<List<User>> GetAllUsersAsync();

// Dans UserRepository

        public async Task<List<User>> GetAllUsersAsync()
        {
            return await context.Users.ToListAsync();
        }

8- Exemple de méthodes CRUD

Interface

namespace LootManagerLite.Repositories.Interfaces
{
    public interface IUserRepository
    {
        Task<User?> AddUserAsync(User user);
        Task<User?> DeleteUserAsync(int id);
        Task<List<User>> GetAllUsersAsync();
        Task<User?> GetUserByIdAsync(int id);
        Task<User?> GetUserWithElementsAsync(int id);
        Task<User?> UpdateUserAsync(User user);
    }
}

Repository

using LootManagerLite.Repositories.Interfaces;
using Microsoft.EntityFrameworkCore;

namespace LootManagerLite.Repositories
{
    public class UserRepository : IUserRepository
    {
        LootManagerLiteContext context;
        ILogger<UserRepository> logger;
        public UserRepository(LootManagerLiteContext context, ILogger<UserRepository> logger) 
        {
            this.context = context;
            this.logger = logger;
        }

        public async Task<User?> AddUserAsync(User user)
        {
            try
            {
                await context.Users.AddAsync(user);
                await context.SaveChangesAsync();
            }
            catch (Exception e)
            {
                logger.LogError(e?.InnerException.ToString());
                return null;
            }

            return user;
        }

        public async Task<User?> DeleteUserAsync(int id)
        {
            try
            {
                var user = await context.Users.FindAsync(id);
                if (user != null)
                {
                    context.Users.Remove(user);
                    await context.SaveChangesAsync();
                }
                return user;
            }
            catch (Exception e)
            {
                logger.LogError(e?.InnerException.ToString());
                return null;
            }
        }

        public async Task<List<User>> GetAllUsersAsync()
        {
            return await context.Users.ToListAsync();
        }

        public async Task<User?> GetUserByIdAsync(int id)
        {
            return await context.Users.FindAsync(id)!;
        }

        public async Task<User?> GetUserWithElementsAsync(int id)
        {
            return await context.Users.Include(u => u.Elements).FirstOrDefaultAsync(u => u.Id == id);
        }

        public async Task<User?> UpdateUserAsync(User user)
        {
            try
            {
                var existingUser = await context.Users.FindAsync(user.Id);
                if (existingUser != null)
                {
                    existingUser.Name = user.Name;
                    existingUser.Email = user.Email;

                    await context.SaveChangesAsync();
                }
                return existingUser;
            }
            catch (Exception e)
            {
                logger.LogError(e?.InnerException.ToString());
                return null;
            }
        }
    }
}