कोड तालिका में अतिरिक्त फ़ील्ड के साथ, पहले कई को कई बनाएँ


297

मेरे पास यह परिदृश्य है:

public class Member
{
    public int MemberID { get; set; }

    public string FirstName { get; set; }
    public string LastName { get; set; }

    public virtual ICollection<Comment> Comments { get; set; }
}

public class Comment
{
    public int CommentID { get; set; }
    public string Message { get; set; }

    public virtual ICollection<Member> Members { get; set; }
}

public class MemberComment
{
    public int MemberID { get; set; }
    public int CommentID { get; set; }
    public int Something { get; set; }
    public string SomethingElse { get; set; }
}

मैं धाराप्रवाह एपीआई के साथ अपने सहयोग को कैसे कॉन्फ़िगर करूं ? या एसोसिएशन टेबल बनाने का एक बेहतर तरीका है?

जवाबों:


524

एक अनुकूलित जॉइन टेबल के साथ कई-से-कई संबंध बनाना संभव नहीं है। कई-से-कई संबंधों में ईएफ आंतरिक रूप से और छिपी हुई तालिका में शामिल होता है। यह आपके मॉडल में एक इकाई वर्ग के बिना एक तालिका है। अतिरिक्त गुणों वाली इस तरह की ज्वाइन टेबल के साथ काम करने के लिए आपको वास्तव में दो एक-से-कई संबंध बनाने होंगे। यह इस तरह दिख सकता है:

public class Member
{
    public int MemberID { get; set; }

    public string FirstName { get; set; }
    public string LastName { get; set; }

    public virtual ICollection<MemberComment> MemberComments { get; set; }
}

public class Comment
{
    public int CommentID { get; set; }
    public string Message { get; set; }

    public virtual ICollection<MemberComment> MemberComments { get; set; }
}

public class MemberComment
{
    [Key, Column(Order = 0)]
    public int MemberID { get; set; }
    [Key, Column(Order = 1)]
    public int CommentID { get; set; }

    public virtual Member Member { get; set; }
    public virtual Comment Comment { get; set; }

    public int Something { get; set; }
    public string SomethingElse { get; set; }
}

यदि आप अब सभी सदस्यों की टिप्पणियों को LastName"= स्मिथ" के साथ खोजना चाहते हैं , उदाहरण के लिए आप इस तरह से एक प्रश्न लिख सकते हैं:

var commentsOfMembers = context.Members
    .Where(m => m.LastName == "Smith")
    .SelectMany(m => m.MemberComments.Select(mc => mc.Comment))
    .ToList();

... और ...

var commentsOfMembers = context.MemberComments
    .Where(mc => mc.Member.LastName == "Smith")
    .Select(mc => mc.Comment)
    .ToList();

या "स्मिथ" नाम के साथ सदस्यों की एक सूची बनाने के लिए (हम मानते हैं कि एक से अधिक है) उनकी टिप्पणियों के साथ आप एक प्रक्षेपण का उपयोग कर सकते हैं:

var membersWithComments = context.Members
    .Where(m => m.LastName == "Smith")
    .Select(m => new
    {
        Member = m,
        Comments = m.MemberComments.Select(mc => mc.Comment)
    })
    .ToList();

यदि आप किसी सदस्य की सभी टिप्पणियों को MemberId= 1 के साथ खोजना चाहते हैं :

var commentsOfMember = context.MemberComments
    .Where(mc => mc.MemberId == 1)
    .Select(mc => mc.Comment)
    .ToList();

अब आप अपनी ज्वाइन टेबल के गुणों को भी फ़िल्टर कर सकते हैं (जो कि कई-कई संबंधों में संभव नहीं होगा), उदाहरण के लिए: सदस्य 1 की सभी टिप्पणियों को फ़िल्टर करें जिनकी संपत्ति 99 है Something:

var filteredCommentsOfMember = context.MemberComments
    .Where(mc => mc.MemberId == 1 && mc.Something == 99)
    .Select(mc => mc.Comment)
    .ToList();

आलसी लोडिंग के कारण चीजें आसान हो सकती हैं। यदि आपके पास एक लोड है, Memberतो आपको एक स्पष्ट प्रश्न के बिना टिप्पणी प्राप्त करने में सक्षम होना चाहिए:

var commentsOfMember = member.MemberComments.Select(mc => mc.Comment);

मुझे लगता है कि आलसी लोडिंग दृश्यों के पीछे की टिप्पणियों को स्वचालित रूप से लाएगा।

संपादित करें

