C#学习笔记(十一)

第11讲属性1

  现在来讲一下C#中的属性。
  属性是类，结构和接口的命名成员。它们提供了通过访问器(accessor)读，写或计算私有字段值的灵活机制。
  属性是这样的成员：它们提供灵活的机制来读取，编写或计算私有字段的值。可以像使用公共数据成员一样使用属性，但实际上它们是称为“访问器”的特殊方法。这使得数据在可被轻松访问的同时，仍能提供方法的安全性和灵活性。
  下面我们用代码一步一步来说明为什么要使用属性。

1. using System;
3. //打个比方我们有个网站，每当有新用户注册的时候，我们需要记录这些用户的信息
5. //声明一个User类来记录这些用户的信息
6. class User
7. {
8.     //姓名，性别
9.     public string name;
10.     public string sex;
11. }
12. //声明一个类去使用User类
13. class Property
14. {
15.     static void Main()
16.     {
17.         //实例化一个张三User对象
18.         User zs = new User();
19.         //对其赋值
20.         zs.name = "张三";
21.         zs.sex = "男";
22.         Console.WriteLine("姓名：" + zs.name + " 性别：" + zs.sex);
23.     }
24. }

  通过编译执行，屏幕上正常输出了预想的结果。大家自己动手运行下程序。这个程序乍看一下感觉没有什么问题，但是呢我们稍做一些修改，比如把zs.sex = "男";改成zs.sex = "牛";。运行代码结果肯定张三的性别成牛了...这个时候就不合逻辑了。现在大家可以明显的感觉到User类的封装非常不合理，存在着非常大的缺陷，那么该如何修改呢？这个时候大家马上会想到是不是可以专门声明一个方法给性别赋值呢，好！我们就来实现这个方法。

1. using System;
2. class User
3. {
4.     public string name;
5.     public string sex;
6. 
   
7.     //SetSex方法
8.     public void SetSex(string values)
9.     {
10.         if (values == "男" || values == "女")
11.         {
12.             sex = values;
13.         }
14.         else
15.         {
16.             Console.WriteLine("性别只能为“男”或“女”");
17.         }
18.     }
19. }
20. class Property
21. {
22.     static void Main()
23.     {
24.         User zs = new User();
25.         zs.name = "张三";
26.         //直接调用SetSex赋值
27.         zs.SetSex("牛");
28.         Console.WriteLine("姓名：" + zs.name + " 性别：" + zs.sex);
29.     }
30. }

  SetSex这个方法乍一看还可以，但是不要忘记name和sex字段还是public属性，我们依然可以直接去调用它，或者说去修改它，一样可以把sex设为“牛”。给类的字段设置为public意味着破坏了类的封装，这样呢会存在潜在的危险。所以呢要设为private，这个时候就分别声明方法去读取和设置这2个字段，修改如下：

1. using System;
2. class User
3. {
4.     //设为私有的
5.     private string name;
6.     private string sex;
7. 
   
8.     //设置
9.     public void SetName(string values)
10.     {
11.         name = values;
12.     }
13.     //读取
14.     public string GetName()
15.     {
16.         return name;
17.     }
18.     public void SetSex(string values)
19.     {
20.         if (values == "男" || values == "女")
21.         {
22.             sex = values;
23.         }
24.         else
25.         {
26.             Console.WriteLine("性别只能为“男”或“女”");
27.         }
28.     }
29.     public string GetSex()
30.     {
31.         return sex;
32.     }
33. }
34. class Property
35. {
36.     static void Main()
37.     {
38.         User zs = new User();
39.         zs.SetName("张三");
40.         zs.SetSex("牛");
41.         Console.WriteLine("姓名：" + zs.GetName() + " 性别：" + zs.GetSex());
42.     }
43. }

  大家执行编译下看下效果是没有问题的。现在这个类的设计就比较合理了，我们看name和sex它们是private字段，也就是说在类的外部是不能访问的，这样呢就保证了它的安全性。当用户想给性别字段添加非法字段的时候，SetSex方法内会对这个添加的值进行判断，如果不为男或女，值就不会被添加。
  这是大家可能会问了，讲了这么久为什么没有提到属性半个字呢？好，现在属性可以粉墨登场了～由于属性的存在，简化了SetSex跟Getsex，也就是读取和设置私有字段值的这么一个方法。好，我们再次修改代码，使用属性：

1. using System;
2. class User
3. {
4.     //设为私有的
5.     private string name;
6.     private string sex;
7. 
   
8.     public void SetName(string values)
9.     {
10.         name = values;
11.     }
12.     public string GetName()
13.     {
14.         return name;
15.     }
16.     public void SetSex(string values)
17.     {
18.         if (values == "男" || values == "女")
19.         {
20.             sex = values;
21.         }
22.         else
23.         {
24.             Console.WriteLine("性别只能为“男”或“女”");
25.         }
26.     }
27.     public string GetSex()
28.     {
29.         return sex;
30.     }
31. 
    
32.     //设置属性Name
33.     public string Name
34.     {
35.         //在属性Name里面声明了2个方法一个是get一个是set
36.         //这2个方法没有任何的修饰符，而这2个方法实现的功能跟SetName和GetName完全一样
37.         get
38.         {
39.             return name;
40.         }
41.         set
42.         {
43.             //大家注意这个value，它是一个隐含的参数
44.             //也就是说IL代码会自动帮你生成一个value这么一个参数，我们可以直接调用它
45.             //value就先当于SetName里面的values参数
46.             //value的类型是跟私有字段name的类型是一致的
47.             name = value;
48.         }
49.     }
50.     //设置一个属性Sex
51.     public string Sex
52.     {
53.         get
54.         {
55.             return sex;
56.         }
57.         set
58.         {
59.             if (value == "男" || value == "女")
60.             {
61.                 sex = value;
62.             }
63.             else
64.             {
65.                 Console.WriteLine("性别只能为“男”或“女”");
66.             }
67.         }
68.     }
69. }
70. class Property
71. {
72.     static void Main()
73.     {
74.         User zs = new User();
75.         zs.SetName("张三");
76.         zs.SetSex("男");
77.         Console.WriteLine("姓名：" + zs.GetName() + " 性别：" + zs.GetSex());
78.         //调用属性
79.         zs.Name = "李四";
80.         zs.Sex = "牛";
81.         Console.WriteLine("姓名：" + zs.Name + " 性别：" + zs.Sex);
82.     }
83. }

  执行代码，效果如下：

  屏幕上正常输出了结果。李四使用的是属性，并且对性别同样能进行判断。也就是说属性实现了同方法一样的功能，它简化了SetSex和GetSex的调用，我们看下属性的调用是和字段的调用一样的，直接用=进行赋值。  
  我们再仔细看下私有字段的命名和属性的命名只是大写小不同而已，这样的命名在C#中没有什么问题。但是如果你的工程中含有VB.NET代码，而那些代码要访问这个类，这样呢就会出现一些问题，因为VB.NET代码是大小写不敏感的，所以最好给私有字段改下名字，比如m_name，这样就更合乎规范了～