Question

我需要进行查询以过滤记录，当获取不同的记录时，通过差异条件获取这些记录信息。此外，我需要这些是动态的（首选中的数量过滤器）

让我举个例子：

我有两张桌子：

tblCustomers：

id    customerName  
1        John  
2        Philip  
3        Steve

tblOrders

id    customerId     ordId    payment
1      1              100      True
2      1              101      True
3      1              102      False 
4      2              101      True
5      2              102      True
6      2              103      False 
7      3              101      True

我的条件是：

where (orderId = 101 and orderId = 102)

但要获得该客户的所有记录payment = true我的意思是我的情况与我需要看到的情况不同。

我希望收到payment=True的所有记录而不关心orderId

我必须得到：

john    100
john    101  
Philip  101
Philip  102

清算：我需要两个步骤 - 第一个过滤客户，其订单ID为101＆amp; 102，第二步我想显示这些选定客户的orderId哪个付款是真的。所以例如在第一步我得到约翰（谁的订单id = 101＆amp; 102）然后显示约翰100 - 约翰101（支付是真实的）。考虑tblorder.id = 1不在第一个查询中，但我必须在最终结果中显示。

@Raphael指示我更好地表达：我想看到有订单的客户（101＆amp; 102）的所有付款真实订单。但秩序可能超过2（感谢@Raphael）。

第二个问题是：它必须是动态的。有时我必须检查超过10个orderId - 有时候更少。我的意思是我的查询必须灵活。

在SQL Server select命令中，我可以准备一个字符串变量并使用但在linq我不能这样做。

Answer 1

根据我对您的帖子和评论的理解，您需要所有客户，其中orderId为101或102且付款为真。

你需要带有orderIds的where子句是动态的，这样你就可以在查询之外更改要检查的ID。

List<int> IDList = new List<int>();
IDList.Add(101);
IDList.Add(102);
IDList.Add(110);
//...

var result = from cust in tblCustomers
             join order in tblOrders on cust.id equals order.customerId
             where IDList.Contains(order.ordId) && order.payment == true
             select new {
                          Name = cust.customerName
                          OrderId = order.ordId
                          payment = order.payment
                          //...
                        }

使用此功能，您可以在列表中存储需要检查的所有orderId，然后您可以从代码中进行编辑。

修改我真的没有为你的问题找到一个干净的解决方案，所以我绕道而行，这不是很干净但应该有用。在我的例子中，我创建了两个类Customer＆amp; Order并填写了上面的数据。然后我接受了我的第一个查询并附加了一个groupBy和一个where子句，将分组的长度与列表的长度进行比较

var result = (from cust in Customers join order in Orders on cust.Id equals order.customerId where IDList.Contains(order.orderId) && order.payment == true select new { Name = cust.Name, OrderId = order.orderId, Payment = order.payment //... }).GroupBy (r => r.Name) .Where (r => r.Count() == IDList.Count());

输出：

Name OrderId Payment Philip 101 True Philip 102 True

如果您需要/需要它，我可以为您提供整个Linqpad查询，这样您就可以看到我的整个代码以及我所做的事情。说到Linqpad：忽略result.Dump（）行。它不适用于Visual Studio。

Answer 2

void Main()
{
    List<Customer> customers = new List<Customer>
    {
        new Customer { Id = 1, Name = "John" },
        new Customer { Id = 2, Name = "Philip" },
        new Customer { Id = 3, Name = "Steve" }
    };

    List<Order> orders = new List<Order>
    {
        new Order { Id = 1, CustomerId = 1, OrderId = 100, Payment = true },
        new Order { Id = 2, CustomerId = 1, OrderId = 101, Payment = true },
        new Order { Id = 3, CustomerId = 1, OrderId = 102, Payment = false },
        new Order { Id = 4, CustomerId = 2, OrderId = 101, Payment = true },
        new Order { Id = 5, CustomerId = 2, OrderId = 102, Payment = true },
        new Order { Id = 6, CustomerId = 2, OrderId = 103, Payment = false },
        new Order { Id = 7, CustomerId = 3, OrderId = 101, Payment = true }
    };

    List<int> orderIds = new List<int> { 101, 102 };

    var customersWithRelevantOrders =
        from ord in orders
        group ord by ord.CustomerId into customerOrders
        where orderIds.All (
            i => customerOrders.Select (co => co.OrderId).Contains(i))
        select customerOrders.Key;

    var paymentTrueOrdersForTheseCustomers =
        from ord in orders
        join cust in customers on ord.CustomerId equals cust.Id
        where ord.Payment
        where customersWithRelevantOrders.Contains(cust.Id)
        select new
        {
            Name = cust.Name,
            OrderId = ord.OrderId
        };
}

public class Customer
{
    public int Id { get; set; }
    public string Name { get; set; }
}

public class Order
{
    public int Id { get; set; }
    public int CustomerId { get; set; }
    public int OrderId { get; set; }
    public bool Payment { get; set; }
}

LINQ EF QUERY（查看与条件和动态的区别）

2 个答案: