c#中类和对象详解

1.1 类和对象

类 (class) 是最基础的 C# 类型。类是一个数据结构，将状态（字段）和操作（方法和其他函数成员）组合在一个单元中。类为动态创建的类实例 (instance) 提供了定义，实例也称为对象 (object)。类支持继承 (inheritance) 和多态性 (polymorphism)，这是派生类 (derived class) 可用来扩展和专用化基类 (base class) 的机制。

使用类声明可以创建新的类。类声明以一个声明头开始，其组成方式如下：先指定类的属性和修饰符，然后是类的名称，接着是基类（如有）以及该类实现的接口。声明头后面跟着类体，它由一组位于一对大括号 { 和 } 之间的成员声明组成。

下面是一个名为 Point 的简单类的声明：

public class Point
{
public int x, y;

public Point(int x, int y) {
     this.x = x;
     this.y = y;
}
}

类的实例使用 new 运算符创建，该运算符为新的实例分配内存，调用构造函数初始化该实例，并返回对该实例的引用。下面的语句创建两个 Point 对象，并将对这两个对象的引用存储在两个变量中：

Point p1 = new Point(0, 0);
Point p2 = new Point(10, 20);

当不再使用对象时，该对象占用的内存将自动收回。在 C# 中，没有必要也不可能显式释放分配给对象的内存。

1.1.1 成员

类的成员或者是静态成员 (static member)，或者是实例成员 (instance member)。静态成员属于类，实例成员属于对象（类的实例）。

下表提供了类所能包含的成员种类的概述。

 

成员	说明
常量	与类关联的常数值
字段	类的变量
方法	类可执行的计算和操作
属性	与读写类的命名属性相关联的操作
索引器	与以数组方式索引类的实例相关联的操作
事件	可由类生成的通知
运算符	类所支持的转换和表达式运算符
构造函数	初始化类的实例或类本身所需的操作
析构函数	在永久丢弃类的实例之前执行的操作
类型	类所声明的嵌套类型

 

1.1.2 可访问性

类的每个成员都有关联的可访问性，它控制能够访问该成员的程序文本区域。有五种可能的可访问性形式。下表概述了这些可访问性。

 

可访问性	含义
public	访问不受限制
protected	访问仅限于此类和从此类派生的类
internal	访问仅限于此程序
protected internal	访问仅限于此程序和从此类派生的类
private	访问仅限于此类

 

1.1.3 基类

类声明可通过在类名称后面加上一个冒号和基类的名称来指定一个基类。省略基类的指定等同于从类型 object 派生。在下面的示例中，Point3D 的基类为 Point，而 Point 的基类为 object：

public class Point
{
public int x, y;

public Point(int x, int y) {
     this.x = x;
     this.y = y;
}
}

public class Point3D: Point
{
public int z;

public Point3D(int x, int y, int z): Point(x, y) {
     this.z = z;
}
}

一个类继承它的基类的成员。继承意味着一个类隐式地包含其基类的所有成员，但基类的构造函数除外。派生类能够在继承基类的基础上添加新的成员，但是它不能移除继承成员的定义。在前面的示例中，Point3D 类从 Point 类继承了 x 字段和 y 字段，每个 Point3D 实例都包含三个字段 x、y 和 z。

从某个类类型到它的任何基类类型存在隐式的转换。因此，类类型的变量可以引用该类的实例或任何派生类的实例。例如，对于前面给定的类声明，Point 类型的变量既可以引用 Point 也可以引用 Point3D：

Point a = new Point(10, 20);
Point b = new Point3D(10, 20, 30);

1.1.4 字段

字段是与类或类的实例关联的变量。

使用 static 修饰符声明的字段定义了一个静态字段 (static field)。一个静态字段只标识一个存储位置。对一个类无论创建了多少个实例，它的静态字段永远都只有一个副本。

不使用 static 修饰符声明的字段定义了一个实例字段 (instance field)。类的每个实例都包含了该类的所有实例字段的一个单独副本。

