Utilisez AutoMapper pour ajouter, mettre à jour et supprimer des éléments dans la liste

AutoMapper n'a-t-il pas une approche native de la mise à jour des listes imbriquées dans lesquelles les instances doivent être supprimées, ajoutées ou mises à jour ?

Bonjour, j'utilise AutoMapper dans mon application ASP.Net Core avec EF Core pour mapper mes ressources API à mes modèles. Cela fonctionne bien pour la plupart de mes applications, mais je ne suis pas satisfait de ma solution de mise à jour des listes imbriquées mappées où les instances répertoriées doivent persister. Je ne veux pas écraser la liste existante, je veux supprimer les instances qui ne sont plus dans ma ressource entrante, ajouter de nouvelles instances et mettre à jour les instances existantes.

Les modèles:

public class MappingProfile : Profile
{
    public MappingProfile()
    {
        CreateMap<MainObject, MainObjectResource>();
        CreateMap<SubItem, SubItemResource>();

        CreateMap<MainObject, MainObjectResource>().ReverseMap()
        .ForMember(m => m.Id, opt => opt.Ignore())
        .ForMember(m => m.SubItems, opt => opt.Ignore())
        .AfterMap((mr, m) => {
                //To remove
                List<MainObject> removedSubItems = m.SubItems.Where(si => !mr.SubItems.Any(sir => si.Id == sir.Id)).ToList();
                foreach (SubItem si in removedSubItems)
                    m.SubItems.Remove(si);
                //To add
                List<SubItemResource> addedSubItems = mr.SubItems.Where(sir => !m.SubItems.Any(si => si.Id == sir.Id)).ToList();
                foreach (SubItemResource sir in addedSubItems)
                    m.SubItems.Add( new SubItem {
                        Value = sir.Value,
                    });
                // To update
                List<SubItemResource> updatedSubItems = mr.SubItems.Where(sir => m.SubItems.Any(si => si.Id == sir.Id)).ToList();
                SubItem subItem = new SubItem();
                foreach (SubItemResource sir in updatedSubItems)
                {
                    subItem = m.SubItems.SingleOrDefault(si => si.Id == sir.Id);
                    subItem.Value = sir.Value;
                }
            });
    }
}

Les ressources:

public class MainController : Controller
{
    private readonly IMapper mapper;
    private readonly IMainRepository mainRepository;
    private readonly IUnitOfWork unitOfWork;

    public MainController(IMapper mapper, IMainRepository mainRepository, IUnitOfWork unitOfWork)
    {
        this.mapper = mapper;
        this.mainRepository = mainRepository;
        this.unitOfWork = unitOfWork;
    }

    [HttpPut("{id}")]
    public async Task<IActionResult> UpdateMain(int id, [FromBody] MainObjectResource mainObjectResource)
    {
        MainObject mainObject = await mainRepository.GetMain(id);
        mapper.Map<MainObjectResource, MainObject>(mainObjectResource, mainObjectResource);
        await unitOfWork.CompleteAsync();

        return Ok(); 
    }
}

Le contrôleur:

public class MainObjectResource
{
    public int Id { get; set; }
    public ICollection<SubItemResource> SubItems { get; set; }

}

public class SubItemResource
{
    public int Id { get; set; }
    public double Value { get; set; }
}

Le profil de mappage:

public class MainObject
{
    public int Id { get; set; }
    public List<SubItem> SubItems { get; set; }

}

public class SubItem
{
    public int Id { get; set; }
    public int MainObjectId { get; set; }
    public MainObject MainObject { get; set; }
    public double Value { get; set; }
}

Ce que je fais ici est un mappage personnalisé, mais je pense que c'est un cas tellement générique que je m'attends à ce qu'AutoMapper soit capable de gérer cela avec une extension. J'ai vu quelques exemples où le profil de mappage utilise un mappage personnalisé (.AfterMap), mais le mappage réel est effectué par une instance statique d'AutoMapper. Je ne suis pas sûr que cela soit approprié pour mon utilisation d'AutoMapper via l'injection de dépendances: je ne suis pas un programmeur expérimenté mais cela ne me semble pas correct.