第五章 类

前一章讨论了数据类型和它们的用法。现在我们转移到C#中至关重要的结构——类。没有了类，就连简单的C#程序都不能编译。这一章假定你知道了一个类的基本组成部分：方法、属性、构造函数和析构函数。 C#在其中增加了索引和事件。

在这一章中，你学到下列有关类的话题。

• 使用构造函数和析构函数
• 给类写方法
• 给一个类增加属性存取标志
• 实现索引
• 创建事件并通过代表元为事件关联客户
• 应用类、成员和存取修饰符。

5.1 构造函数和析构函数

在你可以访问一个类的方法、属性或任何其它东西之前， 第一条执行的语句是包含有相应类的构造函数。甚至你自己不写一个构造函数，也会有一个缺省的构造函数提供给你。

class TestClass
{
    public TestClass(): base() {} // 由编译器提供
}

一个构造函数总是和它的类名相同，但是，它没有声明返回类型。总之，构造函数总是public的，你可以用它们来初始化变量。

public TestClass()
{
    // 在这给变量
    // 初始化代码等等。
}

如果类仅包含静态成员(能以类型调用，而不是以实例调用的成员)，你可以创建一个private的构造函数。

private TestClass() {}

尽管存取修饰符在这一章的后面将要大篇幅地讨论，但是private意味着从类的外面不可能访问该构造函数。所以，它不能被调用，且没有对象可以自该类定义被实例化。

并不仅限于无参数构造函数——你可以传递初始参数来初始化成员。

public TestClass(string strName, int nAge) { ... }

作为一个C/C++程序员，你可能习惯于给初始化写一个附加的方法，因为在构造函数中没有返回值。当然，尽管在C#中也没有返回值，但你可以引发一个自制的异常，以从构造函数获得返回值。更多有关异常处理的知识在第七章 "异常处理"中有讨论。

但是，当你保留引用给宝贵的资源，应该想到写一个方法来解决：一个可以被显式地调用来释放这些资源。问题是当你可以在析构函数(以类名的前面加"~"的方式命名)中做同样的事情时，为何还要写一个附加的方法.

public ~TestClass()
{
    // 清除
}

你应该写一个附加方法的原因是垃圾收集器，它在变量超出范围后并不会立即被调用，而仅当间歇期间或内存条件满足时才被触发。当你锁住资源的时间长于你所计划的时间时，它就会发生。因此，提供一个显式的释放方式是一个好主意，它同样能从析构函数中调用。

public void Release()
{
    // 释放所有宝贵的资源
}

public ~TestClass()
{
    Release();
}

调用析构函数中的释放方法并不是必要的——总之，垃圾收集会留意释放对象。但没有忘记清除是一种良好的习惯。

5.2 方法

既然对象能正确地初始化和结束，所剩下来的就是往类中增加功能。在大多数情况下，功能的主要部分在方法中能得到实现。你早已见过静态方法的使用，但是，这些是类型(类)的部分，不是实例(对象)。

为了让你迅速入门，我把这些方法的烦琐问题安排为三节：

• 方法参数
• 改写方法
• 方法屏蔽

5.2.1 方法参数

因方法要处理更改数值，你多多少少要传递值给方法，并从方法获得返回值。以下三个部分涉及到由传递值和为调用者获取返回结果所引起的问题。

• 输入参数
• 引用参数
• 输出参数

5.2.1.1 输入参数

你早已在例子中见过的一个参数就是输入参数。你用一个输入参数通过值传递一个变量给一个方法——方法的变量被调用者传递进来的值的一个拷贝初始化。清单5.1 示范输入参数的使用。

清单 5.1 通过值传递参数

using System;
public class SquareSample
{
    public int CalcSquare(int nSideLength)
    {
        return nSideLength*nSideLength;
    }
}
class SquareApp
{
    public static void Main()
    {
        SquareSample sq = new SquareSample();
        Console.WriteLine(sq.CalcSquare(25).ToString());
    }
}

因为我传递值而不是引用给一个变量，所以当调用方法时(见第16行)，可以使用一个常量表达式(25)。整型结果被传回给调用者作为返回值，它没有存到中间变量就被立即显示到屏幕上 。

输入参数按C/C++程序员早已习惯的工作方式工作。如果你来自VB，请注意没有能被编译器处理的隐式ByVal或ByRef——如果没有设定，参数总是用值传递。

