Linq to SQL：通过 || 聚合

Question

我正在尝试编写一个 Linq 查询，该查询获取名字或姓氏以字符串列表中至少一个字符串开头的所有用户。这用于消息系统中收件人的自动完成。

这是我的第一次天真的尝试：

var users = UserRepository.ALL()
foreach (var part in new [] { 'Ha', 'Ho', 'He' })
{
    string part1 = part; // "Copy" since we're coding lazily
    users = users.Where(x => x.LastName.StartsWith(part1) ||
                             x.FirstName.StartsWith(part1));
}

但这不起作用，因为结果变成：

users.Where(a || b).Where(c || d).Where(e || f)...

...而我想要：

users.Where(a || b || c || d || e || f || ...)

我将如何去做呢？

Answer 1

您需要使用 2 个集合 - 在您的代码中您正在过滤列表...实际上您需要过滤列表的集合 - 而不是已过滤多次的列表的集合。

一个作为匹配的存储库，另一个在你的循环中

var userCollection = new Collection<string>();
var users = UserRepository.ALL() 
foreach (var part in new [] { 'Ha', 'Ho', 'He' }) 
{ 
    string part1 = part; // "Copy" since we're coding lazily 
    var matches = users.Where(x => x.LastName.StartsWith(part1) || 
                             x.FirstName.StartsWith(part1)); 
    foreach (var i in matches)
    {
        userCollection.Add(i);
    }
} 

我并不是说这是最优雅的解决方案 - 只是试图指出为什么你的逻辑失败。

你也许可以用 Contains 做一些事情

var results= from i in collection 
            where idList.Contains(i.Id) 
            select i; 

，只是看不出我的想法

Answer 2

当然，我应该使用 Union...

IQueryable<User> result = null;
foreach (var part in terms)
{
    string part1 = part;
    var q = users.Where(x => x.FirstName.StartsWith(part1) ||
                             x.LastName.StartsWith(part1));
    result = result == null ? q : result.Union(q);
}

使用 ReSharper 可以将其转换为 Linq 表达式：

IQueryable<User> result = terms.Select(part1 =>
    users.Where(x => x.FirstName.StartsWith(part1) ||
                     x.LastName.StartsWith(part1)))
         .Aggregate<IQueryable<User>, IQueryable<User>>(
                null, (current, q) => current == null ? q : current.Union(q));

...但我可能会使用 foreach 循环这次。 :)

Answer 3

此代码对字符串执行此操作。

var users = new [] {"John", "Richard", "Jack", "Roy", "Robert", "Susan" };
var prefixes = new [] { "J", "Ro" };

var filtered = prefixes.Aggregate(Enumerable.Empty<string>(),
    (acc, pref) => acc.Union(users.Where(u => u.StartsWith(pref)).ToList()));

对于您的 User 类，它看起来像

var filtered = prefixes.Aggregate(
    Enumerable.Empty<User>(),
    (acc, pref) => acc.Union(
        users.Where(
            u => u.FistName.StartsWith(pref) || u.LastName.StartsWith(pref)
            ).ToList()));

Answer 4

这是一行行（为了便于阅读而格式化），我相信它会返回您寻求的结果：

 var users = UserRepository.ALL()
    .ToList() //ToList called only to materialize the list
    .Where(x => new[] { 'Ha', 'Ho', 'He' }
        .Any(y => x.LastName.StartsWith(y))
    );  //Don't need it here anymore!

它可能不是您正在寻求的有效解决方案，但我希望它能以某种方式帮助您！

编辑：正如 gaearon 指出的那样，如果 'ALL()' 命令返回大量记录，我的第一个解决方案可能非常糟糕。试试这个：

var users = UserRepository.ALL()
        .Where(x => new[] { 'Ha', 'Ho', 'He' }
            .Any(y => SqlMethods.Like(x.LastName, y + "%"))
        );

Answer 5

您可以构造一个表达式树：

var parts = new[] { "Ha", "Ho", "He" };

var x = Expression.Parameter(typeof(User), "x");

var body = 
    parts.Aggregate<string, Expression>(
        Expression.Constant(false), 
        (e, p) => 
            Expression.Or(e,
                Expression.Or(
                    Expression.Call(
                        Expression.Property(x, "LastName"), 
                        "StartsWith", 
                        null,
                        Expression.Constant(p)),
                    Expression.Call(
                        Expression.Property(x, "FirstName"), 
                        "StartsWith", 
                        null, 
                        Expression.Constant(p)))));

var predicate = Expression.Lambda<Func<User, bool>>(body, x);

var result = users.Where(predicate);

结果与以下相同：

var result =
    users.Where(x => 
        false ||
        x.LastName.StartsWith("Ha") || x.FirstName.StartsWith("Ha") ||
        x.LastName.StartsWith("Ho") || x.FirstName.StartsWith("Ho") ||
        x.LastName.StartsWith("He") || x.FirstName.StartsWith("He") );