Automapper insieme Dependency Injection

Question

Al momento ho il seguente mappatura:

Mapper.CreateMap<Journal, JournalDto>(); 

Ora, Journal contiene un membro denominato RefTypeID, che esiste valore corrispondente in un'altra tabella del database; per cercare questo valore, ho un servizio che gestisce una semplice richiesta int -> string. La configurazione dell'automa- tore automatico si trova attualmente in una classe statica all'inizio del programma. Va bene spostare il codice di mappatura in una classe che viene iniettata nel mio contenitore DI o esiste un modo migliore?

Answer 1

Ecco come ho risolto:

ho definito un IMappingCreator interfaccia:

public interface IMappingCreator 
{ 
    void CreateMappings(); 
} 

sono andato avanti e implementato una classe con tale interfaccia (sto usando MEF come contenitore DI, è lì gli attributi vengono Provenendo dalla) che è messo nel contenitore dI come IMappingCreator:

[Export(typeof(IMappingCreator))] 
    public class Mapping : IMappingCreator 
    { 
     private readonly IRefTypesLookup iRefTypesLookup; 


     [ImportingConstructor] 
     public Mapping(IRefTypesLookup rtl) 
     { 
      iRefTypesLookup = rtl; 
     } 

     public void CreateMappings() 
     { 
      Mapper.CreateMap<Journal, DisplayJournal>().AfterMap((j, dj) => dj.RefTypeName = iRefTypesLookup.Lookup(j.RefTypeID)); 
     } 
    } 

Infine, a mio avvio dell'applicazione, vado a prendere tutte Instan ES di tale interfaccia nel contenitore e chiamare il metodo CreateMappings su di loro:

var mappings = container.GetExportedValues<IMappingCreator>(); 

    foreach (IMappingCreator mc in mappings) 
    { 
     mc.CreateMappings(); 
    } 

Questo rende la configurazione iniziale abbastanza facile, come tutta la creazione avviene in un unico luogo, e si può avere il maggior numero di creatori di mappatura come si desidera (tuttavia, è necessario mantenerli al minimo, magari una volta per progetto o giù di lì, afferrando tutti i servizi necessari per mappare i tipi specifici in quel progetto).

Answer 2

È possibile utilizzare Dipendenza dal IMappingEngine anziché utilizzare la classe statica Mapper.

C'è un bel post su di esso qui: Mocking out AutoMapper with Dependency Injection

Answer 3

Un modo migliore è quello di utilizzare un resolver cliente. configurazione della mappatura è destinato ad essere statico, in modo resolver personalizzati hanno lo scopo di fornire la mappatura per un singolo membro:

Mapper.Initialize(cfg => { 
    cfg.ConstructServicesUsing(type => WhateverMefUsesToGetInstances.GetInstance(type)); 

    cfg.CreateMap<Journal, DisplayJournal>() 
     .ForMember(dest => dest.RefTypeName, 
      opt => opt.ResolveUsing<RefTypeNameResolver>()); 
}); 

Allora il tuo resolver diventa:

[Export(typeof(IRefTypeNameResolver))] 
public class RefTypeNameResolver : ValueResolver<Journal, string>, IRefTypeNameResolver 
{ 
    private readonly IRefTypesLookup iRefTypesLookup; 

    [ImportingConstructor] 
    public RefTypeNameResolver (IRefTypesLookup rtl) 
    { 
     iRefTypesLookup = rtl; 
    } 

    protected override string ResolveCore(Journal source) 
    { 
     return iRefTypesLookup.Lookup(source.RefTypeID); 
    } 
} 

configurazione ha bisogno per eseguire una volta, che è il motivo per cui la API di configurazione fornisce agganci nella API esecuzione (convertitori di tipi, resolver valore etc.)

Answer 4

Ecco il nuovo modo di farlo ...

https://pintoservice.wordpress.com/2016/01/31/dependency-injection-for-automapper-4-2-in-asp-net-vnext-mvc-project/

Anche se personalmente aggiungo gli auto-mapping nel controller, non nel repository. In questo modo è possibile utilizzare lo stesso repository per diversi controller e avere mappature differenti. Lo stesso concetto, però, è sufficiente iniettare lo IMapper nel controller anziché nel repository.