这点似乎与我前面所陈述的有冲突：对于一些变量类型，用值传递实际上意味着用引用传递。迷惑吗? 一点背景知识也不需要：COM中的东西就是接口，每一个类可以拥有一个或多个接口。一个接口只不过是一组函数指针，它不包含数据。重复该数组会浪费很多内存资源；所以，仅开始地址被拷贝给方法，它作为调用者，仍然指向接口的相同指针。那就是为什么对象用值传递一个引用。

5.2.1.2 引用参数

尽管可以利用输入参数和返回值建立很多方法，但你一想到要传递值并原地修改它(也就是在相同的内存位置)，就没有那么好运了。这里用引用参数就很方便。

void myMethod(ref int nInOut)

因为你传递了一个变量给该方法(不仅仅是它的值)，变量必须被初始化。否则，编译器会报警。

清单 5.2 显示如何用一个引用参数建立一个方法。

清单 5.2 通过引用传递参数

// class SquareSample
using System;
public class SquareSample
{
    public void CalcSquare(ref int nOne4All)
    {
        nOne4All *= nOne4All;
    }
}
class SquareApp
{
    public static void Main()
    {
        SquareSample sq = new SquareSample();

        int nSquaredRef = 20; // 一定要初始化
        sq.CalcSquare(ref nSquaredRef);
        Console.WriteLine(nSquaredRef.ToString());
    }
}

正如所看到的，所有你要做的就是给定义和调用都加上ref限定符。因为变量通过引用传递，你可以用它来计算出结果并传回该结果。但是，在现实的应用程序中，我强烈建议要用两个变量，一个输入参数和一个引用参数。

5.2.1.3 输出参数

传递参数的第三种选择就是把它设作一个输出参数。正如该名字所暗示，一个输出参数仅用于从方法传递回一个结果。它和引用参数的另一个区别在于：调用者不必先初始化变量才调用方法。这显示在清单5.3中。

清单 5.3 定义一个输出参数

using System;
public class SquareSample
{
    public void CalcSquare(int nSideLength, out int nSquared)
    {
        nSquared = nSideLength * nSideLength;
    }
}
class SquareApp
{
    public static void Main()
    {
        SquareSample sq = new SquareSample();
        int nSquared; // 不必初始化
        sq.CalcSquare(15, out nSquared);
        Console.WriteLine(nSquared.ToString());
    }
}

5.2.2 改写方法

面向对象设计的重要原则就是多态性。不要理会高深的理论，多态性意味着：当基类程序员已设计好用于改写的方法时，在派生类中，你就可以重定义(改写)基类的方法。基类程序员可以用virtual 关键字设计方法：

virtual void CanBOverridden()

当从基类派生时，所有你要做的就是在新方法中加入override关键字：

override void CanBOverridden()

当改写一个基类的方法时，你必须明白，不能改变方法的访问属性——在这章的后面，你会学到更多关于访问修饰符的知识。

除了改写基类方法的事实外，还有另一个甚至更重要的改写特性。当把派生类强制转换成基类类型并接着调用虚拟方法时，被调用的是派生类的方法而不是基类的方法。

((BaseClass)DerivedClassInstance).CanBOverridden();

为了演示虚拟方法的概念，清单 5.4 显示如何创建一个三角形基类，它拥有一个可以被改写的成员方法（ComputeArea）。

清单 5.4 改写一个基类的方法

using System;
class Triangle
{
    public virtual double ComputeArea(int a, int b, int c)
    {
        // Heronian formula
        double s = (a + b + c) / 2.0;
        double dArea = Math.Sqrt(s * (s - a) * (s - b) * (s - c));
        return dArea;
    }
}
class RightAngledTriangle : Triangle
{
    public override double ComputeArea(int a, int b, int c)
    {
        double dArea = a * b / 2.0;
        return dArea;
    }
}
class TriangleTestApp
{
    public static void Main()
    {
        Triangle tri = new Triangle();
        Console.WriteLine(tri.ComputeArea(2, 5, 6));
        RightAngledTriangle rat = new RightAngledTriangle();
        Console.WriteLine(rat.ComputeArea(3, 4, 5));
    }
}

基类Triangle定义了方法ComputeArea。它采用三个参数，返回一个double结果，且具有公共访问性。从Triangle类派生出的是RightAngledTriangle，它改写了ComputeArea 方法，并实现了自己的面积计算公式。两个类都被实例化，且在命名为TriangleTestApp的应用类的Main() 方法中得到验证。

