C# 使用实体框架SqlQuery填充子属性

给定以下POCO代码第一个实体

public class Customer
{
    public int CustomerId { get; set; }
    public string CustomerTitle { get; set; }
    public string CustomerFirstName { get; set; }
    public string CustomerLastName { get; set; }

    public ICollection<Order> Orders { get; set; }
}

public class Order
{
   public int OrderId { get; set; }
   ...
   public int CustomerId { get; set; }

   public Customer Customer { get; set; }
}

我尝试使用参数化sql，使用

        Customer co =  context.Customer.SqlQuery(
                    @"select [Customer].[CustomerId], 
                             ...
                             [Order].[OrderId] AS [OrderId], 
                             ...
                            from Customer join Order on Customer.CustomerId = Order.CustomerId where Customer.CustomerId = @custid", sqlParm)
                .FirstOrDefault();

---

如何获取co中的订单。要使用上述命令填充订单，似乎无法将Include语句与SqlQuery一起使用。这是一个非常简化的示例，仅用于说明目的，实际查询将更加复杂。

这根本不可能。直接SQL执行不提供导航属性的填充，您实际上不能使用Include。您必须执行两个单独的SQL查询来获取

Cutomer

和她的

订单

我使用了以下类结构作为解决方法：

public class Customer
{
    public int CustomerId { get; set; }
}

public class Order
{
    public Customer Customer { get; set; }
    private int _customerId;
    private int CustomerId { get { return _customerId; } set { Customer.CustomerId = _customerId = value; } }
    public Order()
    {
        Customer = new Customer();
    }
}

在这种情况下，您不需要运行两次查询，下面的查询将给出客户订单：

db.Database.SqlQuery<Order>(
    "select cu.CustomerId, ord.OrderId from Orders ord join Customer cu on cu.CustomerId=ord.CustomerId")
    .ToList();

db.Database.SqlQuery(
“从订单中选择cu.CustomerId、ord.OrderId或在cu.CustomerId=ord.CustomerId上加入客户cu”）
.ToList（）；

对我有效的方法是在使用关闭之前访问相关成员

public static Customer GetCustomer (int custid)
{
Customer co = null;

using (var context = new YourEntities())
{
    // your code
    co =  context.Customer.SqlQuery(
    @"select [Customer].[CustomerId], 
    ...
    [Order].[OrderId] AS [OrderId], 
    ...
    from Customer join Order on Customer.CustomerId = Order.CustomerId where Customer.CustomerId = @custid", sqlParm)
    .FirstOrDefault();


    // my addition
    // cause lazy loading of Orders before closing the using
    ICollection<Order> orders = co.Orders;

    }

    // can access co.Orders after return.
    return (co);
}

公共静态客户GetCustomer（int-custid）
{
客户co=null；
使用（var context=newYourEntities（））
{
//你的代码
co=context.Customer.SqlQuery(
@“选择[Customer]。[CustomerId]，
...
[Order]。[OrderId]作为[OrderId]，
...
从Customer.CustomerId=Order.CustomerId上的客户加入订单，其中Customer.CustomerId=@custid”，sqlParm）
.FirstOrDefault（）；
//我的补充
//导致在关闭使用前延迟加载订单
i收款订单=公司订单；
}
//返回后可以访问公司订单。
返回（co）；
}

FirstOrDefault（）导致执行查询，因此这实际上等于执行两个查询

public static Customer GetCustomer (int custid)
{
Customer co = null;

using (var context = new YourEntities())
{
    // your code
    co =  context.Customer.SqlQuery(
    @"select [Customer].[CustomerId], 
    ...
    [Order].[OrderId] AS [OrderId], 
    ...
    from Customer join Order on Customer.CustomerId = Order.CustomerId where Customer.CustomerId = @custid", sqlParm)
    .FirstOrDefault();


    // my addition
    // cause lazy loading of Orders before closing the using
    ICollection<Order> orders = co.Orders;

    }

    // can access co.Orders after return.
    return (co);
}