学习《深入理解C#》—— 数据类型、排序和过滤 (第一章1.1---1.2)

引言

在开始看这本书之前看过一些技术博客，填补自己对于一些知识点的不足。无意中发现了《深入理解C#》这本书，本书主要探讨C# 2、C# 3和C# 4的细节与特性，所以做了一下阅读笔记，欢迎拍砖。

目录

• 从简单的数据类型开始
  • C# 1 中定义的产品类型
  • C# 2 中的强类型集合
  • C# 3 中自动实现的属性
  • C# 4 中的命名实参
• 排序和过滤
  • 按名称对产品进行排序
  • 查询集合

C#1 中定义的产品类型

 public class Product
    {
        string name;
        public string Name
        {
            get { return name; }
        }
        decimal price;
        public decimal Price
        {
            get { return price; }
        }
        public Product(string name, decimal price)
        {
            this.name = name;
            this.price = price;
        }
        public static ArrayList GetSampleProducts()
        {
            ArrayList list = new ArrayList();
            list.Add(new Product("硬装芙蓉王", 25m));
            list.Add(new Product("精白沙", 9m));
            list.Add(new Product("软白沙", 5.5m));
            return list;
        }
        public override string ToString()
        {
            return string.Format("{0}:{1}", name, price);
        }
    }

缺点：

1. ArrayList没有提供内部有关编译时的信息。我们很有可能在GetSampleProducts方法中添加一个字符串到ArrayList中，因为ArrayList的Add方法中的参数是object，而编辑器并没有任何反应。
2. 代码中提供了属性的取值方法，如果添加对应的赋值方法，那么赋值方法也必须是公共的方法。
3. 创建属性的代码过于复杂。

C#2 中的强类型集合

因C#1中没有泛型，Product类中的静态方法GetSampleProducts，返回的是ArrayList类型，里面添加的元素只能是Product，而在C#2中的改变就是泛型。（新的内容用红色列出）

public class Product
    {
        string name;
        public string Name
        {
            get { return name; }
            private set { name = value; }
        }
        decimal price;
        public decimal Price
        {
            get { return price; }
            private set { price = value; }
        }
        public Product(string name, decimal price)
        {
            Name = name;
20             Price = price;
        }
        public static List<Product> GetSampleProducts()
        {
            List<Product> list = new List<Product>();
            list.Add(new Product("硬装芙蓉王", 25m));
            list.Add(new Product("精白沙", 9m));
            list.Add(new Product("软白沙", 5.5m));
            return list;
        }
        public override string ToString()
        {
            return string.Format("{0}:{1}", name, price);
        }
    }

优点：

1. 属性有了私有赋值方法，且可以在构造函数中使用这个赋值方法。
2. List<Product>告知编辑器里面只能包含Product，试图将一个不同的类型添加到列表中，会造成编译时错误。并且在使用List<Product>时不需要转换结果的数据类型。

 针对C#1中的存在的局限性，C#2解决了原先存在的前两个问题。

C#3 中自动实现的属性

相对C#2而言，C#3引入了自动属性和集合初始化器。Product中的属性Name和Price，可以通过自动属性简化代码，而编译器最终生成的代码是一致的。

public class Product
    {
        public string Name{ get; private set; }
 5         public decimal Price { get; private set; }
        Product() { }
        public Product(string name, decimal price)
        {
            Name = name;
            Price = price;
        }
        public static List<Product> GetSampleProducts()
        {
            return new List<Product>
17             {
18                 new Product("硬装芙蓉王", 25m),
19                 new Product("精白沙", 9m),
20                 new Product("软白沙", 5.5m)
21             };
        }
        public override string ToString()
        {
            return string.Format("{0}:{1}", Name, Price);
        }
    }

 优点：

1. 没有多余的变量与属性相关联，因为类中没有了name和price变量，在类中使用属性名称是相同的。增强了代码的一致性。
2. 创建的数据列表的方式也截然不同。
3. 有一个私有的无参构造函数，用于新的基于属性的初始化。

C# 4 中的命名实参

 在C#4中引入了命名实参，所谓命名实参是指命名参数调用实参顺序可以和形参不同。

