Wie definieren Sie Beziehungen programmgesteuert in Entity Framework 4.1 Code-Ersten Fluent-API

Ich bin Herumspielen mit der neuen EF4.1 Einhorn-Liebe.

Ich versuche zu verstehen, die verschiedenen Möglichkeiten, die ich nutzen kann code-first - zu programmatisch definieren, meine Beziehungen, die zwischen ein paar einfachen POCO ist.

Wie kann ich definieren, das folgende =>

  1. 1 Team hat 0-viele Users. (und ein User ist in 1 Team)
  2. 1 User hat 0-oder-1 Foo's (aber ein Foo hat keine Eigenschaft wieder zu einer User)
  3. 1 User hat 1 UserStuff
InformationsquelleAutor Pure.Krome | 2011-03-20
  1. 11

    Hier haben Sie Beispiele, die Sie suchen:

    public class User
{
    public int Id { get; set; }
    ...
    public Foo Foo { get; set; }
    public Team Team { get; set; }
    public UserStuff UserStuff { get; set; }
}

public class Team
{
    public int Id { get; set; }
    ...
    public ICollection<User> Users { get; set; }
}

public class Foo
{
    public int Id { get; set; }
    ...
}

public class UserStuff
{
    public int Id { get; set; }
    ...
}

public class Context : DbContext
{
    public DbSet<User> Users { get; set; }
    public DbSet<Foo> Foos { get; set; }
    public DbSet<Team> Teams { get; set; }
    public DbSet<UserStuff> UserStuff { get; set; }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        modelBuilder.Entity<User>()
            .HasRequired(u => u.Team)
            .WithMany(t => t.Users);

        modelBuilder.Entity<User>()
            .HasOptional(u => u.Foo)
            .WithRequired();

        modelBuilder.Entity<User>()
            .HasRequired(u => u.UserStuff)
            .WithRequiredPrincipal();
    }
}
    • Was ist der Unterschied zwischen modelBuilder.Entity<User>() .HasOptional(u => u.Foo) .WithRequired(); UND modelBuilder.Entity<User>() .HasOptional(u => u.Foo) ? Beide erlauben würde 0-oder-1 Foo Benutzer oder?
    InformationsquelleAutor Ladislav Mrnka
  2. 5

    Können stellen Ihnen einige spezielle Klassen zur Veranschaulichung der Lösungen:

    public class Account
{
    public long ID { get; set; }
    public virtual User User { get; set; }
}

public class User
{
    public long ID { get; set; }
    public virtual Account Account { get; set; }
    public virtual Team Team { get; set; }
}

public class Team
{
    public long ID { get; set; }
    public long CompanyID { get; set; }

    public virtual Company Company { get; set; }
    public virtual ICollection<User> Users { get; set; }
}

public class Company
{
    public long ID { get; set; }
}

    Ich bin mit einer helper-Klasse, um die mapping-Klassen etwas weniger ausführlich: 

    internal abstract class AbstractMappingProvider<T> : IMappingProvider where T : class
{
    public EntityTypeConfiguration<T> Map { get; private set; }

    public virtual void DefineModel( DbModelBuilder modelBuilder )
    {
        Map = modelBuilder.Entity<T>();

        Map.ToTable( typeof(T).Name );
    }
}

    Nun für die Zuordnungen. Kann man die "1:1" mapping-ersten. In meinem Beispiel sind Benutzer-und account sind 1:1 verwandt und teilen die gleichen Primärschlüssel (nur einer von Ihnen wird eine identity-Spalte, in diesem Fall ist das Konto.ID).

    internal class UserMapping : AbstractMappingProvider<User>
{
    public override void DefineModel( DbModelBuilder modelBuilder )
    {
        base.DefineModel( modelBuilder );
        Map.HasRequired( e => e.Account ).WithRequiredDependent( r => r.User ).WillCascadeOnDelete( true );
    }
}

internal class AccountMapping : AbstractMappingProvider<Account>
{
    public override void DefineModel( DbModelBuilder modelBuilder )
    {
        base.DefineModel( modelBuilder );
        Map.HasRequired( e => e.User ).WithRequiredPrincipal( r => r.Account ).WillCascadeOnDelete( true );
    }
}

    In der folgenden Zuordnungen, die wir angeben, dass ein team hat (0..n) Benutzer, während ein einzelner user ist in genau einer Mannschaft (erforderlich). Wir geben auch, dass ein team haben ein Unternehmen, aber das Unternehmen nicht offen legen eine Liste der teams.

    internal class TeamMapping : AbstractMappingProvider<Team>
{
    public override void DefineModel( DbModelBuilder modelBuilder )
    {
        base.DefineModel( modelBuilder );
        Map.HasOptional( e => e.Company ).WithMany().HasForeignKey( e => e.CompanyID );
        Map.HasMany( e => e.Users ).WithRequired( r => r.Team );
    }
}   

internal class CompanyMapping : AbstractMappingProvider<Company>
{
    public override void DefineModel( DbModelBuilder modelBuilder )
    {
        base.DefineModel( modelBuilder );
    }
}

    Hoffe, das hilft!

    • Was tun Sie mit EntityTypeConfiguration ?
    • Ich bin mir nicht sicher, was du meinst? Die DbModelBuilder Instanz übergeben DefineModel stellt eine Eigenschaft dieses Typs, die ich setze auf AbstractMappingProvider da die Karte Eigentum. Dies ermöglicht es, die einzelnen abgeleiteten Zuordnung von Klassen zu einfach Zuordnen. Zugriff auf die EntityTypeConfiguration Instanz, die verwendet wird, um die Zuordnungen festlegen.
    InformationsquelleAutor Morten Mertner
Schreibe einen Kommentar