我漏了解释第14行：

class RightAngledTriangle : Triangle

在类语句中冒号（：）表示RightAngledTriangle从类 Triangle派生。那就是你所必须要做的，以让C#知道你想把 Triangle当作RightAngledTriangle的基类。

当仔细观察直角三角形的ComputeArea方法时，你会发现第3个参数并没有用于计算。但是，利用该参数就可以验证是否是“直角”。如清单5.5所示。

清单 5.5 调用基类实现

class RightAngledTriangle : Triangle
{
    public override double ComputeArea(int a, int b, int c)
    {
        const double dEpsilon = 0.0001;
        double dArea = 0;
        if (Math.Abs((a * a + b * b - c * c)) > dEpsilon)
        {
            dArea = base.ComputeArea(a, b, c);
        }
        else
        {
            dArea = a * b / 2.0;
        }
        return dArea;
    }
}

该检测简单地利用了毕达哥拉斯公式，对于直角三角形，检测结果必须为0。如果结果不为0，类就调用它基类的 ComputeArea来实现。

dArea = base.ComputeArea(a,b,c);

例子的要点为：通过显式地利用基类的资格检查，你就能轻而易举地调用基类实现改写方法。当你需要实现其在基类中的功能，而不愿意在改写方法中重复它时，这就非常有帮助。

5.2.3 方法屏蔽

重定义方法的一个不同手段就是要屏蔽基类的方法。当从别人提供的类派生类时，这个功能特别有价值。看清单 5.6，假设BaseClass由其他人所写，而你从它派生出 DerivedClass 。

清单 5.6 Derived Class 实现一个没有包含于 Base Class中的方法

using System;
class BaseClass
{
}
class DerivedClass : BaseClass
{
    public void TestMethod()
    {
        Console.WriteLine("DerivedClass::TestMethod");
    }
}
class TestApp
{
    public static void Main()
    {
        DerivedClass test = new DerivedClass();
        test.TestMethod();
    }
}

在这个例子中，DerivedClass 通过TestMethod()实现了一个额外的功能。但是，如果基类的开发者认为把TestMethod()放在基类中是个好主意，并使用相同的名字实现它时，会出现什么问题呢？（见清单5.7）

清单 5.7 Base Class 实现和 Derived Class相同的方法

class BaseClass
{
    public void TestMethod()
    {
        Console.WriteLine("BaseClass::TestMethod");
    }
}
class DerivedClass : BaseClass
{
    public void TestMethod()
    {
        Console.WriteLine("DerivedClass::TestMethod");
    }
}

在优秀的编程语言中，你现在会遇到一个真正的大麻烦。但是，C#会给你提出警告：

hiding2.cs(13,14): warning CS0114: 'DerivedClass.TestMethod()' hides inherited member 'BaseClass.TestMethod()'. To make the current method override that implementation, add the override keyword. Otherwise add the new keyword.

（hiding2.cs(13,14):警告 CS0114:'DerivedClass.TestMethod()' 屏蔽了所继承的成员'BaseClass.TestMethod()'。要想使当前方法改写原来的实现，加上 override关键字。否则加上新的关键字。）

具有了修饰符new，你就可以告诉编译器，不必重写派生类或改变使用到派生类的代码，你的方法就能屏蔽新加入的基类方法。清单5.8 显示如何在例子中运用new修饰符。

清单 5.8 屏蔽基类方法

class BaseClass
{
    public void TestMethod()
    {
        Console.WriteLine("BaseClass::TestMethod");
    }
}
class DerivedClass : BaseClass
{
    new public void TestMethod()
    {
        Console.WriteLine("DerivedClass::TestMethod");
    }
}

使用了附加的new修饰符，编译器就知道你重定义了基类的方法，它应该屏蔽基类方法。但是，如果你按以下方式编写：

DerivedClass test = new DerivedClass();
((BaseClass)test).TestMethod();

基类方法的实现就被调用了。这种行为不同于改写方法，后者保证大部分派生方法获得调用。

5.3 类属性

有两种途径揭示类的命名属性——通过域成员或者通过属性。前者是作为具有公共访问性的成员变量而被实现的；后者并不直接回应存储位置，只是通过 存取标志(accessors)被访问。

当你想读出或写入属性的值时，存取标志限定了被实现的语句。用于读出属性的值的存取标志记为关键字get，而要修改属性的值的读写符标志记为set。在你对该理论一知半解以前，请看一下清单5.9中的例子，属性SquareFeet被标上了get和set的存取标志。

