Сначала создайте код, многие ко многим, с дополнительными полями в таблице ассоциаций.

298

У меня есть этот сценарий:

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; }
}

Как мне настроить связь с свободно используемым API ? Или есть лучший способ создать таблицу ассоциации?

hgdean
источник

Ответы:

524

Невозможно создать отношение «многие ко многим» с помощью настраиваемой таблицы соединений. В отношениях «многие ко многим» EF управляет внутренней и скрытой таблицей соединений. Это таблица без класса Entity в вашей модели. Чтобы работать с такой таблицей соединений с дополнительными свойствами, вам фактически необходимо создать два отношения «один ко многим». Это может выглядеть так:

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= "Smith", например, вы можете написать запрос следующим образом:

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) Добавить третий комментарий member1:

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) Создайте отношения между существующим member2 и comment3:

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) Удалить member1 и все его связи с комментариями:

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и CommentIdin MemberCommentобнаруживаются как свойства внешнего ключа для свойств Memberи Commentнавигации, и так как свойства FK имеют тип, не допускающий значения NULL int, требуется связь, которая в конечном итоге вызывает каскадную-delete-setup. Имеет смысл в этой модели, я думаю.

Slauma
источник
1
Спасибо. Большое спасибо за дополнительную информацию, которую вы предоставили.
hgdean
7
@hgdean: я спамил еще несколько примеров, извините, но это интересная модель, и время от времени здесь возникают вопросы о многих для многих с дополнительными данными в таблице соединений. Теперь в следующий раз мне есть на что
сослаться
4
@Esteban: нет переопределенных OnModelCreating. Пример опирается только на правила отображения и аннотации данных.
Слаума
4
Примечание: если вы используете этот подход без Fluent API убедитесь , что вы проверить в базе данных , что у вас есть только составной ключ MemberIdи CommentIdстолбцов , а не дополнительный третий столбец Member_CommentId(или что - то подобное) - это означает , что вы не имеете точных имен , соответствующих между объектами для ваших ключей
Simon_Weaver
3
@Simon_Weaver (или любой, кто может знать ответ) У меня похожая ситуация, но я хотел бы иметь первичный ключ "MemberCommentID" для этой таблицы, это возможно или нет? В настоящее время я получаю исключение, пожалуйста, посмотрите на мой вопрос, мне действительно нужна помощь ... stackoverflow.com/questions/26783934/…
duxfox--
98

Отличный ответ от Slauma.

Я просто опубликую код, чтобы сделать это, используя свободное отображение API .

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)
    }
}

Он имеет тот же эффект, что и принятый ответ, с другим подходом, который не лучше и не хуже.

РЕДАКТИРОВАТЬ: я изменил CreatedDate с bool на DateTime.

РЕДАКТИРОВАТЬ 2: из-за нехватки времени я поместил пример из приложения, над которым я работаю, чтобы убедиться, что это работает.

Esteban
источник
1
Я думаю, что это неправильно. Вы создаете отношение M: M здесь, где оно должно быть 1: M для обеих сущностей.
CHS
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
Спасибо. Я следовал этому решению, чтобы сделать отображение многие ко многим.
Thomas.Benz
Я не знаю, но это работает лучше с MySql. Без компилятора 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
LeonardoX
источник
3

Я хочу предложить решение, в котором могут быть достигнуты оба варианта конфигурации «многие ко многим».

«Подвох» заключается в том, что нам нужно создать представление, предназначенное для таблицы соединений, поскольку EF проверяет, что таблица схемы может отображаться не более одного раза в 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) 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 также автоматически обновляет представление в базе данных? Согласитесь ли вы, что это похоже на [Sugar], как описано в плане EF5.0? github.com/dotnet/EntityFramework.Docs/blob/master/…
Krptodr
Мне интересно, почему вы, кажется, переопределяете EntityTypeConfiguration<EntityType>ключ и свойства типа сущности. Например, Property(x => x.MemberID).HasColumnType("int").IsRequired();кажется, излишним с public int MemberID { get; set; }. Не могли бы вы очистить мое запутанное понимание, пожалуйста?
мин
0

TLDR; (частично связано с ошибкой редактора EF в EF6 / VS2012U5) если вы генерируете модель из БД и не видите атрибутивной таблицы m: m: удалите две связанные таблицы -> Сохранить .edmx -> Создать / добавить из базы данных - > Сохранить.

Тем, кто пришел сюда, интересно, как получить отношение «многие ко многим» со столбцами атрибутов для отображения в файле EF .edmx (поскольку в настоящее время он не будет отображаться и рассматриваться как набор навигационных свойств), И вы сгенерировали эти классы из вашей таблицы базы данных (или, я полагаю, сначала из базы данных в MS lingo)

Удалите две рассматриваемые таблицы (чтобы взять пример OP, Member и Comment) в своем .edmx и добавьте их снова через «Создать модель из базы данных». (т.е. не пытайтесь позволить Visual Studio обновить их - удалите, сохраните, добавьте, сохраните)

Затем он создаст 3-ю таблицу в соответствии с тем, что предлагается здесь.

Это актуально в тех случаях, когда сначала добавляется чистое отношение «многие ко многим», а атрибуты создаются в БД позже.

Это было не сразу понятно из этой темы / Googling. Так что просто разместите это, так как это ссылка № 1 в Google, которая ищет проблему, но сначала идет со стороны БД.

Энди С
источник
0

Один из способов решения этой ошибки - поместить ForeignKeyатрибут поверх свойства, которое вы хотите использовать в качестве внешнего ключа, и добавить свойство навигации.

Примечание: в ForeignKeyатрибуте между круглыми скобками и двойными кавычками поместите имя класса, на который ссылаются таким образом.

введите описание изображения здесь

Оскар Эхаверри
источник
Пожалуйста, добавьте минимальное объяснение в самом ответе, так как предоставленная ссылка может оказаться недоступной в будущем.
n4m31ess_c0d3r
2
Это должно быть имя свойства навигации , а не класс.
Aaron