c#函数成员

函数成员

函数成员提供了操作类中数据的某些功能，包括方法、属性、构造函数和终结器(finalizer)、运算符以及索引器。

方法是与某个类相关的函数，它们可以是实例方法，也可以是静态方法。实例方法处理类的某个实例，静态方法提供了更一般的功能，不需要实例化一个类(例如Console. WriteLine()方法)。

属性是可以在客户机上访问的函数组，其访问方式与访问类的公共字段类似。C#为读写类上的属性提供了专用语法，所以不必使用那些名称中嵌有Get或Set的偷工减料的方法。因为属性的这种语法不同于一般函数的语法，在客户代码中，虚拟的对象被当做实际的东西。

构造函数是在实例化对象时自动调用的函数。它们必须与所属的类同名，且不能有返回类型。构造函数用于初始化字段的值。

终结器类似于构造函数，但是在CLR检测到不再需要某个对象时调用。它们的名称与类相同，但前面有一个~符号。终结器在C#中比在C++中用得少得多，因为CLR会自动进行垃圾收集，另外，不可能预测什么时候调用终结器。

运算符执行的最简单的操作就是+和-。在对两个整数进行相加操作时，严格地说，就是对整数使用+运算符。C#还允许指定把已有的运算符应用于自己的类(运算符重载)。

索引器允许对象以数组或集合的方式进行索引。

1. 方法

在Visual Basic、C和C++中，可以定义与类完全不相关的全局函数，但在C#中不能这样做。在C#中，每个函数都必须与类或结构相关。

注意，正式的C#术语实际上区分了函数和方法。在这个术语中，"函数成员"不仅包含方法，而且也包含类或结构的一些非数据成员，例如索引器、运算符、构造函数和析构函数等，甚至还有属性。这些都不是数据成员，字段、常量和事件才是数据成员。

(1) 方法的声明

在C#中，定义方法的语法与C风格的语言相同，与C++和Java中的语法也相同。与C++的主要语法区别是，在C#中，每个方法都单独声明为public或private，不能使用public:块把几个方法定义组合起来。另外，所有的C#方法都在类定义中声明和定义。在C#中，不能像在C++中那样把方法的实现代码分隔开来。

在C#中，方法的定义包括方法的修饰符(例如方法的可访问性)、返回值的类型，然后是方法名、输入参数的列表(用圆括号括起来)和方法体(用花括号括起来)。

[modifiers] return_type MethodName([parameters])
{
// Method body
}

每个参数都包括参数的类型名及在方法体中的引用名称。但如果方法有返回值，return语句就必须与返回值一起使用，以指定出口点，例如：

public bool IsSquare(Rectangle rect)
{
return (rect.Height == rect.Width);
}

这段代码使用了一个表示矩形的.NET基类System.Drawing.Rectangle。

如果方法没有返回值，就把返回类型指定为void，因为不能省略返回类型。如果方法不带参数，仍需要在方法名的后面写上一对空的圆括号()(就像本章前面的Main()方法)。此时return语句就是可选的-- 当到达右花括号时，方法会自动返回。注意方法可以包含任意多个return语句：

public bool IsPositive(int value)
{
if (value < 0)
return false;
return true;
}

(2) 调用方法

C#中调用方法的语法与C++和Java中的一样，C#和Visual Basic的唯一区别是在C#中调用方法时，必须使用圆括号，这要比Visual Basic 6中有时需要括号，有时不需要括号的规则简单一些。

下面的例子MathTest说明了类的定义和实例化、方法的定义和调用的语法。除了包含Main()方法的类之外，它还定义了类MathTest，该类包含两个方法和一个字段。

