C# EF代码第一个异常实体类型不是使用简单Odata客户端的当前上下文的模型的一部分

我有三个类

User

，

Role

和

UserRole

首先使用代码，我创建了如下表

DbContext.cs
rotected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            Database.SetInitializer<CodeFirstDBContext>(null);

    modelBuilder.Entity<DomainModels.Security.User>().HasKey(x => x.Id);
            modelBuilder.Entity<DomainModels.Security.User>().Property(x => x.Id).HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);

              modelBuilder.Entity<DomainModels.Security.Role>().HasKey(x => x.Id);
            modelBuilder.Entity<DomainModels.Security.Role>().Property(x => x.Id).HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);


// UserRoles table column names as UserId and RoleId instead of default created by ER as User_Id and Role_Id.
            modelBuilder.Entity<DomainModels.Security.User>().HasMany(x => x.Roles).WithMany(y => y.Users).Map(
            of =>
            {
                of.MapLeftKey("UserId");
                of.MapRightKey("RoleId");
                of.ToTable("UserRoles");
            });
}

 public virtual DbSet<DomainModels.Security.Role> Roles { get; set; }
 public virtual DbSet<DomainModels.Security.User> Users { get; set; }

我不确定

Simple OData Client

是否支持此功能。

---

我该怎么办？

您所设置的所谓多对多关系是EF为您维护的自动“链接”表。在这种配置中，

用户角色

实体不存在。模型应该是这样的：

public class User
{
    public int Id { get; set; }

    // other properties
    // ...

    // UserRole association
    public virtual ICollection<Role> Roles { get; set; }
}

public class Role
{
    public int Id { get; set; }

    // other properties
    // ...

    // UserRole association
    public virtual ICollection<User> Users { get; set; }
}

DbContext:

public class User
{
    public int Id { get; set; }

    // other properties
    // ...

    // UserRole association
    public virtual ICollection<UserRole> UserRoles { get; set; }
}

public class Role
{
    public int Id { get; set; }

    // other properties
    // ...

    // UserRole association
    public virtual ICollection<UserRole> UserRoles { get; set; }
}

public class UserRole
{
    public int UserId { get; set; }
    public int RoleId { get; set; }
    public virtual User User { get; set; }
    public virtual Role Role { get; set; }
}

 public virtual DbSet<DomainModels.Security.Role> Roles { get; set; }
 public virtual DbSet<DomainModels.Security.User> Users { get; set; }
 public virtual DbSet<DomainModels.Security.UserRoles> UserRoles { get; set; }

modelBuilder.Entity<DomainModels.Security.UserRole>()
    .HasKey(x => new { x.UserId, x.RoleId });

modelBuilder.Entity<DomainModels.Security.UserRole>()
    .HasRequired(x => x.User)
    .WithMany(y => y.UserRoles)
    .HasForeignKey(x => x.UserId)
    .WillCascadeOnDelete();

modelBuilder.Entity<DomainModels.Security.UserRole>()
    .HasRequired(x => x.Role)
    .WithMany(y => y.UserRoles)
    .HasForeignKey(x => x.RoleId)
    .WillCascadeOnDelete();

公共虚拟数据库集角色{get；set；}
公共虚拟数据库集用户{get；set；}
公共虚拟数据库集用户角色{get；set；}

配置：

public class User
{
    public int Id { get; set; }

    // other properties
    // ...

    // UserRole association
    public virtual ICollection<UserRole> UserRoles { get; set; }
}

public class Role
{
    public int Id { get; set; }

    // other properties
    // ...

    // UserRole association
    public virtual ICollection<UserRole> UserRoles { get; set; }
}

public class UserRole
{
    public int UserId { get; set; }
    public int RoleId { get; set; }
    public virtual User User { get; set; }
    public virtual Role Role { get; set; }
}

 public virtual DbSet<DomainModels.Security.Role> Roles { get; set; }
 public virtual DbSet<DomainModels.Security.User> Users { get; set; }
 public virtual DbSet<DomainModels.Security.UserRoles> UserRoles { get; set; }