बस कुछ उदाहरणों के लिए और अधिक कैसे संस्थाओं और रिश्तों को जोड़ने के लिए और उन्हें इस मॉडल में कैसे हटाएं:

1) इस सदस्य का एक सदस्य और दो टिप्पणियाँ बनाएँ:

var member1 = new Member { FirstName = "Pete" };
var comment1 = new Comment { Message = "Good morning!" };
var comment2 = new Comment { Message = "Good evening!" };
var memberComment1 = new MemberComment { Member = member1, Comment = comment1,
                                         Something = 101 };
var memberComment2 = new MemberComment { Member = member1, Comment = comment2,
                                         Something = 102 };

context.MemberComments.Add(memberComment1); // will also add member1 and comment1
context.MemberComments.Add(memberComment2); // will also add comment2

context.SaveChanges();

2) सदस्य 1 की तीसरी टिप्पणी जोड़ें:

var member1 = context.Members.Where(m => m.FirstName == "Pete")
    .SingleOrDefault();
if (member1 != null)
{
    var comment3 = new Comment { Message = "Good night!" };
    var memberComment3 = new MemberComment { Member = member1,
                                             Comment = comment3,
                                             Something = 103 };

    context.MemberComments.Add(memberComment3); // will also add comment3
    context.SaveChanges();
}

3) नया सदस्य बनाएं और इसे मौजूदा टिप्पणी 2 से संबंधित करें:

var comment2 = context.Comments.Where(c => c.Message == "Good evening!")
    .SingleOrDefault();
if (comment2 != null)
{
    var member2 = new Member { FirstName = "Paul" };
    var memberComment4 = new MemberComment { Member = member2,
                                             Comment = comment2,
                                             Something = 201 };

    context.MemberComments.Add(memberComment4);
    context.SaveChanges();
}

4) मौजूदा सदस्य 2 और टिप्पणी 3 के बीच संबंध बनाएं:

var member2 = context.Members.Where(m => m.FirstName == "Paul")
    .SingleOrDefault();
var comment3 = context.Comments.Where(c => c.Message == "Good night!")
    .SingleOrDefault();
if (member2 != null && comment3 != null)
{
    var memberComment5 = new MemberComment { Member = member2,
                                             Comment = comment3,
                                             Something = 202 };

    context.MemberComments.Add(memberComment5);
    context.SaveChanges();
}

5) इस रिश्ते को फिर से हटाएं:

var memberComment5 = context.MemberComments
    .Where(mc => mc.Member.FirstName == "Paul"
        && mc.Comment.Message == "Good night!")
    .SingleOrDefault();
if (memberComment5 != null)
{
    context.MemberComments.Remove(memberComment5);
    context.SaveChanges();
}

6) सदस्य 1 और टिप्पणी के अपने सभी रिश्तों को हटा दें:

var member1 = context.Members.Where(m => m.FirstName == "Pete")
    .SingleOrDefault();
if (member1 != null)
{
    context.Members.Remove(member1);
    context.SaveChanges();
}

इस में रिश्तों को हटा देता है MemberCommentsभी, क्योंकि बीच एक-से-कई रिश्तों को Memberऔर MemberCommentsऔर के बीच Commentऔर MemberCommentsप्रथा के अनुसार नष्ट व्यापक साथ सेटअप कर रहे हैं। और इस मामले वजह से है MemberIdऔर CommentIdमें MemberCommentके लिए विदेशी कुंजी गुण के रूप में पाया जाता है Memberऔर Commentनेविगेशन गुण और FK गुण के बाद से प्रकार गैर-व्यर्थ के हैं intरिश्ते की आवश्यकता है जो अंत में व्यापक हटाना रद्द करें-सेटअप का कारण बनता है। मुझे लगता है कि इस मॉडल में समझदारी है।


1
धन्यवाद। आपके द्वारा प्रदान की गई अतिरिक्त जानकारी की बहुत प्रशंसा करें।
hgdean

7
@hgdean: मैंने कुछ और उदाहरणों के लिए खेद व्यक्त किया है, क्षमा करें, लेकिन यह एक दिलचस्प मॉडल है और जॉइन टेबल में अतिरिक्त डेटा के साथ कई-से-कई के बारे में सवाल हर अब और फिर यहां होते हैं। अब अगली बार मुझे कुछ लिंक करना है ... :)
Slauma

4
@Esteban: कोई ओवरराइड नहीं है OnModelCreating। उदाहरण केवल मैपिंग सम्मेलनों और डेटा एनोटेशन पर निर्भर करता है।
सुलामा

