扩展方法以及LinQ的学习

                我们今天学习的内容其实还是蛮多的，学习了自动属性，扩展方法，复习初始化器，以及LinQ的一些方法，其实感觉有些还是很熟悉的，在前面的学习过程中有时间感觉学习的知识知道了怎么使用，但是还没有在项目中使用，做的习题似乎意义不大，现在依旧如此，感觉仅限于知道怎样使用。很想做一个小小的项目来熟悉下学习的知识。。。下面就总结下今天学习的内容。

          一.自动属性

       private int productid;

        public int Productid
        {
            get { return productid; }
            set { productid = value; }
        }
        public string Name { set; get; }

        private decimal price;
        public decimal Price { set; get; }

 

               自动属性可以避免我们手动声明一个私有成员变量以及get和set的逻辑，快速写一个类，这样更加的方便。

          二.初始化的对比

    public class Product
    {
        public int ProductId { set; get; }
        public string Name { set; get; }
        public string Decription { set; get; }
        public decimal Price { set; get; }
        public string Category { set; get; }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Product p = new Product();         //初始化对象
            p.ProductId = 1;
            p.Name = "张三";


            Product pp = new Product() { ProductId = 2, Name = "李四" };  //对象初始化器

            List<string> lists = new List<string>() { "张三", "李四", "王五" };  //集合初始化器

            List<Product> list = new List<Product> { new Product() { ProductId = 3, Name = "王五" },new Product{ProductId=4,Name="赵六"} };
            foreach (var item in list)          //匿名方法
            {
                Console.WriteLine(item);
            }

            Console.ReadKey();
        }
    }

 

              学习了匿名类型，我们还是要区分一下我们和前面学习的，之前学习了初始化对象，就是方便了传参，直接使用对象调用类的属性定义参数的值；而对象初始化器和集合初始化器就是我们如上所示，其实是更加方便的给属性赋值；在这里主要是一个新的知识，就是匿名类型，其实和匿名方法一样，就是没有名字，然后通过new实例化，再赋值，这样的方式就是你匿名类型。刚开始接触这个其实还是在我们学会了对象初始化器和集合初始化器这样理解起来更加容易些。

          三.简单的扩展方法

    class Program
    {
        static void Main(string[] args)
        {
            string str = "AbcD";
            Console.WriteLine(str.ToCamer());
            Console.WriteLine(str.ToPascal());
            Console.Read();
        }
    }

    public static class Stringstr
    {
        public static string ToCamer(this string s)
        {
            string first = s[0].ToString().ToLower();
            string last = s.Substring(1).ToLower();
            return first + last;
        }
        public static string ToPascal(this string s)
        {
            string first = s[0].ToString().ToUpper();
            string last = s.Substring(1).ToLower();
            return first + last;
        }
    }

 

               说起来扩展方法，其实就是我们在使用方法时间微软没有给我们提供我们想要的方法，所以我们可以自己写一个方法实现，而这样的方法实现就是扩展方法，声明扩展方法的步骤：类必须是static，方法是static，第一个参数是被扩展的对象，前面标注this。使用扩展方法的时候必须保证扩展方法类已经在当前代码中using。扩展方法其实和我们之前写的方法还是差不多的，最大的区别在于方法的参数，这里我们要区分开。

          四.LinQ表达式的总结

         //where的使用
        static void Main(string[] args)
        {
            string[] array = { "旋转音乐盒", "好挤好挤", "爱的多米诺", "客官不可以", "下雨天", "晴天娃娃", "日不落", "黑发尤物" };
            Func<string, bool> func = i => i.Length < 5;       //集合中的字符串的长度小于5
            IEnumerable<string> wherelist = array.Where<string>(func);
            foreach (string item in wherelist)
            {
                Console.WriteLine(item);
            }

            Func<string, bool> f = i => i.Contains("黑");         //集合中的字符串包含“黑”的项
            IEnumerable<string> wherelists = array.Where<string>(f);
            foreach (var item in wherelists)
            {
                Console.WriteLine(item);
            }

            Func<string,int,bool> fun = (p, i) => (i % 2 == 1);     //在这里i这个参数是根据集合的索引，然后输出索引为质数的系列中的字符串
            IEnumerable<string> wherelistss = array.Where<string>(fun);
            foreach (var item in wherelistss)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();
        }

 

                上面主要举例说明了where的使用方法，它的输出类型是bool类型，而在这里Lambda表达式也使用了方法.length（字符串或者数组的长度），和contains（）方法，而contains方法的参数则是判断是否包含该项。在使用where方法应该注意的是输出类型，因为在这里很容易会以输入的类型string作为输出的类型，它启示作用就是根据条件筛选输出想要的结果。

        //select的使用
        static void Main(string[] args)
        {
            string[] array = { "旋转音乐盒", "好挤好挤", "爱的多米诺", "客官不可以", "下雨天", "晴天娃娃", "日不落", "黑发尤物" };
            Func<string, int> func = i => i.Length;          //输出集合中的每一项的长度
            IEnumerable<int> selectlist = array.Select<string,int>(func);        //在这里需要注意的是select<>的参数类型限制为输入的类型和输入的参数类型
            foreach (var item in selectlist)
            {
                Console.WriteLine(item);
            }

            var selects = array.Select(p=>new{p,p.Length});     //在这里使用匿名方法，输入集合中各字符串的长度
            foreach (var item in selects)                     
            {
                Console.WriteLine(item);
            }

            var selectss = array.Select(p => new {name = p, p.Length });
            foreach (var item in selectss)
            {
                Console.WriteLine("歌曲名字是：{0}，歌名的长度是：{1}", item.name,item.Length);
            }
            Console.ReadKey();
        }

        //selectmany的使用
        static void Main(string[] args)
        {
            string[] array = {"旋转音乐盒","淋雨一直走","好挤好挤","爱的多米诺","客官不可以","下雨天","晴天娃娃","日不落","黑发尤物"};

            IEnumerable<char> chars = array.SelectMany(p=>p.ToArray());
            foreach (var item in chars)      //SelectMany这个方法传入一个序列，可以输出多个
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();
        }

 

                   使用select方法，输出的类型可以为int类型，在这里也可以使用匿名方法，这样使用更简单的输出集合的每一项。而selectMany方法则可以转变为数组，然后遍历出每一项。在这里可以存在类型转换，还有就是在使用匿名方法时间返回一个var类型，而它是一个强类型，在编译时间自动给我们生成它能够辨别出的类型。

        static void Main(string[] args)
        {
            string[] array = { "旋转音乐盒", "淋雨一直走", "好挤好挤", "爱的多米诺", "客官不可以", "下雨天", "晴天娃娃", "日不落", "黑发尤物" };
            //IEnumerable<string> arraylist = array.Take(5);   //输出集合中的前五项
            //foreach (var item in arraylist)
            //{
            //    Console.WriteLine(item);
            //}

            IEnumerable<string> arraylists = array.TakeWhile(p => p.Length > 3);
            foreach (var item in arraylists)
            {
                Console.WriteLine(item);
            }

           //IEnumerable<string> skiplist = array.Skip(4);     //略过前四项，输出后面的每一项
           //foreach (var item in skiplist)
           //{
           //    Console.WriteLine(item);
           //}

           //IEnumerable<string> skiplists = array.SkipWhile(s=>s.StartsWith("下"));   
           //foreach (var item in skiplists)
           //{ 
           //    Console.WriteLine(item);
           //}
            Console.ReadKey();
        }

 

                这里简单的写了take与skip两个方法以及的TakeWhile和SkipWhile方法，而take是返回前几条数据，skip是跳过几条数据输出后面的数据。

        static void Main(string[] args)
        {
            string[] array = { "旋转音乐盒", "淋雨一直走", "好挤好挤", "爱的多米诺", "客官不可以", "下雨天", "晴天娃娃", "日不落", "黑发尤物" };
            IEnumerable<string> takelist=  array.Take(3);
            IEnumerable<string> skiplist = array.Skip(5);
            IEnumerable<string> concatlist = takelist.Concat(skiplist);   //Concat方法可以使两个序列合并为一个序列
            foreach (var item in concatlist)
            {
                Console.WriteLine(item);
            }

            IEnumerable<string> orderbylist = array.OrderBy(p => p.Length);  //OrderBy方法是用来排序的，在这里是根据字符串的长度排序
            foreach (var item in orderbylist)
            {
                Console.WriteLine(item);
            }
            IEnumerable<string> orderbylistss = array.OrderByDescending(p=>p.Length).ThenBy(s=>s);
            foreach (var item in orderbylistss)  //OrderByDescending方法是可以根绝多个条件排序，在这里是根据俄字符串长度排序，如果长度相等，可以再根据字母的顺序排序
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();
        }

 

                上面已经添加了注释，嘿嘿，今天学习的知识点还是可以理解的，但是在使用让面还是很陌生的，主要是使用LinQ中的一些方法，感觉使用起来还是有点困难的，这个需要做些练习的，我会好好的练习，就写到这里，明天继续努力orm框架。