1.    问题

c#教程原始的封装是麻烦的
struct Time
{
    ...
    public int GetHour()
    {
        return hour;
    }
    public void SetHour(int value)
    {
        hour = value;
    }
    ...
    private int hour, minute, second;
}
static void Main()
{
    Time lunch = new Time();
    lunch.SetHour(12);
    Console.WriteLine(lunch.GetHour());
}
封装把一些不重要的细节隐藏起来，这样你可以集中精力处理那些重要的内容。但封装很难被掌握，一个典型的封装误用是盲目地把公有字段转为私有字段。例如在上面的例子中，程序定义了一个私有字段hour和SetHour函数和GetHour函数，而不是定义一个公有的hour字段。如果GetHour函数只是返回私有字段的值而SetHour函数只是设置私有字段的值的话，那么你除了使Time类更难使用外，你不会得到任何好处。
2.    c#教程不是解决的办法
       如果字段是公有的，那使用起来是简单的
       但如果你使用公有字段的话，你会失去控制权
       要简化而不是简单
struct Time
{
    ...
    public int Hour;
    public int Minute;
    public int Second;
}
static void Main()
{
    Time lunch = new Time();
    lunch.Hour = 30;
    lunch.Minute = 12;
    lunch.Second = 0;
    ...
}
上面的例子使用公有字段来使字段的使用比较简单。例如，你不用写：
              lunch.SetHour(lunch.GetHour() + 1);
而只要写：
              ++lunch.Hour;
但是，这种简单的表达式是有代价的。考虑上面的例子，程序给Hour和Minute字段分别赋值为30和12。问题是30不在Hour的范围（0-23）内。但如果字段是公有的话，你就没有办法捕获这个错误。
所以虽然get和set函数比较麻烦，但它们在这方面比公有字段具有优势是很明显的。get和set函数允许程序员控制类的内在字段的读和写。这是非常有用的，例如你可以检查set函数的参数范围。
当然最理想的方法是保留公有字段提供的简单而直接的表达式和get和set函数提供的控制权。（呵呵，人总是既想偷懒又想得到很多）
3.    c#教程解决的办法
       属性
       自动使用get 标识符进行读
       自动使用set 标识符进行写
struct Time
{
    ...
    public int Hour //没有（），是H而不是h
    {  
        get { ... }
        set { ... }
    }
    private int hour, minute, second;
}
Time lunch = new Time();
...
lunch.Hour = 12;
...
Console.WriteLine(lunch.Hour);
C#提供了一个解决上述问题的好办法。你可以把get和set函数组合成一个简单的属性。属性的声明包括一个可选的访问修饰符(在例子中是public)、返回值(int)、属性的名字(Hour)和一个包含get和set语句的属性体。特别要注意的是属性没有括号，因为属性不是函数。属性的命名规则应符合一般的命名规则，即公有的使用PascalCase规则，而非公有的使用camelCase规则。在上面的例子中，Hour属性是公有的，所以命名为Hour而不是hour。
例子中演示了属性的用法。属性使用的语法和字段的一样，没有括号。如果你要写一个属性，那你可以这样写：
              lunch.Hour = 12;
属性的set语句自动被执行。
如果你要读一个属性，你可以这样写：
              int hour = lunch.Hour;
属性的get语句自动被执行。
4.    get语句
      get 语句
       必须返回一个有确定类型的值
       功能上就像一个 “get 函数”
struct Time
{
    ...
    public int Hour
    {  
        get
        {
            return hour;
        }
        ...
    }
    private int hour, minute, second;
}
Time lunch = new Time();
... Console.WriteLine(lunch.Hour);
//请注意，get和set不是关键字
当读一个属性的时候，属性的get语句自动运行。
get语句必须返回一个有确定类型的值。在上面的例子中，Time结构类有一个整型属性Hour，所以它的get语句必须返回一个整型值。
属性的返回值不能是void（从这里可以推断出字段的类型也不能是void）。这就意味着get语句必须包含一个完整的return语句（retun;这种形式是错误的）。
get语句可以在retun语句前包含任何其他的语句（比如，可以检查变量的类型）,但return语句不能省略。
注意，get和set不是关键字，所以你可以在任何地方包括get/set语句中声明一个局部变量、常量的名字是get或set，但最好不要这样做。
5.    set语句
        set 语句
       是通过value 标识符来进行赋值的
       可以包含任何语句（甚至没有语句）