在下面的示例中，Color 类的每个实例都有实例字段 r、g 和 b 的单独副本，但是 Black、White、Red、Green 和 Blue 静态字段只存在一个副本：

public class Color
{
public static readonly Color Black = new Color(0, 0, 0);
public static readonly Color White = new Color(255, 255, 255);
public static readonly Color Red = new Color(255, 0, 0);
public static readonly Color Green = new Color(0, 255, 0);
public static readonly Color Blue = new Color(0, 0, 255);

private byte r, g, b;

public Color(byte r, byte g, byte b) {
     this.r = r;
     this.g = g;
     this.b = b;
}
}

如上面的示例所示，可以使用 readonly 修饰符声明只读字段 (read-only field)。给 readonly 字段的赋值只能作为字段声明的组成部分出现，或在同一类中的实例构造函数或静态构造函数中出现。

1.1.5 方法

方法 (method) 是一种用于实现可以由对象或类执行的计算或操作的成员。静态方法 (static method) 通过类来访问。实例方法 (instance method) 通过类的实例来访问。

方法具有一个参数 (parameter) 列表（可能为空），表示传递给该方法的值或变量引用；方法还具有一个返回类型 (return type)，指定该方法计算和返回的值的类型。如果方法不返回值，则其返回类型为 void。

方法的签名 (signature) 在声明该方法的类中必须唯一。方法的签名由方法的名称及其参数的数目、修饰符和类型组成。方法的签名不包含返回类型。

1.1.5.1 参数

参数用于向方法传递值或变量引用。方法的参数从方法被调用时指定的实参 (argument) 获取它们的实际值。有四种类型的参数：值参数、引用参数、输出参数和参数数组。

值参数 (value parameter) 用于输入参数的传递。一个值参数相当于一个局部变量，只是它的初始值来自为该形参传递的实参。对值参数的修改不影响为该形参传递的实参。

引用参数 (reference parameter) 用于输入和输出参数传递。为引用参数传递的实参必须是变量，并且在方法执行期间，引用参数与实参变量表示同一存储位置。引用参数使用 ref 修饰符声明。下面的示例演示 ref 参数的使用。

using System;

class Test
{
static void Swap(ref int x, ref int y) {
     int temp = x;
     x = y;
     y = temp;
}

static void Main() {
     int i = 1, j = 2;
     Swap(ref i, ref j);
     Console.WriteLine("{0} {1}", i, j);           // Outputs "2 1"
}
}

输出参数 (output parameter) 用于输出参数的传递。对于输出参数来说，调用方提供的实参的初始值并不重要，除此之外，输出参数与引用参数类似。输出参数是用 out 修饰符声明的。下面的示例演示 out 参数的使用。

using System;

class Test
{
static void Divide(int x, int y, out int result, out int remainder) {
     result = x / y;
     remainder = x % y;
}

static void Main() {
     int res, rem;
     Divide(10, 3, out res, out rem);
     Console.WriteLine("{0} {1}", res, rem);   // Outputs "3 1"
}
}

参数数组 (parameter array) 允许向方法传递可变数量的实参。参数数组使用 params 修饰符声明。只有方法的最后一个参数才可以是参数数组，并且参数数组的类型必须是一维数组类型。System.Console 类的 Write 和 WriteLine 方法就是参数数组用法的很好示例。它们的声明如下。

public class Console
{
public static void Write(string fmt, params object[] args) {...}

public static void WriteLine(string fmt, params object[] args) {...}

...
}

在使用参数数组的方法中，参数数组的行为完全就像常规的数组类型参数。但是，在具有参数数组的方法的调用中，既可以传递参数数组类型的单个实参，也可以传递参数数组的元素类型的任意数目的实参。在后一种情况下，将自动创建一个数组实例，并使用给定的实参对它进行初始化。示例：

Console.WriteLine("x={0} y={1} z={2}", x, y, z);

等价于写下面的语句。