using System; namespace Wrox.ProCSharp. MathTestSample
{
class MainEntryPoint
{
static void Main()
{
// Try calling some static functions
Console.WriteLine("Pi is " + MathTest.GetPi());
int x = MathTest.GetSquareOf(5);
Console.WriteLine("Square of 5 is " + x);          // Instantiate at MathTest object
MathTest math = new MathTest(); // this is C#'s way of
// instantiating a reference type

// Call non-static methods
math.value = 30;
Console.WriteLine(
"Value field of math variable contains " + math.value);
Console.WriteLine("Square of 30 is " + math.GetSquare());
}
}    // Define a class named MathTest on which we will call a method
class MathTest
{
public int value;       public int GetSquare()
{
return value*value;
}       public static int GetSquareOf(int x)
{
return x*x;
}       public static double GetPi()
{
return 3.14159;
}
}
}

运行mathTest示例，会得到如下结果：

csc MathTest.cs
Microsoft (R) Visual C# Compiler version 9.00.20404
for Microsoft (R) .NET Framework version 3.5
Copyright (C) Microsoft Corporation. All rights reserved. MathTest.exe
Pi is 3.14159
Square of 5 is 25
Value field of math variable contains 30
Square of 30 is 900

从代码中可以看出，MathTest类包含一个字段和一个方法，该字段包含一个数字，该方法计算数字的平方。这个类还包含两个静态方法，一个返回pi的值，另一个计算作为参数传入的数字的平方。

这个类有一些功能并不是C#程序设计的好例子。例如，GetPi()通常作为const字段来执行，而好的设计应使用目前还没有介绍的概念。

C++和Java开发人员应很熟悉这个例子的大多数语法。如果您有Visual Basic的编程经验，只需把MathTest类看作一个执行字段和方法的Visual Basic类模块。但无论使用什么语言，都要注意两个要点。

(3) 给方法传递参数

参数可以通过引用或值传递给方法。在变量通过引用传递给方法时，被调用的方法得到的就是这个变量，所以在方法内部对变量进行的任何改变在方法退出后仍旧发挥作用。而如果变量是通过值传送给方法的，被调用的方法得到的是变量的一个副本，也就是说，在方法退出后，对变量进行的修改会丢失。对于复杂的数据类型，按引用传递的效率更高，因为在按值传递时，必须复制大量的数据。

在C#中，所有的参数都是通过值来传递的，除非特别说明。这与C++是相同的，但与Visual Basic相反。但是，在理解引用类型的传递过程时需要注意。因为引用类型的对象只包含对象的引用，它们只给方法传递这个引用，而不是对象本身，所以对底层对象的修改会保留下来。相反，值类型的对象包含的是实际数据，所以传递给方法的是数据本身的副本。例如，int通过值传递给方法，方法对该int的值所作的任何改变都没有改变原int对象的值。但如果数组或其他引用类型(如类)传递给方法，方法就会使用该引用改变这个数组中的值，而新值会反射到原来的数组对象上。

下面的例子ParameterTest.cs说明了这一点：

using System; namespace Wrox.ProCSharp. ParameterTestSample
{
class ParameterTest
{
static void SomeFunction(int[] ints, int i)
{
ints[0] = 100;
i = 100;
}

public static int Main()
{
int i = 0;
int[] ints = { 0, 1, 2, 4, 8 };
// Display the original values
Console.WriteLine("i = " + i);
Console.WriteLine("ints[0] = " + ints[0]);
Console.WriteLine("Calling SomeFunction...");          // After this method returns, ints will be changed,
// but i will not
SomeFunction(ints, i);
Console.WriteLine("i = " + i);
Console.WriteLine("ints[0] = " + ints[0]);
return 0;
}
}
}

结果如下：

csc ParameterTest.cs
Microsoft (R) Visual C# Compiler version 9.00.20404
for Microsoft (R) .NET Framework version 3.5
Copyright (C) Microsoft Corporation. All rights reserved. ParameterTest.exe
i = 0
ints[0] = 0
Calling SomeFunction...
i = 0
ints[0] = 100

注意，i的值保持不变，而在ints中改变的值在原来的数组中也改变了。

