Linq to sql LINQ到SQL查询

我有一个LINQ TO SQL查询，它检索所有用户及其角色：

var userRoles = from u in db.GetTable<User>()
                            join ur in db.GetTable<UserRole>()
                                on u.UserID equals ur.UserID
                            join r in db.GetTable<Role>()
                                on ur.RoleID equals r.RoleID
                                orderby u.UserID
                            select new
                                       {
                                           u.UserID,
                                           r.RoleName
                                       };

var userRoles=来自db.GetTable（）中的u
在db.GetTable（）中加入ur
在u.UserID上等于ur.UserID
在db.GetTable（）中加入r
关于ur.RoleID等于r.RoleID
orderby u.UserID
选择新的
{
u、 用户ID，
r、 罗兰胺
};

系统中的用户可以有多个角色。此查询的结果（以表格格式）如下所示：

1管理员
1名员工
2名员工
3名员工

如何重新编写此查询以将所有用户角色作为逗号分隔的值返回，如：

1名管理员、员工
2名员工

---

3名员工

嘿，库马尔，我创建了一个小型控制台应用程序来模拟我相信你拥有的数据。我认为它展示了你想要的行为。这不是世界上最伟大的代码，但我认为算法才是关键。我刚刚对ToString（）进行了一次快速重写，以正确显示数据

我所做的主要更改是为要显示的数据创建一个已定义的类，并将linq查询分为两部分：

using System;
using System.Collections.Generic;
using System.Linq;

namespace Test
{
    class Program
    {
        static void Main()
        {
            var users = new List<User>
                            {
                                new User
                                    {
                                        UserID = "1"
                                    },
                                new User
                                    {
                                        UserID = "2"
                                    },
                                new User
                                    {
                                        UserID = "3"
                                    }
                            };

            var roles = new List<Role>
                            {
                                new Role
                                    {
                                        RoleID = "1",
                                        RoleName = "Admin"
                                    },
                                new Role
                                    {
                                        RoleID = "2",
                                        RoleName = "Employee"
                                    }
                            };

            var userRoles = new List<UserRole>
                                {
                                    new UserRole
                                        {
                                            UserID = "1",
                                            RoleID = "1"
                                        },

                                    new UserRole
                                        {
                                            UserID = "1",
                                            RoleID = "2"
                                        },

                                    new UserRole
                                        {
                                            UserID = "2",
                                            RoleID = "2"
                                        },

                                    new UserRole
                                        {
                                            UserID = "3",
                                            RoleID = "2"
                                        }
                                };

            var userRoles2 = from u in users
                             orderby u.UserID
                             select new UserList
                             {
                                 UserID = u.UserID,
                                 Roles = (from r in roles
                                            join ur in userRoles
                                            on u.UserID equals ur.UserID
                                            where ur.RoleID == r.RoleID
                                            select r).ToList()
                             };

            foreach (var item in userRoles2)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();
        }
    }

    public class User
    {
        public string UserID;
    }

    public class UserRole
    {
        public string UserID;
        public string RoleID;
    }

    public class Role
    {
        public string RoleID;
        public string RoleName;
    }

    public class UserList
    {
        public string UserID;
        public List<Role> Roles;

        public override string ToString()
        {
            string output = UserID + " ";
            foreach (var role in Roles)
            {
                output += role.RoleName + ", ";
            }
            output = output.Substring(0, output.Length - 2);
            return output;
        }
    }
}

使用系统；
使用System.Collections.Generic；
使用System.Linq；
名称空间测试
{
班级计划
{
静态void Main（）
{
var users=新列表
{
新用户
{
UserID=“1”
},
新用户
{
UserID=“2”
},
新用户
{
UserID=“3”
}
};
var角色=新列表
{
新角色
{
RoleID=“1”，
RoleName=“Admin”
},
新角色
{
RoleID=“2”，
RoleName=“员工”
}
};
var userRoles=新列表
{
新用户角色
{
UserID=“1”，
RoleID=“1”
},
新用户角色
{
UserID=“1”，
RoleID=“2”
},
新用户角色
{
UserID=“2”，
RoleID=“2”
},
新用户角色
{
UserID=“3”，
RoleID=“2”
}
};
var userRoles2=来自用户中的u
orderby u.UserID
选择新用户列表
{
UserID=u.UserID，
角色=（来自角色中的r）
加入用户角色
在u.UserID上等于ur.UserID
其中ur.RoleID==r.RoleID
选择r.ToList（）
};
foreach（userRoles2中的变量项）
{
控制台写入线（项目）；
}
Console.ReadKey（）；
}
}
公共类用户
{
公共字符串用户标识；
}
公共类用户角色
{
公共字符串用户标识；
公共字符串RoleID；
}
公共阶级角色
{
公共字符串RoleID；
公共字符串RoleName；
}
公共类用户列表
{
公共字符串用户标识；
公开名单角色；
公共重写字符串ToString（）
{
字符串输出=用户ID+“”；
foreach（角色中的var角色）
{
输出+=role.RoleName+“，”；
}
output=output.Substring（0，output.Length-2）；
返回输出；
}
}
}

这是一种方法，但尚未测试：

    from u in db.GetTable<User>()   
                      join ur in db.GetTable<UserRole>()   
                            on u.UserID equals ur.UserID   
                      join r in db.GetTable<Role>()   
                            on ur.RoleID equals r.RoleID   
                      orderby u.UserID
                      group u by u.UserID into g    
                      select new   
                                {   
                                    UserId = g.Key,   
                                    Roles = String.Join (" ,", g.UserRoles.SelectMany(c => c.Roles).Select(p=> p.RoleName).ToArray()))
                                };   

db.GetTable（）中的u的

在db.GetTable（）中加入ur
在u.UserID上等于ur.UserID
在db.GetTable（）中加入r
关于ur.RoleID等于r.RoleID
orderby u.UserID
按u.UserID将u分组为g
选择新的
{   
UserId=g.Key，
Roles=String.Join（“，”，g.UserRoles.SelectMany（c=>c.Roles）。Select（p=>p.RoleName.ToArray（））
};