澳门至尊网站-首页

您的位置:澳门至尊网站 > 免费资源 > 言语各类版本性格,数据类型

言语各类版本性格,数据类型

2019-10-22 21:15

二、排序Product

引言

在开班看那本书此前看过一些本领博客,填补自身对此部分知识点的欠缺。无意中发觉了《深切精通C#》那本书,本书主要斟酌C# 2、C# 3和C# 4的细节与本性,所以做了一下读书笔记,应接拍砖。

1.按名称对成品实行排序,以一定顺序呈现贰个列表的最简易方法便是先将列表排序,再遍历并展现中间的项。

目录

  • 从轻便的数据类型开头
    • C# 1 中定义的成品品类
    • C# 2 中的强类型集结
    • C# 3 中活动完成的性能
    • C# 4 中的命名实参
  • 排序和过滤
    • 按名称对产品进行排序
    • 询问集结

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     }

product类

缺点:

  1. ArrayList未有提供内部有关编写翻译时的消息。大家很有相当的大恐怕在GetSampleProducts方法中增加一个字符串到ArrayList中,因为ArrayList的Add方法中的参数是object,而编辑器并未任何反馈。
  2. 代码中提供了质量的取值方法,假诺加上对应的赋值方法,那么赋值方法也亟须是集体的秘籍。
  3. 成立属性的代码过于复杂。

图片 1图片 2

C#2 中的强类型集合

因C#1中尚无泛型,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     }
 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#第11中学的存在的局限性,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     }

ArrayListSort类

优点:

  1. 从未有过剩余的变量与品质相关联,因为类中绝非了name和price变量,在类中动用质量名称是均等的。加强了代码的生气勃勃致性。
  2. 创办的数额列表的方法也统统区别。
  3. 有三个民用的无参构造函数,用于新的依据属性的开端化。

图片 3图片 4

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     }

图片 5

 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,须求提供多个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         }

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         }

提供叁个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         }

图片 6

区别: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         }

图片 7

那篇就写到这里。下篇大家将承继学习《浓郁领悟C#》的相干文化。

劣势:Compare方法中显得强制类型转变,而ArrayList是项目不安全的,调换为对象Product时或然报错。foreach循环中隐式的编写翻译器自动类型调换,调换为Product类型推行时可能报错。

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

product类

图片 8图片 9

 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

ListSortWithComparer类

图片 10图片 11

 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 }

View Code

应用Comparison<Product>对List<Product>举行排序(C#2),没有须求贯彻ProductNameComparer比较器类型,只是创制一个信托实例(C#2.0 匿有名的模特式)。

图片 12图片 13

 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 }

View Code

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

product类

图片 14图片 15

 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

ListSortWithLambdaExpression类

图片 16图片 17

 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

ListOrderWithExtensionMethod类 使用扩充方法对List<Product>进行排序

图片 18图片 19

 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 }

View Code

总结:

→C#1,弱类型的可比效果与利益不协理委托排序。

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

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

本文由澳门至尊网站发布于免费资源,转载请注明出处:言语各类版本性格,数据类型

关键词:

  • 上一篇:没有了
  • 下一篇:构成