struct Time
{
    ...
    public int Hour
    {  
        ...
        set {
            if (value < 0 || value > 24)
                throw new ArgumentException("value");
            hour = value;
        }
    }
    private int hour, minute, second;
}
Time lunch = new Time();
...
lunch.Hour = 12;
当写一个属性的时候，属性的set语句自动运行。
在上面的例子中，Time结构类有一个整型属性Hour，所以赋给这个属性的值必须是一个整型值。例如：
              lunch.Hour = 12;
把一个整型值12赋给了lunch的Hour属性，这个语句会自动调用属性的set语句。set语句是通过value标识符来获得属性的赋值的。例如，如果12被赋给了Hour属性，那么vaue的值就是12。注意的是value不是一个关键字。value只是在set语句中才是一个标识符。你可以在set语句外的任何语句声明value为一变量的名字。例如：
              public int Hour
              {
                     get { int value; ... }//正确
                     set { int value; ... }//错误
              }
6.    只读属性
       只读属性只有get语句
        任何写操作都会导致错误
        就像一个只读字段
struct Time
{
    ...
    public int Hour
    {  
        get
        {
            return hour;
        }
    }
    private int hour, minute, second;
}
Time lunch = new Time();
...
lunch.Hour = 12; //错误
...
lunch.Hour += 2;//错误
一个属性可以不必同时声明get语句和set语句。你可以只声明一个get语句。在这种情况下，属性是只读的，任何写的操作都会导致错误。例如，下面的语句就会导致一个错误：
              lunch.Hour = 12;
因为Hour是只读属性。
但要注意的是，属性必须至少包括一个get或set语句，一个属性不能是空的：
              public int Hour { }//错误
7.    只写属性
       只写属性只能有set 语句
       任何读操作都是错误的
struct Time
{
    ...
    public int Hour
    {  
        set {
            if (value < 0 || value > 24)
                throw new OutOfRangeException("Hour");
            hour = value;
        }
    }
    private int hour, minute, second;
}
Time lunch = new Time();
...
Console.WriteLine(lunch.Hour); //错误
...
lunch.Hour += 12;//错误
一个属性可以不必同时声明get语句和set语句。你可以只声明一个set语句。在这种情况下，属性是只写的，任何读的操作都会导致错误。例如，下面的语句就会导致一个错误：
              Console.WriteLine(lunch.Hour);
因为Hour是只写属性。
而下面的例子则看上去好像是对的：
       lunch.Hour += 2;
这句语句的实际运作是这样的：
       lunch.Hour = lunch.Hour + 2;
它执行了读的操作，因此是错误的。因此，像+=这种复合型的赋值操作符既不能用于只读属性，也不能用于只写属性。
8.    静态属性
      静态属性是和类联系在一起的
       只能通过类名使用
sealed class Error
{
    ...
    public static TextWriter Log
    {  
        get { return log; }
    }
    ...
    private static Stream sink
        = new FileStream("error.log", FileMode.Append);
    private static TextWriter log
        = new StreamWriter(sink);
}
Error.Log.WriteLine("time out");
字段可以是静态的，所以属性也可以是静态的。声明静态属性的语法很简单，只要在属性名前加入static关键字。静态函数中的机制和限制同样适用于静态属性。静态属性可以同一般的属性一样声明为只读或只写。
静态属性没有隐含的this参数。例如，上面的例子中，Log这个静态属性之所以能访问log这个字段，是因为log是一个静态字段。如果log是一个实例字段，那么Log这个静态属性就不能访问它。例如：
       public sealed class Error
       {
              public static TextWriter Log
              {
                     get { return log; }
              }
              private Stream sink = ...;
              private TextWriter log = ...;
       }
9.    属性vs.字段
      属性和字段的比较：
       属性不能使用ref/out 型参数
       属性使用前必须赋值
//属性
struct Time
{
    ...
    public int Hour
    {  
        set { ... }
    }
    private int hour;
}
Time lunch;
Method(out lunch.Hour); //错误
lunch.Hour = 12;//错误
 
//字段
struct Time
{
    ...
    public int Hour;
    ...
}
Time lunch;
Method(out lunch.Hour); //正确
lunch.Hour = 12;
属性使用前必须赋值，例如：
              Time lunch;
              lunch.Hour = 12;//错误，lunch没有初始化
10.    属性vs.函数
       相似点
       都包含执行代码
       都可以有访问修饰符
       都可以有virtual, abstract, override 修饰符
       都可以用在接口中
       不同点
       属性只能拥有get/set 语句
       属性不可以是void 型
       属性不能使用参数
       属性不能使用[ ] 参数
       属性不能使用括号