深切明白C,语言种种版本天性

By admin in 4858.com on 2019年3月26日

二、排序Product

引言

在起头看这本书以前看过部分技能博客,填补自个儿对于某些知识点的不足。无意中窥见了《深刻驾驭C#》这本书,本书首要研讨C#
2、C# 3和C# 4的细节与特点,所以做了一晃观看笔记,欢迎拍砖。

引言

在上马看那本书从前看过部分技能博客,填补自身对此某些知识点的阙如。无意中发现了《深刻精通C#》那本书,本书主要商讨C#
2、C# 3和C# 4的细节与特色,所以做了弹指间阅览笔记,欢迎拍砖。

① 、数据类型的前行

1.按名称对产品进行排序,以一定顺序显示贰个列表的最简易方法就是先将列表排序,再遍历并体现中间的项。

目录

  • 从不难的数据类型发轫
    • C# 1 中定义的制品类型
    • C# 2 中的强类型集合
    • C# 3 中自行完结的性格
    • C# 4 中的命名实参
  • 排序和过滤
    • 按名称对产品进行排序
    • 询问集合

目录

  • 从简单的数据类型发轫
    • C# 1中定义的出品体系
    • C# 2中的强类型集合
    • C# 3
      中机动完成的习性
    • C# 4
      中的命名实参
  • 排序和过滤
    • 按名称对成品进行排序
    • 查询集合

 C#第11中学贯彻Product类型代码

C#1.1 使用IComparer对ArrayList举行排序

C#第11中学定义的制品种类

 1  public class Product 2     { 3         string name; 4         public string Name 5         { 6             get { return name; } 7         } 8         decimal price; 9         public decimal Price10         {11             get { return price; }12         }13         public Product(string name, decimal price)14         {15             this.name = name;16             this.price = price;17         }18         public static ArrayList GetSampleProducts()19         {20             ArrayList list = new ArrayList();21             list.Add(new Product("硬装芙蓉王", 25m));22             list.Add(new Product("精白沙", 9m));23             list.Add(new Product("软白沙", 5.5m));
25             return list;26         }27         public override string ToString()28         {29             return string.Format("{0}:{1}", name, price);30         }31     }

C#1 中定义的成品品类

 1  public class Product
 2     {
 3         string name;
 4         public string Name
 5         {
 6             get { return name; }
 7         }
 8         decimal price;
 9         public decimal Price
10         {
11             get { return price; }
12         }
13         public Product(string name, decimal price)
14         {
15             this.name = name;
16             this.price = price;
17         }
18         public static ArrayList GetSampleProducts()
19         {
20             ArrayList list = new ArrayList();
21             list.Add(new Product("硬装芙蓉王", 25m));
22             list.Add(new Product("精白沙", 9m));
23             list.Add(new Product("软白沙", 5.5m));
25             return list;
26         }
27         public override string ToString()
28         {
29             return string.Format("{0}:{1}", name, price);
30         }
31     }

4858.com 14858.com 2

product类

缺点:

  1. ArrayList没有提供内部有关编写翻译时的新闻。大家很有大概在Get萨姆pleProducts方法中添加一个字符串到ArrayList中,因为ArrayList的Add方法中的参数是object,而编辑器并不曾其它反应。
  2. 代码中提供了品质的取值方法,即便加上对应的赋值方法,那么赋值方法也亟须是共用的艺术。
  3. 成立属性的代码过于复杂。

缺点:

  1. ArrayList没有提供内部关于编写翻译时的消息。大家很有也许在GetSampleProducts方法中添加1个字符串到ArrayList中,因为ArrayList的Add方法中的参数是object,而编辑器并不曾其余反响。
  2. 代码中提供了质量的取值方法,若是加上对应的赋值方法,那么赋值方法也非得是国有的主意。
  3. 成立属性的代码过于复杂。
 1 public class Product
 2     {
 3         string name;
 4         public string Name
 5         {
 6             get { return name; }
 7         }
 8 
 9         decimal price;
10         public decimal Price
11         {
12             get { return price; }
13         }
14 
15         public Product(string name, decimal price)
16         {
17             this.name = name;
18             this.price = price;
19         }
20      
21         public static ArrayList GetSampleProducts()
22         {
23             ArrayList list = new ArrayList();
24             list.Add(new Product("West Side Story", 9.99m));
25             list.Add(new Product("Assassins", 14.99m));
26             list.Add(new Product("Frogs", 13.99m));
27             list.Add(new Product("Sweeney Todd", 10.99m));
28             return list;
29            
30         }
31 
32         public override string ToString()
33         {
34             return string.Format("{0}: {1}", name, price);
35           
36         }
37       
38 
39     }