4
नोट: यदि आप Fluent एपीआई मेकअप के बिना इस दृष्टिकोण का उपयोग करें कि आप अपने डेटाबेस में जाँच आप केवल के साथ एक समग्र कुंजी है MemberIdऔर CommentIdकॉलम और नहीं एक अतिरिक्त तीसरे स्तंभ Member_CommentId(या ऐसा ही कुछ) - जिसका अर्थ है आपको सटीक मिलान नाम नहीं था अपनी कुंजियों के लिए वस्तुओं पर
सिमोन_विवर

3
@Simon_Weaver (या कोई भी जो उत्तर जान सकता है) मेरे पास एक समान स्थिति है लेकिन मैं उस तालिका के लिए "मेंबरकैमिड" प्राथमिक कुंजी रखना चाहूंगा, क्या यह संभव है या नहीं? मुझे वर्तमान में एक अपवाद मिल रहा है, कृपया मेरे प्रश्न पर एक नज़र डालें, मुझे वास्तव में मदद की ज़रूरत है ... stackoverflow.com/questions/26783934/…
duxfox--

97

सुलामा द्वारा उत्कृष्ट उत्तर।

मैं धाराप्रवाह एपीआई मानचित्रण का उपयोग करके ऐसा करने के लिए कोड पोस्ट करूंगा ।

public class User {
    public int UserID { get; set; }
    public string Username { get; set; }
    public string Password { get; set; }

    public ICollection<UserEmail> UserEmails { get; set; }
}

public class Email {
    public int EmailID { get; set; }
    public string Address { get; set; }

    public ICollection<UserEmail> UserEmails { get; set; }
}

public class UserEmail {
    public int UserID { get; set; }
    public int EmailID { get; set; }
    public bool IsPrimary { get; set; }
}

अपने DbContextव्युत्पन्न वर्ग पर आप यह कर सकते हैं:

public class MyContext : DbContext {
    protected override void OnModelCreating(DbModelBuilder builder) {
        // Primary keys
        builder.Entity<User>().HasKey(q => q.UserID);
        builder.Entity<Email>().HasKey(q => q.EmailID);
        builder.Entity<UserEmail>().HasKey(q => 
            new { 
                q.UserID, q.EmailID
            });

        // Relationships
        builder.Entity<UserEmail>()
            .HasRequired(t => t.Email)
            .WithMany(t => t.UserEmails)
            .HasForeignKey(t => t.EmailID)

        builder.Entity<UserEmail>()
            .HasRequired(t => t.User)
            .WithMany(t => t.UserEmails)
            .HasForeignKey(t => t.UserID)
    }
}

यह एक अलग दृष्टिकोण के साथ स्वीकृत उत्तर के समान प्रभाव है, जो न तो बेहतर है और न ही बदतर है।

संपादित करें: मैंने बूल से डेटटाइम तक क्रिएटेडडेट को बदल दिया है।

EDIT 2: समय की कमी के कारण मैंने एक ऐसे एप्लिकेशन से एक उदाहरण रखा है जिस पर मैं काम कर रहा हूं यह सुनिश्चित करने के लिए काम कर रहा है।


1
मुझे लगता है कि यह गलत है। आप यहां M: M संबंध बना रहे हैं, जहां दोनों संस्थाओं के लिए 1: M होना आवश्यक है।
सीएचएस

1
@CHS In your classes you can easily describe a many to many relationship with properties that point to each other.से लिया: msdn.microsoft.com/en-us/data/hh134698.aspx । जूली लर्मन गलत नहीं हो सकता।
एस्टेबन

1
एस्टेबन, रिलेशनशिप मैपिंग वास्तव में गलत है। @CHS इस बारे में सही है। जूली लर्मन एक "सच्चे" कई-कई संबंधों के बारे में बात कर रही है, जबकि हमारे यहां एक मॉडल के लिए एक उदाहरण है जिसे कई-से-कई के रूप में मैप नहीं किया जा सकता है। आपकी मैपिंग भी संकलित नहीं होगी क्योंकि आपके पास कोई Commentsसंपत्ति नहीं है Member। और आप HasManyकॉल का नाम बदलकर इसे ठीक नहीं कर सकते MemberCommentsक्योंकि MemberCommentइकाई के लिए उलटा संग्रह नहीं है WithMany। वास्तव में आपको सही मैपिंग प्राप्त करने के लिए दो एक-से-कई संबंधों को कॉन्फ़िगर करने की आवश्यकता है ।
सलुमा