注意字符串是不同的，因为字符串是不能改变的(如果改变字符串的值，就会创建一个全新的字符串)，所以字符串无法采用一般引用类型的行为方式。在方法调用中，对字符串所作的任何改变都不会影响原来的字符串。

(4) ref参数

通过值传送变量是默认的，也可以迫使值参数通过引用传送给方法。为此，要使用ref关键字。如果把一个参数传递给方法，且这个方法的输入参数前带有ref关键字，则该方法对变量所作的任何改变都会影响原来对象的值：

static void SomeFunction(int[] ints, ref int i)
{
ints[0] = 100;
i = 100;       //the change to i will persist after SomeFunction() exits
}

在调用该方法时，还需要添加ref关键字：

SomeFunction(ints, ref i);

在C#中添加ref关键字等同于在C++中使用&语法指定按引用传递参数。但是，C#在调用方法时要求使用ref关键字，使操作更明确(因此有助于防止错误)。

最后，C#仍要求对传递给方法的参数进行初始化，理解这一点也是非常重要的。在传递给方法之前，无论是按值传递，还是按引用传递，变量都必须初始化。

(5) out关键字

在C风格的语言中，函数常常能从一个例程中输出多个值，这是使用输出参数实现的，只要把输出值赋给通过引用传递给方法的变量即可。通常，变量通过引用传送的初值是不重要的，这些值会被函数重写，函数甚至从来没有使用过它们。

如果可以在C#中使用这种约定，就会非常方便。但C#要求变量在被引用前必须用一个初值进行初始化。尽管在把输入变量传递给函数前，可以用没有意义的值初始化它们，因为函数将使用真实、有意义的值初始化它们，但是这样做是没有必要的，有时甚至会引起混乱。但有一种方法能够简化C#编译器所坚持的输入参数的初始化。

编译器使用out关键字来初始化。在方法的输入参数前面加上out关键字时，传递给该方法的变量可以不初始化。该变量通过引用传送，所以在从被调用的方法中返回时，方法对该变量进行的任何改变都会保留下来。在调用该方法时，还需要使用out关键字，与在定义该方法时一样：

static void SomeFunction(out int i)
{
i = 100;
} public static int Main()
{
int i; // note how i is declared but not initialized
SomeFunction(out i);
Console.WriteLine(i);
return 0;
}

out关键字是C#中的新增内容，在Visual Basic和C++中没有对应的关键字，该关键字的引入使C#更安全，更不容易出错。如果在函数体中没有给out参数分配一个值，该方法就不能编译。

(6) 方法的重载

C#支持方法的重载--方法的几个有不同签名(方法名相同、但参数的个数和类型不同)的版本，但不支持C++或Visual Basic中的默认参数。为了重载方法，只需声明同名但参数个数或类型不同的方法即可：

class ResultDisplayer
{
void DisplayResult(string result)
{
// implementation
}    void DisplayResult(int result)
{
// implementation
}
}

因为C#不直接支持可选参数，所以需要使用方法重载来达到此目的：

class MyClass
{
int DoSomething(int x)   // want 2nd parameter with default value 10
{
DoSomething(x, 10);
}    int DoSomething(int x, int y)
{
// implementation
}
}

在任何语言中，对于方法重载来说，如果调用了错误的重载方法，就有可能出现运行错误。现在，知道C#在重载方法的参数方面有一些小区别即可：

● 两个方法不能仅在返回类型上有区别。

● 两个方法不能仅根据参数是声明为ref还是out来区分。

2. 属性

属性(property)不太常见，因为它们表示的概念是C#从Visual Basic中提取的，而不是从C++/Java中提取的。属性的概念是：它是一个方法或一对方法，在客户机代码看来，它们是一个字段。例如Windows窗体的Height属性。假定有下面的代码：

// mainForm is of type System.Windows.Form
mainForm.Height = 400;

执行这段代码，窗口的高度设置为400，因此窗口会在屏幕上重新设置大小。在语法上，上面的代码类似于设置一个字段，但实际上是调用了属性访问器，它包含的代码重新设置了窗体的大小。