modelBuilder.Entity<DomainModels.Security.UserRole>()
    .HasKey(x => new { x.UserId, x.RoleId });

modelBuilder.Entity<DomainModels.Security.UserRole>()
    .HasRequired(x => x.User)
    .WithMany(y => y.UserRoles)
    .HasForeignKey(x => x.UserId)
    .WillCascadeOnDelete();

modelBuilder.Entity<DomainModels.Security.UserRole>()
    .HasRequired(x => x.Role)
    .WithMany(y => y.UserRoles)
    .HasForeignKey(x => x.RoleId)
    .WillCascadeOnDelete();

modelBuilder.Entity（）
.HasKey（x=>new{x.UserId，x.RoleId}）；
modelBuilder.Entity（）
.HasRequired（x=>x.User）
.WithMany（y=>y.UserRoles）
.HasForeignKey（x=>x.UserId）
.WillCascadeOnDelete（）；
modelBuilder.Entity（）
.HasRequired（x=>x.Role）
.WithMany（y=>y.UserRoles）
.HasForeignKey（x=>x.RoleId）
.WillCascadeOnDelete（）；

---

通过此配置，您可以使用原始CRUD设计。

您所设置的是所谓的多对多关系，即EF为您维护的自动“链接”表。在这种配置中，

用户角色

实体不存在。模型应该是这样的：

public class User
{
    public int Id { get; set; }

    // other properties
    // ...

    // UserRole association
    public virtual ICollection<Role> Roles { get; set; }
}

public class Role
{
    public int Id { get; set; }

    // other properties
    // ...

    // UserRole association
    public virtual ICollection<User> Users { get; set; }
}

DbContext:

public class User
{
    public int Id { get; set; }

    // other properties
    // ...

    // UserRole association
    public virtual ICollection<UserRole> UserRoles { get; set; }
}

public class Role
{
    public int Id { get; set; }

    // other properties
    // ...

    // UserRole association
    public virtual ICollection<UserRole> UserRoles { get; set; }
}

public class UserRole
{
    public int UserId { get; set; }
    public int RoleId { get; set; }
    public virtual User User { get; set; }
    public virtual Role Role { get; set; }
}

 public virtual DbSet<DomainModels.Security.Role> Roles { get; set; }
 public virtual DbSet<DomainModels.Security.User> Users { get; set; }
 public virtual DbSet<DomainModels.Security.UserRoles> UserRoles { get; set; }

modelBuilder.Entity<DomainModels.Security.UserRole>()
    .HasKey(x => new { x.UserId, x.RoleId });

modelBuilder.Entity<DomainModels.Security.UserRole>()
    .HasRequired(x => x.User)
    .WithMany(y => y.UserRoles)
    .HasForeignKey(x => x.UserId)
    .WillCascadeOnDelete();

modelBuilder.Entity<DomainModels.Security.UserRole>()
    .HasRequired(x => x.Role)
    .WithMany(y => y.UserRoles)
    .HasForeignKey(x => x.RoleId)
    .WillCascadeOnDelete();

公共虚拟数据库集角色{get；set；}
公共虚拟数据库集用户{get；set；}
公共虚拟数据库集用户角色{get；set；}

配置：

public class User
{
    public int Id { get; set; }

    // other properties
    // ...

    // UserRole association
    public virtual ICollection<UserRole> UserRoles { get; set; }
}

public class Role
{
    public int Id { get; set; }

    // other properties
    // ...

    // UserRole association
    public virtual ICollection<UserRole> UserRoles { get; set; }
}

public class UserRole
{
    public int UserId { get; set; }
    public int RoleId { get; set; }
    public virtual User User { get; set; }
    public virtual Role Role { get; set; }
}

 public virtual DbSet<DomainModels.Security.Role> Roles { get; set; }
 public virtual DbSet<DomainModels.Security.User> Users { get; set; }
 public virtual DbSet<DomainModels.Security.UserRoles> UserRoles { get; set; }

