Come si registrano le sottoclassi di DapperExtension ClassMapper in modo che vengano utilizzate?

Question

Ho appena iniziato a giocare con DapperExtensions e sembra molto promettente. Tuttavia, sono confuso su come gestire la registrazione delle sottoclassi di ClassMapper.

Ho sia un PluralizedAutoClassMapper personalizzato che un ClassMapper normale e sto provando ad usarli entrambi.

Ecco il mio mapper pluralizzato ...

public class CustomPluralizedMapper<T> : PluralizedAutoClassMapper<T> 
where T : class 
{ 
    private readonly Type[] SinglularTablePocoTypes = new []{ 
     typeof(LibraryInfo) 
    }; 

    public override void Table(string tableName) 
    { 
     base.Table(tableName); 

     if(SinglularTablePocoTypes.Any(type => string.Equals(type.Name, tableName, StringComparison.CurrentCultureIgnoreCase))) 
      TableName = tableName; 
    } 
} 

... ed ecco il mapper appositamente per la classe LibraryInfo

public class LibraryInfoMapper : ClassMapper<LibraryInfo> 
{ 
    public LibraryInfoMapper() 
    { 
     Map(libraryInfo => libraryInfo.Name).Column("LibraryName"); 
     Map(libraryInfo => libraryInfo.Description).Column("LibraryDescription"); 
     AutoMap(); 
    } 
} 

Il PluralizedAutoClassMapper ho potuto lavorare chiamando il seguente ...

DapperExtensions.DapperExtensions.DefaultMapper = typeof(CustomPluralizedMapper<>); 

Ma non sono sicuro di come utilizzare l'altro allo stesso tempo. Cosa mi manca?

Answer 1

Ok, l'ho capito. Il problema era perché sto usando IoC e i miei POCO si trovano in un assemblaggio diverso dalle mappature.

In breve, il mio modello non ha idea, né si preoccupa di dove o come viene memorizzato. Definisce solo un'interfaccia che descrive come deve interagire con quella memoria. Il mio DAL definisce una classe che implementa quell'interfaccia e utilizza SQLite come supporto di archiviazione. Poiché le mappature hanno senso solo per quanto riguarda SQLite, è qui che ho definito i mapping.

Il problema è DapperExtensions riflette nell'assembly che definisce i POCO in cerca di ClassMappers, ma poiché i miei erano in un assembly diverso, non venivano trovati.

Tuttavia, si può dire DapperExtensions per cercare assembly esterni tramite la seguente riga di codice ...

DapperExtensions.DapperExtensions.SetMappingAssemblies(new[]{ 
    assemblyA, assemblyB, ...assemblyN 
}); 

Quindi siccome i miei mappature sono definiti nello stesso luogo come la mia classe Mapper statica (che ha la statica 'Initialize' chiamata) tutto quello che ora devo fare è dire DapperExtensions per cercare lì in questo modo ...

public static class Mappings 
{ 
    public static void Initialize() 
    { 
     DapperExtensions.DapperExtensions.DefaultMapper = typeof(CustomPluralizedMapper<>); 

     DapperExtensions.DapperExtensions.SetMappingAssemblies(new[] 
     { 
      typeof(Mappings).Assembly 
     }); 
    } 

    public class CustomPluralizedMapper<T> : PluralizedAutoClassMapper<T> 
    where T : class 
    { 
     ... 
    } 

    public class LibraryInfoMapper : ClassMapper<LibraryInfo> 
    { 
     ... 
    } 
} 

E ora tutto funziona!

Meglio ancora, dal momento che posso specificare il nome della tabella nella LibraryInfoMapper, c'è in realtà alcun bisogno per il mio CustomPluralizedMapper e quindi posso solo usare il PluralizedAutoClassMapper standard come così ...

public static class Mappings 
{ 
    public static void Initialize() 
    { 
     DapperExtensions.DapperExtensions.DefaultMapper = typeof(PluralizedAutoClassMapper<>); 

     DapperExtensions.DapperExtensions.SetMappingAssemblies(new[] 
     { 
      typeof(Mappings).Assembly 
     }); 
    } 

    public class LibraryInfoMapper : ClassMapper<LibraryInfo> 
    { 
     public LibraryInfoMapper() 
     { 
      Table("LibraryInfo"); 
      AutoMap(); 
     } 
    } 
} 

fatto e fatto! C'era una documentazione ZERO su come scoprirlo, quindi spero che questo aiuti gli altri!