#1楼 回复 引用
2008-03-03 14:10 by xx_2008[未注册用户]
好长啊 有时间慢慢看
这篇文章是我几个月前写的，今天进行了比较大的修订，重新发了出来，希望和大家共同探讨，并在此感谢Anytao 的讨论和帮助。
从概念上看，值类型直接存储其值，而引用类型存储对其值的引用。这两种类型存储在内存的不同地方。在C#中，我们必须在设计类型的时候就决定类型实例的行为。这种决定非常重要，用《CLR via C# 》作者Jeffrey Richter的话 来 说，“不理解引用类型和值类型区别的程序员将会给代码引入诡异的bug和性能问题（I believe that a developer who misunderstands the difference between reference types and value types will introduce subtle bugs and performance issues into their code.）”。这就要求我们正确理解和使用值类型和引用类型。
- 1. 通用类型系统
- 2. 值类型
- 3. 引用类型
- 4. 值类型和引用类型在内存中的部署
- 4.1 数组在内存中的部署
- 4.2 值类型和引用类型的嵌套
- 5. 正确使用值类型和引用类型
- 5.1 辨明值类型和引用类型的使用场合
- 5.2 将值类型尽可能实现为具有常量性和原子性的类型
- 5.3 确保0为值类型的有效状态
- 5.4 尽量减少装箱和拆箱
- 6. 总结
- 7. 参考
1. 通用类型系统
C#中，变量是值还是引用仅取决于其数据类型。
C#的基本数据类型都以平台无关的方式来定义。C#的预定义类型并没有内置于语言中，而是内置于.NET Framework中。.NET使用通用类型系统（CTS）定义了可以在中间语言（IL）中使用的预定义数据类型，所有面向.NET的语言都最终被编译为 IL，即编译为基于CTS类型的代码。
例如，在C#中声明一个int变量时，声明的实际上是CTS中System.Int32的一个实例。这具有重要的意义：
- 确保IL上的强制类型安全；
- 实现了不同.NET语言的互操作性；
- 所有的数据类型都是对象。它们可以有方法，属性，等。例如：
int
i;
i = 1 ;
string s;
s = i.ToString();
i = 1 ;
string s;
s = i.ToString();
MSDN的这张图 说明了CTS中各个类型是如何相关的。注意，类型的实例可以只是值类型或自描述类型，即使这些类型有子类别也是如此。
2. 值类型
C#的所有值类型均隐式派生自System.ValueType：
- 结构体：struct（直接派生于System.ValueType）；
- 数值类型：
- 整 型：sbyte（System.SByte的别 名），short（System.Int16），int（System.Int32），long（System.Int64），byte（System.Byte），ushort（System.UInt16），uint（System.UInt32），ulong（System.UInt64），char（System.Char）；
- 浮点型：float（System.Single），double（System.Double）；
- 用于财务计算的高精度decimal型：decimal（System.Decimal）。
- bool型：bool（System.Boolean的别名）；
- 用户定义的结构体（派生于System.ValueType）。
- 数值类型：
- 枚举：enum（派生于System.Enum）；
- 可空类型（派生于System.Nullable<T>泛型结构体，T?实际上是System.Nullable<T>的别名）。
每种值类型均有一个隐式的默认构造函数来初始化该类型的默认值。例如：
int
i
=
new
int
();
等价于：
Int32 i
=
new
Int32();
等价于：
int
i
=
0
;
等价于：
Int32 i
=
0
;
使用new运算符时，将调用特定类型的默认构造函数并对变量赋以默认值。在上例中，默认构造函数将值0赋给了i。MSDN上有完整的默认值表 。
关于int和Int32的细节，在我的另一篇文章中有详细解释：《理解C#中的System.Int32和int 》。
所有的值类型都是密封（seal）的，所以无法派生出新的值类型。
值得注意的是，System.ValueType直接派生于System.Object。即System.ValueType本身是一个类类型，而 不是值类型。其关键在于ValueType重写了Equals()方法，从而对值类型按照实例的值来比较，而不是引用地址来比较。
可以用Type.IsValueType属性来判断一个类型是否为值类型：
TestType testType
=
new
TestType ();
if (testTypetype.GetType().IsValueType)
{
Console.WriteLine( " {0} is value type. " , testType.ToString());
}
if (testTypetype.GetType().IsValueType)
{
Console.WriteLine( " {0} is value type. " , testType.ToString());
}
3. 引用类型
C#有以下一些引用类型：
- 数组（派生于System.Array）
- 用户用定义的以下类型：
- 类：class（派生于System.Object）；
- 接口：interface（接口不是一个“东西”，所以不存在派生于何处的问题。Anders在《C# Programming Language 》中说，接口只是表示一种约定[contract]）；
- 委托：delegate（派生于System.Delegate）。
- object（System.Object的别名）；
- 字符串：string（System.String的别名）。
可以看出：
- 引用类型与值类型相同的是，结构体也可以实现接口；
- 引用类型可以派生出新的类型，而值类型不能；
- 引用类型可以包含null值，值类型不能（可空类型功能允许将 null 赋给值类型）；
- 引用类型变量的赋值只复制对对象的引用，而不复制对象本身。而将一个值类型变量赋给另一个值类型变量时，将复制包含的值。
对于最后一条，经常混淆的是string。我曾经在一本书 的一个早期版本上看到String变量比string变量效率高；我还经常听说String是引用类型，string是值类型，等等。例如：
string
s1
=
"
Hello,
"
;
string s2 = " world! " ;
string s3 = s1 + s2; // s3 is "Hello, world!"
string s2 = " world! " ;
string s3 = s1 + s2; // s3 is "Hello, world!"
这确实看起来像一个值类型的赋值。再如：
string
s1
=
"
a
"
;
string s2 = s1 ;
s1 = "b " ; // s2 is still "a"
string s2 = s1 ;
s1 = "b " ; // s2 is still "a"
改变s1的值对s2没有影响。这更使string看起来像值类型。实际上，这是运算符重载的结果，当s1被改变时，.NET在托管堆上为s1重新分配了内存。这样的目的，是为了将做为引用类型的string实现为通常语义下的字符串。
4. 值类型和引用类型在内存中的部署
经常听说，并且经常在书上看到：值类型部署在栈上，引用类型部署在托管堆上。实际上并没有这么简单。
MSDN上说 ：托管堆上部署了所有引用类型。这很容易理解。当创建一个应用类型变量时：
object
reference
=
new
object
();
关键字new将在托管堆上分配内存空间，并返回一个该内存空间的地址。左边的reference位于栈上，是一个引用，存储着一个内存地址；而这个 地址指向的内存（位于托管堆）里存储着其内容（一个System.Object的实例）。下面为了方便，简称引用类型部署在托管推上。
再来看值类型。《C#语言规范 》 上的措辞是“结构体不要求在堆上分配内存（However, unlike classes, structs are value types and do not require heap allocation）”而不是“结构体在栈上分配内存”。这不免容易让人感到困惑：值类型究竟部署在什么地方？
4.1 数组
考虑数组：
int
[] reference
=
new
int
[
100
];
根据定义，数组都是引用类型，所以int数组当然是引用类型（即reference.GetType().IsValueType为false）。
而int数组的元素都是int，根据定义，int是值类型（即reference[i].GetType().IsValueType为true）。那么引用类型数组中的值类型元素究竟位于栈还是堆？
如果用WinDbg去看reference[i]在内存中的具体位置 ，就会发现它们并不在栈上，而是在托管堆上。
实际上，对于数组：
TestType[] testTypes
=
new
TestType[
100
];
如果TestType是值类型，则会一次在托管堆上为100个值类型的元素分配存储空间，并自动初始化这100个元素，将这100个元素存储到这块内存里。
如果TestType是引用类型，则会先在托管堆为testTypes分配一次空间，并且这时不会自动初始化任何元素（即testTypes[i]均为null）。等到以后有代码初始化某个元素的时候，这个引用类型元素的存储空间才会被分配在托管堆上。
4.2 类型嵌套
更容易让人困惑的是引用类型包含值类型，以及值类型包含引用类型的情况：
public
class
ReferenceTypeClass
{
private int _valueTypeField;
public ReferenceTypeClass()
{
_valueTypeField = 0 ;
}
public void Method()
{
int valueTypeLocalVariable = 0 ;
}
}
ReferenceTypeClass referenceTypeClassInstance = new ReferenceTypeClass(); // Where is _valueTypeField?
referenceTypeClassInstance.Method(); // Where is valueTypeLocalVariable?
public struct ValueTypeStruct
{
private object _referenceTypeField;
public void Method()
{
_referenceTypeField = new object ();
object referenceTypeLocalVariable = new object ();
}
}
ValueTypeStruct valueTypeStructInstance = new ValueTypeStruct();
valueTypeStructInstance.Method(); // Where is _referenceTypeField？And where is referenceTypeLocalVariable?
{
private int _valueTypeField;
public ReferenceTypeClass()
{
_valueTypeField = 0 ;
}
public void Method()
{
int valueTypeLocalVariable = 0 ;
}
}
ReferenceTypeClass referenceTypeClassInstance = new ReferenceTypeClass(); // Where is _valueTypeField?
referenceTypeClassInstance.Method(); // Where is valueTypeLocalVariable?
public struct ValueTypeStruct
{
private object _referenceTypeField;
public void Method()
{
_referenceTypeField = new object ();
object referenceTypeLocalVariable = new object ();
}
}
ValueTypeStruct valueTypeStructInstance = new ValueTypeStruct();
valueTypeStructInstance.Method(); // Where is _referenceTypeField？And where is referenceTypeLocalVariable?
单看valueTypeStructInstance，这是一个结构体实例，感觉似乎是整块扔到栈上的。但是字段_referenceTypeField是引用类型，局部变量referenceTypeLocalVarible也是引用类型。
referenceTypeClassInstance也有同样的问题，referenceTypeClassInstance本身是引用类型，似 乎应该整块部署在托管堆上。但字段_valueTypeField是值类型，局部变量valueTypeLocalVariable也是值类型，它们究竟 是在栈上还是在托管堆上？
规律是：
- 引用类型部署在托管堆上；
- 值类型总是分配在它声明的地方：作为字段时，跟随其所属的变量（实例）存储；作为局部变量时，存储在栈上。
我们来分析一下上面的代码。对于引用类型实例，即referenceTypeClassInstance：
- 从上下文看，referenceTypeClassInstance是一个局部变量，所以部署在托管堆上，并被栈上的一个引用所持有；
- 值类型字段_valueTypeField属于引用类型实例referenceTypeClassInstance的一部分，所以跟随引用类型实例referenceTypeClassInstance部署在托管堆上（有点类似于数组的情形）；
- valueTypeLocalVariable是值类型局部变量，所以部署在栈上。
而对于值类型实例，即valueTypeStruct：
- 根据上下文，值类型实例valueTypeStructInstance本身是一个局部变量而不是字段，所以位于栈上；
- 其引用类型字段_referenceTypeField不存在跟随的问题，必然部署在托管堆上，并被一个引用所持有（该引用是valueTypeStruct的一部分，位于栈）；
- 其引用类型局部变量referenceTypeLocalVariable显然部署在托管堆上，并被一个位于栈的引用所持有。
所以，简单地说“值类型存储在栈上，引用类型存储在托管堆上”是不对的。必须具体情况具体分析。
5. 正确使用值类型和引用类型
这一部分主要参考《Effective C# 》，并非本人原创，希望能让你加深对值类型和引用类型的理解。
5.1 辨明值类型和引用类型的使用场合
C#中，我们用struct/class来声明一个类型为值类型/引用类型。
考虑下面的例子：
TestType[] testTypes
=
new
TestType[
100
];
如果TestTye是值类型，则只需要一次分配，大小为TestTye的100倍。而如果TestTye是引用类型，刚开始需要100次分配，分配 后数组的各元素值为null，然后再初始化100个元素，结果总共需要进行101次分配。这将消耗更多的时间，造成更多的内存碎片。所以，如果类型的职责 主要是存储数据，值类型比较合适。
一般来说，值类型（不支持多态）适合存储供 C#应用程序操作的数据，而引用类型（支持多态）应该用于定义应用程序的行为。
通常我们创建的引用类型总是多于值类型。如果以下问题的回答都为yes，那么我们就应该创建为值类型：
- 该类型的主要职责是否用于数据存储？
- 该类型的共有借口是否完全由一些数据成员存取属性定义？
- 是否确信该类型永远不可能有子类？
- 是否确信该类型永远不可能具有多态行为？
5.2 将值类型尽可能实现为具有常量性和原子性的类型
具有常量性的类型很简单：
- 如果构造的时候验证了参数的有效性，之后就一直有效；
- 省去了许多错误检查，因为禁止更改；
- 确保线程安全，因为多个reader访问到同样的内容；
- 可以安全地暴露给外界，因为调用者不能更改对象的内部状态。
具有原子性的类型都是单一的实体，我们通常会直接替换一个原子类型的整个内容。
下面是一个典型的可变类型：
public
struct
Address
{
private string _city;
private string _province;
private int _zipCode;
public string City
{
get { return _city; }
set { _city = value; }
}
public string Province
{
get { return _province; }
set
{
ValidateProvince(value);
_province = value;
}
}
public int ZipCode
{
get { return _zipCode; }
set
{
ValidateZipCode(value);
_zipCode = value;
}
}
}
{
private string _city;
private string _province;
private int _zipCode;
public string City
{
get { return _city; }
set { _city = value; }
}
public string Province
{
get { return _province; }
set
{
ValidateProvince(value);
_province = value;
}
}
public int ZipCode
{
get { return _zipCode; }
set
{
ValidateZipCode(value);
_zipCode = value;
}
}
}
下面创建一个实例：
Address address
=
new
Address();
address.City = "Chengdu " ;
address.Province = "Sichuan " ;
address.ZipCode = 610000 ;
address.City = "Chengdu " ;
address.Province = "Sichuan " ;
address.ZipCode = 610000 ;
然后更改这个实例：
address.City
=
"Nanjing
"
;
//
Now Province and ZipCode are invalid
address.ZipCode = 210000 ; // Now Province is still invalid
address.Province = "Jiangsu " ;
address.ZipCode = 210000 ; // Now Province is still invalid
address.Province = "Jiangsu " ;
可见，内部状态的改变意味着可能违反对象的不变式（invariant），至少是临时的违反。如果上面是一个多线程的程序，那么在 City更改的过程中，另一个线程可能看到不一致的数据视图。如果不是多线程的程序，也有问题：
- 当ZipCode的值无效而抛出异常时，对象仅作了一部分改变，因此处于无效的状态，为了修复这个问题，需要在Address中添加相当多的内部校验代码；
- 为了实现异常安全，我们需要在所有改变多个字段的客户代码处放上防御性的代码；
- 线程安全也要求我们在每一个属性的访问器上添加线程同步检查。
显然，这是一个相当可观的工作量。下面我们把Address实现为常量类型：
public
struct
Address
{
private string _city;
private string _province;
private int _zipCode;
public Address ( string city, string province, int zipCode)
{
_city = city;
_province = province;
_zipCode = zipCode;
ValidateProvince(province);
ValidateZipCode(zipCode);
}
public string City
{
get { return _city; }
}
public string Province
{
get { return _province; }
}
public int ZipCode
{
get { return _zipCode; }
}
}
{
private string _city;
private string _province;
private int _zipCode;
public Address ( string city, string province, int zipCode)
{
_city = city;
_province = province;
_zipCode = zipCode;
ValidateProvince(province);
ValidateZipCode(zipCode);
}
public string City
{
get { return _city; }
}
public string Province
{
get { return _province; }
}
public int ZipCode
{
get { return _zipCode; }
}
}
如果要改变Address，不能修改现有的实例，只能创建一个新的实例：
Address address
=
new
Address(
"Chengdu
"
,
"Sichuan
"
,
610000
);
//
create a instance
address = new Address( "Nanjing " , "Jiangsu " , 210000 ); // modify the instance
address = new Address( "Nanjing " , "Jiangsu " , 210000 ); // modify the instance
address将不存在任何无效的临时状态。那些临时状态只存在于Address的构造函数执行过程中。这样一来，Address是异常安全的，也是线程安全的。
5.3 确保0为值类型的有效状态
.NET的默认初始化机制会将引用类型设置为二进制意义上的0，即null。而对于值类型，不论我们是否提供构造函数，都会有一个默认的构造函数，将其设置为0。
一种典型的情况是枚举：
public
enum
Sex
{
Male = 1 ;
Female = 2 ;
}
{
Male = 1 ;
Female = 2 ;
}
然后用做值类型的成员：
public
struct
Employee
{
private Sex _sex;
// other
}
{
private Sex _sex;
// other
}
创建Employee结构体将得到一个无效的Sex字段：
Employee employee
=
new
Employee ();
employee的_sex是无效的，因为其为0。我们应该将0作为一个为初始化的值明确表示出来：
public
Sex
{
None = 0 ;
Male = 1 ;
Female = 2 ;
}
{
None = 0 ;
Male = 1 ;
Female = 2 ;
}
如果值类型中包含引用类型，会出现另一种初始化问题：
public
struct
ErrorLog
{
private string _message;
// other
}
{
private string _message;
// other
}
然后创建一个ErrorLog：
ErrorLog errorLog
=
new
ErrorLog ();
errorLog的_message字段将是一个空引用。我们应该通过一个属性来将_message暴露给客户代码，从而使该问题限定在ErrorLog 的内部：
public
struct
ErrorLog
{
private string _message;
public string Message
{
get
{
return (_message ! = null ) ? _message : string .Empty;
}
set { _message = value; }
}
// other
}
{
private string _message;
public string Message
{
get
{
return (_message ! = null ) ? _message : string .Empty;
}
set { _message = value; }
}
// other
}
5.4 尽量减少装箱和拆箱
装箱指把一个值类型放入一个未具名类型的引用类型中，比如：
int
valueType
=
0
;
object referenceType = i; // boxing
object referenceType = i; // boxing
拆箱则是从前面的装箱对象中取出值类型：
object
referenceType;
int valueType = ( int )referenceType; // unboxing
int valueType = ( int )referenceType; // unboxing
装箱和拆箱是比较耗费性能的，还会引入一些诡异的bug，我们应当避免装箱和拆箱。
装箱和拆箱最大的问题是会自动发生。比如：
Console.WriteLine(
"
A few numbers: {0}, {1}.
"
,
25
,
32
);
其中，Console.WriteLine()接收的参数类型是(string，object，object)。因此，实际上会执行以下操作：
int
i
=
25
;
obeject o = i; // boxing
obeject o = i; // boxing
然后把o传给WriteLine()方法。在WriteLine()方法的内部，为了调用i上的ToString()方法，又会执行：
int
i
=
(
int
)o;
//
unboxing
string output = i,ToString();
string output = i,ToString();
所以正确的做法应该是：
Console.WriteLine(
"
A few numbers: {0}, {1}.
"
,
25
.ToString(),
32
.ToString());
25.ToString()只是执行一个方法并返回一个引用类型，不存在装箱/拆箱的问题。
另一个典型的例子是ArryList的使用：
public
struct
Employee
{
private string _name;
public Employee( string name)
{
_name = name;
}
public string Name
{
get { return _name; }
set { _name = value; }
}
public override string ToString()
{
return _name;
}
}
ArrayList employees = new ArrayList();
employees.Add( new Employee( " Old Name " )); // boxing
Employee ceo = (Employee)employees[ 0 ]; // unboxing
ceo.Name = " New Name " ; // employees[0].ToString() is still "Old Name"
{
private string _name;
public Employee( string name)
{
_name = name;
}
public string Name
{
get { return _name; }
set { _name = value; }
}
public override string ToString()
{
return _name;
}
}
ArrayList employees = new ArrayList();
employees.Add( new Employee( " Old Name " )); // boxing
Employee ceo = (Employee)employees[ 0 ]; // unboxing
ceo.Name = " New Name " ; // employees[0].ToString() is still "Old Name"
上面的代码不仅存在性能的问题，还容易导致错误发生。
在这种情况下，更好的做法是使用泛型集合：
List
<
Employee
> employees
=
new
List
<
Employee
>
();
由于List<T>是强类型的集合，employees.Add()方法不进行类型转换，所以不存在装箱/拆箱的问题。
6. 总结
C#中，变量是值还是引用仅取决于其数据类型。
C#的值类型包括：结构体（数值类型，bool型，用户定义的结构体），枚举，可空类型。
C#的引用类型包括：数组，用户定义的类、接口、委托，object，字符串。
数组的元素，不管是引用类型还是值类型，都存储在托管堆上。
引用类型在栈中存储一个引用，其实际的存储位置位于托管堆。为了方便，本文简称引用类型部署在托管推上。
值类型总是分配在它声明的地方：作为字段时，跟随其所属的变量（实例）存储；作为局部变量时，存储在栈上。
值类型在内存管理方面具有更好的效率，并且不支持多态，适合用作存储数据的载体；引用类型支持多态，适合用于定义应用程序的行为。
应该尽可能地将值类型实现为具有常量性和原子性的类型。
应该尽可能地确保0为值类型的有效状态。
应该尽可能地减少装箱和拆箱。
7. 参考
Feedback
#4楼 回复 引用
2008-03-03 14:44 by calem[未注册用户]
看了你的文章，我觉得好长见识！！
#5楼 回复 引用
2008-03-03 14:46 by zzyy[未注册用户]
支持
#7楼 回复 引用
2008-03-03 15:36 by aceting[未注册用户]
很全很深刻
#8楼 回复 引用
2008-03-03 15:40 by 小雨点[未注册用户]
终于明白了~~~
#9楼 回复 引用
2008-03-03 15:41 by chaochao2008[未注册用户]
专业！
#10楼 回复 引用
2008-03-03 15:43 by albertfay[未注册用户]
竞无语凝噎。。。
#11楼 回复 引用
2008-03-03 15:47 by KerU[未注册用户]
收藏了，回头看
#13楼 回复 引用
2008-03-03 15:53 by michaelkira[未注册用户]
细节决定成败啊
头像和和谐~
@xx_2008
@柯
@calem
@zzyy
@aceting
@小雨点
@chaochao2008
@albertfay
@KerU
@michaelkira
谢谢支持！
@柯
@calem
@zzyy
@aceting
@小雨点
@chaochao2008
@albertfay
@KerU
@michaelkira
谢谢支持！
#18楼 回复 引用
2008-03-03 16:46 by yfang[未注册用户]
牛人啊~~
#22楼 回复 引用
2008-03-03 19:19 by kisfs[未注册用户]
好长的文章，慢慢看！
Effective C#》也提及了关于何时使用引用类型和值类型的问题。有一点我希望请教楼主。
比如说,我们现在有一个class
public class DataType
{
private string _data = string.Empty;
public string Data
{
set {_data = value;}
get {return _data;}
}
}
好,我们在另一个class中去使用上边的class
public class Run
{
private DataType dataType = new DataType();
... ...
public DataType Foo()
{
return dataType;
}
}
依据面向对象的理论,上边的代码是有问题的。因为我们把一个私有的数据成员轻易地暴露出去了。但是,在实际开发中,我们经常会遇到上面类似的问题。那么是不是应该把DataType定义为一个struct呢？
但是,如果说我们将DataType定义为一个值类型,但是在若干年后,DataType如果涉及到多态,那么对于整个系统来说改动太大了。
这个问题一直困扰着我,希望能点播一二。
比如说,我们现在有一个class
public class DataType
{
private string _data = string.Empty;
public string Data
{
set {_data = value;}
get {return _data;}
}
}
好,我们在另一个class中去使用上边的class
public class Run
{
private DataType dataType = new DataType();
... ...
public DataType Foo()
{
return dataType;
}
}
依据面向对象的理论,上边的代码是有问题的。因为我们把一个私有的数据成员轻易地暴露出去了。但是,在实际开发中,我们经常会遇到上面类似的问题。那么是不是应该把DataType定义为一个struct呢？
但是,如果说我们将DataType定义为一个值类型,但是在若干年后,DataType如果涉及到多态,那么对于整个系统来说改动太大了。
这个问题一直困扰着我,希望能点播一二。
@RZ
你的意思我理解，因为我平时也会碰到类似的情况。比如这样一个类型：
class Data {
private Hashtable _field;
public Data() {
_field = new Hashtable();
_field["test"] = "old";
}
public Hashtable Property {
set {
_field = value;
}
get {
return _field;//Here is the problem.
}
}
}
然后使用这个类型：
class Program {
static void Main(string[] args) {
Data data = new Data();
Console.WriteLine(data.Property["test"]);//_field["test"] is "old".
Hashtable reference = data.Property;//_field is exposed.
reference["test"] = "new";//_field is also changed!
Console.WriteLine(data.Property["test"]);//_field["test"] is "new".
Console.Read();
}
}
这就是你说的把一个私有的数据成员（_field）轻易地暴露出去了。
我也没有比较完善的解决方案。一个简单的办法是，暴露私有数据成员的副本，而不是该成员本身。比如，将
get {
return _field;//Here is the problem.
}
改为
get {
return _field.Clone() as HashTable;//Here is the problem.
}
这样，就不会有这样的问题。Clone()方法来自ICloneable接口。
这样做的问题是，Clone()方法可能实现为deep copy，也可能是shallow copy。使用时应特别小心。比如，调用DataSet的Clone()方法，只会拷贝数据结构，要连同数据一起拷贝，要调用Copy()方法。
本人才疏学浅，大家有没有更好的办法？
你的意思我理解，因为我平时也会碰到类似的情况。比如这样一个类型：
class Data {
private Hashtable _field;
public Data() {
_field = new Hashtable();
_field["test"] = "old";
}
public Hashtable Property {
set {
_field = value;
}
get {
return _field;//Here is the problem.
}
}
}
然后使用这个类型：
class Program {
static void Main(string[] args) {
Data data = new Data();
Console.WriteLine(data.Property["test"]);//_field["test"] is "old".
Hashtable reference = data.Property;//_field is exposed.
reference["test"] = "new";//_field is also changed!
Console.WriteLine(data.Property["test"]);//_field["test"] is "new".
Console.Read();
}
}
这就是你说的把一个私有的数据成员（_field）轻易地暴露出去了。
我也没有比较完善的解决方案。一个简单的办法是，暴露私有数据成员的副本，而不是该成员本身。比如，将
get {
return _field;//Here is the problem.
}
改为
get {
return _field.Clone() as HashTable;//Here is the problem.
}
这样，就不会有这样的问题。Clone()方法来自ICloneable接口。
这样做的问题是，Clone()方法可能实现为deep copy，也可能是shallow copy。使用时应特别小心。比如，调用DataSet的Clone()方法，只会拷贝数据结构，要连同数据一起拷贝，要调用Copy()方法。
本人才疏学浅，大家有没有更好的办法？
@RZ
但是你举的例子恰好有一定的特殊性。在你的例子里，真正的数据是被string型字段持有。比如：
class Data {
private string _field = "old";
public string Property {
set {
_field = value;
}
get {
return _field == null ? string.Empty : _field;
}
}
}
然后：
class Program {
static void Main(string[] args) {
Data data = new Data();
Console.WriteLine(data.Property);//_field is "old".
string reference = data.Property;//Attention! _field and reference are "old".
reference = "new";//_field is not changed.
Console.WriteLine(data.Property);//_field is "old".
Console.Read();
}
}
原因就是我文章里提到的：string reference = data.Property这种赋值看起来就像是值类型的赋值。
但是你举的例子恰好有一定的特殊性。在你的例子里，真正的数据是被string型字段持有。比如：
class Data {
private string _field = "old";
public string Property {
set {
_field = value;
}
get {
return _field == null ? string.Empty : _field;
}
}
}
然后：
class Program {
static void Main(string[] args) {
Data data = new Data();
Console.WriteLine(data.Property);//_field is "old".
string reference = data.Property;//Attention! _field and reference are "old".
reference = "new";//_field is not changed.
Console.WriteLine(data.Property);//_field is "old".
Console.Read();
}
}
原因就是我文章里提到的：string reference = data.Property这种赋值看起来就像是值类型的赋值。
#29楼 回复 引用
2008-03-04 09:54 by 天堂落日[未注册用户]
4.2的例子有待商榷：
结构不能包含显式的无参数构造函数
结构不能包含显式的无参数构造函数
4.1 数组
TestType[] testTypes = new TestType[100];
如果TestType是值类型，则会一次在托管堆上为100个值类型的元素分配存储空间，并自动初始化这100个元素，将这100个元素存储到这块内存里。
如果TestType是引用类型，则会先在托管堆为testTypes分配一次空间，并且这时不会自动初始化任何元素（即testTypes[i]均为null）。等到以后有代码初始化某个元素的时候，这个引用类型元素的存储空间才会被分配在托管堆上。
----------------------------------------------------------------
5. 正确使用值类型和引用类型
TestType[] testTypes = new TestType[100];
如果TestTye是值类型，则只需要一次分配，大小为TestTye的100倍。而如果TestTye是引用类型，刚开始需要100次分配，分 配后数组的各元素值为null，然后再初始化100个元素，结果总共需要进行101次分配。这将消耗更多的时间，造成更多的内存碎片。所以，如果类型的职 责主要是存储数据，值类型比较合适。
---------------------------------------------------------------
lz 4,5 说得有些矛盾，能够把这点讲得清楚一些，多谢。（就是引用类型数组）
TestType[] testTypes = new TestType[100];
如果TestType是值类型，则会一次在托管堆上为100个值类型的元素分配存储空间，并自动初始化这100个元素，将这100个元素存储到这块内存里。
如果TestType是引用类型，则会先在托管堆为testTypes分配一次空间，并且这时不会自动初始化任何元素（即testTypes[i]均为null）。等到以后有代码初始化某个元素的时候，这个引用类型元素的存储空间才会被分配在托管堆上。
----------------------------------------------------------------
5. 正确使用值类型和引用类型
TestType[] testTypes = new TestType[100];
如果TestTye是值类型，则只需要一次分配，大小为TestTye的100倍。而如果TestTye是引用类型，刚开始需要100次分配，分 配后数组的各元素值为null，然后再初始化100个元素，结果总共需要进行101次分配。这将消耗更多的时间，造成更多的内存碎片。所以，如果类型的职 责主要是存储数据，值类型比较合适。
---------------------------------------------------------------
lz 4,5 说得有些矛盾，能够把这点讲得清楚一些，多谢。（就是引用类型数组）
class
Program {
static void Main( string [] args) {
int [] valueTypeArray = new int [ 100 ]; // 注意new，valueTypeArray的100个成员一次性初始化为0(即int的默认值)，即所需内存1次分配好了
Console.WriteLine(valueTypeArray[ 10 ].ToString()); // 输出0
Hashtable[] referenceTypeArray = new Hashtable[ 100 ]; // 注意new，这时为referenceTypeArray分配内存
Console.WriteLine((referenceTypeArray[ 10 ] == null ).ToString()); // 但是referenceTypeArray的成员并没有被初始化，referenceTypeArray[10]为null，输出True
for ( int i = 0 ; i < 100 ; i ++ ) {
referenceTypeArray[i] = new Hashtable(); // 注意new，要初始化100个成员，我们要分配100次内存
}
// 所以一共是101次
Console.Read();
}
}
static void Main( string [] args) {
int [] valueTypeArray = new int [ 100 ]; // 注意new，valueTypeArray的100个成员一次性初始化为0(即int的默认值)，即所需内存1次分配好了
Console.WriteLine(valueTypeArray[ 10 ].ToString()); // 输出0
Hashtable[] referenceTypeArray = new Hashtable[ 100 ]; // 注意new，这时为referenceTypeArray分配内存
Console.WriteLine((referenceTypeArray[ 10 ] == null ).ToString()); // 但是referenceTypeArray的成员并没有被初始化，referenceTypeArray[10]为null，输出True
for ( int i = 0 ; i < 100 ; i ++ ) {
referenceTypeArray[i] = new Hashtable(); // 注意new，要初始化100个成员，我们要分配100次内存
}
// 所以一共是101次
Console.Read();
}
}
#34楼 回复 引用
2008-03-04 15:31 by qb2xxx[未注册用户]
楼主说得挺好的。回答别人的问题也挺有耐心。顶一个。
#35楼 回复 引用
2008-03-04 16:17 by 路人A[未注册用户]
好文章啊。
学到了很多。
学到了很多。
博主如果精通C++就知道了。
我的理解，C#的引用就是指指针。
比如int[] p = new int[10];这句话等于
int * p = new int[10];肯定分配在堆上。
而如string[] s = new string[10]这类的就是分配一个指针数组。
我的理解，C#的引用就是指指针。
比如int[] p = new int[10];这句话等于
int * p = new int[10];肯定分配在堆上。
而如string[] s = new string[10]这类的就是分配一个指针数组。
#39楼 回复 引用
2008-03-05 09:03 by GPS监控[未注册用户]
博主有才
#41楼 回复 引用
2008-03-05 12:36 by server[未注册用户]
@笼民
Jeffrey Richter的那本书你看也不止三遍吧：）
觉得你要是画出图能更清晰，调用实例方法和静态方法的你没有涉及到，还要说一下方法表指针，同步索引块
而关于引用类型，你要说的更狠一点才行，因为封装、继承，多态主要就是围绕引用类型来的，我是写不好，呵呵，但实际上一个helloworld程序说清楚不是也能讲个几天几夜吗
Jeffrey Richter的那本书你看也不止三遍吧：）
觉得你要是画出图能更清晰，调用实例方法和静态方法的你没有涉及到，还要说一下方法表指针，同步索引块
而关于引用类型，你要说的更狠一点才行，因为封装、继承，多态主要就是围绕引用类型来的，我是写不好，呵呵，但实际上一个helloworld程序说清楚不是也能讲个几天几夜吗
@server
那本书我断断续续看过一些。。。
我是一个UI designer，能花在技术上的时间非常有限，有机会我一定写：）
谢谢你的建议！
那本书我断断续续看过一些。。。
我是一个UI designer，能花在技术上的时间非常有限，有机会我一定写：）
谢谢你的建议！
#43楼 回复 引用
2008-03-06 08:36 by Wey[未注册用户]
有两个类A和B,其中B继承于A,为什么A a=new B() ; a.GetType() 会是B 呢?能解释一下吗?
@Wey
你说的这个叫多态（Polymorphism）
简单地说，你把a想象成一个指针，指向一个B的实例，调用a.GetType()，调用的是a指向的实例上的GetType()方法。
你说的这个叫多态（Polymorphism）
简单地说，你把a想象成一个指针，指向一个B的实例，调用a.GetType()，调用的是a指向的实例上的GetType()方法。
#46楼 回复 引用
2008-07-03 14:00 by 赵晓伟[未注册用户]
赵晓伟到此一游
程序我不行，
程序我不行，
#48楼 回复 引用
2008-08-01 12:04 by 蒋能忠[未注册用户]
很好!!
#49楼 回复 引用
2008-08-04 17:31 by gosling[未注册用户]
楼主能这么详细的讲解。。支持。。。望能结交朋友，，还有很多题想请教。。
404886498
404886498
扫一扫
3515
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
