एक संघ के प्रमुख अंत का अर्थ एंटिटी ढांचे में 1: 1 संबंध में है

Question

public class Foo
{
    public string FooId{get;set;}
    public Boo Boo{get;set;}
}


public class Boo
{
    public string BooId{get;set;}
    public Foo Foo{get;set;}
}

त्रुटि मिलने पर मैं एंटिटी फ्रेमवर्क में यह करने की कोशिश कर रहा था:

प्रकार 'ConsoleApplication5.Boo' और 'ConsoleApplication5.Foo' के बीच संबंध के मुख्य अंत को निर्धारित करने में असमर्थ। इस एसोसिएशन का मुख्य अंत स्पष्ट रूप से या तो संबंध धाराप्रवाह एपीआई या डेटा एनोटेशन का उपयोग करके कॉन्फ़िगर किया जाना चाहिए।

मैंने इस त्रुटि के समाधान के साथ StackOverflow पर प्रश्न देखे हैं, लेकिन मैं समझना चाहता हूं कि "प्रिंसिपल एंड" शब्द का क्या अर्थ है।

Comments

शर्तों की व्याख्या के लिए docs.microsoft.com/en-us/ef/core/modeling/relationships देखें

— DeepSpace101

Answer 1

एक-से-एक संबंध में एक छोर प्रिंसिपल होना चाहिए और दूसरा एंड डिपेंडेंट होना चाहिए। प्रधान अंत वह है जिसे पहले डाला जाएगा और जो बिना आश्रित के मौजूद हो सकता है। आश्रित अंत वह है जो मूलधन के बाद डाला जाना चाहिए क्योंकि इसमें मूलधन की विदेशी कुंजी है।

निर्भरता में इकाई ढांचे के मामले में FK भी इसका PK होना चाहिए ताकि आपके मामले में आपको इसका उपयोग करना चाहिए:

public class Boo
{
    [Key, ForeignKey("Foo")]
    public string BooId{get;set;}
    public Foo Foo{get;set;}
}

या धाराप्रवाह मानचित्रण

modelBuilder.Entity<Foo>()
            .HasOptional(f => f.Boo)
            .WithRequired(s => s.Foo);

Comments

@ लादिस्लाव, मुझे दो स्वतंत्र तालिकाएँ बनाने की ज़रूरत है कि दोनों में एक-दूसरे के लिए एक वैकल्पिक संदर्भ हो (एक से एक), मैं चाहता हूं कि दोनों के पास अपने-अपने पीके हों, यह कैसे संभव है? मैंने एक अलग प्रश्न पोस्ट किया ।

— शिम्मी वेइटहैंडलर

आपको पता नहीं है कि इस का जवाब खोजने में कितने घंटे लगे - एमएस प्रलेखन POOOOOOP ty है।

— गैंगेलो

ध्यान दें कि आपको System.ComponentModel.DataAnnotations.Schema का उपयोग करने की आवश्यकता हो सकती है; VS2012 में फॉरेनकेय को पाने के लिए

— स्टुअर्टेनडनेट

क्या इसका मतलब यह Fooहै कि मूलधन है?

— bflemi3

@ bflemi3 आप सही हैं Booनिर्भर है, एक की आवश्यकता है Foo, और विदेशी कुंजी प्राप्त करता है। Fooप्रिंसिपल है और बिना मौजूद रह सकता है Boo।

— कॉलिन

Answer 2

[Required]इसे हल करने के लिए आप डेटा एनोटेशन विशेषता का भी उपयोग कर सकते हैं :

public class Foo
{
    public string FooId { get; set; }

    public Boo Boo { get; set; }
}

public class Boo
{
    public string BooId { get; set; }

    [Required]
    public Foo Foo {get; set; }
}

Fooके लिए आवश्यक है Boo।

Comments

यह मेरे निम्नलिखित कोड के लिए सही था, जहां मुझे दोनों के बीच एक अलग संस्था पब्लिक क्लास ऑर्गनाइज़ेशन {public int Id {get; सेट; }} सार्वजनिक वर्ग उपयोगकर्ता {सार्वजनिक int Id {प्राप्त करें; सेट; }} सार्वजनिक वर्ग UserGroup {[कुंजी] सार्वजनिक int Id {प्राप्त करें; सेट; } [आवश्यक] सार्वजनिक आभासी संगठन संगठन {प्राप्त करें; सेट; } [आवश्यक] सार्वजनिक आभासी उपयोगकर्ता उपयोगकर्ता {प्राप्त करें; सेट; }}

— एंडीएम

