फ्लुएंट एनएचबेर्नेट - एक सबक्लास को एक-से-एक मानचित्र कैसे मैप करें?

Question

मान लीजिए कि मेरे पास तीन वर्ग हैं। यह ए को तुरंत चालू करने के लिए मान्य है, लेकिन विशेष मामलों बी और डी भी हैं जो उप-वर्ग ए को जोड़ते हैं, अतिरिक्त जानकारी जोड़ते हैं।

मैं इसके लिए (धाराप्रवाह) NHibernate में मैपिंग फ़ाइलों को कैसे करूं?

public class A 
{ 
    public int ID { get; set;} 
    public string CommonProperty1 { get; set; } 
    public string CommonProperty2 { get; set; } 
} 

public class B : A 
{ 
    public string BSpecificProperty1 { get; set; } //not null 
    public string BSpecificProperty2 { get; set; } //not null 
} 

public class D : A 
{ 
    public string DSpecificProperty { get; set; } //not null 
} 

मैं निम्नलिखित की कोशिश की है, लेकिन यह सब पर काम नहीं करता:

public class AMap : ClassMap<A> 
{ 
    public AMap() 
    { 
     Id(x => x.ID); 

     Map(x => x.CommonProperty1); 
     Map(x => x.CommonProperty2); 
    } 
} 

public class BMap : ClassMap<B> 
{ 
    public BMap() 
    { 
     References(x => x.ID); 
     Map(x => x.BSpecificProperty1) 
      .CanNotBeNull(); 
     Map(x => x.BSpecificProperty2) 
      .CanNotBeNull(); 
    } 
} 

public class DMap : ClassMap<D> 
{ 
    public DMap() 
    { 
     References(x => x.ID); 

     Map(x => x.DSpecificProperty) 
      .CanNotBeNull(); 
    } 
} 

Answer 1

मुझे यकीन है कि मैं समझता हूँ कि आप "एक उपवर्ग नक्शा एक-से-एक" द्वारा क्या मतलब है नहीं कर रहा हूँ, लेकिन अगर आप विरासत जहां उपवर्गों गुण है कि नल नहीं हैं मैप करना चाहते हैं, तो आप Fluent-NHibernate में इस तरह कर सकते हैं:

// Domain classes 
public class Animal 
{ 
    public virtual int Id { get; set; } 
    public virtual string Name { get; set; } 
} 

public class Cat : Animal 
{ 
    public virtual int WhiskerLength { get; set; } 
    public virtual int ClawCount { get; set; } 
} 

public class Dog : Animal 
{ 
    public virtual int TailWagRate { get; set; } 
} 



// Mapping file 
public class AnimalMap : ClassMap<Animal> 
{ 
    public AnimalMap() 
    { 
     Id(x => x.Id) 
      .WithUnsavedValue(0) 
      .GeneratedBy.Native(); 

     Map(x => x.Name); 

     var catMap = JoinedSubClass<Cat>("CatId", sm => sm.Map(x => x.Id)); 

     catMap.Map(x => x.WhiskerLength) 
      .CanNotBeNull(); 
     catMap.Map(x => x.ClawCount) 
      .CanNotBeNull(); 

     JoinedSubClass<Dog>("DogId", sm => sm.Map(x => x.Id)) 
      .Map(x => x.TailWagRate) 
       .CanNotBeNull(); 
    } 
} 

जब से तुम नहीं-अशक्त होने की उपवर्गों 'गुण चाहते हैं, आप के लिए है टेबल-प्रति-वर्ग का उपयोग करें (शामिल-उप-वर्ग) विरासत मॉडलिंग का तरीका। ऐसा इसलिए है क्योंकि तालिका-प्रति-पदानुक्रम के लिए सभी सबक्लास गुणों को निरर्थक होना आवश्यक है।

मुझे उम्मीद है कि यह मदद करता है।

/एरिक

Answer 2

वाक्य रचना एरिक की पोस्ट के बाद से FNH में परिवर्तित हो गई हों, लेकिन उनके उदाहरण सही निशाने पर है। यहां कुछ कोड है जो मैंने एफएनएच के माध्यम से काम करने के लिए एरिक की पोस्ट के आधार पर उपयोग किया है, जो मुझे अभी पता है कि दो एफएनएच सबक्लास रणनीतियों (सबक्लस (नीचे टिप्पणी की गई कोड, और शामिलस्कूल क्लास)। एक तरफ, मैंने अन्य नामों का वर्णन करने के लिए उपयोग किया है एक ही रणनीति, NHibernate डॉक्स, जो जब यह आपके लिए नया है थोड़ा भ्रामक है में भी शामिल है। (https://www.hibernate.org/hib_docs/nhibernate/html/inheritance.html)।

// Domain classes 
public class Animal : Entity 
{ 
    public virtual string Name { get; set; } 
    public virtual string Unwanted { get; set; } 
} 

public class Cat : Animal 
{ 
    public virtual int WhiskerLength { get; set; } 
    public virtual int ClawCount { get; set; } 
} 

public class Dog : Animal 
{ 
    public virtual int TailWagRate { get; set; } 
} 

public class Boxer : Dog 
{ 
    public string DroolBucket { get; set; } 
} 

public class AnimalMapJoinedSubclassOverride : IAutoMappingOverride<Animal> 
{ 
    public void Override(AutoMap<Animal> mapping) { 
     mapping.Map(x => x.Name); 

     mapping.IgnoreProperty(x => x.Unwanted); 

     mapping.JoinedSubClass("CatId", CatMap.AsJoinedSubClass()); 
     mapping.JoinedSubClass("DogId", DogMap.AsJoinedSubClass()); 
     //mapping.DiscriminateSubClassesOnColumn("Type") 
     // .SubClass<Cat>("CatId", CatMap.AsSubClass()) 
     // .SubClass<Dog>("CatId", DogMap.AsSubClass()); 
    } 
} 

public class CatMap 
{ 
    public static Action<JoinedSubClassPart<Cat>> AsJoinedSubClass() 
    { 
     return part => 
     { 
      part.Map(x => x.ClawCount).Not.Nullable(); 
      part.Map(x => x.WhiskerLength).Not.Nullable(); 
     }; 
    } 

    public static Action<SubClassPart<Cat>> AsSubClass() 
    { 
     return part => 
     { 
      part.Map(x => x.ClawCount); 
      part.Map(x => x.WhiskerLength); 
     }; 
    } 
} 

public class DogMap 
{ 
    public static Action<JoinedSubClassPart<Dog>> AsJoinedSubClass() 
    { 
     return sub => 
     { 
      sub.Map(x => x.TailWagRate).Not.Nullable(); 
     }; 
    } 

    public static Action<SubClassPart<Dog>> AsSubClass() 
    { 
     return sub => 
     { 
      sub.Map(x => x.TailWagRate); 
     }; 
    } 
} 

public class BoxerMap 
{ 
    public static Action<JoinedSubClassPart<Boxer>> AsJoinedSubClass() 
    { 
     return sub => 
     { 
      sub.Map(x => x.DroolBucket); 
     }; 
    } 

    public static Action<SubClassPart<Boxer>> AsSubClass() 
    { 
     return sub => 
     { 
      sub.Map(x => x.DroolBucket); 
     }; 
    } 
}