Linq学习

最新推荐文章于 2022-05-01 08:20:00 发布

转载最新推荐文章于 2022-05-01 08:20:00 发布 · 2.4k 阅读

C# 同时被 2 个专栏收录

270 篇文章

订阅专栏

ASP.NET

111 篇文章

订阅专栏

 protected void Page_Load(object sender, EventArgs e)
        {
            string bb = "<a href=\"http://www.baidu.com\">百度</a><Br />";
            Response.Write(bb);


            IList<string> list = new List<string>()
            {
                "One", "Two", "Three", "Four",  
                "Five", "Six", "Seven"  
            };
            #region
            /*1.
             * Where 和Select是两个定义在Ienumerable<TSource>接口中非常重要的方法.它们的定义如下: 
             * public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate) 
             * public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, int, bool> predicate)
             * 所以任何来源于Ienumerable<TSource>接口的数据结构都能访问这个方法
             * 
             * var numbersLengthThree = list.Where(x => x.Length == 3).Select(x => x).ToList();
               numbersLengthThree.ForEach(x => Response.Write(x + "<br />"));
             */




            /*2.
             * All 这个方法确定是否所有元素序列都满足某种条件，如果每一个元素都可以满足设定的特殊条件或者它是空，则方法返回true，否则返回false
             * 定义如下：
             * public static bool All<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate) 
             * 
             * if (list.All(x => x.Length >= 3))
                   Response.Write("All numbers have at least three characters. ");
             */




            /*3.
             * Any 这个方法确定序列中的元素是否存在或者满足某种特定的条件。方法定义如下：
             * public static bool Any<TSource>(this IEnumerable<TSource> source) 
             * public static bool Any<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate) 
             * 第一种重载会找出元素序列是否包含元素, 第二种重载将会找出序列中是否有满足条件的元素
             * 
             * if (list.Any())
                   Response.Write("The sequence contains item.");
             * 
             * if (list.Any(x => x.Length >= 3))
                   Response.Write("The sequence contains at least a item which has three or more characters.");
             */


            #endregion


            IList<int> listNumber = new List<int>()
            {
                 1,2,3,4,5,6,7,8,9,10 
            };
            #region
            /*4.
             * Average 方法会计算在序列中的数字的平均值,这个方法的定义如下： 
             * public static double Average(this IEnumerable<int> source) 
             * public static decimal Average<TSource>(this IEnumerable<TSource> source, Func<TSource, decimal> selector) 
             * 
             * //  55/10=5.5
               Response.Write(string.Format("Average of the numbers :{0}", listNumber.Average()));
               //  2,4,6,8,10 =>30/5=6 =>6*2=12
               Response.Write(
                   string.Format("Average of the original numbers x2 :{0}",
                   listNumber.Where<int>(x => x % 2 == 0).Select(x => x).Average(x => x * 2))
               );
             */


            #endregion
            /*5. 
             * Concat 这个方法的作用是连接(拼接)两个序列，它和Union不同，Union则返回序列中不重复(独一无二)的元素
             * 而Concat返回序列中所有的原始元素,这个方法的定义如下： 
             * public static IEnumerable<TSource> Concat<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second) 
             * 
             * 
             * Contains 是否包含有个或符合某条件的元素;
             * Count 获取或获取符合某条件的元素个数;
             * Distinct 去掉重复或符合某条件的重复元素;(  Distict是用来排除相同序列中元素的，对于基础类型，可以直接使用Distinct)
             * ElementAt 在序列(集合)中,这个方法返回一个特定索引的一个元素; 
             * Except 方法可以用在从一个集合中删除一个项集合.它放回一个由两个序列产生的集合差;
             * Intersect 它将产生两个序列的交集;
             * First 这个方法会返回序列中的第一个元素;
             * FirstOrDefault 它返回序列中第一个元素或者当没有元素未被找到时放回默认值.这个方法是First和Default的综合;
             * Last 返回序列中最后一个元素;
             * LastOrDefault 它返回序列中最后一个元素或者当没有元素未被找到时放回默认值.这个方法是Last和Default的综合;
             * 
             * 
             * LongCount 它会返回一个Int64去表示序列中元素的个数,方法定义是: 
             * public static long LongCount<TSource>(this IEnumerable<TSource> source) 
             * public static long LongCount<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate) 
             * 
             */
            IList<int> tempList = new List<int>()
            {
                11,12,13,2,5,12,13
            };


            #region


            //Linq查询表达式中提供了join运算，比较常见的是join.. on ..equals,也就是内联接运算
            //下面的demo相当于交集运算Intersect
            var do_join = from itemsA in tempList
                          join itemsB in listNumber
                          on itemsA equals itemsB into tempArr
                          from arr in tempArr
                          select arr;
            do_join.ToList().ForEach(x => Response.Write("join运算" + x + "&emsp;"));
            Response.Write("<br />");


            listNumber.Concat(tempList).ToList().ForEach(x => Response.Write(x + " , "));
            Response.Write("<br />");
            listNumber.Union(tempList).ToList().ForEach(x => Response.Write(x + " , "));
            Response.Write("<br />");
            Response.Write(string.Format("大于7的元素个数为{0}", listNumber.Count<int>(s => s > 7)));
            Response.Write("<br />");
            tempList.Distinct<int>().Select(x => x).ToList().ForEach(x => Response.Write(x + " , "));
            //但是对于自定义类型，则需要额外的一些操作，方式有多种，这里选择其中一种，即实现IEquatable<>
            List<Employee> employee = new List<Employee>()
            {
                new Employee {Id= 1, Name = "Ringgo"},
                new Employee {Id= 2, Name = "Rex"},
                new Employee {Id = 1, Name = "jj"}
            };
            employee.Distinct().ToList().ForEach(x => Response.Write("&emsp;" + x.Id + ":" + x.Name));


            Response.Write("<br />");
            Response.Write(tempList.Where(x => x % 2 == 1).Select(x => x).ToList().ElementAt(1).ToString()); //所有奇数元素集合中第二个元素
            Response.Write("<br />");
            IList<Person> personA = new List<Person>()
            {
                new Person{Name="jon",Address="hangzhou"},
                new Person{Name="aa",Address="shanghai"},
                new Person{Name="tt",Address="hangzhou"},
                new Person{Name="gg",Address="hangzhou"}
            };
            IList<Person> personB = new List<Person>()
            {
                new Person{Name="aa",Address="beijing"},
                new Person{Name="dd",Address="shenzhen"}
            };


            var resultPerson = (from p in personA select p.Name).Except(from q in personB select q.Name).ToList();
            resultPerson.ForEach(x => Response.Write(x + " , "));
            Response.Write("<br />");
            tempList.Except(listNumber).ToList().ForEach(x => Response.Write(x + " , ")); //差集（减去另一个集合中包含的元素，如果没有包含就全部输出，有就去掉）


            Response.Write("<br />");
            tempList.Intersect(listNumber).ToList().ForEach(x => Response.Write(x + " , ")); //交集（两个集合共有的元素）
            Response.Write("<br />");


            #endregion


            /*6.
             *Contains 这个方法用来判断在一个序列(集合)中是否存在一个特殊的元素
             *public static bool Contains<TSource>(this IEnumerable<TSource> source, TSource value)
             *public static bool Contains<TSource>(this IEnumerable<TSource> source, TSource value, IEqualityComparer<TSource> comparer) 
             *
             * Response.Write(string.Format("{0}\t{1}", tempList.Contains(2).ToString(), tempList.Contains(200).ToString()));
             */




            /*7.
             * DefaultIfEmpty 这个方法会返回一个IEnumerable<T>类型的元素或者当序列(集合)为空事放回一个默认的单例集合.方法的定义如下: 
             * public static IEnumerable<TSource> DefaultIfEmpty<TSource>(this IEnumerable<TSource> source) 
             * public static IEnumerable<TSource> DefaultIfEmpty<TSource>(this IEnumerable<TSource> source, TSource defaultValue) 
             * 
             * 
             */


            #region
            List<Product> products = new List<Product>()
            {
                new Product(){ Id="1", Name="n1"},
                new Product(){ Id="1", Name="n2"},
                new Product(){ Id="2", Name="n1"},
                new Product(){ Id="2", Name="n2"},
            };
            var ggresult = products.GroupBy(p => p.Id).Select(p => new
            {
                Id = p.Key,
                Name = p.FirstOrDefault().Name
            });
            ggresult.ToList().ForEach(v =>
            {
                Response.Write(v.Id + ":" + v.Name + "&emsp;");
            });
            #endregion
        }




        public class Product
        {
            public string Id { get; set; }
            public string Name { get; set; }
        }


        public class Employee : IEquatable<Employee>
        {
            public int Id { get; set; }
            public string Name { get; set; }


            public bool Equals(Employee other)
            {
                try
                {
                    if (Object.ReferenceEquals(other, null))
                        return false;
                    if (Object.ReferenceEquals(this, other))
                        return true;


                    return Id.Equals(other.Id);
                }
                catch
                {
                    throw new NotImplementedException();
                }
            }
            /// <summary>
            ///  这里重写了GetHashCode，Equals根据ID相同过滤对象
            /// </summary>
            public override int GetHashCode()
            {
                return Id.GetHashCode();
            }
        }


        public class Person
        {
            public string Name { get; set; }
            public string Address { get; set; }
        }

Find和FindAll的区别，Find找到第一个匹配项就结束了，而FindAll会去找所有符合的匹配对象

 string[] arry = { "aa", "bb", "cc", "aabb" };
            //var t = arry.ToList().Find(x => x.Contains("aa")); //只有aa
            var t = arry.ToList().FindAll(x => x.Contains("aa")); //aa和aabb
            t.ToList().ForEach(x => Response.Write(x + ", "));