Linq GroupBy操作

 
Linq GroupBy操作。

1.   #region GroupBy Operator
3.         /* GroupBy第一种原型
4.          * 
5.          * 返回值为IGroupting<K,T>集合数组,每个IGroupting<k,t>包含一个(K)Key及
6.          * 一个拥有相同Key的集合数组T
7.          * 
8.          * 将含有相同的Key 分成一组
9.          * public static IEnumerable<IGrouping<K, T>> GroupBy<T, K>(
10.          *   this IEnumerable<T> source,
11.          *   Func<T, K> keySelector);
12.          * 
13.          */
14.         static void GroupByFirstPrototype()
15.         {
16.             PresidentsOption[] presidentsOptions ={new PresidentsOption(1,10),
17.                                                 new PresidentsOption(2,10),
18.                                                 new PresidentsOption(2,50),
19.                                                 new PresidentsOption(3,100),
20.                                                 new PresidentsOption(4,30),
21.                                                 new PresidentsOption(4,80),
22.                                                 new PresidentsOption(5,200),
23.                                                 new PresidentsOption(5,10),
24.                                                 new PresidentsOption(6,90),
25.                                                 new PresidentsOption(6,80),
26.                                                 new PresidentsOption(7,10)};
27.             IEnumerable<IGrouping<int, PresidentsOption>> outerSequence = presidentsOptions.GroupBy(p => p.Id);
29.             foreach (IGrouping<int, PresidentsOption> keyGroupSequence in outerSequence)
30.             {
31.                 Console.WriteLine("-----------------------------------");
32.                 Console.WriteLine("....key(id):" + keyGroupSequence.Key);
33.                 foreach (PresidentsOption presidents in keyGroupSequence)
34.                 {
35.                     Console.WriteLine("id={0}...option={1}", presidents.Id, presidents.Option);
36.                 }
37.             }
38.         }
40.         /*GroupBy第二种原型
41.          * 
42.          * 功能和第一种一样,只是比较方法 comparer自定义
43.          * 需要实现IEqualityComparer<K>接口
44.          * 
45.          * public static IEnumerable<IGrouping<K, T>> GroupBy<T, K>(
46.          *   this IEnumerable<T> source,
47.          *   Func<T, K> keySelector,
48.          *   IEqualityComparer<K> comparer);
49.          * 
50.          */
51.         static void GroupBySecondPrototype()
52.         {
53.             PresidentsOption[] presidentsOptions ={new PresidentsOption(1,10),
54.                                                 new PresidentsOption(2,10),
55.                                                 new PresidentsOption(2,50),
56.                                                 new PresidentsOption(3,100),
57.                                                 new PresidentsOption(4,30),
58.                                                 new PresidentsOption(4,80),
59.                                                 new PresidentsOption(5,200),
60.                                                 new PresidentsOption(5,10),
61.                                                 new PresidentsOption(6,90),
62.                                                 new PresidentsOption(6,80),
63.                                                 new PresidentsOption(7,10)};
64.             GroupByCompare compare=new GroupByCompare();
66.             //通过compare比较.具有相同hashCode的Key分成一组
67.             IEnumerable<IGrouping<int, PresidentsOption>> outerSequence = presidentsOptions.GroupBy(p => p.Id, compare);
69.             foreach (IGrouping<int, PresidentsOption> keyGroupSequence in outerSequence)
70.             {
71.                 
72.                 Console.WriteLine("-----------------------------------");
73.                 Console.WriteLine("....key(hashCode):" + keyGroupSequence.Key);
74.                 foreach (PresidentsOption presidents in keyGroupSequence)
75.                 {
76.                     Console.WriteLine("id={0}...option={1}" , presidents.Id, presidents.Option);
77.                 }
78.             }
80.         }
82.         /* GroupBy第三种原型
83.          * 
84.          * 第三钟原型和第一种类似,只不过IGrouping<K, E>中E值为T的一个元素,
85.          * 而不是是T类型的实体对象
86.          * 
87.          * public static IEnumerable<IGrouping<K, E>> GroupBy<T, K, E>(
88.          *    this IEnumerable<T> source,
89.          *    Func<T, K> keySelector,
90.          *    Func<T, E> elementSelector);
91.          * 
92.          */
93.         static void GroupByThirdPrototype()
94.         {
95.             PresidentsOption[] presidentsOptions ={new PresidentsOption(1,10),
96.                                                 new PresidentsOption(2,10),
97.                                                 new PresidentsOption(2,50),
98.                                                 new PresidentsOption(3,100),
99.                                                 new PresidentsOption(4,30),
100.                                                 new PresidentsOption(4,80),
101.                                                 new PresidentsOption(5,200),
102.                                                 new PresidentsOption(5,10),
103.                                                 new PresidentsOption(6,90),
104.                                                 new PresidentsOption(6,80),
105.                                                 new PresidentsOption(7,10)};
107.             IEnumerable<IGrouping<int, int>> outerSequence = presidentsOptions.GroupBy(p => p.Id,p=>p.Option);
109.             foreach (IGrouping<int, int> keyGroupSequence in outerSequence)
110.             {
112.                 Console.WriteLine("-----------------------------------");
113.                 Console.WriteLine("....key(id):" + keyGroupSequence.Key);
114.                 foreach (int options in keyGroupSequence)
115.                 {
116.                     Console.WriteLine("...option={0}", options);
117.                 }
118.             }
119.         }
121.         /*GroupBy第四种原型
122.          * 
123.          *
124.          * 第四种具有第二种和第三中功能
125.          * 
126.          *    public static IEnumerable<IGrouping<K, E>> GroupBy<T, K, E>(
127.          *       this IEnumerable<T> source,
128.          *       Func<T, K> keySelector,
129.          *       Func<T, E> elementSelector,
130.          *       IEqualityComparer<K> comparer);
131.          * 
132.          */
133.         static void GroupByFourthPrototype()
134.         {
135.             PresidentsOption[] presidentsOptions ={new PresidentsOption(1,10),
136.                                                 new PresidentsOption(2,10),
137.                                                 new PresidentsOption(2,50),
138.                                                 new PresidentsOption(3,100),
139.                                                 new PresidentsOption(4,30),
140.                                                 new PresidentsOption(4,80),
141.                                                 new PresidentsOption(5,200),
142.                                                 new PresidentsOption(5,10),
143.                                                 new PresidentsOption(6,90),
144.                                                 new PresidentsOption(6,80),
145.                                                 new PresidentsOption(7,10)};
146.             GroupByCompare compare = new GroupByCompare();
149.             IEnumerable<IGrouping<int, int>> outerSequence = presidentsOptions.GroupBy(p => p.Id, p => p.Option,compare);
151.             foreach (IGrouping<int, int> keyGroupSequence in outerSequence)
152.             {
154.                 Console.WriteLine("-----------------------------------");
155.                 Console.WriteLine("....key(hashCode):" + keyGroupSequence.Key);
157.                 foreach (int options in keyGroupSequence)
158.                 {
159.                     Console.WriteLine("...option={0}", options);
160.                 }
161.             }
164.         }
166.         #endregion

用到的类：

1.   public class PresidentsOption
2.    {
3.        public int Id
4.        {
5.            get;
6.            set;
7.        }
8.        public int Option
9.        {
10.            get;
11.            set;
12.        }
13.        public PresidentsOption(int id, int option)
14.        {
15.            this.Id = id;
16.            this.Option = option;
17.        }
18.    }
20.    //实现IEqualityComparer<T>
21.    public class GroupByCompare : IEqualityComparer<int>
22.    {
23.        public bool Equals(int x, int y)
24.        {
25.            return (isLessFive(x) == isLessFive(y)); 
26.        }
28.        //小于返回1的HashCode、大于等于5的返回5的hashCode
29.        public int GetHashCode(int x)
30.        {
31.            int intStart = 1;
32.            int intCompare = 5;
33.            return isLessFive(x) ? intStart.GetHashCode() : intCompare.GetHashCode();
35.        }
36.        public bool isLessFive(int x)
37.        {
38.            return (x < 5);
39.        }
40.    }