LINQ EF查询（查看与条件和动态的差异）

我需要做一个查询来过滤记录，当得到不同的记录时，根据不同的条件得到这些记录信息。我还需要这些是动态的（数量过滤器在第一选择）

让我给你举个例子：

我有两张桌子：

tbl客户：

id    customerName  
1        John  
2        Philip  
3        Steve

t领主

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    

清除：我需要两步-第一步筛选orderId=101和102的客户，第二步我想显示这些选定客户的orderId，其中付款是真实的。例如，在第一步中，我得到john（订单id=101和102），然后显示john 100-john 101（哪个付款是正确的）。考虑TBLoord.ID＝1不在第一个查询中，但我必须在最终结果中显示。 @Raphael告诉我更好的表达方式：我希望看到有订单的客户（101和102）的所有付款都是真实的订单。但是OrderID可能不止2个（谢谢@Raphael）

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

---

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

根据我从您的帖子和评论中了解到的，您需要所有客户，其中orderId为101或102，并且付款是真实的

您需要带有orderID的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
                          //...
                        }

输出：

Name OrderId Payment
Philip 101   True 
Philip 102   True 

如果您想要/需要它，我可以为您提供整个Linqpad查询，这样您就可以看到我的全部代码和我所做的工作。说到Linqpad：忽略result.Dump（）行。它在visual Studio上不起作用。

void Main（）
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; }
}

{
列出客户=新列表
{
新客户{Id=1，Name=“John”}，
新客户{Id=2，Name=“Philip”}，
新客户{Id=3，Name=“Steve”}
};
列表顺序=新列表
{
新订单{Id=1，CustomerId=1，OrderId=100，Payment=true}，
新订单{Id=2，CustomerId=1，OrderId=101，Payment=true}，
新订单{Id=3，CustomerId=1，OrderId=102，Payment=false}，
新订单{Id=4，CustomerId=2，OrderId=101，Payment=true}，
新订单{Id=5，CustomerId=2，OrderId=102，Payment=true}，
新订单{Id=6，CustomerId=2，OrderId=103，Payment=false}，
新订单{Id=7，CustomerId=3，OrderId=101，Payment=true}
};
List orderIds=新列表{101，102}；
具有相关订单的var客户=
从ord订购
按ord.CustomerId将ord分组为CustomerOrder
OrderID在哪里(
i=>customerOrders.Select（co=>co.OrderId.Contains（i））
选择customerOrders.Key；
var PaymentTrueOrdersForthes客户=
从ord订购
在ord.CustomerId等于cust.Id上加入客户
付款地点在哪里
其中customersWithRelevantOrders.Contains（cust.Id）
选择新的
{
Name=客户名称，
OrderId=order.OrderId
};
}
公共类客户
{
公共int Id{get；set；}
公共字符串名称{get；set；}
}
公共阶级秩序
{
公共int Id{get；set；}
public int CustomerId{get；set；}
公共int-OrderId{get；set；}
公共布尔支付{get；set；}
}

嗨，穆罕默德，我不确定我是否理解你的问题。您想要id为101或102且付款设置为true的所有订单吗？或者你只想要所有付款设置为true的记录？@Raphael，谢谢你，事实上我首先需要每个orderId=101和102的人，但显示包含上一步结果payment=true的记录。让我澄清我的问题（编辑）。@Raphael，请检查我添加的澄清部分。谢谢。好的，现在我明白了，你应该为有订单的客户（101和102）提供所有付款真实订单。是的，你总结得比我好！“其中orderId为101或102”是错误的，我想：“其中orderId为101和102”。例如，我不喜欢只有101的人。哦，让我在Linqpad中把它记下来。我想我们这里需要一个groupBy，但我需要几分钟来编写和测试。我只是想确认一下。只有101的用户是错误的。只有102的用户是错误的。你希望用户拥有101和102。是的。你得到了我需要的谢谢。据我所知，分组只是为了计数！如果你有一些资料可以直接读给我看。有可能在linq吗？我已经编辑了一个，我认为是，可行的解决方案。不是很圆滑，但应该可以。让我们希望像Söner Order Tim这样的职业选手能够通过并改进它；）谢谢，让我检查一下。我必须将其转换为vb。我打开了一个c#项目，但在join中出现了错误：join子句中某个表达式的类型不正确。调用“Join”时类型推断失败。修复了两个小错误（where中缺少分号和“h”）。否则我可以直接复制到LinqPad中，它就可以工作了。问题是在我的表字段类型中，vb并没有提醒我，但当切换到c#visual studio时，会提醒我。不管怎么说，我想再次检查一下，把这个帖子回复过来。非常感谢。太好了。

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; }
}