在C#中定义属性，可以使用下面的语法：

public string SomeProperty
{
get
{
return "This is the property value";
}
set
{
// do whatever needs to be done to set the property
}
}

get访问器不带参数，且必须返回属性声明的类型。也不应为set访问器指定任何显式参数，但编译器假定它带一个参数，其类型也与属性相同，并表示为value。例如，下面的代码包含一个属性ForeName，它设置了一个字段foreName，该字段有一个长度限制。

private string foreName; public string ForeName
{
get
{
return foreName;
}
set
{
if (value.Length > 20)
// code here to take error recovery action 
// (eg. throw an exception)
else
foreName = value;
}
}

注意这里的命名模式。我们采用C#的区分大小写模式，使用相同的名称，但公共属性采用Pascal大小写命名规则，而私有属性采用camel大小写命名规则。一些开发人员喜欢使用前面有下划线的字段名_foreName，这会为识别字段提供极大的便利。

Visual Basic 6程序员应注意，C#不区分Visual Basic 6中的Set和Let，在C#中，写入访问器总是用关键字set标识。

(1) 只读和只写属性

在属性定义中省略set访问器，就可以创建只读属性。因此，把上面例子中的ForeName变成只读属性：

private string foreName; public string ForeName
{
get
{
return foreName;
}
}

同样，在属性定义中省略get访问器，就可以创建只写属性。但是，这是不好的编程方式，因为这可能会使客户机代码的作者感到迷惑。一般情况下，如果要这么做，最好使用一个方法替代。

(2) 属性的访问修饰符

C#允许给属性的get和set 访问器设置不同的访问修饰符，所以属性可以有公共的get访问器和私有或受保护的set访问器。这有助于控制属性的设置方式或时间。在下面的例子中，注意set访问器有一个私有访问修饰符，而get访问器没有任何访问修饰符。这表示get访问器具有属性的访问级别。在get 和 set 访问器中，必须有一个具备属性的访问级别。如果get访问器的访问级别是protected，就会产生一个编译错误，因为这会使两个访问器的访问级别都不是属性。

public string Name
{
get
{
return _name;
}
set
{
_name = value;
}
}

(3) 自动实现的属性

如果属性的set和get访问器中没有任何逻辑，就可以使用自动实现的属性。这种属性会自动实现基础成员变量。上例的代码如下：

public string ForeName {get; set;}

不需要声明private string foreName。编译器会自动创建它。

使用自动实现的属性，就不能在属性设置中进行属性的有效性验证。所以在上面的例子中，不能检查foreName是否少于20个字符。但必须有两个访问器。尝试把该属性设置为只读属性，就会出错：

public string ForeName {get; }

但是，每个访问器的访问级别可以不同。因此，下面的代码是合法的：

public string ForeName {get; private set;}

(4) 内联

一些开发人员可能会担心，我们列举了标准C#编码方式导致了非常小的函数的许多情形，例如通过属性访问字段，而不是直接访问字段。这些额外的函数调用是否会增加系统开销，导致性能下降？其实，不需要担心这种编程方式会在C#中带来性能损失。C#代码会编译为IL，然后在运行期间进行正常的JIT编译，获得内部可执行代码。JIT编译器可生成高度优化的代码，并在适当的时候内联代码(即用内联代码来替代函数调用)。如果某个方法或属性的执行代码仅是调用另一个方法，或返回一个字段，则该方法或属性肯定是内联的。但要注意，在何处内联代码的决定完全由CLR做出。我们无法使用像C++中inline这样的关键字来控制哪些方法是内联的。

3. 构造函数

在C#中声明基本构造函数的语法与在Java 和C++中相同。下面声明一个与包含的类同名的方法，但该方法没有返回类型：