2
धन्यवाद। मैंने कई-कई मैपिंग करने के लिए इस समाधान का पालन किया।
थॉमस.बेंज

मुझे नहीं पता, लेकिन यह MySql के साथ बेहतर काम करता है। जब मैंने माइग्रेशन का प्रयास किया, तो बिल्डर के बिना, मैसकल ने मुझे एक त्रुटि दी।
रॉड्रिगो प्रिटो

11

@Esteban, आपके द्वारा प्रदान किया गया कोड सही है, धन्यवाद, लेकिन अधूरा, मैंने इसे परीक्षण किया है। "UserEmail" वर्ग में लापता गुण हैं:

    public UserTest UserTest { get; set; }
    public EmailTest EmailTest { get; set; }

अगर मैंने किसी को दिलचस्पी है, तो मैंने उस कोड को पोस्ट किया है जो मैंने परीक्षण किया है। सादर

using System.Data.Entity;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.Linq;
using System.Web;

#region example2
public class UserTest
{
    public int UserTestID { get; set; }
    public string UserTestname { get; set; }
    public string Password { get; set; }

    public ICollection<UserTestEmailTest> UserTestEmailTests { get; set; }

    public static void DoSomeTest(ApplicationDbContext context)
    {

        for (int i = 0; i < 5; i++)
        {
            var user = context.UserTest.Add(new UserTest() { UserTestname = "Test" + i });
            var address = context.EmailTest.Add(new EmailTest() { Address = "address@" + i });
        }
        context.SaveChanges();

        foreach (var user in context.UserTest.Include(t => t.UserTestEmailTests))
        {
            foreach (var address in context.EmailTest)
            {
                user.UserTestEmailTests.Add(new UserTestEmailTest() { UserTest = user, EmailTest = address, n1 = user.UserTestID, n2 = address.EmailTestID });
            }
        }
        context.SaveChanges();
    }
}

public class EmailTest
{
    public int EmailTestID { get; set; }
    public string Address { get; set; }

    public ICollection<UserTestEmailTest> UserTestEmailTests { get; set; }
}

public class UserTestEmailTest
{
    public int UserTestID { get; set; }
    public UserTest UserTest { get; set; }
    public int EmailTestID { get; set; }
    public EmailTest EmailTest { get; set; }
    public int n1 { get; set; }
    public int n2 { get; set; }


    //Call this code from ApplicationDbContext.ConfigureMapping
    //and add this lines as well:
    //public System.Data.Entity.DbSet<yournamespace.UserTest> UserTest { get; set; }
    //public System.Data.Entity.DbSet<yournamespace.EmailTest> EmailTest { get; set; }
    internal static void RelateFluent(System.Data.Entity.DbModelBuilder builder)
    {
        // Primary keys
        builder.Entity<UserTest>().HasKey(q => q.UserTestID);
        builder.Entity<EmailTest>().HasKey(q => q.EmailTestID);

        builder.Entity<UserTestEmailTest>().HasKey(q =>
            new
            {
                q.UserTestID,
                q.EmailTestID
            });

        // Relationships
        builder.Entity<UserTestEmailTest>()
            .HasRequired(t => t.EmailTest)
            .WithMany(t => t.UserTestEmailTests)
            .HasForeignKey(t => t.EmailTestID);

        builder.Entity<UserTestEmailTest>()
            .HasRequired(t => t.UserTest)
            .WithMany(t => t.UserTestEmailTests)
            .HasForeignKey(t => t.UserTestID);
    }
}
#endregion

3

मैं एक समाधान का प्रस्ताव करना चाहता हूं, जहां दोनों कई-से-कई कॉन्फ़िगरेशन के स्वादों को प्राप्त किया जा सकता है।

"कैच" हमें एक दृश्य बनाने की आवश्यकता है जो जॉइन टेबल को लक्षित करता है, क्योंकि ईएफ यह पुष्टि करता है कि स्कीमा की तालिका को प्रति बार एक बार मैप किया जा सकता है EntitySet

यह उत्तर जोड़ता है कि पहले से ही पिछले उत्तरों में क्या कहा गया है और उन दृष्टिकोणों में से कोई भी ओवरराइड नहीं करता है, यह उन पर बनाता है।

आदर्श:

public class Member
{
    public int MemberID { get; set; }

    public string FirstName { get; set; }
    public string LastName { get; set; }

    public virtual ICollection<Comment> Comments { get; set; }
    public virtual ICollection<MemberCommentView> MemberComments { get; set; }
}

