01.C#数据类型、排序、过滤(一章1.1-1.2)

　　随着看的文章及探讨越多，越发现自己实在太不定性了，看下《C#深入理解》吧，做一下读书笔记，从中发现自己的不足。闲话不说，进入正题吧。

　　在C#1中定下一个简单的数据类型

 public class Product1
     {
         private string name;
         private long price;

         public string Name { get { return name; } }
         public long Price { get { return price; } }

         public Product1(string n, long p)
         {
             this.name = n;
             this.price = p;
         }

         public static ArrayList GetProducts()
         {
             ArrayList list = new ArrayList();
             list.Add(new Product1("cat", ));
             list.Add(new Product1("fish", ));
             list.Add(new Product1("dog", ));
             list.Add(new Product1("pig", ));
             return list;
         }
     }

　　C#1中没有泛型的概念，在Product1类中的静态方法返回是的ArrayList类型，里面的元素类型当然是Product1。而在C#2中引入泛型后，该类可定义为(重命名为Product2)

 public class Product2
     {
         private string name;
         private long price;

         public string Name { get { return name; } private set { name = value; } }
         public long Price { get { return price; } private set { price = value; } }

         public Product2(string n, long p)
         {
             Name = n;
             Price = p;
         }

         public static List<Product2> GetProducts()
         {
             List<Product2> list = new List<Product2>();
             list.Add(new Product2("cat", ));
             list.Add(new Product2("fish", ));
             list.Add(new Product2("dog", ));
             list.Add(new Product2("pig", ));
             return list;
         }
     }

　　相比较于C#3，对于属性的改进，则是引入自动实现属性的概念，Product1和Product2中私有属性name和price，可以通过自动属性进行书写，如下

 class Product3
     {
         public string Name { get; private set; }
         public long Price { get; private set; }

         public Product3(string n, long p)
         {
             Name = n;
             Price = p;
         }

         public static List<Product3> GetProducts()
         {
             List<Product3> list = new List<Product3> {
                 new Product3("cat",),
                 new Product3("fish",),
                 new Product3("dog",),
                 new Product3("pig",)
             };
             return list;
         }
     }

　　C#4中对类的实现主要体现在类的实例化中，引入命名实参，注意下面GetProducts方法中类对象的实例化

 class Product4
     {
         readonly string name;
         readonly long price;
         public string Name { get { return name; } }
         public long Price { get { return price; } }

         public Product4(string n, long p)
         {
             name = n;
             price = p;
         }

         public static List<Product4> GetProducts()
         {
             return new List<Product4>
             {
                 new Product4(n:"cat",p:),
                 new Product4(n:"fish",p:),
                 new Product4(n:"dog",p:),
                 new Product4(n:"pig",p:)
             };
         }
     }

　　如new Product4(n:"cat",p:1)，格式如[参数:参数值]，在实例化中可以显示的指定参数的值。

　　接下来说下C#进化过程中对排序方法的实现

　　在C#1中，需要定义一个实现于IComparer接口的类

 //使用IComparer对ArrayList进行排序
     public class ComparerName1 : IComparer
     {
         public int Compare(object x, object y)
         {
             Product1 p1 = (Product1)x;
             Product1 p2 = (Product1)y;
             return p1.Name.CompareTo(p2.Name);
         }
     }

　　在功能页面要对上述类实例化

 class Program
     {
         static void Main(string[] args)
         {
             ArrayList list = Product1.GetProducts();

             list.Sort(new ComparerName1());

             foreach (Product1 p in list)
             {
                 Console.WriteLine(p.Name);
             }
             Console.ReadKey();

         }
     }

　　可以看出ArrayList类型有一个公开的接口(用于排序Sort)，传入的参数是实现IComparer接口的一个实例，正好我们上面定义的ComparerName1(根据产品的名字来排序)，那么在C#2中又是如何实现？

正如前面所说C#2引入泛型的概念(对应的产品类为Product2类)，定义一个实现IComparer<Product2>接口的类即可

 public class ComparerName2 : IComparer<Product2>
     {
         public int Compare(Product2 x, Product2 y)
         {
             return x.Name.CompareTo(y.Name);
         }
     }

　　在功能页面使用方法和C#1一样，主要区别在于ComparerName1中需要将Object类型强制转换成Product1类型，而在使用泛型的情况下，因为已经知道了具体的类型，则避免了强制转换带来的性能损耗
。

　　C#3中的自动属性对于排序没有作用，但是可以使用引入的Lambda表达式对排序代码的进一步精简。

 class Program
     {
         static void Main(string[] args)
         {
             //在C#3中使用Lambda表达式进行排序
             List<Product3> list = Product3.GetProducts();

             list.Sort(
                 (x, y) => x.Name.CompareTo(y.Name)
             );

             foreach (Product3 p in list)
             {
                 Console.WriteLine(p.Name);
             }
             Console.ReadKey();
         }
     }

　　Lambda表达式的实现其实是委托，用于委托实现也是一样的。

　　下面来说下对于查询、打印的实现。

C#1

 class Program
     {
         static void Main(string[] args)
         {
             ArrayList list = Product1.GetProducts();
             /*
                 C#1使用查询、测试、打印
             */
             foreach (Product1 p in list)
             {
                 if (p.Price > )
                 {
                     Console.WriteLine(p.Name);
                 }
             }
             Console.ReadKey();

         }
     }

　　C#2中的查询实现可以使用委托

 class Program
     {
         static void Main(string[] args)
         {
             List<Product2> list = Product2.GetProducts();

             //C#2使用匿名方法创建委托

             Predicate<Product2> test = delegate (Product2 p) { return p.Price > ; };
             List<Product2> matches = list.FindAll(test);
             Action<Product2> print = delegate (Product2 p) { Console.WriteLine(p.Name); }; ;
             matches.ForEach(print);
             list.FindAll(test).ForEach(print);

             Console.ReadKey();

         }
     }

　　结果和C#1中是一样的，打印价格大于2产品的名称，到了C#3则更精简了，因为有了Lambda表达式

 class Program
     {
         static void Main(string[] args)
         {
             List<Product3> list = Product3.GetProducts();

             //C#3中使用Lambda表达式进行查询
             list.FindAll(x => x.Price > ).ForEach(x => Console.WriteLine(x.Name));

             Console.ReadKey();

         }
     }

　　写到这里，我们有理由相信，Lambda表达式就是变相的委托，则可以引入一个想法，在使用委托的时候均可以使用Lambda表达式替代。great！！！

　　请斧正。