Question

我有一种情况，我以这种方式从数据库中获取数据，所有内容都存储在一维数组中。
例如：

User table: UserId, Name
Group table: GroupId, Name
UserGroup table: UserId, GroupId

作为连接这些表的结果，我获得了以下形式的数组：

result[0] = "1" // user id
result[1] = "John Doe" // user name
result[2] = "121" // group id
result[3] = "SomeGroup" // group name
result[4] = "1" // user id
result[5] = "John Doe" // user name
result[6] = "2135" // group id
result[7] = "SomeOtherGroup" // group name

我知道这不是一个保存数据的好方法，但是这些数据是从我不允许更改的其他代码中找到的，所以我必须处理它。

我的问题是：

是否可以使用LINQ来解析此数组并将数据放在我自己的对象中（包含Groups集合的User类）。
如果不是LINQ，处理它的最佳方法是什么？

Answer 1

Pure linq Expression：

int i = 0;
var objects = result.GroupBy(x => Math.Floor(i++ / 4.0))
            .Select(g => new { id =g.ElementAt(0), name = g.ElementAt(1), gId= g.ElementAt(2), group = g.ElementAt(3)})
            .GroupBy(x=>new {x.id, x.name}, x=>new {x.gId, x.group})
            .Select(y=>new {y.Key, groups = y.ToList()});

在第一个GroupBy I组中，使用楼层和临时变量生成4个元素子集。
然后下一个Select将生成的数组放在匿名类型中，以便在接下来的步骤中更好地使用。
下一个GroupBy用于按员工对条目进行分组。密钥将是员工，值将是相应的组。
最后，激光Select用于将GroupBy结果设置为更好的形状。我选择将结果放在另一个匿名类型中，但您可以在此实例化自定义对象，并使用花括号构造函数将值放在正确的字段中。

Answer 2

如果您的逻辑依赖于索引LINQ很少是正确的工具。与纯循环相比，它导致代码的可读性，可维护性，高效性和可靠性。

我会使用类似下面的内容来创建两个代表多对多关系的词典。注意for - 循环在每次迭代时递增4，因为它似乎是用户组 - ＆＃34;包＆＃34;：

var userIdGroups = new Dictionary<int, HashSet<Group>>();
var groupIdUsers = new Dictionary<int, HashSet<User>>();

for(int i = 0; i < result.Length; i += 4)
{
    int id;
    if(int.TryParse(result[i], out id))
    {
        string name = result.ElementAtOrDefault(i + 1);
        if(name == null)
            continue; // end, invalid data

        User user = new User{ UserId = id, Name = name };
        string groupID = result.ElementAtOrDefault(i + 2);
        if(!int.TryParse(groupID, out id))
            continue; // end, invalid data

        name = result.ElementAtOrDefault(i + 3);
        if(name == null)
            continue; // end, invalid data

        Group group = new Group{ GroupId = id, Name = name };
        HashSet<Group> userGroups;
        HashSet<User> groupUsers;
        if (userIdGroups.TryGetValue(user.UserId, out userGroups))
            userGroups.Add(group);
        else
            userIdGroups.Add(user.UserId, new HashSet<Group>{ group });

        if (groupIdUsers.TryGetValue(group.GroupId, out groupUsers))
            groupUsers.Add(user);
        else
            groupIdUsers.Add(group.GroupId, new HashSet<User> { user });
    }
}

结果是：

用户词典包含一个具有两个组的用户
group-dictionary包含两个映射到同一用户的组

您必须覆盖Equals和GetHashCode才能比较ID：

class User
{
    public int UserId { get; set; }
    public string Name { get; set; }

    public override bool Equals(object obj)
    {
        User u2 = obj as User;
        if (u2 == null) return false;
        return UserId == u2.UserId;
    }
    public override int GetHashCode()
    {
        return UserId;
    }
}
class Group
{
    public int GroupId { get; set; }
    public string Name { get; set; }

    public override bool Equals(object obj)
    {
        Group g2 = obj as Group;
        if (g2 == null) return false;
        return GroupId == g2.GroupId;
    }
    public override int GetHashCode()
    {
        return GroupId;
    }
}

Answer 3

你可以使用像loop这样的基本结构：

void Main()
{
    var result = new string[] {"1","John Doe","2","Joes Group","3","Jack Daniel","4","Jacks Group","5","Foo Bar","6","FooBar Group",};
    List<Person> personList = new List<Person>();
    List<Group> groupList = new List<Group>();

    for(int i = 0; i < result.Length; i+=2) 
    {
        i = i + 2;
        //check if group does not already exist
        groupList.Add(new Group() {Name = result[i+1]});
    }

    for(int i = 0; i < result.Length; i+=2)
    {
        //check if person exists.
        //if person only add group to person personList.Where(x => x.Name ==result[i+1])....
        personList.Add(new Person() { Id = int.Parse(result[i]), 
                                      Name = result[i+1],
                                      Groups = new List<Group>()
                                      {
                                        groupList.FirstOrDefault (l => l.Name == result[i+3])
                                      }
                                    });
        i = i+2;    
    }

    personList.Dump();
}

public class Person
{
    public Person()
    {
        Groups = new List<Group>();
    }
    public int Id { get; set; }
    public string Name { get; set; }
    public List<Group> Groups { get; set; }

}

public class Group
{
    public string Name { get; set; }
}
// Define other methods and classes here

输出：

enter image description here

请注意：此代码不包含任何验证逻辑或重复检查。你必须自己解决这个问题。但是在你实现这样的事情之前，我宁愿改变你传递数据的方式。这样你就可以处理你的peroblems的根，而不是症状。

Answer 4

我认为不需要linq

//某个班级

    public class Result
    {    
        public string UserId {get;set;}
        public string UserName {get;set;}
        public string GroupId {get;set;}
        public string GroupName {get;set;}
        public string UserGroupUserId {get;set;}
        public string UserGroupUserName {get;set;}
        public string UserGroupId {get;set;}
        public string UserGroupGroupId {get;set;}

    }

//你的阵列

    private void Form1_Load(object sender, EventArgs e)
     {
        string[] result = new string[8];
        result[0] = "1";
        result[1] = "John Doe";
        result[2] = "121";
        result[3] = "SomeGroup";
        result[4] = "1";
        result[5] = "John Doe";
        result[6] = "2135";
        result[7] = "SomeOtherGroup";



        Result r = CastResult(result);


    }

//将简单的数组转换为某种类型

    public Result CastResult(string[] array)
    {
        return new Result() { UserId=array[0], UserName=array[1], GroupId=array[2], GroupName=array[3], UserGroupUserId=array[4], UserGroupUserName=array[5] , UserGroupId=array[6], UserGroupGroupId=array[7] };
    }

使用LINQ将记录存储在一维数组中

4 个答案: