LINQ LEFT JOIN，用OR组合多个WHERE子句

本文关键字：WHERE 子句 组合 OR LEFT JOIN LINQ | 更新日期: 2023-09-27 18:00:03

LINQ，

var clause = PredicateBuilder.False<User>();
clause = clause.Or(u => u.uid.Equals(1));
clause = clause.Or(u => u.uid.Equals(2));
var usersInGroup = (from u in db.Users
                    join g in db.GroupUsers
                        on u.uid equals g.uid
                        into ug
                    from g in ug.DefaultIfEmpty()
                    where g.gid.Equals(0)
                    select u).Where(clause);

这两个where子句被链接在一起作为；

其中（[t0].[gid]=0）AND（（[t1].[uid]=1）OR（[t1][uid]=2））

 

如何将两个where条件添加为

其中（[t0].[gid]=0）OR（（[t1].[uid]=1）OR（[t1][uid]=2））

LINQ LEFT JOIN，用OR组合多个WHERE子句

感谢

PredicateBuilder是否可以生成跨越多个表的谓词？

我现在有一个可行的解决方案，但我的结果集是基于一个新的混合类。因此，我不得不反映所有相关领域。请参见下文。

public class HybridGroupUser {
    private User _user;
    public User User {
        get { return _user; }
        set {
            _user = value;
            if (value != null) {
                uid = value.uid;
                fname = value.fname;
                lname = value.lname;
                email = value.email;
            }
        }
    }
    private GroupUser _GroupUser;
    public GroupUser GroupUser {
        get { return _GroupUser; }
        set {
            _GroupUser = value;
            if (value != null) {
                uid = value.uid;
                fname = value.fname;
                lname = value.lname;
                email = value.email;
            }
        }
    }
    public int? uid { get; set; }
    public string fname { get; set; }
    public string lname { get; set; }
    public string email { get; set; }
}

有了这门课，我现在可以做以下事情；

var clause = PredicateBuilder.False<HybridGroupUser>();
clause = clause.Or(u => u.GroupUser.gid.Equals(0);
foreach (int i in AddedUsers) {
    int tmp = i;
    clause = clause.Or(u => u.User.uid.Equals(tmp));
}
var usersInGroup = (from u in db.Users
                    join gusr in db.GroupUser
                        on u.uid equals gusr.uid
                        into ug
                    from gusr in ug.DefaultIfEmpty()
                    select new HybridGroupUser {
                       User = u, 
                       GroupUser = gusr
                    }).Where(clause);

var usersInGroup = (from u in db.Users
join g in db.Groups
on u.uid equals g.uid
where g.gid.Equals(0) || (u.uid.Equals(1) || u.uid.Equals(2))
select u)

与其做多个Or子句，为什么不只做Contains呢。这样，你的ID列表就可以是完全动态的（只要不超过2000）：

var ids = new int[] {1, 2, 3}; 
var usersInGroup = (from u in db.Users 
                    join g in db.GroupUsers 
                        on u.uid equals g.uid 
                        into ug 
                    from g in ug.DefaultIfEmpty() 
                    where g.gid.Equals(0) 
                      && ids.Contains(u.uid)
                    select u);
相关文章：