public class MyClass
{
public MyClass()
{
}
// rest of class definition

与Java 和 C++相同，没有必要给类提供构造函数，在我们的例子中没有提供这样的构造函数。一般情况下，如果没有提供任何构造函数，编译器会在后台创建一个默认的构造函数。这是一个非常基本的构造函数，它只能把所有的成员字段初始化为标准的默认值(例如，引用类型为空引用，数字数据类型为0，bool为false)。这通常就足够了，否则就需要编写自己的构造函数。

注意：

对于C++程序员来说，C#中的基本字段在默认情况下初始化为0，而C++中的基本字段不进行初始化，不需要像C++那样频繁地在C#中编写构造函数。

构造函数的重载遵循与其他方法相同的规则。换言之，可以为构造函数提供任意多的重载，只要它们的签名有明显的区别即可：

   public MyClass()   // zero-parameter constructor
{
// construction code 
}
public MyClass(int number)   // another overload
{
// construction code 
}

但注意，如果提供了带参数的构造函数，编译器就不会自动提供默认的构造函数，只有在没有定义任何构造函数时，编译器才会自动提供默认的构造函数。在下面的例子中，因为定义了一个带单个参数的构造函数，所以编译器会假定这是可以使用的唯一构造函数，不会隐式地提供其他构造函数：

public class MyNumber
{
private int number;
public MyNumber(int number)   
{
this.number = number; 
}
}

上面的代码还说明，一般使用this关键字区分成员字段和同名的参数。如果试图使用无参数的构造函数实例化MyNumber对象，就会得到一个编译错误：

MyNumber numb = new MyNumber();   // causes compilation error

注意，可以把构造函数定义为private或protected，这样不相关的类就不能访问它们：

public class MyNumber
{
private int number;
private MyNumber(int number)   // another overload
{
this.number = number; 
}
}

在这个例子中，我们并没有为MyNumber定义任何公共或受保护的构造函数。这就使MyNumber不能使用new运算符在外部代码中实例化(但可以在MyNumber上编写一个公共静态属性或方法，以进行实例化)。这在下面两种情况下是有用的：

● 类仅用作某些静态成员或属性的容器，因此永远不会实例化

● 希望类仅通过调用某个静态成员函数来实例化(这就是所谓对象实例化的类代理方法)

(1) 静态构造函数

C#的一个新特征是也可以给类编写无参数的静态构造函数。这种构造函数只执行一次，而前面的构造函数是实例构造函数，只要创建类的对象，它都会执行。静态构造函数在C++和Visual Basic 6中没有对应的函数。

class MyClass
{
static MyClass()
{
// initialization code
}
// rest of class definition
}

编写静态构造函数的一个原因是，类有一些静态字段或属性，需要在第一次使用类之前，从外部源中初始化这些静态字段和属性。

.NET运行库没有确保静态构造函数什么时候执行，所以不要把要求在某个特定时刻(例如，加载程序集时)执行的代码放在静态构造函数中。也不能预计不同类的静态构造函数按照什么顺序执行。但是，可以确保静态构造函数至多运行一次，即在代码引用类之前执行。在C#中，静态构造函数通常在第一次调用类的成员之前执行。

注意，静态构造函数没有访问修饰符，其他C#代码从来不调用它，但在加载类时，总是由.NET运行库调用它，所以像public和private这样的访问修饰符就没有意义了。同样，静态构造函数不能带任何参数，一个类也只能有一个静态构造函数。很显然，静态构造函数只能访问类的静态成员，不能访问实例成员。

注意，无参数的实例构造函数可以在类中与静态构造函数安全共存。尽管参数列表是相同的，但这并不矛盾，因为静态构造函数是在加载类时执行，而实例构造函数是在创建实例时执行，所以构造函数的执行不会有冲突。

如果多个类都有静态构造函数，先执行哪个静态构造函数是不确定的。此时静态构造函数中的代码不应依赖其他静态构造函数的执行情况。另一方面，如果静态字段有默认值，它们就在调用静态构造函数之前指定。

下面用一个例子来说明静态构造函数的用法，该例子基于包含用户设置的程序(用户设置假定存储在某个配置文件中)。为了简单一些，假定只有一个用户设置-- BackColor，表示要在应用程序中使用的背景色。因为这里不想编写从外部数据源中读取数据的代码，所以假定该设置在工作日的背景色是红色，在周末的背景色是绿色。程序仅在控制台窗口中显示设置-- 但这足以说明静态构造函数是如何工作的。

namespace Wrox.ProCSharp.StaticConstructorSample
{
public class UserPreferences
{
public static readonly Color BackColor;       static UserPreferences()
{
DateTime now = DateTime.Now;
if (now.DayOfWeek == DayOfWeek.Saturday 
|| now.DayOfWeek == DayOfWeek.Sunday)
BackColor = Color.Green;
else
BackColor = Color.Red;
}       private UserPreferences()
{
}
}
}

这段代码说明了颜色设置如何存储在静态变量中，该静态变量在静态构造函数中进行初始化。把这个字段声明为只读类型，表示其值只能在构造函数中设置。本章后面将详细介绍只读字段。这段代码使用了Microsoft在Framework类库中支持的两个有用的结构System.DateTime和System.Drawing.Color。DateTime结构实现了静态属性Now和实例属性DayOfWeek，Now属性返回当前的时间，DayOfWeek属性可以计算出某个日期是星期几。Color(详见第33章)用于存储颜色，它实现了各种静态属性，例如本例使用的Red和Green，返回常用的颜色。为了使用Color结构，需要在编译时引用System.Drawing.dll程序集，且必须为System.Drawing命名空间添加一个using语句：

using System; 
using System.Drawing;

用下面的代码测试静态构造函数：