मैं ओरेकल का उपयोग कर रहा हूं और कोई भी धाराप्रवाह एपी मेरे लिए काम नहीं कर रहा है। धन्यवाद भाई। बहुत आसन।

— कैमरनप

इस बात का ध्यान रखें कि इस समाधान का उपयोग करने पर आपको सत्यापन के अपवाद मिलेंगे जब आप Booडेटाबेस से पुनर्प्राप्त करने का प्रयास करते हैं और अपडेट करते हैं, जब तक कि आप पहले Fooसंपत्ति के आलसी-भार को ट्रिगर नहीं करते हैं। Unitframework.codeplex.com/SourceControl/network/forks/…

— NathanAldenSr

Boo Booतब आभासी नहीं होना चाहिए ?

— सिमोन_विवर

@NathanAldenSr लिंक अभी खराब है, आप उस परिवर्तन को कैसे बनाते हैं?

— कैमहार्ट

Answer 3

यह वन-टू-वन संबंध को कॉन्फ़िगर करने के लिए धाराप्रवाह एपीआई का उपयोग करने पर @Ladislav Mrnka के जवाब के संदर्भ में है।

एक ऐसी स्थिति थी जहाँ FK of dependent must be it's PKहोना संभव नहीं था।

उदाहरण के लिए, Fooपहले से ही एक-से-कई संबंध हैं Bar।

public class Foo {
   public Guid FooId;
   public virtual ICollection<> Bars; 
}
public class Bar {
   //PK
   public Guid BarId;
   //FK to Foo
   public Guid FooId;
   public virtual Foo Foo;
}

अब, हमें फू और बार के बीच एक-से-एक संबंध जोड़ना था।

public class Foo {
   public Guid FooId;
   public Guid PrimaryBarId;// needs to be removed(from entity),as we specify it in fluent api
   public virtual Bar PrimaryBar;
   public virtual ICollection<> Bars;
}
public class Bar {
   public Guid BarId;
   public Guid FooId;
   public virtual Foo PrimaryBarOfFoo;
   public virtual Foo Foo;
}

धाराप्रवाह एपीआई का उपयोग करते हुए एक-से-एक रिश्ते को कैसे निर्दिष्ट किया जाए:

modelBuilder.Entity<Bar>()
            .HasOptional(p => p.PrimaryBarOfFoo)
            .WithOptionalPrincipal(o => o.PrimaryBar)
            .Map(x => x.MapKey("PrimaryBarId"));

ध्यान दें कि जोड़ने की PrimaryBarIdजरूरत है, जबकि हम धाराप्रवाह एपीआई के माध्यम से इसे हटाने की जरूरत है।

यह भी ध्यान दें कि विधि का नाम [WithOptionalPrincipal()][1]एक प्रकार की विडंबना है। इस मामले में, प्रिंसिपल बार हैं। Msdn पर withOptionalDependent () विवरण इसे और अधिक स्पष्ट करता है।

Comments

क्या होगा यदि आप वास्तव में संपत्ति चाहतेPrimaryBarId हैं? यह मेरे लिए हास्यास्पद है। यदि मैं संपत्ति जोड़ता हूं और कहता हूं कि यह विदेशी कुंजी है, तो मुझे एक त्रुटि मिलती है। लेकिन अगर मेरे पास संपत्ति नहीं है, तो ईएफ इसे वैसे भी बनाएगा। क्या फर्क पड़ता है?

— क्रिस प्रैट

@ChrisPratt यह उचित नहीं लग सकता है। मैं निशान और त्रुटि के बाद इस समाधान पर पहुंचा। जब मेरे पास इकाई PrimayBarIdमें संपत्ति थी तो मैं एक-से-एक मैपिंग को कॉन्फ़िगर करने में सक्षम नहीं था Foo। संभवत: वही उपाय जो आपने आजमाया। ईएफ में सीमाएं शायद?

— सुदर्शन_एसएमडी

हाँ यह है। मुझे पता चला है कि इस दिन के लिए ईएफ ने कभी भी अद्वितीय अनुक्रमित नहीं किया है। नतीजतन, एक-से-एक मैप करने के लिए उपलब्ध एकमात्र तरीका प्रिंसिपल एंड की प्राथमिक कुंजी पर निर्भर अंत की प्राथमिक कुंजी के रूप में उपयोग करना है, क्योंकि एक प्राथमिक कुंजी प्रकृति द्वारा अद्वितीय है। दूसरे शब्दों में, उन्होंने इसे आधा लागू किया और एक ऐसा शॉर्टकट लिया जो यह तय करता है कि आपकी तालिकाओं को गैर-मानक तरीके से डिज़ाइन करना है।

— क्रिस प्रैट