4858.com 34858.com 4

C#2 中的强类型集合

因C#第11中学没有泛型,Product类中的静态方法GetSampleProducts,重返的是ArrayList类型,里面添加的要素只可以是Product,而在C#第22中学的改变正是泛型。(新的情节用铁红列出)

 1 public class Product 2     { 3         string name; 4         public string Name 5         { 6             get { return name; } 7             private set { name = value; } 8         }10         decimal price;11         public decimal Price12         {13             get { return price; }14             private set { price = value; }15         }17         public Product(string name, decimal price)18         {19             Name = name;20             Price = price;21         }22         public static List<Product> GetSampleProducts()23         {24             List<Product> list = new List<Product>();25             list.Add(new Product("硬装芙蓉王", 25m));26             list.Add(new Product("精白沙", 9m));27             list.Add(new Product("软白沙", 5.5m));28             return list;29         }30         public override string ToString()31         {32             return string.Format("{0}:{1}", name, price);33         }34     }

C#2 中的强类型集合

因C#第11中学从未泛型,Product类中的静态方法GetSampleProducts,再次来到的是ArrayList类型,里面添加的成分只好是Product,而在C#深切明白C,语言种种版本天性。第22中学的改变就是泛型。(新的内容用樱桃红列出)

 1 public class Product
 2     {
 3         string name;
 4         public string Name
 5         {
 6             get { return name; }
 7             private set { name = value; }
 8         }
10         decimal price;
11         public decimal Price
12         {
13             get { return price; }
14             private set { price = value; }
15         }
17         public Product(string name, decimal price)
18         {
19             Name = name;
20             Price = price;
21         }
22         public static List<Product> GetSampleProducts()
23         {
24             List<Product> list = new List<Product>();
25             list.Add(new Product("硬装芙蓉王", 25m));
26             list.Add(new Product("精白沙", 9m));
27             list.Add(new Product("软白沙", 5.5m));
28             return list;
29         }
30         public override string ToString()
31         {
32             return string.Format("{0}:{1}", name, price);
33         }
34     }

View Code

 1 using System.Collections;
 2 using System.ComponentModel;
 3 
 4 namespace Chapter01.CSharp1
 5 {
 6     [Description("Listing 1.01")]
 7     public class Product
 8     {
 9         string name;
10         public string Name
11         {
12             get { return name; }
13         }
14 
15         decimal price;
16         public decimal Price
17         {
18             get { return price; }
19         }
20 
21         public Product(string name, decimal price)
22         {
23             this.name = name;
24             this.price = price;
25         }
26 
27         public static ArrayList GetSampleProducts()
28         {
29             ArrayList list = new ArrayList();
30             list.Add(new Product("West Side Story", 9.99m));
31             list.Add(new Product("Assassins", 14.99m));
32             list.Add(new Product("Frogs", 13.99m));
33             list.Add(new Product("Sweeney Todd", 10.99m));
34             return list;
35         }
36 
37         public override string ToString()
38         {
39             return string.Format("{0}: {1}", name, price);
40         }
41     }
42 }

优点:

  1. 质量有了民用赋值方法,且能够在构造函数中接纳这几个赋值方法。
  2. List<Product>告知编辑器里面只好分包Product,试图将3个比不上的类型丰裕到列表中,会招致编写翻译时不当。并且在应用List<Product>时不须求更换结果的数据类型。

针对C#第11中学的存在的局限性,C#2缓解了本来存在的前三个难点。

优点:

  1. 品质有了私家赋值方法,且可以在构造函数中运用那些赋值方法。
  2. List<Product>告知编辑器里面只好分包Product,试图将几个例外的类型丰裕到列表中,会促成编写翻译时不当。并且在选择List<Product>时不需求更换结果的数据类型。

 针对C#第11中学的存在的局限性,C#2缓解了原本存在的前三个难点。

C#2中的强类型集合和私家的赋值方法

View Code

C#3 中自动完毕的本性

