// ENTITIES
public class Message{
    public virtual int Id { get; set; }
    public virtual ICollection<MessageReference> MessageReference { get; set; }
}
public class A{
    public virtual int Id { get; set; }
    public virtual ICollection<MessageA> Message { get; set; }
}
public class B{
    public virtual int Id { get; set; }
    public virtual ICollection<MessageB> Message { get; set; }
}
public abstract class MessageReference{
    public virtual int Id { get; set; }
	public virtual int MessageId { get; set; }
    public virtual Message Message { get; set; }
    public abstract object Reference { get; }
}
public class MessageA : MessageReference{
    public virtual ICollection<A> A { get; set; }
    public override object Reference { get { return A != null ? A.FirstOrDefault() : null; } }
}
public class MessageB : MessageReference {
    public virtual ICollection<B> B { get; set; }
    public override object Reference { get { return B != null ? B.FirstOrDefault() : null; } }
}
// MAP FLUENT
public class MessageAMap : EntityTypeConfiguration<MessageA>{
    public MessageAMap(){
        HasMany(s => s.A).WithMany(s => s.Message).Map(m => {
            m.MapLeftKey("MessageA_Id");
            m.MapRightKey("A_Id");
            m.ToTable("MessageA");});
    }
}
public class MessageBMap : EntityTypeConfiguration<MessageB>{
    public MessageBMap(){
        HasMany(s => s.B).WithMany(s => s.Message).Map(m => {
            m.MapLeftKey("MessageB_Id");
            m.MapRightKey("B_Id");
            m.ToTable("MessageB");});
    }
}
// BUILD
protected override void OnModelCreating(DbModelBuilder modelBuilder){
    modelBuilder.Entity<MessageReference>()
        .Map<MessageA>(m => m.Requires("Discriminator").HasValue("MessageA"))
        .Map<MessageB>(m => m.Requires("Discriminator").HasValue("MessageB"));
    modelBuilder.Configurations.Add(new MessageAMap());
    modelBuilder.Configurations.Add(new MessageBMap());
}

public class Message {
    public virtual int Id { get; set; }
    public virtual string Content { get; set; }
    public virtual IList<MessageReferences> MessageReference { get; set; }
}
public abstract class MessageReferences {
    public virtual int Id { get; set; }
    public virtual Message Message { get; set; }
    public abstract object Reference { get; }
}
public class MessageA : MessageReferences {
    public virtual A A { get; set; }
    public override object Reference { get { return A; } }
}
public class MessageB : MessageReferences {
    public virtual B B { get; set; }
    public override object Reference { get { return B; } }
}
public class Catalog {
    public virtual int Id { get; set; }
    public virtual string Articule { get; set; }
}
public class A : Catalog {
    public virtual string Name { get; set; }
    public virtual IList<MessageA> Message { get; set; }
}
public class B : Catalog {
    public virtual string Cool { get; set; }
    public virtual IList<MessageB> Message { get; set; }
}
// MAPPING
public class CatalogMap : ClassMap<Catalog> {
    public CatalogMap() {
        Schema("dbo"); 
		Table("Catalog");
        Id(p => p.Id).Column("Id");
        Map(p => p.Articule).Column("Articule");
    }
}
public class AMap : SubclassMap<A> {
    public AMap() {
        Schema("dbo");
        Table("A");
        KeyColumn("Id");
        Map(p => p.Name).Column("Name");
        HasMany(x => x.Message).Table("MessageA").KeyColumn("A_Id").Inverse().Cascade.AllDeleteOrphan();
    }
}
public class BMap : SubclassMap<B> {
    public BMap() {
        Schema("dbo");
        Table("B");
        KeyColumn("Id");
        Map(p => p.Cool).Column("Cool");
        HasMany(x => x.Message).Table("MessageB").KeyColumn("B_Id").Inverse().Cascade.AllDeleteOrphan();
    }
}
public class MessageMap : ClassMap<Message>{
    public MessageMap(){
        Schema("dbo");
        Table("Message");
        Id(p => p.Id).Column("Id");
        Map(p => p.Content).Column("Content");
        HasMany(x => x.MessageReference).KeyColumn("MessageId");
    }
}
public class MessageReferencesMap : ClassMap<MessageReferences> {
    public MessageReferencesMap() {
        Id(x => x.Id).Column("Id");
        DiscriminateSubClassesOnColumn("Discriminator");
    }
}
public class MessageAMap : SubclassMap<MessageA> {
    public MessageAMap() {
        Schema("dbo");
        able("MessageA");
        DiscriminatorValue("MessageA");
        HasOne(x => x.A).ForeignKey("A_Id").Cascade.None();
        HasOne(x => x.Message).ForeignKey("MessageA_Id").Cascade.None();
    }
}
public class MessageBMap : SubclassMap<MessageB> {
    public MessageBMap()
    {
        Schema("dbo");
        Table("MessageB");         
        DiscriminatorValue("MessageB");
        HasOne(x => x.B).ForeignKey("B_Id").Cascade.None();
        HasOne(x => x.Message).ForeignKey("MessageB_Id").Cascade.None();
    }
}