Wie registrieren Sie DapperExtension ClassMapper-Unterklassen, damit sie verwendet werden?

Question

Ich habe gerade angefangen mit DapperExtensions zu spielen und es sieht sehr vielversprechend aus. Ich bin jedoch verwirrt, wie die Registrierung der ClassMapper-Unterklassen zu behandeln ist.

Ich habe sowohl einen benutzerdefinierten PluralizedAutoClassMapper und einen regulären ClassMapper und ich versuche beide zu verwenden.

Hier ist mein pluralisierte Mapper ...

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; 
    } 
} 

... und hier ist die Mapper speziell für die LibraryInfo Klasse

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

Die PluralizedAutoClassMapper ich telefonisch unter der an die Arbeit ...

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

Aber ich bin mir nicht sicher, wie man den anderen zur gleichen Zeit benutzt. Was vermisse ich?

Answer 1

Ok, ich habe es herausgefunden. Das Problem war, weil ich IoC verwende und meine POCOs in einer anderen Assembly als die Mappings sind.

Kurz gesagt, mein Modell hat keine Ahnung und kümmert sich nicht darum, wo oder wie es gelagert wird. Es definiert nur eine Schnittstelle, die beschreibt, wie es mit diesem Speicher interagieren muss. Meine DAL definiert eine Klasse, die diese Schnittstelle implementiert und SQLite verwendet, da sie Speicher unterstützt. Da die Mappings nur in Bezug auf SQLite sinnvoll sind, habe ich dort die Mappings definiert.

Das Problem ist DapperExtensions reflektiert in die Baugruppe, die die POCOs auf der Suche nach ihren ClassMapper definiert, aber da meins in einer anderen Baugruppe waren, wurden sie nicht gefunden.

Sie können jedoch DapperExtensions sagen externe Baugruppen über die folgende Codezeile suchen ...

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

So da meine Zuordnungen in der gleichen Stelle wie meine statische Mapper-Klasse definiert sind (die die statische ‚initialisieren‘ Call) alles, was ich jetzt tun müssen, ist DapperExtensions zu sagen, es zu suchen, wie so ...

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> 
    { 
     ... 
    } 
} 

Und jetzt alles funktioniert!

Noch besser wäre es, da ich den Tabellennamen in der LibraryInfoMapper angeben können, gibt es eigentlich keine Notwendigkeit für meine CustomPluralizedMapper und deshalb kann ich nur den Standard PluralizedAutoClassMapper wie so ...

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(); 
     } 
    } 
} 

Fertig und fertig! Es gab ZERO-Dokumentation, um das herauszufinden, also hoffe ich, dass dies anderen hilft!