object[] args = new object[3];
args[0] = x;
args[1] = y;
args[2] = z;
Console.WriteLine("x={0} y={1} z={2}", args);

1.1.5.2 方法体和局部变量

方法体指定了在该方法被调用时将执行的语句。

方法体可以声明仅用在该方法调用中的变量。这样的变量称为局部变量 (local variable)。局部变量声明指定了类型名称、变量名称，还可指定初始值。下面的示例声明一个初始值为零的局部变量 i 和一个没有初始值的变量 j。

using System;

class Squares
{
static void Main() {
     int i = 0;
     int j;
     while (i < 10) {
        j = i * i;
        Console.WriteLine("{0} x {0} = {1}", i, j);
        i = i + 1;
     }
}
}

C# 要求在对局部变量明确赋值 (definitely assigned) 之后才能获取其值。例如，如果前面的 i 的声明未包括初始值，则编译器将对随后对 i 的使用报告错误，因为 i 在程序中的该位置还没有明确赋值。

方法可以使用 return 语句将控制返回到它的调用方。在返回 void 的方法中，return 语句不能指定表达式。在返回非 void 的方法中，return 语句必须含有一个计算返回值的表达式。

1.1.5.3 静态方法和实例方法

使用 static 修饰符声明的方法为静态方法 (static method)。静态方法不对特定实例进行操作，并且只能访问静态成员。

不使用 static 修饰符声明的方法为实例方法 (instance method)。实例方法对特定实例进行操作，并且能够访问静态成员和实例成员。在调用实例方法的实例上，可以通过 this 显式地访问该实例。而在静态方法中引用 this 是错误的。

下面的 Entity 类具有静态成员和实例成员。

class Entity
{
static int nextSerialNo;

int serialNo;

public Entity() {
     serialNo = nextSerialNo++;
}

public int GetSerialNo() {
     return serialNo;
}

public static int GetNextSerialNo() {
     return nextSerialNo;
}

public static void SetNextSerialNo(int value) {
     nextSerialNo = value;
}
}

每个 Entity 实例都包含一个序号（并且假定这里省略了一些其他信息）。Entity 构造函数（类似于实例方法）使用下一个可用的序号初始化新的实例。由于该构造函数是一个实例成员，它既可以访问 serialNo 实例字段，也可以访问 nextSerialNo 静态字段。

GetNextSerialNo 和 SetNextSerialNo 静态方法可以访问 nextSerialNo 静态字段，但是如果访问 serialNo 实例字段就会产生错误。

下面的示例演示 Entity 类的使用。

using System;

class Test
{
static void Main() {
     Entity.SetNextSerialNo(1000);

     Entity e1 = new Entity();
     Entity e2 = new Entity();

     Console.WriteLine(e1.GetSerialNo());             // Outputs "1000"
     Console.WriteLine(e2.GetSerialNo());             // Outputs "1001"
     Console.WriteLine(Entity.GetNextSerialNo());     // Outputs "1002"
}
}

注意：SetNextSerialNo 和 GetNextSerialNo 静态方法是在类上调用的，而 GetSerialNo 实例方法是在该类的实例上调用的。

1.1.5.4 虚方法、重写方法和抽象方法

若一个实例方法的声明中含有 virtual 修饰符，则称该方法为虚方法 (virtual method)。若其中没有 virtual 修饰符，则称该方法为非虚方法 (non-virtual method)。

在调用一个虚方法时，该调用所涉及的那个实例的运行时类型 (runtime type) 确定了要被调用的究竟是该方法的哪一个实现。在非虚方法调用中，实例的编译时类型 (compile-time type) 是决定性因素。

虚方法可以在派生类中重写 (override)。当某个实例方法声明包括 override 修饰符时，该方法将重写所继承的具有相同签名的虚方法。虚方法声明用于引入新方法，而重写方法声明则用于使现有的继承虚方法专用化（通过提供该方法的新实现）。

