[读书笔记]C#学习笔记五: C#3.0自动属性,匿名属性及扩展方法

[读书笔记]C#学习笔记五: C#3.0自动属性,匿名属性及扩展方法

前言

这一章算是看这本书最大的收获了, Lambda表达式让人用着屡试不爽, C#3.0可谓颠覆了咱们的代码编写风格. 由于Lambda所需篇幅挺大, 因此先总结C#3.0智能编译器给咱们带来的诸多好处, 下一遍会单独介绍Lambda表达式. 这篇主要包括的内容有: 自动属性,隐式类型,对象集合初始化,匿名类型,扩展方法.

下面一块儿来看下C#3.0 所带来的变化吧.

1,自动实现的属性
在C#3.0以前, 定义属性时通常会像下面这样去编写代码:

 1 class Person 2 { 3     //定义私有字段 4     private string name; 5  6     //定义可读写属性 7     public string Name 8     { 9         get{return name;}10         set{name = value;}11     }12 13     private int age;14     //定义只读属性15     public int Age16     {17         get{return age;}18     }19 }

 

PS: 这里有一个快捷键: private string name; 选中name 而后Ctrl + R + E 就能够快捷生成Name属性.

C#3.0以后, 对于不须要额外验证的属性(须要额外验证的属性仍是必须采用以前的方式来定义), 咱们可使用自动实现的特性来对属性的定义进行简化, 此时再也不需额外定义一个私有字段了.代码以下:

1 class Person2 {3     //使用自动实现的属性来定义属性4     //定义可读写属性5     public string Name{get; set;}6     //定义只读属性7     public int Age{get; private set;}8 }

PS: 这里也有一个快捷键: 打出prop 而后点击两下Tab键就能够生成上面的属性了, 不过还需手动改值.
相似的快捷键有: 输入cw 而后点击两下Tab键 就能够直接生成Console.WriteLine();了. 相似的还有不少, 在这里就不列举了.

之因此能够这样定义属性, 主要是由于编译器在编译时会为咱们建立一个私有字段. 利用反编译工具能够知道使用自动实现的属性时,C#都会帮咱们建立必要的字段.
另外在结构体中使用自动属性时, 须要注意的是全部构造函数都须要显式地调用无参构造函数this, 不然会出现编译错误. 由于只有这样,编译器才能知道全部的字段都已经被赋值.
然而, 类却不须要显式地调用无参构造函数, 这主要是由C#编译器的设计决定, 咱们记住就行了.

 1 public struct TestPerson 2 { 3     public string Name { get; set; } 4     public int Age { get; private set; } 5  6     //结构体中, 不显式地调用无参构造函数this()时, 会出现编译时错误 7     public TestPerson(string name) 8     : this() 9     {10         this.Name = name;11     }12 }

 

2,隐式类型 var关键字
C#是强类型语言, 在定义一个变量时, 须要声明变量的类型. 然而类型的长度过长,就可能影响代码的可读写性. 为了不这样的问题, C#3.0 引入了隐式类型,便可以使用关键字var来声明变量或数组.
var关键字告诉编译器去根据变量的值来推断其类型.

1 class Program2 {3     static void Main(stirng[] args)4     {5         //用var声明局部变量6         var stringValue = "Barry Wang";7         stringValue = 2;8     }9 }

 

这里就会报错"没法将类型int 隐式转换为string". 调试会发现stringValue是string类型的.
使用隐式类型有一些限制, 包括如下几点:
(1)被声明的变量是一个局部变量, 不能为字段
(2)变量在声明时必须被初始化, 由于编译器要根据变量的赋值来推断类型
(3)变量不能初始化为一个方法组, 也不能为一个匿名函数

 

3,对象集合初始化
在C#3.0以前定义类, 咱们每每须要定义多个构造函数来完成不一样状况下的初始化, C#3.0 提供了对象初始化器, 它减小了咱们在类中定义的构造函数代码, 从而使代码更加简洁.

 1 class Program 2 { 3     static void Main(string[] args) 4     { 
 5         //没有对象初始化器时的代码 6         Person p = new Person("BarryWang", 25); 7         p.Weight = 60; 8         p.Height = 170; 9     }10 }11 12 public class Person13 {14     public string Name { get; set; }15     public int Age { get; set; }16     public int Weight { get; set; }17     public int Height { get; set; }18 19     //定义不一样状况下的初始化函数20     public Person() { }21     public Person(string name) { } 
22     public Person(string name, int age) { }23     public Person(string name, int age, int weight) { }24     public Person(string name, int age, int weight, int height) 
25     {26         this.Name = name;27         this.Age = age;28         this.Weight = weight;29         this.Height = height;30     }31 }

 

在C#3.0引入对象初始化以后, 咱们就不须要定义多个构造函数了, 前面的代码能够简化为以下的形式:

 1 class Program 2 { 3     static void Main(string[] args) 4     { 5         //使用对象初始化器初始化 6         Person p = new Person() {Name = "Barry Wang", Age = 25, Weght = 60, Height = 70}; 7         //下面这行代码和上面一行是等价的, 只不过下面省略了构造函数的圆括号而已 8         Person p2 = new Person {Name = "Barry Wang", Age = 25, Weght = 60, Height = 70}; 9     }10 }11 12 public class Person13 {14     public string Name { get; set; }15     public int Age { get; set; }16     public int Weight { get; set; }17     public int Height { get; set; }18 }

 

利用反编译工具能够知道编译器为对象作了以下处理: 首先C#编译器生成了一个Person类的临时对象, 并调用Person类的默认无参构造函数对其初始化.而后对它的属性逐个赋值.
由此能够想到,要使用对象初始化器,则必须保证类中具备一个无参构造函数. 若是咱们自定义了一个有参构造函数而把默认的无参构造函数覆盖了, 则须要从新定义一个无参构造函数.

再例如 给List 中添加元素, 在C#3.0 以前咱们须要一个个Add 添加, 而如今直接能够利用集合初始化器便可, 编译器会调用Add方法, 一个个地将初始化的内容添加进去.

1 class Program2 {3     List<string> newNames = new List<string>4     {5         "A", "B", "C"6     };7 }

4,匿名类型
匿名类型顾名思义就是没有知名类型的类型, 经过隐式类型和对象初始化器两种特性建立了一个类型未知的对象, 使咱们在不定义类型的状况下能够实现对象的建立,从而减小了类定义过程的代码.

 1 class Program 2 { 3     static void Main(string[] args) 4     { 
 5         //定义匿名类型对象 6         var person = new {Name = "Barry Wang", Age = 25 }; 7         Console.WriteLine("{0} 的年龄为: {1}", person.Name, person.Age); 8  9         //定义匿名类型数组10         var personCollection = new[]11         {12             new {Name = "Barry", Age = 30},13             new {Name = "Brad", Age = 22},14             new {Name = "Tony", Age = 25}15         };16 17         int totalAge = 0;18         foreach (var p in personCollection)19         {20             //下面一行代码证实了Age属性时int类型21             totalAge += p.Age;22         }23 24         Console.WriteLine("全部人的年龄总和为: {0}", totalAge);25         Console.ReadKey();26     }27 }

 

 

5,扩展方法
扩展方法, 首先是一个方法, 他能够用来扩展已定义类型中的方法成员.
以下例所示:

 1 public static class Extensions 2 { 3     //对string 类扩展，注意this关键字 4     public static void TestStr(this string s) 5     { 6         Console.WriteLine(s.ToString()); 7     } 8     //对int 类扩展 9     public static void TestInt(this int i, string s)10     {11         Console.WriteLine(s + i.ToString());12     }13 }14 class Program15 {16     static void Main(string[] args)17     {18         //使用扩展方法19         string s = "Test Extensions Methods";20         s.TestStr();//调用方法121         Extensions.TestStr(s);//调用方法222         int i = 100;23         i.TestInt("This value is ");24         Extensions.TestInt(i, "This value is ");25         Console.ReadKey();26     }27 }

 

并非全部的方法均可以用做扩展方法, 咱们须要考察它是否符合下列扩展方法的定义规则:
(1)扩展方法必须在一个非嵌套, 非泛型的静态类中定义
(2)它至少要有一个参数
(3)第一个参数必须加上this关键字做为前缀(第一个参数类型也称为扩展类型, 即指方法对这个类型进行扩展)
(4)第一个参数不能使用任何其余修饰符(如不能使用ref out等)

 1 namespace CurrentNameSpace 2 { 3     //要想使用不用命名空间下的扩展方法, 须要先引入该命名空间 4     using CustomNameSpace; 5     class Program 6     { 7         static void Main(string[] args) 8         { 9             Person p = new Person {Name = "BarryWang"};10             p.Print();//等价于==>ExtensionClass.Print(p);11             p.Print("Hello");12             Console.ReadKey();13         }14     }15 16     //自定义类型17     public class Person18     {19         public string Name { get; set; }20     }21 22     //当前命名空间下的扩展方法定义23     public static class ExtensionClass24     {25         public static void Print(this Person p)26         {27             Console.WriteLine("调用的是当前命名空间下的扩展方法输出, 姓名为: {0}", p.Name);28         }29     }30 }31 32 namespace CustomNameSpace33 {34     using CurrentNameSpace;35     public static class CustomExtensionClass36     {37         //扩展方法定义38         public static void Pint(this Person p)39         {40             Console.WriteLine("调用的是CustomNameSpace命名空间下扩展方法输出: 姓名为: {0}", p.Name);41         }42 43         //扩展方法定义44         public static void Pint(this Person p, string s)45         {46             Console.WriteLine("调用的是CustomNameSpace命名空间下扩展方法输出: 姓名为: {0},附加字符串为{1}", p.Name, s);47         }48     }49 }

 

打印结果是:
调用的是当前命名空间下的扩展方法输出, 姓名为: Barry Wang
调用的是CustomNameSpace命名空间下扩展方法输出, 姓名为: Barry Wang, 附加字符串为Hello

注解: 你们看到p.Print(); 是否有些疑惑呢? 对于C#3.0编译器而言, 当它看到某个类型的变量在调用方法时, 它会首先去该对象的实例方法进行chazhao,若是没有找到与调用方法同名并参数一致的实例方法,
编译器就回去查找是否存在合适的扩展方法. 编译器会检查全部导入的命名空间和当前命名空间中的扩展方法, 并将变量类型匹配到扩展类型.
从编译器发现扩展方法的过程来看, 方法调用的优先级别顺序为: 类型的实例方法-->当前命名空间下的扩展方法-->导入命名空间的扩展方法.

解释上面代码打印结果的由来: 在以上代码中存在另个不一样的命名空间, 它们都定义了带一个参数的扩展方法Print. 根据执行顺序, 编译器会首先查看Person类型中是否认义了无参的Print实例方法.
若是有, 则中止查找; 不然继续查找当前命名空间下, 即CurrentNameSpace下是否认义了一个带参数的扩展方法Print.
此时在CurrentNameSpace命名空间下, 正好存在带一个扩展类型参数的Print扩展方法, 编译器所以不会再继续查找其余引入命名空间了. 因此p.Print() 调用的是当前命名空间下的Print扩展方法.
而p.Print("Hello")的调用也是一个道理.

 

PS: 终于把今天的两篇博文更新完了, 这么冷的天 真是不容易, 记录到这里但愿本身之后有时间还会再看看吧!  

分类: C#基础系列, 读书笔记

好文要顶 关注我 收藏该文  

一枝花算不算浪漫