modelBuilder.Entity<DomainModels.Security.UserRole>()
    .HasKey(x => new { x.UserId, x.RoleId });

modelBuilder.Entity<DomainModels.Security.UserRole>()
    .HasRequired(x => x.User)
    .WithMany(y => y.UserRoles)
    .HasForeignKey(x => x.UserId)
    .WillCascadeOnDelete();

modelBuilder.Entity<DomainModels.Security.UserRole>()
    .HasRequired(x => x.Role)
    .WithMany(y => y.UserRoles)
    .HasForeignKey(x => x.RoleId)
    .WillCascadeOnDelete();

modelBuilder.Entity（）
.HasKey（x=>new{x.UserId，x.RoleId}）；
modelBuilder.Entity（）
.HasRequired（x=>x.User）
.WithMany（y=>y.UserRoles）
.HasForeignKey（x=>x.UserId）
.WillCascadeOnDelete（）；
modelBuilder.Entity（）
.HasRequired（x=>x.Role）
.WithMany（y=>y.UserRoles）
.HasForeignKey（x=>x.RoleId）
.WillCascadeOnDelete（）；

通过此配置，您可以使用原始CRUD设计。

EF中的多对多表不能作为物理可访问实体使用，而是您必须使用其中一个实体对其执行操作，因为相关实体在两个模型中都可以作为

ICollection

使用。EF不公开这个实体，而是在内部管理它

i、 e，您必须在*

角色

中将ICollection Users*作为导航属性，反之亦然

比方说，您有一个

User

的对象，您需要针对它获取/设置角色。您必须按照以下方式进行操作：

User user = GetSomeUser();
Role adminRole = GetAdminRole();
user.Roles.Add(adminRole);

Role role = user.Roles.Where(x => x.Id == adminRoleId).firstOrDefault();

上面的示例只是让您了解如何处理EF中的

多对多

关系EF中的多对多表不能作为物理可访问的实体使用，而您必须使用其中一个实体对其执行操作，因为相关实体在这两种模型中都以

ICollection

的形式提供。EF不公开这个实体，而是在内部管理它

i、 e，您必须在*

角色

中将ICollection Users*作为导航属性，反之亦然

比方说，您有一个

User

的对象，您需要针对它获取/设置角色。您必须按照以下方式进行操作：

User user = GetSomeUser();
Role adminRole = GetAdminRole();
user.Roles.Add(adminRole);

Role role = user.Roles.Where(x => x.Id == adminRoleId).firstOrDefault();

---

上面的示例只是让您了解如何处理EF中的

多对多

关系

您是否更新了数据库？是的，我已成功更新了数据库！你更新数据库了吗？是的，我成功地更新了数据库！非常感谢，但是我们正在使用简单的Odata客户端来插入/更新如何使用它？我不明白这个问题。如何使用什么？使用替代EF模型更新了答案，我想这可以让您保留

UserRole

CRUD设计。我不熟悉OData，这里讨论的只是可能的EF模型以及如何执行CRUD操作。例如，在第二个模型中添加

UserRole

相当于

UserRole.User.Roles.Add（UserRole.Role）

或

UserRole.Role.Users.Add（UserRole.User）

，前提是

User

和

Role

对象从数据库中正确填充。是的，谢谢Ivan，为odata创建了一个包含更多详细信息的新问题，请看一看，非常感谢，但是我们正在使用简单的odata客户端来插入/更新如何使用它？我不明白这个问题。如何使用什么？使用替代EF模型更新了答案，我想这可以让您保留

UserRole

CRUD设计。我不熟悉OData，这里讨论的只是可能的EF模型以及如何执行CRUD操作。例如，在第二个模型中添加

UserRole

相当于

UserRole.User.Roles.Add（UserRole.Role）

或

UserRole.Role.Users.Add（UserRole.User）

，前提是

User

和

Role

对象从数据库中正确填充。是的，谢谢Ivan，为odata创建了一个包含更多详细信息的新问题，请查看