C# 使用联接的相同LINQ查询，但条件不同

我有一些非常类似的LINQ查询：

var city = "Hamburg";

var query1 = 
    from c in DB.Customers
    join address in DB.Addresses on c.ID equals address.CustomerID
    where address.City == city
    select c;

var query2 = 
    from c in DB.Customers
    join address in DB.Addresses on c.ID equals address.CustomerID
    where address.City.StartsWith(city)
    select c;

etc.

我想使用循环创建查询以减少冗余：

var city = "Hamburg";

var expressions = new Expression<Func<string, bool>>[] {
    a => a == city,
    a => a.StartsWith(city)
};

for(int i = 1; i <= 2; i++) {
    queries.Add(
        from c in DB.Customers
        join address in DB.Addresses on c.ID equals address.CustomerID
        where expressions[i](address.City) 
        select c
        );
}

var city=“汉堡”；
变量表达式=新表达式[]{
a=>a==城市，
a=>a.StartsWith（城市）
};
对于（inti=1；i，您可以在公共查询中保存公共连接部分

var query = from c in DB.Customers
         join address from DB.Addresses on c.ID equals address.CustomerID
         select new {A=a, C=c};
var query1 = query.Where ( item => item.A.temp == item.C.test).Select (item => item.C);
var query2 = query.Where ( item => item.A.temp2 == item.C.test2).Select (item => item.C);

您可以直接使用
Join
方法，而不是使用查询语法：

public IQueryable<Customer> FindCustomers(Expression<Func<Customer, Address, bool>> predicate)
{
    return DB.Customers.Join(DB.Addresses, c => c.ID, a => d.CustomerID, (c, a) => new { Address = a, Customer = c})
        .Where(pair => predicate(pair.Address))
        .Select(pair => pair.Customer)
}

然后，您可以将阵列创建为：

IQueryable<Customer>[] queries = expressions.Select(expr => FindCustomers(expr)).ToArray();

IQueryable[]querys=expressions.Select（expr=>FindCustomers（expr））.ToArray（）；
var city=“汉堡”；
//谓词应该接受地址
变量表达式=新表达式[]{
a=>a.City==City，
a=>a.City.StartsWith（城市）
};
foreach（表达式中的var谓词）{
查询。添加(
DB.Customers.Join(
DB.Addresses.Where（谓词），//此处筛选
c=>c.ID，
a=>a.CustomerID，
（c，a）=>c）//返回客户
));
}
var查询=(
从f到in
新函数[]{
x=>x.City==City，
x=>x.City.StartsWith（城市）
}
选择
来自数据库中的c
数据库中的联接地址。c.ID上的地址等于address.CustomerID
其中f（地址）
选择c
).ToArray（）；

您正在创建一个
表达式数组
，这意味着您最终将生成一个
表达式数组
；您不需要将委托设置为
表达式数组

您不需要foreach的

如果以后要将更多表达式添加到
查询
，请将
ToArray（）
更改为
ToList（）

如果要在生成
查询之前修改
Func
，请为其定义一个局部变量，只需替换
Func[]

老实说，这看起来像是一个存储过程的作业。您期望的结果是什么？一个列表，
i
lists？@Hogan我希望
i
列表包含通过不同表达式过滤的客户。另外，Expression？在EF中，
join
几乎不需要。您没有像
Customer.Addresses这样的导航属性吗？问题是谓词需要访问地址的属性，但当我加入
（c，a）时=>c
我只能在谓词中使用客户，还是我遗漏了什么？@Dennis-我已将其更改为使用
地址而不是
客户
。谢谢。什么是协会奖金，我刚收到通知。
IQueryable<Customer>[] queries = expressions.Select(expr => FindCustomers(expr)).ToArray();

var city = "Hamburg";

// predicate should accept Address
var expressions = new Expression<Func<Address, bool>>[] {
    a => a.City == city,
    a => a.City.StartsWith(city)
};

foreach(var predicate in expressions) {
    queries.Add(
        DB.Customers.Join(
           DB.Addresses.Where(predicate), // filtering here
           c => c.ID, 
           a => a.CustomerID, 
           (c, a) => c) // return customer
    ));
}

var queries=(
    from f in
        new Func<Address, bool>[] { 
            x => x.City==city, 
            x => x.City.StartsWith(city)
            }
    select
        from c in DB.Customers
        join address in DB.Addresses on c.ID equals address.CustomerID
        where f(address)
        select c
    ).ToArray();