properties
在c#中为类预定义属性是件再简单不过的事，见程序1。
程序1
using system;
namespace propertiesdemo
{
public class mydata
{
...............
}
public class class1
{
private mydata _data;
public mydata data
{
get { return _data; }
}
public class1()
{
_data = new mydata();
}
}
}
这是相当常见的属性预定义方式，同时也是个可正常运行的程序，不过其中隐含着一个设计上的问题，那就是创建mydata对象的时机。按照程序2-1的手法，当class1对象被创建之初，其内的_data对象也随着被创建起来，这造成了class1对象于创建初期就付出了一个mydata对象的内存成本，这对简单的类来说或如牛毛，但倘若class1对象中拥有一群这类属性呢?为了解决这类问题，.net framework中大量使用lazy-allocate(缓分配)技术，见程序2。
程序2 lazy-allocate范例
public class class1
{
private mydata _data;
public mydata data
{
get
{
if(_data == null)
data = new mydata();
return _data;
}
}
public class1() { }
}
lazy-allocate的设计概念很简单，就是未使用前不预付成本。相对于程序2-1所使用的pre-allocate(预分配)概念，程序2-2采取以时间换取空间的策略，付出存取判断式的代价来减轻空间浪费的情况。当然，pre-allocate也不是一无是处，不须预判断的快速存取特色适用于用户必然会存取的属性，但在一些特定的属性上，例如asp.net中常见的style属性就不适合使用pre-allocate技巧，因为用户不一定会使用该属性，于此情况下，lazy-allocate模式说可以让对象省下一些内存成本。
event
事件处理是组件设计中相当重要的一环，在c#中事件与delegate是紧密相关的，程序3是一个简单的事件范例。
程序3 简单的事件范例
using system;
namespace eventdemo
{
public delegate void processhandler(object sender);
public class class1
{
private event processhandler _processhandler = null;
public event processhandler processstart
{
add
{
_processhandler += value;
}
remove
{
_processhandler -= value;
}
}
public void process()
{
_processhandler(this);
for(int i = 0; i < 10; i++)
i = i+1;
}
public class1()
{}
}
}
c#之中delegate扮演着函数指针的角色，用户可以将某个函数加入一个delegate之中，而一个delegate允许用户加入一个以上的函数，当调用此delegate时就等同于调用其内所含的所有函数。不过程序2-3的设计手法潜藏着一个问题，就是当事件数众多时，对象就必须付出相应数量的delegate变量，如程序4所示。
程序4 传统事件设计
private event processhandler _processstart = null;
private event processhandler _processend = null;
private event processhandler _processstep = null;
不管用户是否用到了这些事件，当对象被创建起来时就得付出这些成本，这在窗口应用程序上更显得可怕，因为windows message(窗口消息)的数量以千为单位，假如一个简单的窗口程序就必须付出相对于windows message数量的变量成本，这样一来对象岂不成了庞然大物了。针对这个问题，.net framework采取了与lazy-allocate类似的方式来处理，见程序5。
程序5 新事件设计模式
public class class1
{
private hashtable _eventlist = new hashtable();
private static object _processstart = new object();
private static object _processend = new object();
public event processhandler processstart
{
add
{
_eventlist.add(_processstart,value);
}
remove
{
_eventlist.remove(_processstart);
}
}
public event processhandler processend
{
add
{
_eventlist.add(_processend,value);
}
remove
{
_eventlist.remove(_processend);
}
}
public void process()
{
processhandler start = (processhandler)_eventlist[_processstart];
processhandler end = (processhandler)_eventlist[_processend];
if(start != null) start(this);
for(int i = 0; i < 10; i++)
i = i+1;
if(end != null)
end(this);
}
程序中声明了一个hashtable类型的对象:_eventlist，每一个class1类的实体都拥有这个对象，另外还声明了两个object类型的对象:_processstart、_processend，注意!这两个对象是static(静态)类型，也就是说，不管有多少个对象实体，都只须花费两个object的空间。那这与2-4的范例做法有何不同呢?答案是对象所占的内存大小不同，当用户创建一个对象实体之后，此对象占用了一个hashtable对象的内存空间，在用户设定了processstart事件时，此对象随之占用了一个hashtable元素的内存空间，若用户未设定事件，那么此元素的内存空间就不会被占用，相较于2-4范例的预付行为，此方式可以省下不必要付出的内存成本。再详细点说，假设class1拥有1000个事件，那么程序2-4的做法在对象创建初期就会占用1000个event变量的内存空间，而程序2-5则要付出一个hashtable对象及1000个static变量的代价，当用户创建了第二个对象时，程序2-4要再次占用了1000个event变量的代价，但程序5只须占用一个hashtable对象的代价，优劣立见不是吗?很幸运，这种设计概念在.net framework中已提供了基础建设，设计人员只要套用即可，见程序6。
程序6 .net framework内建的事件支持
public class component1:component
{
private static object _processstart = new object();
public event eventhandler processstart
{
add
{
events.addhandler(_processstart,value);
}
remove
{
events.removehandler(_processstart,value);
}
}
public void process()
{
eventhandler handler = (eventhandler)events[_processstart];
if(handler != null)
handler(this,null);
}
}
只要继承自component类或其子类就可使用这种方式来处理事件。
static helper object
c#是个纯oop的语言，这代表着它不允许设计人员声明全局性的函数或是变量，它提倡以静态函数与静态变量来取代原本须要使用全局性函数及变量的地方，由于静态函数与静态变量都要声明于类内，这个限制形成群集的效应，同时引出了另一种类型的运用:static helper object，见程序7。
程序7 static helper object范例
public sealed class domainhelper
{
public static string getcurrentdomaindir()
{
return appdomain.currentdomain.basedirectory;
}
private domainhelper()
{}
}
............
messagebox.show(domainhelper.getcurrentdomaindir());
domainhelper是一个不允许继承且具备私有构造函数的类，这代表着设计人员不可能创建或是继承此类，domainhelper提供了getcurrentdomaindir静态函数，用来返回目前application domain所在的路径，这比起原来调用appdomain. getcurrentdomain. basedirectory函数来取得同样结果的方式简短了许多。helper object的中心概念就是将常用的辅助型函数包装成静态函数，设计人员就无须一再重复地撰写这些程序代码，组件设计技术与helper object息息相关，读者们会在后面的章节中看到更多这类型的例子。
