Najpierw Utwórz kod, wiele do wielu, z dodatkowymi polami w tabeli asocjacji

Doskonała odpowiedź przez Slauma.

po prostu wyślę kod, aby to zrobić, używając mapowania fluent 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; }
}

Na Twojej DbContext klasie pochodnej możesz to zrobić:

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

Ma taki sam efekt jak przyjęta odpowiedź, z innym podejściem, które jest nie lepsze lub gorsze.

Edytuj: zmieniłem CreatedDate z bool na DateTime.

Edycja 2: Ze względu na brak czasu umieściłem przykład z aplikacji Pracuję nad tym, żeby to zadziałało.

@Esteban, podany przez Ciebie kod jest prawidłowy, dzięki, ale niekompletny, Przetestowałem go. Brak właściwości w klasie "UserEmail":

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

Zamieszczam kod, który przetestowałem, jeśli ktoś jest zainteresowany. Regards

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

TLDR; (częściowo związane z błędem edytora EF w EF6/VS2012U5) jeśli wygenerujesz model z DB i nie zobaczysz przypisanej tabeli m: M: Usuń dwie powiązane tabele - > Zapisz .edmx - > Wygeneruj/Dodaj z bazy danych - > Zapisz.

Dla tych, którzy przybyli tutaj zastanawiając się, jak uzyskać wiele do wielu relacji z kolumnami atrybutów, aby pokazać w EF .plik edmx (gdyż obecnie nie pokazywałby się i był traktowany jako zbiór właściwości nawigacyjnych), a te klasy wygenerowałeś z tabela bazy danych (lub baza danych-pierwsza w MS lingo, jak sądzę.)

Usuń 2 tabele (aby wziąć przykład OP, Member i komentarz) w Twoim .edmx i dodać je ponownie poprzez 'Generuj model z bazy danych'. (tzn. nie próbuj pozwolić, aby Visual Studio je aktualizowało-Usuń , Zapisz, dodaj, Zapisz)

Następnie utworzy trzecią tabelę zgodnie z tym, co jest tutaj sugerowane.

Jest to istotne w przypadkach, gdy na początku dodawana jest czysta relacja wiele do wielu, a atrybuty są zaprojektowany później w DB.

To nie było od razu jasne z tego wątku / googlowania. Więc po prostu umieszczając to tam, ponieważ jest to link #1 w Google, szukający problemu, ale pochodzący od strony DB.

Jednym ze sposobów rozwiązania tego błędu jest umieszczenie atrybutu ForeignKey Na górze właściwości, którą chcesz jako klucz obcy i dodanie właściwości nawigacji.

Uwaga: w atrybucie ForeignKey, pomiędzy nawiasami i podwójnymi cudzysłowami, umieść nazwę klasy, o której mowa w ten sposób.

Chcę zaproponować rozwiązanie, w którym można osiągnąć oba smaki konfiguracji wielu do wielu.

"catch" polega na tym, że musimy stworzyć widok, który będzie skierowany na tabelę Join, ponieważ EF potwierdza, że tabela schematu może być mapowana co najwyżej raz na EntitySet.

Ta odpowiedź dodaje do tego, co już zostało powiedziane w poprzednich odpowiedziach i nie nadpisuje żadnego z tych podejść, opiera się na nich.

Model:

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

The konfiguracja:

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

Kontekst:

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

From Saluma ' s (@Saluma) answer

Jeśli chcesz teraz znaleźć wszystkie komentarze użytkowników z lastname = "Smith" na przykład możesz napisać zapytanie w następujący sposób:

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

...ale teraz też może być...

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

Lub stworzyć listę członków o nazwie "Smith" (Zakładamy, że jest więcej niż jeden) wraz z ich komentarzami można użyć rzut:

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

...ale teraz też może być...

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

Jeśli chcesz usunąć komentarz od członka

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

member.Comments.Remove(comment);

If you want to Include() a member ' s comments

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

To wszystko wygląda jak cukier składniowy, jednak daje Ci kilka korzyści, jeśli chcesz przejść przez dodatkową konfigurację. Tak czy inaczej wydaje się być w stanie uzyskać najlepsze z obu podejść.