清单 5.9 实现属性存取标志

using System;
public class House
{
    private int m_nSqFeet;
    public int SquareFeet
    {
        get { return m_nSqFeet; }
        set { m_nSqFeet = value; }
    }
}
class TestApp
{
    public static void Main()
    {
        House myHouse = new House();
        myHouse.SquareFeet = 250;
        Console.WriteLine(myHouse.SquareFeet);
    }
}

House类有一个命名为SquareFeet的属性，它可以被读和写。实际的值存储在一个可以从类内部访问的变量中——如果你想当作一个域成员重写它，你所要做的就是忽略存取标志而把变量重新定义为：

public int SquareFeet;

对于一个如此简单的变量，这样不错。但是，如果你想要隐藏类内部存储结构的细节时，就应该采用存取标志。在这种情况下，set 存取标志给值参数中的属性传递新值。（可以改名，见第10行。）

除了能够隐藏实现细节外，你还可自由地限定各种操作：

• get和set：允许对属性进行读写访问。
• get only：只允许读属性的值。
• set only：只允许写属性的值。

除此之外，你可以获得实现在set标志中有效代码的机会。例如，由于种种原因（或根本没有原因），你就能够拒绝一个新值。最好是没有人告诉你它是一个动态属性——当你第一次请求它后，它会保存下来，故要尽可能地推迟资源分配。

5.4 索引

你想过象访问数组那样使用索引访问类吗 ？使用C#的索引功能，对它的期待便可了结。

语法基本上象这样：

属性 修饰符 声明 { 声明内容 }

具体的例子为

public string this[int nIndex]
{
    get { ... }
    set { ... }
}

索引返回或按给出的index设置字符串。它没有属性，但使用了public修饰符。声明部分由类型string和this 组成用于表示类的索引。

get和set的执行规则和属性的规则相同。（你不能取消其中一个。） 只存在一个差别，那就是：你几乎可以任意定义大括弧中的参数。限制为，必须至少规定一个参数，允许ref 和out 修饰符。

this关键字确保一个解释。索引没有用户定义的名字，this 表示默认接口的索引。如果类实现了多个接口，你可以增加更多个由InterfaceName.this说明的索引。