抽象 (abstract) 方法是没有实现的虚方法。抽象方法使用 abstract 修饰符进行声明，并且只有在同样被声明为 abstract 的类中才允许出现。抽象方法必须在每个非抽象派生类中重写。

下面的示例声明一个抽象类 Expression，它表示一个表达式树节点；它有三个派生类 Constant、VariableReference 和 Operation，它们分别实现了常量、变量引用和算术运算的表达式树节点。

using System;
using System.Collections;

public abstract class Expression
{
public abstract double Evaluate(Hashtable vars);
}

public class Constant: Expression
{
double value;

public Constant(double value) {
     this.value = value;
}

public override double Evaluate(Hashtable vars) {
     return value;
}
}

public class VariableReference: Expression
{
string name;

public VariableReference(string name) {
     this.name = name;
}

public override double Evaluate(Hashtable vars) {
     object value = vars[name];
     if (value == null) {
        throw new Exception("Unknown variable: " + name);
     }
     return Convert.ToDouble(value);
}
}

public class Operation: Expression
{
Expression left;
char op;
Expression right;

public Operation(Expression left, char op, Expression right) {
     this.left = left;
     this.op = op;
     this.right = right;
}

public override double Evaluate(Hashtable vars) {
     double x = left.Evaluate(vars);
     double y = right.Evaluate(vars);
     switch (op) {
        case '+': return x + y;
        case '-': return x - y;
        case '*': return x * y;
        case '/': return x / y;
     }
     throw new Exception("Unknown operator");
}
}

上面的四个类可用于为算术表达式建模。例如，使用这些类的实例，表达式 x + 3 可如下表示。

Expression e = new Operation(
new VariableReference("x"),
'+',
new Constant(3));

Expression 实例的 Evaluate 方法将被调用，以计算给定的表达式的值，从而产生一个 double 值。该方法接受一个包含变量名称（作为哈希表项的键）和值（作为项的值）的 Hashtable 作为参数。Evaluate 方法是一个虚抽象方法，意味着非抽象派生类必须重写该方法以提供具体的实现。

Constant 的 Evaluate 实现只是返回所存储的常量。VariableReference 的实现在哈希表中查找变量名称，并返回产生的值。Operation 的实现先对左操作数和右操作数求值（通过递归调用它们的 Evaluate 方法），然后执行给定的算术运算。

下面的程序使用 Expression 类，对于不同的 x 和 y 值，计算表达式 x * (y + 2) 的值。

using System;
using System.Collections;

class Test
{
static void Main() {

     Expression e = new Operation(
        new VariableReference("x"),
        '*',
        new Operation(
            new VariableReference("y"),
            '+',
            new Constant(2)
        )
     );

     Hashtable vars = new Hashtable();

     vars["x"] = 3;
     vars["y"] = 5;
     Console.WriteLine(e.Evaluate(vars));      // Outputs "21"

    vars["x"] = 1.5;
     vars["y"] = 9;
     Console.WriteLine(e.Evaluate(vars));      // Outputs "16.5"
   }
}

1.1.5.5 方法重载

方法重载 (overloading) 允许同一类中的多个方法具有相同名称，条件是这些方法具有唯一的签名。在编译一个重载方法的调用时，编译器使用重载决策 (overload resolution) 确定要调用的特定方法。重载决策将查找与参数最佳匹配的方法，如果没有找到任何最佳匹配的方法则报告错误信息。下面的示例演示重载决策的工作机制。Main 方法中的每个调用的注释表明实际被调用的方法。

class Test
{
static void F() {...}
     Console.WriteLine("F()");
}

static void F(object x) {
     Console.WriteLine("F(object)");
}

static void F(int x) {
     Console.WriteLine("F(int)");
}

static void F(double x) {
     Console.WriteLine("F(double)");
}

static void F(double x, double y) {
     Console.WriteLine("F(double, double)");
}

static void Main() {
     F();                 // Invokes F()
     F(1);                // Invokes F(int)
     F(1.0);              // Invokes F(double)
     F("abc");         // Invokes F(object)
     F((double)1);     // Invokes F(double)
     F((object)1);     // Invokes F(object)
     F(1, 1);             // Invokes F(double, double)
}
}

