C# 执行join linq查询时出错

我正在尝试执行以下代码：

    public ActionResult JoinSupToPro()
    {

        SupplierDBContext dbS = new SupplierDBContext();
        var innerJoinQuery = from pro in db.Products join sup in dbS.Suppliers on pro.SupplierId equals sup.ID
        select new {Name= pro.Name,Price =pro.Price, SupplierName =sup.Name , Phone =sup.Phone};
        IndexModel m = new IndexModel();
        foreach (var item in innerJoinQuery)
        {
            SupplierProduct p = new SupplierProduct();
            p.SupplierName = item.SupplierName;
            p.Phone = item.Phone;
            p.Price = item.Price;
            p.ProductName = item.Name;
                m.MenuItems.Add(p);
        }

        return View(m.MenuItems.ToList());
    }

我遇到了这个问题： 指定的LINQ表达式包含对与不同上下文关联的查询的引用。

---

有什么想法吗？

看起来您正在连接来自两个不同上下文的数据：tms和实体

这在LINQ中是不可能的，因为两者都有自己的数据库连接和完全独立的模型

EF不可能将其转换为SQL语句。（据它所知，这些表可能位于不同的数据库中）

---

您需要将所有实体移动到一个上下文中，或者分别执行两个查询，然后将它们连接到内存中。（如果所有表都在同一个数据库中，则使用第一个选项；如果有单独的数据库，则使用第二个选项）

看起来您正在连接来自两个不同上下文的数据：tms和实体

这在LINQ中是不可能的，因为两者都有自己的数据库连接和完全独立的模型

EF不可能将其转换为SQL语句。（据它所知，这些表可能位于不同的数据库中）

---

您需要将所有实体移动到一个上下文中，或者分别执行两个查询，然后将它们连接到内存中。（如果所有表都在同一个数据库中，则使用第一个选项；如果有单独的数据库，则使用第二个选项）

看起来您正在连接来自两个不同上下文的数据：tms和实体

这在LINQ中是不可能的，因为两者都有自己的数据库连接和完全独立的模型

EF不可能将其转换为SQL语句。（据它所知，这些表可能位于不同的数据库中）

---

您需要将所有实体移动到一个上下文中，或者分别执行两个查询，然后将它们连接到内存中。（如果所有表都在同一个数据库中，则使用第一个选项；如果有单独的数据库，则使用第二个选项）

看起来您正在连接来自两个不同上下文的数据：tms和实体

这在LINQ中是不可能的，因为两者都有自己的数据库连接和完全独立的模型

EF不可能将其转换为SQL语句。（据它所知，这些表可能位于不同的数据库中）

---

您需要将所有实体移动到一个上下文中，或者分别执行两个查询，然后将它们连接到内存中。（如果所有表都在同一个数据库中，请使用第一个选项；如果有单独的数据库，请使用第二个选项）

