.net编程中的一些技巧（一）

Lazy_Allocate(缓分配)

它可以让对象节省一些内存成本

public class myclass
{
private DataSet _ds;
public DataSet ds
{
get
{
if(_ds==null)//如果没有创建实例,则创建一个新的
{
_ds=new DataSet();
}
return _ds;
}
}
}

Static Helper Object

sealed关键字可以防止类被继承.static可以定义类的静态变量或静态函数.

public sealed class mystring
{
public static string getHello()
{
return "Hello World!";
}
}

这样可以通过mystring.getHello()取得字符串"Hello World!"

Helper Object的中心概念就是将常用的辅助型函数包装成静态函数,设计人员无需重复撰写这些程序代码

Event
c#中Event于delegate是密切相关的,delegate翻译过来就是委托,其实就是函数指针.

以下代码是delegate的最简单的应用示例，会在浏览器端输出Hello World!

public delegate void mydele(string a);
public class delegatetest : System.Web.UI.Page
{
private void Page_Load(object sender, System.EventArgs e)
{
mydele md=new mydele(output);
md("Hello World!");
}

public void output(string a)
{
Response.Write(a);
}

#region Web 窗体设计器生成的代码
override protected void OnInit(EventArgs e)
{
//
// CODEGEN: 该调用是 ASP.NET Web 窗体设计器所必需的。
//
InitializeComponent();
base.OnInit(e);
}

/// <summary>
/// 设计器支持所需的方法 - 不要使用代码编辑器修改
/// 此方法的内容。
/// </summary>
private void InitializeComponent()
{
this.Load += new System.EventHandler(this.Page_Load);

}
#endregion
}

event 关键字使您得以指定当代码中的某些“事件”发生时调用的委托。此委托可以有一个或多个关联的方法，当代码指示该事件已发生时将调用关联的方法。可使一个程序中的事件用于面向 .NET Framework 公共语言运行库的其他程序。

为了创建并使用 C# 事件，必须采取以下步骤：

1. 创建或标识一个委托。如果正在定义自己的事件，还必须确保有与事件关键字一起使用的委托。如果已经预定义了事件（例如在 .NET Framework 中），则事件的使用者只需要知道委托的名称。
2. 创建一个类，包含：
   1. 从委托创建的事件。
   2. （可选）验证用 event 关键字声明的委托实例是否存在的方法。否则，该逻辑必须放置在引发此事件的代码中。
   3. 调用此事件的方法。这些方法可以重写一些基类功能。
   此类定义事件。

3. 定义一个或多个将方法连接到事件的类。所有这些类都包括：
   • 使用 += 运算符和 -= 运算符将一个或多个方法与基类中的事件关联。
   • 将与事件关联的方法的定义。
4. 使用此事件：
   • 创建包含事件声明的类对象。
   • 使用定义的构造函数，创建包含事件定义的类对象。

下面示例代码改编自MSDN：

using System;
namespace MyCollections
{
using System.Collections;
//定义委托
public delegate void ChangedEventHandler(object sender, EventArgs e);
//该类功能与ArrayList一样，但是添加了当其内容被修改时的事件
public class ListWithChangedEvent: ArrayList
{
//定义事件的名称
public event ChangedEventHandler Changed;
// 内部方法，每一个内部修改的方法都调用它
protected virtual void OnChanged(EventArgs e)
{
if (Changed != null)
Changed(this, e);
}
//覆写每一个类内部修改的方法，使修改的时候事件被触发
public override int Add(object value)
{
int i = base.Add(value);
OnChanged(EventArgs.Empty);
return i;
}
public override void Clear()
{
base.Clear();
OnChanged(EventArgs.Empty);
}
public override object this[int index]
{
set
{
base[index] = value;
OnChanged(EventArgs.Empty);
}
}
}
}
namespace TestEvents
{
using MyCollections;
class EventListener
{
private ListWithChangedEvent List;

//构造函数
public EventListener(ListWithChangedEvent list)
{
List = list;
//添加List的changed事件，使触发时调用ListChanged方法
List.Changed += new ChangedEventHandler(ListChanged);
}
// 触发时调用的ListChanged方法
private void ListChanged(object sender, EventArgs e)
{
Console.WriteLine("This is called when the event fires.");
}
public void Detach()
{
// 将与事件关联的方法分离，并将list从内存清除
List.Changed -= new ChangedEventHandler(ListChanged);
List = null;
}
}
class Test
{
public static void Main()
{
// 创建ListWithChangedEvent的实例
ListWithChangedEvent list = new ListWithChangedEvent();
// 创建list的侦听类的实例
EventListener listener = new EventListener(list);
// list执行添加和清空项的操作
list.Add("item 1");//这里触发一次changed的事件
list.Clear();//这里触发一次changed的事件
listener.Detach();
}
}
}