public class Comment
{
    public int CommentID { get; set; }
    public string Message { get; set; }

    public virtual ICollection<Member> Members { get; set; }
    public virtual ICollection<MemberCommentView> MemberComments { get; set; }
}

public class MemberCommentView
{
    public int MemberID { get; set; }
    public int CommentID { get; set; }
    public int Something { get; set; }
    public string SomethingElse { get; set; }

    public virtual Member Member { get; set; }
    public virtual Comment Comment { get; set; }
}

विन्यास:

using System.ComponentModel.DataAnnotations.Schema;
using System.Data.Entity.ModelConfiguration;

public class MemberConfiguration : EntityTypeConfiguration<Member>
{
    public MemberConfiguration()
    {
        HasKey(x => x.MemberID);

        Property(x => x.MemberID).HasColumnType("int").IsRequired();
        Property(x => x.FirstName).HasColumnType("varchar(512)");
        Property(x => x.LastName).HasColumnType("varchar(512)")

        // configure many-to-many through internal EF EntitySet
        HasMany(s => s.Comments)
            .WithMany(c => c.Members)
            .Map(cs =>
            {
                cs.ToTable("MemberComment");
                cs.MapLeftKey("MemberID");
                cs.MapRightKey("CommentID");
            });
    }
}

public class CommentConfiguration : EntityTypeConfiguration<Comment>
{
    public CommentConfiguration()
    {
        HasKey(x => x.CommentID);

        Property(x => x.CommentID).HasColumnType("int").IsRequired();
        Property(x => x.Message).HasColumnType("varchar(max)");
    }
}

public class MemberCommentViewConfiguration : EntityTypeConfiguration<MemberCommentView>
{
    public MemberCommentViewConfiguration()
    {
        ToTable("MemberCommentView");
        HasKey(x => new { x.MemberID, x.CommentID });

        Property(x => x.MemberID).HasColumnType("int").IsRequired();
        Property(x => x.CommentID).HasColumnType("int").IsRequired();
        Property(x => x.Something).HasColumnType("int");
        Property(x => x.SomethingElse).HasColumnType("varchar(max)");

        // configure one-to-many targeting the Join Table view
        // making all of its properties available
        HasRequired(a => a.Member).WithMany(b => b.MemberComments);
        HasRequired(a => a.Comment).WithMany(b => b.MemberComments);
    }
}

प्रसंग:

using System.Data.Entity;

public class MyContext : DbContext
{
    public DbSet<Member> Members { get; set; }
    public DbSet<Comment> Comments { get; set; }
    public DbSet<MemberCommentView> MemberComments { get; set; }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);

        modelBuilder.Configurations.Add(new MemberConfiguration());
        modelBuilder.Configurations.Add(new CommentConfiguration());
        modelBuilder.Configurations.Add(new MemberCommentViewConfiguration());

        OnModelCreatingPartial(modelBuilder);
     }
}

सलुमा के (@Saluma) उत्तर से

यदि आप अब LastName = "Smith" के सदस्यों की सभी टिप्पणियाँ प्राप्त करना चाहते हैं, उदाहरण के लिए आप इस तरह से एक प्रश्न लिख सकते हैं:

यह अभी भी काम करता है ...

var commentsOfMembers = context.Members
    .Where(m => m.LastName == "Smith")
    .SelectMany(m => m.MemberComments.Select(mc => mc.Comment))
    .ToList();

... लेकिन अब यह भी हो सकता है ...

var commentsOfMembers = context.Members
    .Where(m => m.LastName == "Smith")
    .SelectMany(m => m.Comments)
    .ToList();

या "स्मिथ" नाम के साथ सदस्यों की एक सूची बनाने के लिए (हम मानते हैं कि एक से अधिक है) उनकी टिप्पणियों के साथ आप एक प्रक्षेपण का उपयोग कर सकते हैं:

यह अभी भी काम करता है ...

var membersWithComments = context.Members
    .Where(m => m.LastName == "Smith")
    .Select(m => new
    {
        Member = m,
        Comments = m.MemberComments.Select(mc => mc.Comment)
    })
    .ToList();

... लेकिन अब यह भी हो सकता है ...

var membersWithComments = context.Members
    .Where(m => m.LastName == "Smith")
    .Select(m => new
    {
        Member = m,
        m.Comments
    })
        .ToList();

यदि आप किसी सदस्य की टिप्पणी को हटाना चाहते हैं

var comment = ... // assume comment from member John Smith
var member = ... // assume member John Smith

member.Comments.Remove(comment);