正如该示例所示，总是通过显式地将实参强制转换为确切的形参类型，来选择一个特定的方法。

1.1.6 其他函数成员

包含可执行代码的成员统称为类的函数成员 (function member)。前一节描述的方法是函数成员的主要类型。本节描述 C# 支持的其他种类的函数成员：构造函数、属性、索引器、事件、运算符和析构函数。

下表演示一个名为 List 的类，它实现一个可增长的对象列表。该类包含了几种最常见的函数成员的示例。

 

public class List {
const int defaultCapacity = 4;	常量
object[] items;     int count;	字段
public List(): List(defaultCapacity) {}     public List(int capacity) {        items = new object[capacity];     }	构造函数
public int Count {        get { return count; }     }     public string Capacity {        get {            return items.Length;        }        set {            if (value < count) value = count;            if (value != items.Length) {               object[] newItems = new object[value];               Array.Copy(items, 0, newItems, 0, count);               items = newItems;            }        }     }	属性
public object this[int index] {        get {            return items[index];        }        set {            items[index] = value;            OnListChange();        }     }	索引器
public void Add(object item) {        if (count == Capacity) Capacity = count * 2;        items[count] = item;        count++;        OnChanged();     }     protected virtual void OnChanged() {        if (Changed != null) Changed(this, EventArgs.Empty);     }     public override bool Equals(object other) {        return Equals(this, other as List);     }     static bool Equals(List a, List b) {        if (a == null) return b == null;        if (b == null || a.count != b.count) return false;        for (int i = 0; i < a.count; i++) {            if (!object.Equals(a.items[i], b.items[i])) {               return false;            }        }       return true;     }	方法
public event EventHandler Changed;	事件
public static bool operator ==(List a, List b) {        return Equals(a, b);     }     public static bool operator !=(List a, List b) {        return !Equals(a, b);     }	运算符
}

 

1.1.6.1 构造函数

C# 支持两种构造函数：实例构造函数和静态构造函数。实例构造函数 (instance constructor) 是实现初始化类实例所需操作的成员。静态构造函数 (static constructor) 是一种用于在第一次加载类本身时实现其初始化所需操作的成员。

构造函数的声明如同方法一样，不过它没有返回类型，并且它的名称与其所属的类的名称相同。如果构造函数声明包含 static 修饰符，则它声明了一个静态构造函数。否则，它声明的是一个实例构造函数。

实例构造函数可以被重载。例如，List 类声明了两个实例构造函数，一个无参数，另一个接受一个 int 参数。实例构造函数使用 new 运算符进行调用。下面的语句分别使用 List 类的每个构造函数分配两个 List 实例。

List list1 = new List();
List list2 = new List(10);

实例构造函数不同于其他成员，它是不能被继承的。一个类除了其中实际声明的实例构造函数外，没有其他的实例构造函数。如果没有为某个类提供任何实例构造函数，则将自动提供一个不带参数的空的实例构造函数。

1.1.6.2 属性

属性 (propery) 是字段的自然扩展。属性和字段都是命名的成员，都具有相关的类型，且用于访问字段和属性的语法也相同。然而，与字段不同，属性不表示存储位置。相反，属性有访问器 (accessor)，这些访问器指定在它们的值被读取或写入时需执行的语句。

属性的声明与字段类似，不同的是属性声明以位于定界符 { 和 } 之间的一个 get 访问器和/或一个 set 访问器结束，而不是以分号结束。同时具有 get 访问器和 set 访问器的属性是读写属性 (read-write property)，只有 get 访问器的属性是只读属性 (read-only property)，只有 set 访问器的属性是只写属性 (write-only property)。

get 访问器相当于一个具有属性类型返回值的无参数方法。除了作为赋值的目标，当在表达式中引用属性时，将调用该属性的 get 访问器以计算该属性的值。