工作时，我发现解决我的答案的方法是将两个查询分开，然后像这样连接它们：

    public ActionResult JoinSupToPro()
    {

        List<Supplier> dbS = new SupplierDBContext().Suppliers.ToList();
        List<Product> prod = db.Products.ToList();
        var innerJoinQuery = from pro in prod join sup in dbS on pro.SupplierId equals sup.ID
        select new {Name= pro.Name,Price =pro.Price, SupplierName =sup.Name , Phone =sup.Phone};
        IndexModel m = new IndexModel();
        m.MenuItems = new List<SupplierProduct>();
        foreach (var item in innerJoinQuery)
        {
            SupplierProduct p = new SupplierProduct();
            p.SupplierName = item.SupplierName;
            p.Phone = item.Phone;
            p.Price = item.Price;
            p.ProductName = item.Name;
                m.MenuItems.Add(p);
        }

public ActionResult JoinSupToPro（）
{
List dbS=new SupplierDBContext（）.Suppliers.ToList（）；
List prod=db.Products.ToList（）；
var innerJoinQuery=pro.SupplierId等于sup.ID上的prod join sup in dbS中的pro
选择新建{Name=pro.Name，Price=pro.Price，SupplierName=sup.Name，Phone=sup.Phone}；
IndexModel m=新的IndexModel（）；
m、 MenuItems=新列表（）；
foreach（innerJoinQuery中的变量项）
{
供应商产品p=新供应商产品（）；
p、 供应商名称=item.SupplierName；
p、 电话=项目。电话；
p、 价格=项目价格；
p、 ProductName=item.Name；
m、 菜单项添加（p）；
}

在工作时，我发现我的答案的解决方案是将两个查询分开，然后像这样将它们连接起来：

    public ActionResult JoinSupToPro()
    {

        List<Supplier> dbS = new SupplierDBContext().Suppliers.ToList();
        List<Product> prod = db.Products.ToList();
        var innerJoinQuery = from pro in prod join sup in dbS on pro.SupplierId equals sup.ID
        select new {Name= pro.Name,Price =pro.Price, SupplierName =sup.Name , Phone =sup.Phone};
        IndexModel m = new IndexModel();
        m.MenuItems = new List<SupplierProduct>();
        foreach (var item in innerJoinQuery)
        {
            SupplierProduct p = new SupplierProduct();
            p.SupplierName = item.SupplierName;
            p.Phone = item.Phone;
            p.Price = item.Price;
            p.ProductName = item.Name;
                m.MenuItems.Add(p);
        }

public ActionResult JoinSupToPro（）
{
List dbS=new SupplierDBContext（）.Suppliers.ToList（）；
List prod=db.Products.ToList（）；
var innerJoinQuery=pro.SupplierId等于sup.ID上的prod join sup in dbS中的pro
选择新建{Name=pro.Name，Price=pro.Price，SupplierName=sup.Name，Phone=sup.Phone}；
IndexModel m=新的IndexModel（）；
m、 MenuItems=新列表（）；
foreach（innerJoinQuery中的变量项）
{
供应商产品p=新供应商产品（）；
p、 供应商名称=item.SupplierName；
p、 电话=项目。电话；
p、 价格=项目价格；
p、 ProductName=item.Name；
m、 菜单项添加（p）；
}

在工作时，我发现我的答案的解决方案是将两个查询分开，然后像这样将它们连接起来：

    public ActionResult JoinSupToPro()
    {

        List<Supplier> dbS = new SupplierDBContext().Suppliers.ToList();
        List<Product> prod = db.Products.ToList();
        var innerJoinQuery = from pro in prod join sup in dbS on pro.SupplierId equals sup.ID
        select new {Name= pro.Name,Price =pro.Price, SupplierName =sup.Name , Phone =sup.Phone};
        IndexModel m = new IndexModel();
        m.MenuItems = new List<SupplierProduct>();
        foreach (var item in innerJoinQuery)
        {
            SupplierProduct p = new SupplierProduct();
            p.SupplierName = item.SupplierName;
            p.Phone = item.Phone;
            p.Price = item.Price;
            p.ProductName = item.Name;
                m.MenuItems.Add(p);
        }

public ActionResult JoinSupToPro（）
{
List dbS=new SupplierDBContext（）.Suppliers.ToList（）；
List prod=db.Products.ToList（）；
var innerJoinQuery=pro.SupplierId等于sup.ID上的prod join sup in dbS中的pro
选择新建{Name=pro.Name，Price=pro.Price，SupplierName=sup.Name，Phone=sup.Phone}；
IndexModel m=新的IndexModel（）；
m、 MenuItems=新列表（）；
foreach（innerJoinQuery中的变量项）
{
供应商产品p=新供应商产品（）；
p、 供应商名称=item.SupplierName；
p、 电话=项目。电话；
p、 价格=项目价格；
p、 ProductName=item.Name；
m、 菜单项添加（p）；
}

在工作时，我发现我的答案的解决方案是将两个查询分开，然后像这样将它们连接起来：

    public ActionResult JoinSupToPro()
    {

        List<Supplier> dbS = new SupplierDBContext().Suppliers.ToList();
        List<Product> prod = db.Products.ToList();
        var innerJoinQuery = from pro in prod join sup in dbS on pro.SupplierId equals sup.ID
        select new {Name= pro.Name,Price =pro.Price, SupplierName =sup.Name , Phone =sup.Phone};
        IndexModel m = new IndexModel();
        m.MenuItems = new List<SupplierProduct>();
        foreach (var item in innerJoinQuery)
        {
            SupplierProduct p = new SupplierProduct();
            p.SupplierName = item.SupplierName;
            p.Phone = item.Phone;
            p.Price = item.Price;
            p.ProductName = item.Name;
                m.MenuItems.Add(p);
        }

public ActionResult JoinSupToPro（）
{
List dbS=new SupplierDBContext（）.Suppliers.ToList（）；
List prod=db.Products.ToList（）；
var innerJoinQuery=pro.SupplierId等于sup.ID上的prod join sup in dbS中的pro
选择新建{Name=pro.Name，Price=pro.Price，SupplierName=sup.Name，Phone=sup.Phone}；
IndexModel m=新的IndexModel（）；
m、 MenuItems=新列表（）；
foreach（innerJoinQuery中的变量项）
{
供应商产品p=新供应商产品（）；
p、 供应商名称=item.SupplierName；
p、 电话=项目。电话；
p、 价格=项目价格；
p、 ProductName=item.Name；
m、 菜单项