   class MainEntryPoint
{
static void Main(string[] args)
{
Console.WriteLine("User-preferences: BackColor is: " + 
UserPreferences.BackColor.ToString());
}
}

编译并运行这段代码，会得到如下结果：

StaticConstructor.exe
User-preferences: BackColor is: Color [Red]

当然，如果在周末执行代码，颜色设置就是Green。

(2) 从其他构造函数中调用构造函数

有时，在一个类中有几个构造函数，以容纳某些可选参数，这些构造函数都包含一些共同的代码。例如，下面的情况：

class Car
{
private string description;
private uint nWheels;
public Car(string model, uint nWheels)
{
this.description = description;
this.nWheels = nWheels;
}

public Car(string description)
{
this.description = description;
this.nWheels = 4;
}
// etc.

这两个构造函数初始化了相同的字段，显然，最好把所有的代码放在一个地方。C#有一个特殊的语法，称为构造函数初始化器，可以实现此目的：

class Car
{
private string description;
private uint nWheels;    public Car(string description, uint nWheels)
{
this.description = description;
this.nWheels = nWheels;
}    public Car(string description) : this(model, 4)
{
}
// etc  

这里，this关键字仅调用参数最匹配的那个构造函数。注意，构造函数初始化器在构造函数之前执行。现在假定运行下面的代码：

Car myCar = new Car("Proton Persona");

在本例中，在带一个参数的构造函数执行之前，先执行带2个参数的构造函数(但在本例中，因为带一个参数的构造函数没有代码，所以没有区别)。

C#构造函数初始化符可以包含对同一个类的另一个构造函数的调用(使用前面介绍的语法)，也可以包含对直接基类的构造函数的调用(使用相同的语法，但应使用base关键字代替this)。初始化符中不能有多个调用。

在C#中，构造函数初始化符的语法类似于C++中的构造函数初始化列表，但C++开发人员要注意，除了语法类似之外，C#初始化符所包含的代码遵循完全不同的规则。可以使用C++初始化列表指定成员变量的初始值，或调用基类构造函数，而C#初始化符中的代码只能调用另一个构造函数。这就要求C#类在构造时遵循严格的顺序，但C++就没有这个要求。