set 访问器相当于具有一个名为 value 的参数并且没有返回类型的方法。当某个属性作为赋值的目标被引用，或者作为 ++ 或 -- 的操作数被引用时，将调用 set 访问器，并传入提供新值的实参。

List 类声明了两个属性 Count 和 Capacity，它们分别是只读属性和读写属性。下面是这些属性的使用示例。

List names = new List();
names.Capacity = 100;        // Invokes set accessor
int i = names.Count;             // Invokes get accessor
int j = names.Capacity;          // Invokes get accessor

与字段和方法相似，C# 同时支持实例属性和静态属性。静态属性使用 static 修饰符声明，而实例属性的声明不带该修饰符。

属性的访问器可以是虚的。当属性声明包括 virtual、abstract 或 override 修饰符时，修饰符应用于该属性的访问器。

1.1.6.3 索引器

索引器 (indexer) 是这样一个成员：它使对象能够用与数组相同的方式进行索引。索引器的声明与属性类似，不同的是该成员的名称是 this，后跟一个位于定界符 [ 和 ] 之间的参数列表。在索引器的访问器中可以使用这些参数。与属性类似，索引器可以是读写、只读和只写的，并且索引器的访问器可以是虚的。

该 List 类声明了单个读写索引器，该索引器接受一个 int 参数。该索引器使得通过 int 值对 List 实例进行索引成为可能。例如

List numbers = new List();
names.Add("Liz");
names.Add("Martha");
names.Add("Beth");
for (int i = 0; i < names.Count; i++) {
string s = (string)names[i];
names[i] = s.ToUpper();
}

索引器可以被重载，这意味着一个类可以声明多个索引器，只要它们的参数的数量和类型不同即可。

1.1.6.4 事件

事件 (event) 是一种使类或对象能够提供通知的成员。事件的声明与字段类似，不同的是事件的声明包含 event 关键字，并且类型必须是委托类型。

在声明事件成员的类中，事件的行为就像委托类型的字段（前提是该事件不是抽象的并且未声明访问器）。该字段存储对一个委托的引用，该委托表示已添加到该事件的事件处理程序。如果尚未添加事件处理程序，则该字段为 null。

List 类声明了一个名为 Changed 的事件成员，它指示有一个新的项已被添加到列表中。Changed 事件由 OnChanged 虚方法引发，后者先检查该事件是否为 null（表明没有处理程序）。“引发一个事件”与“调用一个由该事件表示的委托”完全等效，因此没有用于引发事件的特殊语言构造。

客户端通过事件处理程序 (event handler) 来响应事件。事件处理程序使用 += 运算符添加，使用 -= 运算符移除。下面的示例向 List 类的 Changed 事件添加一个事件处理程序。

using System;

class Test
{
static int changeCount;

static void ListChanged(object sender, EventArgs e) {
     changeCount++;
}

static void Main() {
     List names = new List();
     names.Changed += new EventHandler(ListChanged);
     names.Add("Liz");
     names.Add("Martha");
     names.Add("Beth");
     Console.WriteLine(changeCount);    // Outputs "3"
}
}

对于要求控制事件的底层存储的高级情形，事件声明可以显式提供 add 和 remove 访问器，它们在某种程度上类似于属性的 set 访问器。

1.1.6.5 运算符

运算符 (operator) 是一种类成员，它定义了可应用于类实例的特定表达式运算符的含义。可以定义三种运算符：一元运算符、二元运算符和转换运算符。所有运算符都必须声明为 public 和 static。

List 类声明了两个运算符 operator == 和 operator !=，从而为将那些运算符应用于 List 实例的表达式赋予了新的含义。具体而言，上述运算符将两个 List 实例的相等关系定义为逐一比较其中所包含的对象（使用所包含对象的 Equals 方法）。下面的示例使用 == 运算符比较两个 List 实例。

using System;

