Fluent NHibernate JoinedSubClass obsoleto

Question

Mi chiedo qualcosa. Sono seduto qui con una soluzione lì ho 1 superclasse che ha 2 sottoclassi e attualmente sto mappando questo usando JoinedSubClass, ma ottengo che questo metodo è obsoleto e dice che dovrei ClassMap e SubClassMap, ma se lo faccio l'AutoMapping non funziona e non lo voglio. C'è qualche soluzione alternativa per questo?

Ecco la gerarchia:

public class Tag : Entity 
{ 

public virtual string Name {get;set;} 
public virtual User User {get;set;} 

} 

public class RespondentTag : Tag 
{ 
    public virtual IList<Respondent> Respondents {get;set;} 
} 


public class ArchiveTag : Tag 
{ 
    public virtual IList<Survey> Surveys {get;set;} 
} 

Come probabilmente capito io voglio che questo sia un tavolo per ogni gerarchia di mappatura con sottoclassi con le liste che sono molti-a-molti. Come una tabella "Tag", quindi Tag_Respondent e Tag_Archive (per la relazione many-to-many).

Ecco la mappatura che sono attualmente in uso:

public class TagMap : IAutoMappingOverride<Tag> 
{ 
    public void Override(AutoMapping<Tag> mapping) 
    { 
    //This is obsolete 
    mapping.JoinedSubClass("RespondentTagId", RespondentTagMap.AsJoinedSubClass()); 
    mapping.JoinedSubClass("ArchiveTagId", ArchiveTagMap.AsJoinedSubClass()); 

    } 
} 

public class RespondentTagMap 
{ 
    public static Action<JoinedSubClassPart<RespondentTag>> AsJoinedSubClass() 
    { 
    return part => 

     part.HasManyToMany(x => x.RespondentList) 
      .Cascade 
      .SaveUpdate() 
      .Inverse() 
      .Table("Tag_Respondent"); 

    } 
} 


public class ArchiveTagMap 
{ 
    public static Action<JoinedSubClassPart<ArchiveTag>> AsJoinedSubClass() 
    { 
    return part => 

     part.HasManyToMany(x => x.Surveys) 
      .Cascade 
      .SaveUpdate() 
      .Inverse() 
      .Table("Tag_Archive"); 

    } 
} 

Qualcuno sa su una soluzione o un'altra soluzione per risolvere questo? (Senza disattivare la creazione automatica)

Qualsiasi risposta sarà apprezzata.

Grazie in anticipo!

Answer 1

Perdonami se sto fraintendendo il tuo obiettivo, ma mi prendo una coltellata perché ho un'eredità simile nel mio progetto (anche se io uso un modello di tabella per base-classe con una colonna discriminante).

io credo che si possa realizzare quello che stai cercando di fare avendo FNH ignorare la classe Tag base, quindi ignorando la mappatura sui vostri RespondentTag e ArchiveTag oggetti per implementare la relazione molti-a-molti. Quindi, nella configurazione FNH, devi specificare un argomento al vostro mappature chiamata:

m.AutoMappings.Add(AutoMap.AssemblyOf<SomeObjectInMyAssembly>(new MyAutoMapConfig()) // Assuming you're using a config class 
    .IgnoreBase(typeof(Entity)) 
    .IgnoreBase(typeof(Tag)) 
    .UseOverridesFromAssemblyOf<SomeOverrideClass>()); 

Allora dovreste impostare le sostituzioni in qualunque assemblea li stai memorizzazione. Avresti qualcosa di simile:

public class RespondentTagOverride : IAutoMappingOverride<RespondentTag> 
{ 
    public void Override(AutoMapping<RespondentTag> mapping) 
    { 
     mapping.HasManyToMany(x => x.RespondentList) 
      .Cascade 
      .SaveUpdate() 
      .Inverse() 
      .Table("Tag_Respondent"); // Not sure if the table call works in the override...you may have to use a convention for this 
    } 
} 

Lo stesso vale per l'oggetto ArchiveTag.

che è simile a quello che faccio nel mio schema di successione, anche se, come ho già detto, nella mia classe automap config ho sovrascrivere il metodo IsDiscriminated per indicare che i miei oggetti sono tabella-per-classe base e discriminati.