二、排序Product

引言

在起来看那本书在此以前看过局地技艺博客,填补自个儿对于一些知识点的阙如。无意中窥见了《深远精晓C#》那本书,本书首要研究C#
2、C# 3和C# 四的细节与特色,所以做了一下阅读笔记,欢迎拍砖。

引言

在开班看那本书从前看过局地技艺博客,填补自个儿对此某个知识点的供不应求。无意中窥见了《深切了解C#》那本书,本书主要商量C#
2、C# 3和C# 4的底细与风味,所以做了须臾间观望笔记,欢迎拍砖。

1、数据类型的升华

一.按名称对成品举行排序,以特定顺序展现1个列表的最简易方法正是先将列表排序,再遍历并展现在那之中的项。

目录

  • 从不难的数据类型先导
    • C# 一 中定义的成品品类
    • C# 二 中的强类型集合
    • C# 三 中活动落成的习性
    • C# 四 中的命名实参
  • 排序和过滤
    • 按名称对成品实行排序
    • 查询集合

目录

  • 从简单的数据类型开头
    • C# 第11中学定义的产品种类
    • C# 第22中学的强类型集合
    • C# 三中自动完成的性质
    • C# 4中的命名实参
  • 排序和过滤
    • 按名称对成品实行排序
    • 查询集合

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

C#一.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  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     }

金沙注册送58 1金沙注册送58 2

product类

缺点:

  1. ArrayList没有提供内部关于编写翻译时的消息。大家很有极大可能在GetSampleProducts方法中添加三个字符串到ArrayList中,因为ArrayList的Add方法中的参数是object,而编辑器并从未别的影响。
  2. 代码中提供了质量的取值方法,假如加上对应的赋值方法,那么赋值方法也务必是国有的方式。
  3. 创建属性的代码过于复杂。

缺点:

  1. ArrayList未有提供内部有关编写翻译时的新闻。大家很有非常的大可能率在GetSampleProducts方法中添加三个字符串到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     }

金沙注册送58 3金沙注册送58 4

C#二 中的强类型集合

因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#二 中的强类型集合

因C#第11中学一向不泛型,Product类中的静态方法Get萨姆pleProducts,重临的是ArrayList类型,里面添加的要素只可以是Product,而在C#2中的改变正是泛型。(新的剧情用蓝色列出)

 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,试图将二个见仁见智的花色丰盛到列表中,会导致编写翻译时不当。并且在行使List<Product>时不须求转移结果的数据类型。

针对C#1中的存在的局限性,C#2缓解了原本存在的前七个难点。

优点:

  1. 质量有了个体赋值方法,且能够在构造函数中动用那些赋值方法。
  2. 金沙注册送58,List<Product>告知编辑器里面只好分包Product,试图将3个分歧的品种丰裕到列表中,会导致编译时不当。并且在行使List<Product>时不要求更换结果的数据类型。

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

C#第22中学的强类型集合和民用的赋值方法

View Code

C#3 中机动完结的习性

相对C#2而言,C#叁引入了机关属性和聚众初阶化器。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#叁引入了活动属性和集合伊始化器。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     }

金沙注册送58 5金沙注册送58 6

ArrayListSort类

优点:

  1. 不曾剩余的变量与质量相关联,因为类中尚无了name和price变量,在类中运用性质名称是一模一样的。增强了代码的壹致性。
  2. 开创的数目列表的艺术也完全不相同。
  3. 有一个私有的无参构造函数,用于新的依据属性的初阶化。

 优点:

  1. 从不剩余的变量与品质相关联,因为类中从未了name和price变量,在类中使用性质名称是壹模1样的。增强了代码的一致性。
  2. 始建的数量列表的不二等秘书籍也完全不一致。
  3. 有3个私家的无参构造函数,用于新的根据属性的开头化。
 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     }

金沙注册送58 7金沙注册送58 8

C# 4 中的命名实参

在C#四中引进了命名实参,所谓命名实参是指命名参数调用实参顺序能够和形参差异。

 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     }

金沙注册送58 9

C# 肆 中的命名实参

 在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     }

金沙注册送58 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类中的静态方法Get萨姆pleProducts,重返的是ArrayList类型,大家供给采取ArrayList.Sort,须求提供1个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         }

按名称对产品举办排序

列表排序最简便的不2秘诀便是先将列表排好序,然后遍历并呈现当中的项。在上述代码C#
1中,Product类中的静态方法GetSampleProducts,再次来到的是ArrayList类型,大家供给接纳 ArrayList.Sort,须求提供1个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包涵3个字符串货别的种类,那么代码会出错——因为在可比时会将字符串强制转型为
    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#第22中学引进泛型了能够协理大家缓解上述难点。

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         }

金沙注册送58 11金沙注册送58 12

提供二个IComparer实现,比较器。或许Product类完成IComparable。

优点:

  1. 千帆竞发提供的便是Product(而十分小概是其余体系),在Compare方法中不必要开始展览强制类型转换。
  2. foreach也不用隐式的类型转换。

假定大家不期望引进额外的系列来帮助排序,而是径直对列表排序。C#二选取委托来排序。代码如下:

 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#三使用扩大方法开始展览排序。

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         }

金沙注册送58 13

 优点:

  1. 开班提供的正是Product(而不容许是其余门类),在Compare方法中不须要开展强制类型转换。
  2. foreach也不用隐式的类型转换。

要是大家不愿意引进额外的类别来扶助排序,而是径直对列表排序。C#二施用委托来排序。代码如下:

 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#三能够将匿名方式替换来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         }

 金沙注册送58 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(相比较器接口和可正如的接口)

询问集合

找寻集合中符合条件的富有因素,是1件很简单的工作,大家来一头来看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#二此外贰个版本代码:

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         }

金沙注册送58 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#二此外叁个版本代码:

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         }

金沙注册送58 16

这篇就写到那里。下篇我们将继续深造《深刻精通C#》的连带文化。

View Code

缺陷:Compare方法中显得强制类型转换,而ArrayList是项目不安全的,转换为对象Product时恐怕报错。foreach循环中隐式的编写翻译器自动类型转换,转换为Product类型执行时或然报错。

C#四中命名实参

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

金沙注册送58 17金沙注册送58 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     }

金沙注册送58 19金沙注册送58 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进行排序

金沙注册送58 21金沙注册送58 22

金沙注册送58 23金沙注册送58 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

View Code

接纳Comparison<Product>对List<Product>进行排序(C#贰),不需求贯彻ProductNameComparer相比较器类型,只是创设三个委托实例(C#二.0
匿名情势)。

C#2中运用IComparer<product>对List<Product>实行排序

金沙注册送58 25金沙注册送58 26

金沙注册送58 27金沙注册送58 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#三.0 拉姆da表明式
在拉姆da表达式中使用Comparison<Product>举办排序(C#3)

C#第22中学选择委托开始展览比较

product类

金沙注册送58 29金沙注册送58 30

金沙注册送58 31金沙注册送58 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#三中行使lambda表明式实行比较

ListSortWithLambdaExpression类

金沙注册送58 33金沙注册送58 34

金沙注册送58 35金沙注册送58 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)

金沙注册送58 37金沙注册送58 38

金沙注册送58 39金沙注册送58 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#一,弱类型的可比效益不援助委托排序。

金沙注册送58 41金沙注册送58 42

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

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#三拉姆da表达式,扩大方法,允许列表保持未排序状态。

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地图