相对C#2而言,C#3引入了活动属性和集合初叶化器。Product中的属性Name和Price,能够经过机关属性简化代码,而编写翻译器最终生成的代码是一样的。

 1 public class Product 2     { 3         public string Name{ get; private set; } 5         public decimal Price { get; private set; } 6         Product() { } 8         public Product(string name, decimal price) 9         {10             Name = name;11             Price = price;12         }14         public static List<Product> GetSampleProducts()15         {16             return new List<Product>17             {18                 new Product("硬装芙蓉王", 25m),19                 new Product("精白沙", 9m),20                 new Product("软白沙", 5.5m)21             };22         }24         public override string ToString()25         {26             return string.Format("{0}:{1}", Name, Price);27         }28     }

C#3 中机动实现的习性

相对C#2而言,C#3引入了自行属性和聚集早先化器。Product中的属性Name和Price,能够透过活动属性简化代码,而编写翻译器最后生成的代码是均等的。

 1 public class Product
 2     {
 3         public string Name{ get; private set; }
 5         public decimal Price { get; private set; }
 6         Product() { }
 8         public Product(string name, decimal price)
 9         {
10             Name = name;
11             Price = price;
12         }
14         public static List<Product> GetSampleProducts()
15         {
16             return new List<Product>
17             {
18                 new Product("硬装芙蓉王", 25m),
19                 new Product("精白沙", 9m),
20                 new Product("软白沙", 5.5m)
21             };
22         }
24         public override string ToString()
25         {
26             return string.Format("{0}:{1}", Name, Price);
27         }
28     }

4858.com 54858.com 6

ArrayListSort类

优点:

  1. 一贯不剩余的变量与脾性相关联,因为类中没有了name和price变量,在类中动用性质名称是平等的。增强了代码的一致性。
  2. 开创的数目列表的不二法门也截然区别。
  3. 有一个私人住房的无参构造函数,用于新的基于属性的初步化。

 优点:

  1. 平素不剩余的变量与性子相关联,因为类中从不了name和price变量,在类中运用性质名称是一律的。增强了代码的一致性。
  2. 开创的数码列表的艺术也完全差异。
  3. 有2个个体的无参构造函数,用于新的基于属性的开首化。
 1  public class Product
 2     {
 3         string name;
 4         public string Name
 5         {
 6             get { return name; }
 7             private set { Name = value; } 私有的赋值方法
 8         }
 9 
10         decimal price;
11         public decimal Price
12         {
13             get { return price; }
14             private set { Price = value; }
15         }
16         //C#3:Product(){}
17         public Product(string name, decimal price)
18         {
19            
20               Name = name;
21               Price = price;
22         }
23       public static List<Product>GetSampleProducts()
24         {
25              List<Product>list= new List<Product>();
26             list.Add(new Product("West Side Story", 9.99m));
27             list.Add(new Product("Assassins", 14.99m));
28             list.Add(new Product("Frogs", 13.99m));
29             list.Add(new Product("Sweeney Todd", 10.99m));
30             return list;
31            
32         }
33 
34         public override string ToString()
35         {
36             return string.Format("{0}: {1}", name, price);
37           
38         }
39 
40     }

4858.com 74858.com 8

C# 4 中的命名实参

在C#4中引入了命名实参,所谓命名实参是指命名参数调用实参顺序能够和形参不一样。

 1 public class Product 2     { 3         readonly string name; 4         public string Name 5         { 6             get { return name; } 7         } 9         readonly decimal price;10         public decimal Price11         {12             get { return price; }13         }15         public Product(string name, decimal price)16         {17             this.name = name;18             this.price = price;19         }20         public static List<Product> GetSampleProducts()21         {22             List<Product> list = new List<Product>();23             list.Add(new Product(name: "硬装芙蓉王", price: 25m));24             list.Add(new Product(name: "精白沙", price: 9m));25             list.Add(new Product(name: "软白沙", price: 5.5m));26             return list;27         }28         public override string ToString()29         {30             return string.Format("{0}:{1}", name, price);31         }32     }

4858.com 9

C# 4 中的命名实参

 在C#4中引入了命名实参,所谓命名实参是指命名参数调用实参顺序能够和形参不一致。

 1 public class Product
 2     {
 3         readonly string name;
 4         public string Name
 5         {
 6             get { return name; }
 7         }
 9         readonly decimal price;
10         public decimal Price
11         {
12             get { return price; }
13         }
15         public Product(string name, decimal price)
16         {
17             this.name = name;
18             this.price = price;
19         }
20         public static List<Product> GetSampleProducts()
21         {
22             List<Product> list = new List<Product>();
23             list.Add(new Product(name: "硬装芙蓉王", price: 25m));
24             list.Add(new Product(name: "精白沙", price: 9m));
25             list.Add(new Product(name: "软白沙", price: 5.5m));
26             return list;
27         }
28         public override string ToString()
29         {
30             return string.Format("{0}:{1}", name, price);
31         }
32     }

