C# 使用嵌套的任意运算符查询五个表

我试图创建一个查询来获取属于某个公告的所有用户，但我似乎无法使我的查询正常工作

我得到以下错误：

无法创建“RequestSupplierEntity”类型的常量值。 此类型中仅支持基元类型或枚举类型 上下文

我不知道错误消息的确切含义，或者我应该做什么/避免什么来防止它。任何对问题的帮助或洞察，甚至是一个有效的查询，都将不胜感激。 在我看来，单个T-SQL查询应该可以使用EXIST子查询，我只是不知道在这种情况下实体框架是否能够构造它

我的查询语句：

Users.Where(u => notification.Announcement.RequestSuppliers.Any(rs => rs.Supplier.OrganisationId == u.OrganisationId));

用户是一个数据库集。notification是我试图查找关联用户的实体实例。我觉得问题在于如何在DBSet的where方法中使用NotificationEntity实例，但我不知道如何才能做到这一点

POCO实体关系如下：

• 用户有一个组织
• 供应商是一个组织
• 请求供应商是一个供应商
• 供应商有一个公告
• 通知中有一条公告

所以我想做的是通过RequestSupplier获取与公告相关联的供应商的OrganizationID用户

相关的FluentAPI是：

modelBuilder.Entity<NotificationEntity>()
    .HasOptional<AnnouncementEntity>(n => n.Announcement)
    .WithMany(a => a.Notifications)
    .HasForeignKey(n => n.AnnouncementId)
    .WillCascadeOnDelete(false);
modelBuilder.Entity<RequestSupplierEntity>()
    .HasRequired<SupplierEntity>(rs => rs.Supplier)
    .WithMany(s => s.RequestSuppliers)
    .WillCascadeOnDelete(false);
modelBuilder.Entity<RequestSupplierEntity>()
    .HasKey(rs => new { rs.SupplierId });
modelBuilder.Entity<RequestSupplierEntity>()
    .HasRequired<AnnouncementEntity>(rs => rs.Announcement)
    .WithMany(a => a.RequestSuppliers)
    .HasForeignKey(rs => rs.AnnouncementId)
    .WillCascadeOnDelete(false);
modelBuilder.Entity<SupplierEntity>()
    .HasRequired<OrganisationEntity>(s => s.Organisation)
    .WithMany(o => o.Suppliers)
    .HasForeignKey(s => s.OrganisationId)
    .WillCascadeOnDelete(false);
modelBuilder.Entity<UserEntity>()
    .HasOptional<OrganisationEntity>(u => u.Organisation)
    .WithMany(o => o.Users)
    .WillCascadeOnDelete(true);

modelBuilder.Entity（）
.has可选（n=>n.Announcement）
.WithMany（a=>a.notification）
.HasForeignKey（n=>n.AnnouncementId）
.WillCascadeOnDelete（假）；
modelBuilder.Entity（）
.HasRequired（rs=>rs.Supplier）
.有许多（s=>s.Request供应商）
.WillCascadeOnDelete（假）；
modelBuilder.Entity（）
.HasKey（rs=>new{rs.SupplierId}）；
modelBuilder.Entity（）
.has必需（rs=>rs.Announcement）
.WithMany（a=>a.RequestSuppliers）
.HasForeignKey（rs=>rs.AnnouncementId）
.WillCascadeOnDelete（假）；
modelBuilder.Entity（）
.HasRequired（s=>s.Organization）
.有许多（o=>o.供应商）
.HasForeignKey（s=>s.OrganizationID）
.WillCascadeOnDelete（假）；
modelBuilder.Entity（）
.HAS可选（u=>u.Organization）
.WithMany（o=>o.Users）
.WillCascadeOnDelete（真）；

我正在查询的通知始终具有关联的通知

实体：

[Table("Announcement")]
public class AnnouncementEntity
{
    public int Id { get; set; }

    public virtual ICollection<RequestSupplierEntity> RequestSuppliers { get; set; }
    public virtual ICollection<NotificationEntity> Notifications { get; set; }
}

[Table("Notification")]
public class NotificationEntity
{
    public int Id { get; set; }
    public int? AnnouncementId { get; set; }

    public virtual AnnouncementEntity Announcement { get; set; }
}

[Table("Organisation")]
public class OrganisationEntity
{
    public int Id { get; set; }

    public virtual ICollection<SupplierEntity> Suppliers { get; set; }
    public virtual ICollection<UserEntity> Users { get; set; }
}

[Table("RequestSupplier")]
public class RequestSupplierEntity
{
    public int SupplierId { get; set; }
    public int AnnouncementId { get; set; }

    public virtual SupplierEntity Supplier { get; set; }
    public virtual AnnouncementEntity Announcement { get; set; }
}

[Table("Supplier")]
public class SupplierEntity
{
    public int Id { get; set; }
    public int OrganisationId { get; set; }

    public virtual OrganisationEntity Organisation { get; set; }
    public virtual ICollection<RequestSupplierEntity> RequestSuppliers { get; set; }
}

[Table("User")]
public class UserEntity
{
    public int Id { get; set; }
    public int? OrganisationId { get; set; }

    public virtual OrganisationEntity Organisation { get; set; }
}

[表格（“公告”）]
公共类公告实体
{
公共int Id{get；set；}
公共虚拟ICollection请求供应商{get；set；}
公共虚拟ICollection通知{get；set；}
}
[表（“通知”）]
公共类通知实体
{
公共int Id{get；set；}
public int？AnnouncementId{get；set；}
公共虚拟公告实体公告{get；set；}
}
[表（“组织”）]
公营机构
{
公共int Id{get；set；}
公共虚拟ICollection供应商{get；set；}
公共虚拟ICollection用户{get；set；}
}
[表（“请求供应商”）]
公共类RequestSupplierEntity
{
public int SupplierId{get；set；}
public int AnnouncementId{get；set；}
公共虚拟供应商实体供应商{get；set；}
公共虚拟公告实体公告{get；set；}
}
[表（“供应商”）]
公共类供应商实体
{
公共int Id{get；set；}
公共int组织ID{get；set；}
公共虚拟组织实体组织{get；set；}
公共虚拟ICollection请求供应商{get；set；}
}
[表格（“用户”）]
公共类用户实体
{
公共int Id{get；set；}
公共int？组织ID{get；set；}
公共虚拟组织实体组织{get；set；}
}

我不确定，但试试这个

  db.Users.Where(u => db.Notifications.Select(n=>n.Announcement).SelectMany(a=>a.RequestSuppliers).Any(rs => rs.Supplier.OrganisationId == u.OrganisationId));

我猜您试图创建一个RequestSuppliers集合，该集合是通过Where（）方法中通知集合的注释选择的 在这种情况下，您必须使用SelectMany

在任何情况下都可以使用join来实现此目的

var users=(from u in db.Users
         join s in db.Suppliers
         on u.OrganisationId equals s.OrganisationId
         join rs in db.RequestSuppliers
         on s.Id equals rs.SupplierId
         join a in db.Announcements
         on rs.AnnouncementId equals a.Id
         join n in db.Notifications
         on a.Id equals n.AnnouncementId
         select u);

---

两种解决方案都奏效了。谢谢我必须在这两个查询中为notificationId添加where子句，但除此之外，这两个查询都非常有效。