class Test
{
static void Main() {
     List a = new List();
     a.Add(1);
     a.Add(2);
     List b = new List();
     b.Add(1);
     b.Add(2);
     Console.WriteLine(a == b);      // Outputs "True"
     b.Add(3);
     Console.WriteLine(a == b);      // Outputs "False"
}
}

第一个 Console.WriteLine 输出 True，原因是两个列表包含的对象数目和值均相同。如果 List 未定义 operator ==，则第一个 Console.WriteLine 将输出 False，原因是 a 和 b 引用的是不同的 List 实例。

1.1.6.6 析构函数

析构函数 (destructor) 是一种用于实现销毁类实例所需操作的成员。析构函数不能带参数，不能具有可访问性修饰符，也不能被显式调用。垃圾回收期间会自动调用所涉及实例的析构函数。

垃圾回收器在决定何时回收对象和运行析构函数方面允许有广泛的自由度。具体而言，析构函数调用的时机并不是确定的，析构函数可能在任何线程上执行。由于这些以及其他原因，仅当没有其他可行的解决方案时，才应在类中实现析构函数。

 

c#引用参数传递的深入剖析

在c#中，数据有2中基本类型：值类型和引用类型

值类型的变量存储数据，而引用类型的变量存储对实际数据的引用。

在参数传递时，值类型是以值的形式传递的，是将要传递的参数的值复制给函数的形参，因此在函数体类对于该形参的任何改变都不会影响原来的值；

引用类型是以对象引用的形式传递的，是将要传递的对象的引用复制给函数的形参，这时形参是实参引用的复制，注意：是引用的复制，而不是原引用，和原引用指向相同的对象，因此对于引用对象所做的更改将会直接影响原来的值，但是对于引用本身，在函数内的任何改变将不会影响原引用。

给一个直观的示例：

    class A    {       public  string data="";    }    class Program    {        static void F(  A a1)        {            //a1指向传来的对象a                         a1.data = "2";//修改a1指向的对象            a1 = new A();//a1指向另一个对象,注意，这时a1已经不指向原来的对象a了，而原来的引用还是指向对象a            a1.data = "3";//修改新建的对象，不会影响原来对象a的值        }        static void Main()        {            A a = new A();//实例化A的一个对象，并用a1指向该对象            a.data = "1";//将a的data字段赋值为"1"            F(a);//调用函数F，注意：这时将对象a的引用(不是对象a)赋值给参数a1,            Console.WriteLine(a.data);        }    }结果是2而不是3也不是1.ref 串参数：ref 关键字使参数按引用传递。其效果是，当控制权传递回调用方法时，在方法中对参数所做的任何更改都将反映在该变量中。若要使用 ref 参数，则方法定义和调用方法都必须显式使用 ref 关键字。例如：对于值类型，可以向上面的引用串参数一样传递，对于已经是引用类型的参数，大家可能会说那不是多此一举吗？其实不然，因为其中的实机理完全不一样：考查上个示例的变种    class A    {       public  string data="";    }    class Program    {        static void F( ref A a1)        {            //a1和a是同一个实例，而不是指向同一对象的引用，即a1和a在存在于内存中的地址是一样的            a1.data = "2";//修改a1指向的对象            a1 = new A();//a1指向另一个对象,理所当然别名a也指向该对象了，注意,这时原来的对象已经没有任何引用指向了，因此，可以说原来的对象已经不可访问了。            a1.data = "3";//修改新建的对象的属性        }        static void Main()        {            A a = new A();//实例化A的一个对象，并用a1指向该对象            a.data = "1";//将a的data字段赋值为"1"            F(ref a);//调用函数F，注意：这时将对象a的引用传给a1，不是赋值，相当与 给a对象的引用起了个别名            Console.WriteLine(a.data);//这时a已经指向函数中新建的对象，因此值应为"3"        }    } 可以这么理解，没有ref时的引用对象的参数传递就相当于c++中的一般指针传递(函数声明相当于： void F(Type * v))，而有ref时的引用对象的参数传递相当于c++中的一般指向指针的指针传递(函数声明相当于： void F(Type ** v)).