以下是MSDN给出的代码解释：

声明事件 若要在类内声明事件，首先必须声明该事件的委托类型（如果尚未声明的话）。
public delegate void ChangedEventHandler(object sender, EventArgs e);
委托类型定义传递给处理该事件的方法的一组参数。多个事件可共享相同的委托类型，因此仅当尚未声明任何合适的委托类型时才需要执行该步骤。
接下来，声明事件本身。
public event ChangedEventHandler Changed;
声明事件的方法与声明委托类型的字段类似，只是关键字 event 在事件声明前面，在修饰符后面。事件通常被声明为公共事件，但允许任意可访问修饰符。
调用事件 类声明了事件以后，可以就像处理所指示的委托类型的字段那样处理该事件。如果没有任何客户将委托与该事件挂钩，该字段将为空；否则该字段引用应在调用该事件时调用的委托。因此，调用事件时通常先检查是否为空，然后再调用事件。
if (Changed != null)
Changed(this, e);
调用事件只能从声明该事件的类内进行。
与事件挂钩 从声明事件的类外看，事件像个字段，但对该字段的访问是非常受限制的。只可进行如下操作：
在该字段上撰写新的委托。
从字段（可能是复合字段）移除委托。
使用 += 和 -= 运算符完成此操作。为开始接收事件调用，客户代码先创建事件类型的委托，该委托引用应从事件调用的方法。然后它使用 += 将该委托写到事件可能连接到的其他任何委托上。

// Add "ListChanged" to the Changed event on "List":
List.Changed += new ChangedEventHandler(ListChanged);

当客户代码完成接收事件调用后，它将使用运算符 -= 从事件移除其委托。

// Detach the event and delete the list:
List.Changed -= new ChangedEventHandler(ListChanged);

MSDN的示例代码中有一个中间的EventListener类，看起来可能不大好理解，我自己写了一个，难度比MSDN上提供的简单些：

namespace DesignPattern
{
/// <summary>
/// eventtest 的摘要说明。
/// </summary>
using myns;
public class eventtest : System.Web.UI.Page
{
private void Page_Load(object sender, System.EventArgs e)
{
Data d=new Data();
d.Added+=new ChangedHandler(this.add);
d.ReLoaded+=new ChangedHandler(this.reload);
d.Add(5);
d.ReLoad();
}
private void add(object sender,System.EventArgs e)
{
Response.Write("add finish<br>");
}
private void reload(object sender,System.EventArgs e)
{
Response.Write("reload finish<br>");
}
#region Web 窗体设计器生成的代码
override protected void OnInit(EventArgs e)
{
//
// CODEGEN: 该调用是 ASP.NET Web 窗体设计器所必需的。
//
InitializeComponent();
base.OnInit(e);
}

/// <summary>
/// 设计器支持所需的方法 - 不要使用代码编辑器修改
/// 此方法的内容。
/// </summary>
private void InitializeComponent()
{
this.Load += new System.EventHandler(this.Page_Load);
}
#endregion
}

}
namespace myns
{
public delegate void ChangedHandler(Object sender,System.EventArgs e);
//一个超级简单的数据类，里面只有一个int变量，类只有最简单的加和归零2个方法，定义了2个事件
public class Data
{
private int i=0;
public event ChangedHandler Added;
public event ChangedHandler ReLoaded;
protected void OnAdd(EventArgs e)
{
if(Added!=null)Added(this,e);
}
protected void OnReLoad(EventArgs e)
{
if(ReLoaded!=null)ReLoaded(this,e);
}
public void Add(int key)
{
i+=key;
OnAdd(EventArgs.Empty);
}
public void ReLoad()
{
i=0;
OnReLoad(EventArgs.Empty);
}
public int getNum()
{
return i;
}
}
}