4858.com 10

View Code

 1 using System;
 2 using System.Collections;
 3 using System.ComponentModel;
 4 
 5 namespace Chapter01.CSharp1
 6 {
 7     [Description("Listing 1.05")]
 8     class ArrayListSort
 9     {
10         class ProductNameComparer : IComparer
11         {
12             public int Compare(object x, object y)
13             {
14                 Product first = (Product)x;
15                 Product second = (Product)y;
16                 return first.Name.CompareTo(second.Name);
17             }
18         }
19 
20         static void Main()
21         {
22             ArrayList products = Product.GetSampleProducts();
23             products.Sort(new ProductNameComparer());
24             foreach (Product product in products)
25             {
26                 Console.WriteLine(product);
27             }
28         }
29     }
30 }

按名称对成品进行排序

列表排序最简便易行的措施正是先将列表排好序,然后遍历并显示中间的项。在上述代码C#
第11中学,Product类中的静态方法GetSampleProducts,重返的是ArrayList类型,大家须要利用ArrayList.Sort,须要提供3个IComparer达成。完成代码如下:

1  public class ProductNameComparer : IComparer2     {3         public int Compare(object x, object y)4         {5             Product i = x;6             Product j = y;7             return i.Name.CompareTo;8         }9     }

 1  static void Main(string[] args) 2         { 3             ArrayList arraylist = Product.GetSampleProducts(); 4             arraylist.Sort(new ProductNameComparer; 5             foreach(Product pr in arraylist) 6             { 7                 Console.WriteLine; 8             } 9             Console.Read();10         }

按名称对产品进行排序

列表排序最简便的格局正是先将列表排好序,然后遍历并体现个中的项。在上述代码C#
1中,Product类中的静态方法GetSampleProducts,重回的是ArrayList类型,大家渴求选用 ArrayList.Sort,须求提供三个IComparer完毕。完结代码如下:

1  public class ProductNameComparer : IComparer
2     {
3         public int Compare(object x, object y)
4         {
5             Product i = (Product)x;
6             Product j = (Product)y;
7             return i.Name.CompareTo(j.Name);
8         }
9     }

 1  static void Main(string[] args)
 2         {
 3             ArrayList arraylist = Product.GetSampleProducts();
 4             arraylist.Sort(new ProductNameComparer());
 5             foreach(Product pr in arraylist)
 6             {
 7                 Console.WriteLine(pr.Name);
 8             }
 9             Console.Read();
10         }

C#3机动完成的质量和更简短的起始化

View Code

缺点:

  1. 务必引入额外的连串来提携排序。
  2. Compare 方法中的强制类型转换。
  3. 要是ArrayList包蕴一个字符串货别的门类,那么代码会出错——因为在可比时会将字符串强制转型为
    Product 。
  4. foreach 循环会隐式将列表中的每种成分转换为 Product
    类型,假设内部饱含字符串或别的类型,同样会报错。

然后在C#第22中学引入泛型了足以帮衬大家缓解上述难点。

1 public class ProductNameComparer : IComparer<Product>2     {3         public int Compare(Product x, Product y)4         {5             return x.Name.CompareTo;6         }7     }

 1  static void Main(string[] args) 2         { 3             List<Product> arraylist = Product.GetSampleProducts(); 4             arraylist.Sort(new ProductNameComparer; 5             foreach(Product pr in arraylist) 6             { 7                 Console.WriteLine; 8             } 9             Console.Read();10         }

 缺点:

  1. 不可能不引入额外的体系来救助排序。
  2. Compare 方法中的强制类型转换。
  3. 尽管ArrayList包蕴叁个字符串货其余种类,那么代码会出错——因为在可比时会将字符串强制转型为
    Product 。 
  4. foreach 循环会隐式将列表中的每种元素转换为 Product
    类型,假设内部蕴藏字符串或其它体系,同样会报错。

然后在C#2中引入泛型了足以扶持我们缓解上述难题。

1 public class ProductNameComparer : IComparer<Product>
2     {
3         public int Compare(Product x, Product y)
4         {
5             return x.Name.CompareTo(y.Name);
6         }
7     }

 1  static void Main(string[] args)
 2         {
 3             List<Product> arraylist = Product.GetSampleProducts();
 4             arraylist.Sort(new ProductNameComparer());
 5             foreach(Product pr in arraylist)
 6             {
 7                 Console.WriteLine(pr.Name);
 8             }
 9             Console.Read();
10         }

4858.com 114858.com 12

提供叁个IComparer实现,比较器。可能Product类实现IComparable。

优点:

  1. 开班提供的正是Product(而非常小概是其它项目),在Compare方法中不须求展开强制类型转换。
  2. foreach也不用隐式的类型转换。

固然我们不希望引入额外的项目来提携排序,而是直接对列表排序。C#2用到委托来排序。代码如下:

 1 static void Main(string[] args) 2         { 3             List<Product> arraylist = Product.GetSampleProducts(); 4             arraylist.Sort(delegate(Product x, Product y) 5             { 6                 return x.Name.CompareTo; 7             }); 8             foreach (Product pr in arraylist) 9             {10                 Console.WriteLine;11             }12 13         }

C#3
能够将匿名情势替换到Lambda表明式的点子开始展览排序。

 1 static void Main(string[] args) 2         { 3             List<Product> arraylist = Product.GetSampleProducts(); 4             arraylist.Sort => x.Name.CompareTo; 5             foreach (Product pr in arraylist) 6             { 7                 Console.WriteLine; 8             } 9             Console.Read();10         }

C#3行使扩展方法开展排序。

1 static void Main(string[] args)2         {3             List<Product> arraylist = Product.GetSampleProducts();4             foreach (Product pr in arraylist.OrderBy(p => p.Name))5             {6                 Console.WriteLine;7             }8             Console.Read();9         }

4858.com 13

 优点:

  1. 始发提供的就是Product(而不容许是任何项目),在Compare方法中不必要展开强制类型转换。
  2. foreach也不用隐式的类型转换。

假如我们不希望引入额外的档次来支援排序,而是向来对列表排序。C#2利用委托来排序。代码如下:

 1 static void Main(string[] args)
 2         {
 3             List<Product> arraylist = Product.GetSampleProducts();
 4             arraylist.Sort(delegate(Product x, Product y)
 5             {
 6                 return x.Name.CompareTo(y.Name);
 7             });
 8             foreach (Product pr in arraylist)
 9             {
10                 Console.WriteLine(pr.Name);
11             }
12 13         } 

C#3
能够将匿名方式替换到Lambda表明式的办法开始展览排序。 

 1 static void Main(string[] args)
 2         {
 3             List<Product> arraylist = Product.GetSampleProducts();
 4             arraylist.Sort((x, y) => x.Name.CompareTo(y.Name));
 5             foreach (Product pr in arraylist)
 6             {
 7                 Console.WriteLine(pr.Name);
 8             }
 9             Console.Read();
10         }

 C#3 使用扩充方法开始展览排序。 

1 static void Main(string[] args)
2         {
3             List<Product> arraylist = Product.GetSampleProducts();
4             foreach (Product pr in arraylist.OrderBy(p => p.Name))
5             {
6                 Console.WriteLine(pr.Name);
7             }
8             Console.Read();
9         }

 4858.com 14

 1  public class Product
 2     {
 3         public string Name { get; private set; }
 4         public string Price { get; private set; }
 5 
 6         public Product(string name, decimal price)
 7         {
 8            
 9               Name = name;
10               Price = price;
11         }
12 
13         private Product()
14         {
15         }
16 
17         public static List<Product> GetSampleProducts()
18         {
19             return new List<Product>
20             {
21                 new Product {Name = "West Side Story", Price = 9.99m},
22                 new Product {Name = "Assassins", Price = 14.99m},
23                 new Product {Name = "Frogs", Price = 13.99m},
24                 new Product {Name = "Sweeney Todd", Price = 10.99m}
25             };
26         }
27 
28         public override string ToString()
29         {
30             return string.Format("{0}: {1}", Name, Price);
31         }
32       
33     }

有别于:IComparer和IComparable(相比较器接口和可正如的接口)

询问集合

检索集合中符合条件的有所因素,是一件很简单的业务,我们来一同来看C#1、C#2、C#以内查询集合的不一致。

现供给查找价格高于20的制品音讯。

C#1代码:

 1 static void Main(string[] args) 2         { 3             ArrayList arraylist = Product.GetSampleProducts(); 4             foreach (Product pr in arraylist) 5             { 6                 if (pr.Price > 20) 7                 { 8                     Console.WriteLine; 9                 }10             }11             Console.Read();12         }

C#2代码:

 1 static void Main(string[] args) 2         { 3             List<Product> list = Product.GetSampleProducts(); 4             Predicate<Product> test = delegate(Product p) //设定查询条件 5             { 6                 return p.Price > 20; 7             }; 8             List<Product> all = list.FindAll;      //查询所有价格大于20的产品,并保存到all中 9             Action<Product> pro = Console.WriteLine;     //输出产品信息10             all.ForEach; //循环输出产品信息11             Console.Read();12         }

C#2此外三个本子代码:

1 static void Main(string[] args)2         {3             List<Product> list = Product.GetSampleProducts();4             list.FindAll(delegate(Product p) //设定查询条件5             {6                 return p.Price > 20;7             }).ForEach(Console.WriteLine);8             Console.Read();9         }

C#3代码:

1 static void Main(string[] args)2         {3             List<Product> list = Product.GetSampleProducts();4             list.FindAll(p => { return p.Price > 20; }).ForEach(Console.WriteLine);5             Console.Read();6         }

1 static void Main(string[] args)2         {3             List<Product> list = Product.GetSampleProducts();4             foreach (Product pro in list.Where(p => p.Price > 20))5             {6                 Console.WriteLine;7             }8             Console.Read();9         }

4858.com 15

那篇就写到那里。下篇大家将一而再上学《深刻精晓C#》的连锁知识。

询问集合

探寻集合中符合条件的全数因素,是一件很简单的政工,大家来一块来看C#1、C#2、C#里头查询集合的不及。

现须求寻找价格超越20的出品消息。

C#1代码:

 1 static void Main(string[] args)
 2         {
 3             ArrayList arraylist = Product.GetSampleProducts();
 4             foreach (Product pr in arraylist)
 5             {
 6                 if (pr.Price > 20)
 7                 {
 8                     Console.WriteLine(pr);
 9                 }
10             }
11             Console.Read();
12         }

 C#2代码:

 1 static void Main(string[] args)
 2         {
 3             List<Product> list = Product.GetSampleProducts();
 4             Predicate<Product> test = delegate(Product p) //设定查询条件
 5             {
 6                 return p.Price > 20;
 7             };
 8             List<Product> all = list.FindAll(test);      //查询所有价格大于20的产品,并保存到all中
 9             Action<Product> pro = Console.WriteLine;     //输出产品信息
10             all.ForEach(pro); //循环输出产品信息
11             Console.Read();
12         }

 C#2此外多少个本子代码:

1 static void Main(string[] args)
2         {
3             List<Product> list = Product.GetSampleProducts();
4             list.FindAll(delegate(Product p) //设定查询条件
5             {
6                 return p.Price > 20;
7             }).ForEach(Console.WriteLine);
8             Console.Read();
9         }

 C#3代码:

1 static void Main(string[] args)
2         {
3             List<Product> list = Product.GetSampleProducts();
4             list.FindAll(p => { return p.Price > 20; }).ForEach(Console.WriteLine);
5             Console.Read();
6         }

1 static void Main(string[] args)
2         {
3             List<Product> list = Product.GetSampleProducts();
4             foreach (Product pro in list.Where(p => p.Price > 20))
5             {
6                 Console.WriteLine(pro);
7             }
8             Console.Read();
9         }

4858.com 16

那篇就写到那里。下篇大家将继续上学《深切驾驭C#》的有关知识。

View Code

缺陷:Compare方法中展示强制类型转换,而ArrayList是类别不安全的,转换为目的Product时可能报错。foreach循环中隐式的编写翻译器自动类型转换,转换为Product类型执行时也许报错。

C#4中命名实参

2.C#2.0
引入泛型,使用IComparer<Product>对List<Product>实行排序

4858.com 174858.com 18

product类

 1 public class Product
 2     {
 3      
 4         public override string ToString()
 5         {
 6             return string.Format("{0}: {1}", name, price);
 7         }
 8         //C#4中的参数:尽管私有赋值不能被公共的改变,但如果要求它也不能被私有的改变,将会更加的清晰,在C#4中,我们用调用构造函数时指定实参的名称
 9         readonly string name;
10         public string Name { get { return name; } }
11         return new List<Product>
12         {
13             new Product {name = "West Side Story", price = 9.99m},
14             new Product {name = "Assassins", price = 14.99m},
15             new Product {name = "Frogs", price = 13.99m},
16             new Product {name = "Sweeney Todd", price = 10.99m},
17         };
18 
19 
20     }

4858.com 194858.com 20

View Code

 1 using System.Collections.Generic;
 2 using System.ComponentModel;
 3 
 4 namespace Chapter01.CSharp2
 5 {
 6     [Description("Listing 1.02")]
 7     public class Product
 8     {
 9         string name;
10         public string Name
11         {
12             get { return name; }
13             private set { name = value; }
14         }
15 
16         decimal price;
17         public decimal Price
18         {
19             get { return price; }
20             private set { price = value; }
21         }
22 
23         public Product(string name, decimal price)
24         {
25             Name = name;
26             Price = price;
27         }
28 
29         public static List<Product> GetSampleProducts()
30         {
31             List<Product> list = new List<Product>();
32             list.Add(new Product("West Side Story", 9.99m));
33             list.Add(new Product("Assassins", 14.99m));
34             list.Add(new Product("Frogs", 13.99m));
35             list.Add(new Product("Sweeney Todd", 10.99m));
36             return list;
37         }
38 
39         public override string ToString()
40         {
41             return string.Format("{0}: {1}", name, price);
42         }
43     }
44 }

二 、排序和过滤的演化

View Code

 1、排序

ListSortWithComparer类

C#第11中学生运动用IComparer对ArrayList实行排序

4858.com 214858.com 22

4858.com 234858.com 24

 1 using System;
 2 using System.Collections.Generic;
 3 using System.ComponentModel;
 4 
 5 namespace Chapter01.CSharp2
 6 {
 7     [Description("Listing 1.06")]
 8     class ListSortWithComparer
 9     {
10         class ProductNameComparer : IComparer<Product>
11         {
12             public int Compare(Product first, Product second)
13             {
14                 return first.Name.CompareTo(second.Name);
15             }
16         }
17 
18         static void Main()
19         {
20             List<Product> products = Product.GetSampleProducts();
21             products.Sort(new ProductNameComparer());
22             foreach (Product product in products)
23             {
24                 Console.WriteLine(product);
25             }
26         }
27     }
28 }
 1 class ProductNameComparer : IComparer
 2         {
 3             public int Compare(object x, object y)
 4             {
 5                 Product first = (Product)x;
 6                 Product second = (Product)y;
 7                 return first.Name.CompareTo(second.Name);
 8             }
 9         }
10  static void Main()
11         {
12             ArrayList products = Product.GetSampleProducts();
13             products.Sort(new ProductNameComparer());
14             foreach (Product product in products)
15             {
16                 Console.WriteLine(product);
17             }
18         }

View Code

4858.com,View Code

选拔Comparison<Product>对List<Product>实行排序(C#2),不要求贯彻ProductNameComparer比较器类型,只是创造一个信托实例(C#2.0
匿名格局)。

C#第22中学应用IComparer<product>对List<Product>实行排序

4858.com 254858.com 26

4858.com 274858.com 28

 1 using System;
 2 using System.Collections.Generic;
 3 using System.ComponentModel;
 4 
 5 namespace Chapter01.CSharp2
 6 {
 7     [Description("Listing 1.07")]
 8     class ListSortWithComparisonDelegate
 9     {
10         static void Main()
11         {
12             List<Product> products = Product.GetSampleProducts();
13             products.Sort(delegate(Product first, Product second)
14                 { return first.Name.CompareTo(second.Name); }
15             );
16             foreach (Product product in products)
17             {
18                 Console.WriteLine(product);
19             }
20         }
21     }
22 }
 1  class ProductNameComparer : IComparer<Product>
 2         {
 3             public int Compare(Product x, Product y)
 4             {
 5                 return x.Name.CompareTo(y.Name);
 6             }
 7         }
 8 static void Main()
 9 {
10  List<Product> products = Product.GetSampleProducts();
11  products.Sort(new ProductNameComparer());
12             foreach (Product product in products)
13             {
14                 Console.WriteLine(product);
15             }
16 }

View Code

View Code

3.C#3.0 Lambda表明式
在拉姆da表明式中央银行使Comparison<Product>进行排序(C#3)

C#第22中学使用委托开始展览比较

product类

4858.com 294858.com 30

4858.com 314858.com 32

1  /* 
2          * C#2的方法1确实有了一定的改进,但是我们希望能直接指定要进行的标胶,就能开始对产品进行排序,而不需要实现一个接口来做这件事
3          * 下面它告诉sort方法如何用一个委托来比较俩个产品.省略了接口实现的代码和products.Sort(new ProductNameComparer());
4          * List<Product> products = Product.GetSampleProducts();
5          * products.Sort(delegate (Product x,Product y)
6          * {return x.Name.CompareTo(y.Name);}
7          * );
8          */
 1 using System.Collections.Generic;
 2 using System.ComponentModel;
 3 
 4 namespace Chapter01.CSharp3
 5 {
 6     [Description("Listing 1.3")]
 7     class Product
 8     {
 9         public string Name { get; private set; }
10         public decimal Price { get; private set; }
11 
12         public Product(string name, decimal price)
13         {
14             Name = name;
15             Price = price;
16         }
17 
18         Product()
19         {
20         }
21 
22         public static List<Product> GetSampleProducts()
23         {
24             return new List<Product>
25             {
26                 new Product { Name="West Side Story", Price = 9.99m },
27                 new Product { Name="Assassins", Price=14.99m },
28                 new Product { Name="Frogs", Price=13.99m },
29                 new Product { Name="Sweeney Todd", Price=10.99m}
30             };
31         }
32 
33         public override string ToString()
34         {
35             return string.Format("{0}: {1}", Name, Price);
36         }
37     }
38 }

View Code

View Code

C#3中选择lambda表明式进行比较

ListSortWithLambdaExpression类

4858.com 334858.com 34

4858.com 354858.com 36

 1  List<Product> products = Product.GetSampleProducts();
 2 products.Sort((x,y)=>x.Name.CompareTo(y.Name));
 3 foreach(Product product in products)
 4 {
 5          console.writeline(product);
 6 }
 7 C#3还有另一种写法排序
 8 foreach(Product product in product.OrderBy(p=>p.Name))
 9 {
10          console.writeline(product);//通知轻松的按顺序打印名称,同时不必修改原产品列表
11 }
 1 using System;
 2 using System.Collections.Generic;
 3 using System.ComponentModel;
 4 
 5 namespace Chapter01.CSharp3
 6 {
 7     [Description("Listing 1.08")]
 8     class ListSortWithLambdaExpression
 9     {
10         static void Main()
11         {
12             List<Product> products = Product.GetSampleProducts();
13             products.Sort(
14                 (first, second) => first.Name.CompareTo(second.Name)
15             );
16             foreach (Product product in products)
17             {
18                 Console.WriteLine(product);
19             }
20         }
21     }
22 }

View Code

View Code

  2、查询

ListOrderWithExtensionMethod类 使用扩充方法对List<Product>举办排序

   循环、测试和打字与印刷(C#1)

4858.com 374858.com 38

4858.com 394858.com 40

 1 using System;
 2 using System.Collections.Generic;
 3 using System.ComponentModel;
 4 using System.Linq;
 5 
 6 namespace Chapter01.CSharp3
 7 {
 8     [Description("Listing 1.09")]
 9     class ListOrderWithExtensionMethod
10     {
11         static void Main()
12         {
13             List<Product> products = Product.GetSampleProducts();
14 
15             foreach (Product product in products.OrderBy(p => p.Name))
16             {
17                 Console.WriteLine(product);
18             }
19         }
20     }
21 }
1  ArrayList products = Product.GetSampleProducts();
2             foreach (Product product in products.Cast<Product>().Where(product => product.Price > 10m))
3             {
4                 Console.WriteLine(product);
5             }

View Code

View Code

总结:

  测试和打字与印刷分开进行(C#2)

→C#1,弱类型的可比效益不支持委托排序。

4858.com 414858.com 42

→C#2,强类型的比较效益,委托相比,匿名格局。

1 List<Product> products =Product.GetSampleProducts();
2           Predicate<Product> test = delegate(Product p){ return p.Price > 10m;};
3            List<Product>  matches=products.FindAll(test);
4           Action<Product> print=console.writeLine;
5           matches.ForEach(print);

→C#3Lambda表明式,扩充方法,允许列表保持未排序状态。

View Code

测试和打字与印刷分开实行的另三个版本(C#2)

List<Product> products =Product.GetSampleProducts();
products.FindAll(delegate (Product p){ return p.Price >10;}).ForEach(Console.WriteLine);

用lambda表明式来展开测试(c#3)

List<Product> products =Product.GetSampleProducts();
foreach(Product product in products.Where(p=>p.price>10))
{
    Console.WriteLine(product);
}

C#中使用Linq表达式

foreach (Product product in products.Cast<Product>().Where(product => product.Price > 10m))
{
Console.WriteLine(product);
}

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有