public class Product
    {
        readonly string name;
        public string Name
        {
            get { return name; }
        }
        readonly decimal price;
        public decimal Price
        {
            get { return price; }
        }
        public Product(string name, decimal price)
        {
            this.name = name;
            this.price = price;
        }
        public static List<Product> GetSampleProducts()
        {
            List<Product> list = new List<Product>();
            list.Add(new Product(name: "硬装芙蓉王", price: 25m));
24             list.Add(new Product(name: "精白沙", price: 9m));
25             list.Add(new Product(name: "软白沙", price: 5.5m));
            return list;
        }
        public override string ToString()
        {
            return string.Format("{0}:{1}", name, price);
        }
    }

按名称对产品进行排序

列表排序最简单的方式就是先将列表排好序，然后遍历并显示其中的项。在上述代码C# 1中，Product类中的静态方法GetSampleProducts，返回的是ArrayList类型，我们要求使用 ArrayList.Sort，要求提供一个IComparer实现。实现代码如下：

 public class ProductNameComparer : IComparer
    {
        public int Compare(object x, object y)
        {
            Product i = (Product)x;
            Product j = (Product)y;
            return i.Name.CompareTo(j.Name);
        }
    }

 static void Main(string[] args)
        {
            ArrayList arraylist = Product.GetSampleProducts();
            arraylist.Sort(new ProductNameComparer());
            foreach(Product pr in arraylist)
            {
                Console.WriteLine(pr.Name);
            }
            Console.Read();
        }

 缺点：

1. 必须引入额外的类型来帮助排序。
2. Compare 方法中的强制类型转换。
3. 假如ArrayList包含一个字符串货其他类型，那么代码会出错——因为在比较时会将字符串强制转型为 Product 。 
4. foreach 循环会隐式将列表中的每个元素转换为 Product 类型，如果其中包含字符串或其他类型，同样会报错。

然后在C#2中引入泛型了可以帮助我们解决上述问题。

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

 static void Main(string[] args)
        {
            List<Product> arraylist = Product.GetSampleProducts();
            arraylist.Sort(new ProductNameComparer());
            foreach(Product pr in arraylist)
            {
                Console.WriteLine(pr.Name);
            }
            Console.Read();
        }

 优点：

1. 开始提供的就是 Product（而不可能是其他类型），在Compare方法中不需要进行强制类型转换。
2. foreach也不用隐式的类型转换。

如果我们不希望引入额外的类型来帮助排序，而是直接对列表排序。C#2使用委托来排序。代码如下：

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

C#3 可以将匿名方法替换成Lambda表达式的方式进行排序。 

static void Main(string[] args)
        {
            List<Product> arraylist = Product.GetSampleProducts();
            arraylist.Sort((x, y) => x.Name.CompareTo(y.Name));
            foreach (Product pr in arraylist)
            {
                Console.WriteLine(pr.Name);
            }
            Console.Read();
        }

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

static void Main(string[] args)
        {
            List<Product> arraylist = Product.GetSampleProducts();
            foreach (Product pr in arraylist.OrderBy(p => p.Name))
            {
                Console.WriteLine(pr.Name);
            }
            Console.Read();
        }

 

查询集合

查找集合中符合条件的所有元素，是一件很简单的事情，我们来一起来看C#1、C#2、C#之间查询集合的不同。

现要求查找价格大于20的产品信息。

C#1代码：

static void Main(string[] args)
        {
            ArrayList arraylist = Product.GetSampleProducts();
            foreach (Product pr in arraylist)
            {
                if (pr.Price > 20)
                {
                    Console.WriteLine(pr);
                }
            }
            Console.Read();
        }

 C#2代码：

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

 C#2另外一个版本代码：

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

 C#3代码：

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

static void Main(string[] args)
        {
            List<Product> list = Product.GetSampleProducts();
            foreach (Product pro in list.Where(p => p.Price > 20))
            {
                Console.WriteLine(pro);
            }
            Console.Read();
        }

这篇就写到这里。下篇我们将继续学习《深入理解C#》的相关知识。