यदि आप Include()किसी सदस्य की टिप्पणी चाहते हैं

var member = context.Members
    .Where(m => m.FirstName == "John", m.LastName == "Smith")
    .Include(m => m.Comments);

यदि आप अतिरिक्त कॉन्फ़िगरेशन के माध्यम से जाने के इच्छुक हैं, तो यह सब कुछ सिंथेटिक चीनी की तरह लगता है, हालांकि यह आपको कुछ भत्ते देता है। किसी भी तरह से आप दोनों दृष्टिकोणों में से सबसे अच्छा पाने में सक्षम प्रतीत होते हैं।


LINQ क्वेरी टाइप करते समय बढ़ी हुई पठनीयता की मैं सराहना करता हूँ। मुझे बस यह तरीका अपनाना पड़ सकता है। मुझे पूछना है, क्या EF EntitySet डेटाबेस में भी दृश्य को स्वचालित रूप से अपडेट करता है? क्या आप इस बात से सहमत होंगे कि EF5.0 योजना में वर्णित चीनी के समान है? github.com/dotnet/EntityFramework.Docs/blob/master/…
क्राप्टोड्र

मुझे आश्चर्य है कि आप EntityTypeConfiguration<EntityType>इकाई प्रकार की कुंजी और गुणों में फिर से परिभाषित क्यों कर रहे हैं । जैसे Property(x => x.MemberID).HasColumnType("int").IsRequired();लगता है बेमानी है public int MemberID { get; set; }। क्या आप कृपया मेरी भ्रमित समझ को साफ़ कर सकते हैं?
मिनट

0

TLDR; ( यदि EF6 / VS2012U5 में एक EF संपादक बग से संबंधित है) यदि आप DB से मॉडल बनाते हैं और आप एट्रिब्यूटेड m: m टेबल नहीं देख सकते हैं: दो संबंधित तालिकाओं को हटा दें -> .edmx को सहेजें -> डेटाबेस से उत्पन्न / जोड़ें -। > बचाओ।

उन लोगों के लिए, जो सोच रहे थे कि EF .edmx फ़ाइल में दिखाने के लिए विशेषता स्तंभों के साथ कई-से-कई संबंध कैसे प्राप्त करें (क्योंकि यह वर्तमान में नहीं दिखाएंगे और नेविगेशनल गुणों के एक सेट के रूप में माना जाएगा), और आपने इन कक्षाओं को उत्पन्न किया आपकी डेटाबेस तालिका (या डेटाबेस-प्रथम एमएस लिंगो में, मेरा मानना ​​है।)

अपने .edmx में विचाराधीन 2 तालिकाओं (ओपी उदाहरण, सदस्य और टिप्पणी को लेने के लिए) को हटाएं और उन्हें 'डेटाबेस से उत्पन्न मॉडल' के माध्यम से फिर से जोड़ें। (यानी विजुअल स्टूडियो को उन्हें अपडेट करने की कोशिश न करें - हटाएं, सहेजें, जोड़ें, सहेजें)

इसके बाद यहां जो सुझाव दिया गया है, उसके अनुरूप एक तीसरी तालिका बनाएंगे।

यह उन मामलों में प्रासंगिक है जहां पहले कई शुद्ध-से-कई संबंध जोड़े जाते हैं, और विशेषताओं को बाद में डीबी में डिज़ाइन किया गया है।

यह इस धागे / Googling से तुरंत स्पष्ट नहीं था। तो बस इसे वहां डाल दें क्योंकि यह Google पर # 1 लिंक है जो इस मुद्दे की तलाश में है लेकिन पहले डीबी की तरफ से आ रहा है।


0

इस त्रुटि को हल करने का एक तरीका यह है ForeignKeyकि आप जिस संपत्ति को विदेशी कुंजी के रूप में चाहते हैं, उसके शीर्ष पर विशेषता को डालें और नेविगेशन संपत्ति जोड़ें।

नोट: ForeignKeyविशेषता में, कोष्ठक और दोहरे उद्धरण चिह्नों के बीच, इस तरह निर्दिष्ट वर्ग का नाम रखें।

यहां छवि विवरण दर्ज करें


कृपया उत्तर में केवल एक न्यूनतम स्पष्टीकरण जोड़ें, क्योंकि प्रदान की गई लिंक भविष्य में अनुपलब्ध हो सकती है।
n4m31ess_c0d3r

2
यह क्लास के बजाय नेविगेशन प्रॉपर्टी का नाम होना चाहिए ।
ऐरन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.