为了演示一个索引的使用，我创建了一个小型的类，它能够解析一个主机名为IP地址——或一个IP地址列表(以http://www.microsoft.com为例 )。这个列表通过索引可以访问，你可以看一下清单5.10 的具体实现。

清单 5.10 通过一个索引获取一个IP地址

using System;
using System.Net;
class ResolveDNS
{
    IPAddress[] m_arrIPs;
    public void Resolve(string strHost)
    {
        IPHostEntry iphe = DNS.GetHostByName(strHost);
        m_arrIPs = iphe.AddressList;
    }
    public IPAddress this[int nIndex]
    {
        get
        {
            return m_arrIPs[nIndex];
        }
    }
    public int Count
    {
        get { return m_arrIPs.Length; }
    }
}
class DNSResolverApp
{
    public static void Main()
    {
        ResolveDNS myDNSResolver = new ResolveDNS();
        myDNSResolver.Resolve("http://www.microsoft.com");
        int nCount = myDNSResolver.Count;
        Console.WriteLine("Found {0} IP's for hostname", nCount);
        for (int i = 0; i < nCount; i++)
            Console.WriteLine(myDNSResolver[i]);
    }
}

为了解析主机名，我用到了DNS类，它是System.Net 名字空间的一部分。但是，由于这个名字空间并不包含在核心库中，所以必须在编译命令行中引用该库：

csc /r:System.Net.dll /out:resolver.exe dnsresolve.cs

解析代码是向前解析的。在该Resolve方法中，代码调用DNS类的静态方法GetHostByName，它返回一个IPHostEntry对象。结果，该对象包含有我要找的数组——AddressList数组。在退出Resolve方法之前，在局部的对象实例成员m_arrIPs中，存储了一个AddressList array的拷贝(类型IPAddress 的对象存储在其中)。

具有现在生成的数组 ，通过使用在类ResolveDNS中求得的索引，应用程序代码就可以在第37至38行列举出IP地址。(在第6章 "控制语句"，有更多有关语句的信息。) 因为没有办法更改IP地址，所以仅给索引使用了get存取标志。为了简单其见，我忽略了数组的边界溢出检查。

5.4 事件

当你写一个类时，有时有必要让类的客户知道一些已经发生的事件。如果你是一个具有多年编程经验的程序员，似乎有很多的解决办法，包括用于回调的函数指针和用于ActiveX控件的事件接收（event sinks）。现在你将要学到另外一种把客户代码关联到类通知的办法——使用事件。

事件既可以被声明为类域成员（成员变量），也可以被声明为属性。两者的共性为，事件的类型必定是代表元，而函数指针原形和C#的代表元具有相同的含义。

每一个事件都可以被0或更多的客户占用，且客户可以随时关联或取消事件。你可以以静态或者以实例方法定义代表元，而后者很受C++程序员的欢迎。

既然我已经提到了事件的所有功能及相应的代表元，请看清单5.11中的例子。它生动地体现了该理论。

清单5.11 在类中实现事件处理

using System;
// 向前声明
public delegate void EventHandler(string strText);
class EventSource
{
    public event EventHandler TextOut;
    public void TriggerEvent()
    {
        if (null != TextOut) TextOut("Event triggered");
    }
}
class TestApp
{
    public static void Main()
    {
        EventSource evsrc = new EventSource();

        evsrc.TextOut += new EventHandler(CatchEvent);
        evsrc.TriggerEvent();

        evsrc.TextOut -= new EventHandler(CatchEvent);
        evsrc.TriggerEvent();

        TestApp theApp = new TestApp();
        evsrc.TextOut += new EventHandler(theApp.InstanceCatch);
        evsrc.TriggerEvent();
    }
    public static void CatchEvent(string strText)
    {
        Console.WriteLine(strText);
    }
    public void InstanceCatch(string strText)
    {
        Console.WriteLine("Instance " + strText);
    }
}

第4行声明了代表元（事件方法原形），它用来给第8行中的EventSource类声明TextOut事件域成员。你可以观察到代表元作为一种新的类型声明，当声明事件时可以使用代表元。

该类仅有一个方法，它允许我们触发事件。请注意，你必须进行事件域成员不为null的检测，因为可能会出现没有客户对事件感兴趣这种情况。

TestApp类包含了Main方法，也包含了另外两个方法，它们都具备事件所必需的信号。其中一个方法是静态的，而另一个是实例方法。

EventSource 被实例化，而静态方法CatchEvent被预关联上了TextOut事件：

evsrc.TextOut += new EventHandler(CatchEvent);

从现在起，当事件被触发时，该方法被调用。如果你对事件不再感兴趣，简单地取消关联：

evsrc.TextOut -= new EventHandler(CatchEvent);

注意，你不能随意取消关联的处理函数——在类代码中仅创建了这些处理函数。为了证明事件处理函数也和实例方法一起工作，余下的代码建立了TestApp 的实例，并钩住事件处理方法。

事件在哪方面对你特别有用？你将经常在ASP+中或使用到WFC (Windows Foundation Classes)时，涉及到事件和代表元。

5.5 应用修饰符

在这一章的学习过程中，你已经见过了象public、virtual等修饰符。欲以一种易于理解的方法概括它们，我把它们划分为三节：

• 类修饰符
• 成员修饰符
• 存取修饰符

5.5.1 类修饰符

到目前为止，我还没有涉及到类修饰符，而只涉及到了应用于类的存取修饰符。但是，有两个修饰符你可以用于类：

• abstract——关于抽象类的重要一点就是它不能被实例化。只有不是抽象的派生类才能被实例化。派生类必须实现抽象基类的所有抽象成员。你不能给抽象类使用sealed修饰符。
• sealed——密封 类不能被继承。使用该修饰符防止意外的继承，在.NET框架中的类用到这个修饰符。

要见到两个修饰符的运用，看看清单5.12 ，它创建了一个基于一个抽象类的密封类（肯定是一个十分极端的例子）。

清单 5.12 抽象类和密封类

using System;
abstract class AbstractClass
{
    abstract public void MyMethod();
}
sealed class DerivedClass : AbstractClass
{
    public override void MyMethod()
    {
        Console.WriteLine("sealed class");
    }
}
public class TestApp
{
    public static void Main()
    {
        DerivedClass dc = new DerivedClass();
        dc.MyMethod();
    }
}

5.5.2 成员修饰符

与有用的成员修饰符的数量相比，类修饰符的数量很少。我已经提到了一些，这本书即将出现的例子描述了其它的成员修饰符。

以下是有用的成员修饰符：

• abstract——说明一个方法或存取标志不能含有一个实现。它们都是隐式虚拟，且在继承类中，你必须提供 override关键字。
• const——这个修饰符应用于域成员或局部变量。在编译时常量表达式被求值，所以，它不能包含变量的引用。
• event ——定义一个域成员或属性作为类型事件。用于捆绑客户代码到类的事件。
• extern——告诉编译器方法实际上由外部实现。第10章 “和非受管代码互相操作” 将全面地涉及到外部代码。
• override——用于改写任何基类中被定义为virtual的方法和存取标志。要改写的名字和基类的方法必须一致。
• readonly——一个使用 readonly修饰符的域成员只能在它的声明或者在包含它的类的构造函数中被更改。
• static——被声明为static的成员属于类，而不属于类的实例。你可以用static 于域成员、方法、属性、操作符甚至构造函数。
• virtual——说明方法或存取标志可以被继承类改写。

5.5.3 存取修饰符

存取修饰符定义了某些代码对类成员（如方法和属性）的存取等级。你必须给每个成员加上所希望的存取修饰符，否则，默认的存取类型是隐含的。

你可以应用4个 存取修饰符之一：

• public——任何地方都可以访问该成员，这是具有最少限制的存取修饰符。
• protected——在类及所有的派生类中可以访问该成员，不允许外部访问。
• private——仅仅在同一个类的内部才能访问该成员。甚至派生类都不能访问它。
• internal——允许相同组件（应用程序或库）的所有代码访问。在.NET组件级别，你可以把它视为public，而在外部则为private。

为了演示存取修饰符的用法，我稍微修改了Triangle例子，使它包含了新增的域成员和一个新的派生类（见清单 5.13）。

清单 5.13 在类中使用存取修饰符

using System;

internal class Triangle
{
    protected int m_a, m_b, m_c;
    public Triangle(int a, int b, int c)
    {
        m_a = a;
        m_b = b;
        m_c = c;
    }
    public virtual double Area()
    {
        // Heronian formula
        double s = (m_a + m_b + m_c) / 2.0;
        double dArea = Math.Sqrt(s * (s - m_a) * (s - m_b) * (s - m_c));
        return dArea;
    }
}
internal class Prism : Triangle
{
    private int m_h;
    public Prism(int a, int b, int c, int h) : base(a, b, c)
    {
        m_h = h;
    }
    public override double Area()
    {
        double dArea = base.Area() * 2.0;
        dArea += m_a * m_h + m_b * m_h + m_c * m_h;
        return dArea;
    }
}
class PrismApp
{
    public static void Main()
    {
        Prism prism = new Prism(2, 5, 6, 1);
        Console.WriteLine(prism.Area());
    }
}

Triangle类和 Prism 类现在被标为 internal。这意味着它们只能在当前组件中被访问。请记住“.NET组件”这个术语指的是包装（ packaging,），而不是你可能在COM+中用到的组件。Triangle 类有三个 protected成员，它们在构造函数中被初始化，并用于面积计算的方法中。由于这些成员是protected 成员，所以我可以在派生类Prism中访问它们，在那里执行不同的面积计算。Prism自己新增了一个成员m_h，它是私有的——甚至派生类也不能访问它。

花些时间为每个类成员甚至每个类计划一种保护层次，通常是个好主意。当需要引入修改时，全面的计划最终会帮助你，因为没有程序员会愿意使用“没有文档”的类功能。

5.6 小结

这章显示了类的各种要素，它是运行实例（对象）的模板。在一个对象的生命期，首先被执行的代码是个构造函数。构造函数用来初始化变量，这些变量后来在方法中用于计算结果。

方法允许你传递值、引用给变量，或者只传送一个输出值。方法可以被改写以实现新的功能，或者你可以屏蔽基类成员，如果它实现了一个具有和派生类成员相同名字的方法。

命名属性可以被当作域成员（成员变量）或属性存取标志实现。后者是get和set存取标志，忽略一个或另外一个，你可以创建仅写或仅读属性。存取标志非常适合于确认赋给属性的值。

C#类的另外一个功能是索引，它使象数组语法一样访问类中值成为可能。还有，如果当类中的某些事情发生时，你想客户得到通知，要让它们与事件关联。

当垃圾收集器调用析构函数时，对象的生命就结束了。由于你不能准确地预测这种情况什么时候会发生，所以应该创建一个方法以释放这些宝贵的资源，当你停止使用它们时。