请教一个List合并的算法问题

[plcly1]

有一个类，如下所示，现在有两个的List<A>，里面Name一样的合并一起，B下面DES如果一样的就不添加，如果不一样就添加。

 public class A
    {
        public string Name { get; set; }
        public List<B> BS { get; set; }
    }
    public class B
    {
        public string DES { get; set; }
    }

[/color]

我写了个多重循环的方法，想知道有没有可以优化的，坐等大神。

 private static List<A> listA;
        private static List<A> listA1;
        private static List<A> listA2;
        static void Main(string[] args)
        {
            Init();
            listA = CombineA(listA, listA1);
            listA = CombineA(listA, listA2);
            Console.ReadKey();
        }
        static List<A> CombineA(List<A> a1, List<A> a2)
        {
            bool bUnequal = true;
            bool bDetailUnequal = true;
            for (int i = 0; i < a2.Count; i++)
            {
                bUnequal = true;
                for (int j = 0; j < a1.Count; j++)
                {
                    if (a1[j].Name == a2[i].Name)
                    {
                        bUnequal = false;
                        for (int k = 0; k < a2[i].BS.Count; k++)
                        {
                            bDetailUnequal = true;
                            for (int l = 0; l < a1[j].BS.Count; l++)
                            {
                              if (a1[j].BS[l].DES == a2[i].BS[k].DES)
                              {
                              bDetailUnequal = false;
                              }
                            }
                            if (bDetailUnequal)
                            {
                              a1[j].BS.Add(a2[i].BS[k]);
                            }
                        }
                    }
                }
                if (bUnequal)
                {
                    a1.Add(a2[i]);
                }
            }
            return a1;
        }
        static void Init()
        {
            listA = new List<A> 
           {
               new A 
               {
                   Name="a",BS=new List<B> 
                   {
                       new B{DES="a1"},
                       new B{DES="a2"}
                   }
               }
           };
            listA1 = new List<A> 
           {
               new A 
               {
                   Name="b",BS=new List<B> 
                   {
                       new B{DES="b1"},
                       new B{DES="b2"}
                   }
               },
                new A 
               {
                   Name="c",BS=new List<B> 
                   {
                       new B{DES="c1"},
                       new B{DES="c2"}
                   }
               }
           };
            listA2 = new List<A> 
           {
               new A 
               {
                   Name="c",BS=new List<B> 
                   {
                       new B{DES="b1"},
                       new B{DES="c2"}
                   }
               },
                new A 
               {
                   Name="a",BS=new List<B> 
                   {
                       new B{DES="c1"},
                       new B{DES="c2"}
                   }
               }
           };
        }

    }

[以专业开发人员为伍]

无暇看你这类代码啊。 学学 LInq 吧。本来可能是一句声明性的规则就完事儿的，写那么一大堆代码，多么废脑细胞啊。

[娃都会打酱油了]

Linq有个Union来生成并集的方法，你可以指定IEqualityComparer<TSource> comparer实现，来对应你的name相同

[以专业开发人员为伍]

这类东西需要学认真一下 linq。不知道网上还有没有 “linq 101 例子”的网页了。 如果你的 sql 语言学的比较好，应该能看懂这种 linq 表达式：

var query = from x in listA
            group x by x.Name into g
            select new A
            {
                Name = g.Key,
                BS = (from y in g
                        from z in y.BS
                        select z).Distinct().ToList()
            };

或者

var query = from x in listA
                group x by x.Name into g
                select new A
                {
                    Name = g.Key,
                    BS = g.SelectMany(y => y.BS).Distinct().ToList()
                };

学好 linq，需要下点功夫。否则写一大堆无聊的“循环”代码，看起来费劲，理解起来更费劲。不如 Linq 计算形式干净易懂。

[plcly1]

引用 1 楼 sp1234 的回复:

无暇看你这类代码啊。 学学 LInq 吧。本来可能是一句声明性的规则就完事儿的，写那么一大堆代码，多么废脑细胞啊。

我的是笨方法，求Linq代码

[plcly1]

引用 3 楼 sp1234 的回复:

这类东西需要学认真一下 linq。不知道网上还有没有 “linq 101 例子”的网页了。 如果你的 sql 语言学的比较好，应该能看懂这种 linq 表达式：

var query = from x in listA
            group x by x.Name into g
            select new A
            {
                Name = g.Key,
                BS = (from y in g
                        from z in y.BS
                        select z).Distinct().ToList()
            };

或者

var query = from x in listA
                group x by x.Name into g
                select new A
                {
                    Name = g.Key,
                    BS = g.SelectMany(y => y.BS).Distinct().ToList()
                };

学好 linq，需要下点功夫。否则写一大堆无聊的“循环”代码，看起来费劲，理解起来更费劲。不如 Linq 计算形式干净易懂。

这个有重复，我添加了一下可以了，多谢，一开始我以Linq没办法弄，看来是我理解的太浅了

var query = from x in listA
                        group x by x.Name into g
                        select new A
                        {
                            Name = g.Key,
                            BS = (from y in g
                                  from z in y.BS
                                  group z by z.DES into h
                                  select new B
                                  {
                                      DES=h.Key
                                  }).ToList ()
                        };

[以专业开发人员为伍]

我没有测试数据，这个只是例子、思路。 没有实际测试的随手写的代码，都不保证正确。

[plcly1]

引用 6 楼 sp1234 的回复:

我没有测试数据，这个只是例子、思路。 没有实际测试的随手写的代码，都不保证正确。

思路很好

[以专业开发人员为伍]

是的，应该在 Distinct() 中使用 a=> a.DES 为键。 这个部分其实不需要写成 group by 表达式，仍然使用 Distinct() 其实挺好的了 :-)

[threenewbee]

list1.union(list2)

[大鱼>]

这代码辣眼睛