C#Object类型

在C#中，Object类型是所有类型的根，大家平常开发中都要跟它打交道，但不见得对它里面的每个方法都知根知底，下面对它里面的每个方法都进行仔细的总结。
概述：
构造函数
Equals函数
Finalize函数
GetHashCode函数
GetType()函数
ReferenceEquals函数
MemberWiseClone()函数
ToString()函数
Object类型中一共有8个方法，重载的方法没有算进来。下面一一来看看这些方法。
1、构造函数
函数签名：public Object()
作用：这个就不用多说了
注意点：直接使用new Object()可以用来创建对象；如果非Object类型，则在该类型的构造函数被调用时，该函数自动被调用。
2、Equals函数,该方法有重载函数
函数签名:public virtual bool Equals(Object obj)
public static bool Equals(Object objA,Object objB)
先来看看public virtual bool Equals(Object obj)，从签名里就可以看出来，这个方法是用来开放给继承类去根据实际情况重写的。
注意点：
1）默认情况下，对于引用类型，该方法对比的时引用的地址，对于值类型，对比的是值的二进制描述是否相同。100.0与100虽然都是100，但是它们的二进制分布是不一样的。
2）不管是引用类型还是值类型，重写该方法的主要目的都是实现根据值来判断对象是否相等。
3）该方法本身只支持原子类型的比较以及简单对象的比较，如果是自定义复杂的类型，则有必要重写该方法。
4）重写该方法时，应满足一些规则。
首先x.Equals(x)应该返回true；
x.Equals(y)的结果应该与y.Equals(x)相同；
x.Equals(y)返回true，如果x和y都是Nan；
如果x.Equals(y) && y.Equals(z),则x.Equals(z)应该返回true；
x.Equals(null)都返回false;
5）在重写Equals()方法时，不应该抛出异常；
6）实现IComparable接口的话，一定记得重写Equals方法；
7）如果重写了Equals()，则一般情况也必须重写GetHashCode(),不然如果把该类型的对方放在hashtable结构上的话可能产生问题；
8）如果对==进行了操作符重载，则记得一定重写Equals()；按照这样的设计方法，类型代码在调用Equals时的运行结果，能够跟应用程序调用==时的结果保持一致。
看完了public virtual bool Equals(Object obj),我们接着来看看它的重载方法public static bool Equals(Object objA,Object objB)
该方法返回true的条件：
1）objA和objB是同一个实例
2）objA和objB都是null
3）objA.Equas(objB)返回true
注意上面三个条件是||的关系
对比这两个Equals方法，还是很容易对比出不同点的。
3、Finalize函数
函数签名：protected virtual void Finalize()
作用：允许对象在垃圾回收回收该对象之前尝试释放资源并执行其它清理操作。
注意点：
Finalize 是受保护的，因此只能通过此类或派生类访问它。
对象变为不可访问后将自动调用此方法，除非已通过 SuppressFinalize 调用使对象免除了终结。在应用程序域的关闭过程中，对没有免除终结的对象将自动调用 Finalize，即使那些对象仍是可访问的。对于给定的实例仅自动调用 Finalize 一次，除非使用 ReRegisterForFinalize 这类机制重新注册该对象并且后面没有调用 GC.SuppressFinalize。
派生类型中的每个 Finalize 实现都必须调用其基类型的 Finalize 实现。这是唯一一种允许应用程序代码调用 Finalize 的情况。
Finalize 操作具有下列限制：
垃圾回收过程中执行终结器的准确时间是不确定的。不保证资源在任何特定的时间都能释放，除非调用 Close 方法或 Dispose 方法。
即使一个对象引用另一个对象，也不能保证两个对象的终结器以任何特定的顺序运行。即，如果对象 A 具有对对象 B 的引用，并且两者都有终结器，则当对象 A 的终结器启动时，对象 B 可能已经终结了。
运行终结器的线程是未指定的。
在下面的异常情况下，Finalize 方法可能不会运行完成或可能根本不运行：
另一个终结器无限期地阻止（进入无限循环，试图获取永远无法获取的锁，诸如此类）。由于运行时试图运行终结器来完成，所以如果一个终结器无限期地阻止，则可能不会调用其他终结器。
进程终止，但不给运行时提供清理的机会。在这种情况下，运行时的第一个进程终止通知是 DLL_PROCESS_DETACH 通知。
在关闭过程中，只有当可终结对象的数目继续减少时，运行时才继续 Finalize 对象。
如果 Finalize 或 Finalize 的重写引发异常，并且运行库并非寄宿在重写默认策略的应用程序中，则运行库将终止进程，并且不执行任何活动的 try-finally 块或终结器。如果终结器无法释放或销毁资源，此行为可以确保进程完整性。
对实现者的说明：
默认情况下，Object..::.Finalize 不执行任何操作。只有在必要时才必须由派生类重写它，因为如果必须运行 Finalize 操作，垃圾回收过程中的回收往往需要长得多的时间。
如果 Object 保存了对任何资源的引用，则 Finalize 必须由派生类重写，以便在垃圾回收过程中，在放弃 Object 之前释放这些资源。
当类型使用文件句柄或数据库连接这类在回收使用托管对象时必须释放的非托管资源时，该类型必须实现 Finalize。有关辅助和具有更多控制的资源处置方式，请参见 IDisposable 接口。
Finalize 可以采取任何操作，包括在垃圾回收过程中清理了对象后使对象复活（即，使对象再次可访问）。但是，对象只能复活一次；在垃圾回收过程中，不能对复活对象调用 Finalize。
析构函数是执行清理操作的 C# 机制。析构函数提供了适当的保护措施，如自动调用基类型的析构函数。
4、GetHashCode函数
函数签名：public virtual int GetHashCode()
作用：用作特定类型的哈希函数。
注意点：
GetHashCode 方法适用于哈希算法和诸如哈希表之类的数据结构。
GetHashCode 方法的默认实现不保证针对不同的对象返回唯一值。而且，.NET Framework 不保证 GetHashCode 方法的默认实现以及它所返回的值在不同版本的 .NET Framework 中是相同的。因此，在进行哈希运算时，该方法的默认实现不得用作唯一对象标识符。
GetHashCode 方法可以由派生类型重写。值类型必须重写此方法，以提供适合该类型的哈希函数和在哈希表中提供有用的分布。为了获得最佳结果，哈希代码必须基于实例字段或属性（而非静态字段或属性）的值。
用作 Hashtable 对象中键的对象还必须重写 GetHashCode 方法，因为这些对象必须生成其各自的哈希代码。如果用作键的对象不提供 GetHashCode 的有用实现，您可以在构造 Hashtable 对象时指定哈希代码提供程序。在 .NET Framework 2.0 版之前，哈希代码提供程序是基于 System.Collections..::.IHashCodeProvider 接口的。从 2.0 版开始，哈希代码提供程序基于 System.Collections..::.IEqualityComparer 接口。
对实现者的说明：
哈希函数用于快速生成一个与对象的值相对应的数字（哈希代码）。哈希函数通常是特定于每个 Type 的，而且，必须至少使用一个实例字段作为输入。
哈希函数必须具有以下特点：
如果两个对象的比较结果相等，则每个对象的 GetHashCode 方法都必须返回同一个值。但是，如果两个对象的比较结果不相等，则这两个对象的 GetHashCode 方法不一定返回不同的值。
一个对象的 GetHashCode 方法必须总是返回同一个哈希代码，但前提是没有修改过对象状态，对象状态用来确定对象的 Equals 方法的返回值。请注意，这仅适用于应用程序的当前执行，再次运行该应用程序时可能会返回另一个哈希代码。
为了获得最佳性能，哈希函数必须为所有输入生成随机分布。
例如，String 类提供的 GetHashCode 方法的实现为相同的字符串值返回相同的哈希代码。因此，如果两个 String 对象表示相同的字符串值，则它们返回相同的哈希代码。另外，该方法使用字符串中的所有字符生成相当随机的分布式输出，即使当输入集中在某些范围内时（例如，许多用户可能有只包含低位 128 个 ASCII 字符的字符串，即使字符串可以包含 65,535 个 Unicode 字符中的任何字符）。
对于 Object 的派生类，当且仅当此派生类将值相等性定义为引用相等并且类型不是值类型时，GetHashCode 方法才可以委托给 Object..::.GetHashCode 实现。
在类上提供好的哈希函数可以显著影响将这些对象添加到哈希表的性能。在具有好的哈希函数实现的哈希表中，搜索元素所用的时间是固定的（例如运算复杂度为 O(1) 的运算）。而在具有不好的哈希函数实现的哈希表中，搜索性能取决于哈希表中的项数（例如运算复杂度为 O(n) 的运算，其中的 n 是哈希表中的项数）。哈希函数的计算成本也必须不高。
GetHashCode 方法的实现必须不会导致循环引用。例如，如果 ClassA.GetHashCode 调用 ClassB.GetHashCode，ClassB.GetHashCode 必须不直接或间接调用 ClassA.GetHashCode。
GetHashCode 方法的实现必须不引发异常。
重写 GetHashCode 的派生类还必须重写 Equals，以保证被视为相等的两个对象具有相同的哈希代码；否则，Hashtable 类型可能无法正常工作。
示例
在某些情况下，GetHashCode 方法的实现只返回整数值。下面的代码示例阐释了返回整数值的 GetHashCode 的实现。
using System;
public struct Int32 {
public int value;
//other methods…
public override int GetHashCode()
{
return value;
}
}
一个类型常具有多个可以参与生成哈希代码的数据字段。生成哈希代码的一种方法是使用 XOR (eXclusive OR) 运算合并这些字段，如下面的代码示例所示。
using System;
public struct Point {
public int x;
public int y;
//other methods
public override int GetHashCode() {
return x ^ y;
}
}
下面的代码示例阐释了另一种情况：使用 XOR (eXclusive OR) 合并该类型的字段以生成哈希代码。注意，在该代码示例中，字段表示用户定义的类型，每个类型都实现 GetHashCode 和 Equals。
using System;
public class SomeType {
public override int GetHashCode() {
return 0;
}
}
public class AnotherType {
public override int GetHashCode() {
return 1;
}
}
public class LastType {
public override int GetHashCode() {
return 2;
}
}
public class MyClass {
SomeType a = new SomeType();
AnotherType b = new AnotherType();
LastType c = new LastType();
public override int GetHashCode () {
return a.GetHashCode() ^ b.GetHashCode() ^ c.GetHashCode();
}
}
如果派生类的数据成员比 Int32 大，则可以使用 XOR (eXclusive OR) 运算合并该值的高序位和低序位，如下面的代码示例所示。
using System;
public struct Int64 {
public long value;
//other methods…
public override int GetHashCode() {
return ((int)value ^ (int)(value >> 32));
}
}
5、GetType()函数
函数签名：public Type GetType()
作用：获取当前实例的确切运行时类型。
注意点：
对于具有相同运行时类型的两个对象 x 和 y，虽然Object.ReferenceEquals(x,y)返回的是false，但是 Object.ReferenceEquals(x.GetType(),y.GetType()) 返回 true。
Type 对象公开与当前 Object 的类关联的元数据。
下面的代码示例说明 GetType 返回当前实例的运行时类型。
using System;
public class MyBaseClass: Object {
}
public class MyDerivedClass: MyBaseClass {
}
public class Test {
public static void Main() {
MyBaseClass myBase = new MyBaseClass();
MyDerivedClass myDerived = new MyDerivedClass();
object o = myDerived;
MyBaseClass b = myDerived;
Console.WriteLine(“mybase: Type is {0}”, myBase.GetType());
Console.WriteLine(“myDerived: Type is {0}”, myDerived.GetType());
Console.WriteLine(“object o = myDerived: Type is {0}”, o.GetType());
Console.WriteLine(“MyBaseClass b = myDerived: Type is {0}”, b.GetType());
}
}
6、ReferenceEquals函数
函数原型：public static bool ReferenceEquals( Object objA,Object objB )
作用：判断两个指定的对象实例是否是同一个实例。从描述也可以看出来，如果参数是值类型，则会装箱，比较的是装箱后的对象实例。
注意：
如果 objA 是与 objB 是相同的实例，或者如果二者都为空引用，则为 true；否则为 false。
下面的代码示例使用 ReferenceEquals 确定两个对象是否是相同的实例。
using System;
class MyClass {
static void Main() {
object o = null;
object p = null;
object q = new Object();
Console.WriteLine(Object.ReferenceEquals(o, p));
p = q;
Console.WriteLine(Object.ReferenceEquals(p, q));
Console.WriteLine(Object.ReferenceEquals(o, p));
}
}
7、MemberWiseClone()函数
函数签名：protected Object MemberWiseClone()
作用：创建当前 Object 的浅表副本。
注意：
MemberwiseClone 方法创建一个浅表副本，方法是创建一个新对象，然后将当前对象的非静态字段复制到该新对象。如果字段是值类型的，则对该字段执行逐位复制。如果字段是引用类型，则复制引用但不复制引用的对象；因此，原始对象及其复本引用同一对象。非静态字段属于整个类，不管是深拷贝，还是浅拷贝，都是不需要处理的。并且需要注意该方法是protected的，即只有在类本身内部，或者它的继承者内部才能够调用它。
例如，考虑一个名为 X 的对象，该对象引用对象 A 和 B。对象 B 又引用对象 C。X 的浅表副本创建一个新对象 X2，该对象也引用对象 A 和 B。与此相对照，X 的深层副本创建一个新对象 X2，该对象引用新对象 A2 和 B2，它们分别是 A 和 B 的副本。B2 又引用新对象 C2，C2 是 C 的副本。使用实现 ICloneable 接口的类执行对象的浅表或深层复制。
下面的代码示例说明如何使用 MemberwiseClone 复制类的实例。
using System;
class MyBaseClass {
public static string CompanyName = “My Company”;
public int age;
public string name;
}
class MyDerivedClass: MyBaseClass {
static void Main() {
// Creates an instance of MyDerivedClass and assign values to its fields.
MyDerivedClass m1 = new MyDerivedClass();
m1.age = 42;
m1.name = “Sam”;
// Performs a shallow copy of m1 and assign it to m2.
MyDerivedClass m2 = (MyDerivedClass) m1.MemberwiseClone();
}
}
8、ToString()函数
函数签名：public virtual string ToString()
作用：返回一个代表当前对象的字符串
注意：默认情况下返回的是该对象所属类型的全名称。继承类可以重写该方法，以便自定义显示输出内容，如果继承类需要控制更多的格式化输出，则需要实现IFormattable接口。
下面的代码演示了如何重写ToString(),以及如何实现IFormattable接口
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace IFormattablePractise
{
public class Point : IFormattable
{
int x;
int y;
public Point(int x , int y)
{
this.x = x;
this.y = y;
}
public override string ToString()
{
return ToString(null, null);
}

region IFormattable Members

public string ToString(string format, IFormatProvider formatProvider)
{
// If no format is passed, display like this: (x, y).
if (format == null) return String.Format(“({0}, {1})”, x, y);
// For “x” formatting, return just the x value as a string
if (format == “x”) return x.ToString();
// For “y” formatting, return just the y value as a string
if (format == “y”) return y.ToString();
// For any unrecognized format, throw an exception.
throw new FormatException(String.Format(“Invalid format string: ‘{0}’.”, format));
}

endregion

}
class Program
{
static void Main(string[] args)
{
// Create the object.
Point p = new Point(5, 98);
// Test ToString with no formatting.
Console.WriteLine(“This is my point: ” + p.ToString());
// Use custom formatting style “x”
Console.WriteLine(“The point’s x value is {0:x}”, p);
// Use custom formatting style “y”
Console.WriteLine(“The point’s y value is {0:y}”, p);
Console.WriteLine(“my custom point value is ({0:x}:{1:y})”,p,p);
try
{
// Use an invalid format; FormatException should be thrown here.
Console.WriteLine(“Invalid way to format a point: {0:XYZ}”, p);
}
catch (FormatException e)
{
Console.WriteLine(“The last line could not be displayed: {0}”, e.Message);
}
Console.ReadLine();
}
}
}

转自：http://blog.csdn.net/wnln25/article/details/6678357
C#中的object类深入理解
C#中所有的类都直接或间接继承自System.Object类，这使得C#中的类得以单根继承。如果我们没有明确指定继承类，编译器缺省认为该类继承自System.Object类。System.Object类也可用小写的object关键字表示，两者完全等同。自然C#中所有的类都继承了System.Object类的公共接口，剖析它们对我们理解并掌握C#中类的行为非常重要。下面是仅用接口形式表示的System.Object类：

namespace System
{
public class Object
{
public static bool Equals(object objA,object objB){}
public static bool ReferenceEquals(object objA,object objB){}

    public Object(){}

    public virtual bool Equals(object obj){}
    public virtual int GetHashCode(){}
    public Type GetType(){}
    public virtual string ToString(){}

    protected virtual void Finalize(){}
    protected object MemberwiseClone(){}
}

我们先看object的两个静态方法Equals(object objA,object objB)，ReferenceEquals(object objA,object objB)和一个实例方法Equals(object obj)。在我们阐述这两个方法之前我们首先要清楚面向对象编程两个重要的相等概念：值相等和引用相等。值相等的意思是它们的数据成员按内存位分别相等。引用相等则是指它们指向同一个内存地址，或者说它们的对象句柄相等。引用相等必然推出值相等。对于值类型关系等号“==”判断两者是否值相等（结构类型和枚举类型没有定义关系等号“==”，我们必须自己定义）。对于引用类型关系等号“==”判断两者是否引用相等。值类型在C#里通常没有引用相等的表示，只有在非托管编程中采用取地址符“&”来间接判断二者的地址是否相等。

静态方法Equals(object objA,object objB)首先检查两个对象objA和objB是否都为null，如果是则返回true，否则进行objA.Equals(objB)调用并返回其值。问题归结到实例方法Equals(object obj)。该方法缺省的实现其实就是{return this= =obj;}也就是判断两个对象是否引用相等。但我们注意到该方法是一个虚方法，C#推荐我们重写此方法来判断两个对象是否值相等。实际上Microsoft.NET框架类库内提供的许多类型都重写了该方法，如：System.String（string），System.Int32（int）等，但也有些类型并没有重写该方法如：System.Array等，我们在使用时一定要注意。对于引用类型，如果没有重写实例方法Equals(object obj)，我们对它的调用相当于this= =obj，即引用相等判断。所有的值类型（隐含继承自System.ValueType类）都重写了实例方法Equals(object obj)来判断是否值相等。

注意对于对象x，x.Equals(null)返回false，这里x显然不能为null（否则不能完成Equals()调用，系统抛出空引用错误）。从这里我们也可看出设计静态方法Equals(object objA,object objB)的原因了–如果两个对象objA和objB都可能为null，我们便只能用object. Equals(object objA,object objB)来判断它们是否值相等了–当然如果我们没有改写实例方法Equals(object obj)，我们得到的仍是引用相等的结果。我们可以实现接口IComparable来强制改写实例方法Equals(object obj)。

对于值类型，实例方法Equals(object obj)应该和关系等号“==”的返回值一致，也就是说如果我们重写了实例方法Equals(object obj)，我们也应该重载或定义关系等号“==”操作符，反之亦然。虽然值类型（继承自System.ValueType类）都重写了实例方法Equals(object obj)，但C#推荐我们重写自己的值类型的实例方法Equals(object obj)，因为系统的System.ValueType类重写的很低效。对于引用类型我们应该重写实例方法Equals(object obj)来表达值相等，一般不应该重载关系等号“==”操作符，因为它的缺省语义是判断引用相等。

静态方法ReferenceEquals(object objA,object objB)判断两个对象是否引用相等。如果两个对象为引用类型，那么它的语义和没有重载的关系等号“==”操作符相同。如果两个对象为值类型，那么它的返回值一定是false。

实例方法GetHashCode()为相应的类型提供哈希（hash）码值，应用于哈希算法或哈希表中。需要注意的是如果我们重写了某类型的实例方法Equals(object obj)，我们也应该重写实例方法GetHashCode()–这理所应当，两个对象的值相等，它们的哈希码也应该相等。下面的代码是对前面几个方法的一个很好的示例：

using System;
struct A
{
public int count;
}
class B
{
public int number;
}
class C
{
public int integer=0;
public override bool Equals(object obj)
{
C c=obj as C;
if (c!=null)
return this.integer==c.integer;
else
return false;
}
public override int GetHashCode()
{
return 2^integer;
}
}
class Test
{
public static void Main()
{
A a1,a2;
a1.count=10;
a2=a1;

    //Console.Write(a1==a2);没有定义“==”操作符
    Console.Write(a1.Equals(a2));//True

Console.WriteLine(object.ReferenceEquals(a1,a2));//False

    B b1=new B();
    B b2=new B();

    b1.number=10;
    b2.number=10;
    Console.Write(b1==b2);//False
    Console.Write(b1.Equals(b2));//False

Console.WriteLine(object.ReferenceEquals(b1,b2));//False

    b2=b1;
    Console.Write(b1==b2);//True
    Console.Write(b1.Equals(b2));//True
    Console.WriteLine(object.ReferenceEquals(b1,b2));//True

    C c1=new C();
    C c2=new C();

    c1.integer=10;
    c2.integer=10;
    Console.Write(c1==c2);//False
    Console.Write(c1.Equals(c2));//True

Console.WriteLine(object.ReferenceEquals(c1,c2));//False

    c2=c1;
    Console.Write(c1==c2);//True
    Console.Write(c1.Equals(c2));//True
    Console.WriteLine(object.ReferenceEquals(c1,c2));//True
}

}

如我们所期望，编译程序并运行我们会得到以下输出：

True False
False False False
True True True
False True False
True True True

实例方法GetType()与typeof的语义相同，它们都通过查询对象的元数据来确定对象的运行时类型，我们在“第十讲 特征与映射”对此作详细的阐述。

实例方法ToString()返回对象的字符串表达形式。如果我们没有重写该方法，系统一般将类型名作为字符串返回。

受保护的Finalize()方法在C#中有特殊的语义，我们将在“第五讲 构造器与析构器”里详细阐述。

受保护的MemberwiseClone()方法返回目前对象的一个“影子拷贝”，该方法不能被子类重写。“影子拷贝”仅仅是对象的一份按位拷贝，其含义是对对象内的值类型变量进行赋值拷贝，对其内的引用类型变量进行句柄拷贝，也就是拷贝后的引用变量将持有对同一块内存的引用。相对于“影子拷贝”的是深度拷贝，它对引用类型的变量进行的是值复制，而非句柄复制。例如X是一个含有对象A,B引用的对象，而对象A又含有对象M的引用。Y是X的一个“影子拷贝”。那么Y将拥有同样的A,B的引用。但对于X的一个“深度拷贝”Z来说，它将拥有对象C和D的引用，以及一个间接的对象N的引用，其中C是A的一份拷贝，D是B的一份拷贝，N是M的一份拷贝。深度拷贝在C#里通过实现ICloneable接口（提供Clone()方法）来完成。

转自：http://apps.hi.baidu.com/share/detail/14180240
C# 中object sender与EventArgs e
一、了解C#中的预定义事件处理机制
在写代码前我们先来熟悉.net框架中和事件有关的类和委托，了解C#中预定义事件的处理。
EventArgs是包含事件数据的类的基类,用于传递事件的细节。
EventHandler是一个委托声明如下
public delegate void EventHandler( object sender , EventArgs e )
注意这里的参数,前者是一个对象（其实这里传递的是对象的引用，如果是button1的click事件则sender就是button1），后面是包含事件数据的类的基类。
下面我们研究一下Button类看看其中的事件声明（使用WinCV工具查看），以Click事件为例。
public event EventHandler Click;
这里定义了一个EventHandler类型的事件Click
前面的内容都是C#在类库中已经为我们定义好了的。下面我们来看编程时产生的代码。
private void button1_Click(object sender, System.EventArgs e)
{
…
}
这是我们和button1_click事件所对应的方法。注意方法的参数符合委托中的签名（既参数列表）。那我们怎么把这个方法和事件联系起来呢，请看下面的代码。
this.button1.Click += new System.EventHandler(this.button1_Click);
把this.button1_Click方法绑定到this.button1.Click事件。
下面我们研究一下C#事件处理的工作流程，首先系统会在为我们创建一个在后台监听事件的对象(如果是 button1的事件那么监听事件的就是button1)，这个对象用来产生事件，如果有某个用户事件发生则产生对应的应用程序事件，然后执行订阅了事件的所有方法。
二、简单的自定义事件(1)
首先我们需要定义一个类来监听客户端事件，这里我们监听键盘的输入。
定义一个委托。
public delegate void UserRequest(object sender,EventArgs e);
前面的object用来传递事件的发生者，后面的EventArgs用来传递事件的细节，现在暂时没什么用处，一会后面的例子中将使用。
下面定义一个此委托类型类型的事件
public event UserRequest OnUserRequest;
下面我们来做一个死循环
public void Run() { bool finished=false; do { if (Console.ReadLine()==”h”) { OnUserRequest(this,new EventArgs()); } }while(!finished); }
此代码不断的要求用户输入字符，如果输入的结果是h,则触发OnUserRequest事件，事件的触发者是本身（this），事件细节无(没有传递任何参数的EventArgs实例)。我们给这个类取名为UserInputMonitor。
下面我们要做的是定义客户端的类 首先得实例化UserInputMonitor类
UserInputMonitor monitor=new UserInputMonitor();
然后我们定义一个方法。
private void ShowMessage(object sender,EventArgs e)
{
Console.WriteLine(“HaHa!!”);
}
最后要做的是把这个方法和事件联系起来（订阅事件），我们把它写到库户端类的构造函数里。
Client(UserInputMonitor m)
{
m.OnUserRequest+=new UserInputMonitor.UserRequest(this.ShowMessage);
//m.OnUserRequest+=new m.UserRequest(this.ShowMessage);
//注意这种写法是错误的，因为委托是静态的

  }
  下面创建客户端的实例。
    new Client(monitor);
  对了，别忘了让monitor开始监听事件。
     monitor.run();
  大功告成，代码如下：

using System; class UserInputMonitor { public delegate void UserRequest(object sender,EventArgs e); //定义委托 public event UserRequest OnUserRequest; //此委托类型类型的事件 public void Run() { bool finished=false; do { if (Console.ReadLine()==”h”) { OnUserRequest(this,new EventArgs()); } }while(!finished); } }
public class Client { public static void Main() { UserInputMonitor monitor=new UserInputMonitor(); new Client(monitor); monitor.Run(); } private void ShowMessage(object sender,EventArgs e) { Console.WriteLine(“HaHa!!”); } Client(UserInputMonitor m) { m.OnUserRequest+=new UserInputMonitor.UserRequest(this.ShowMessage); //m.OnUserRequest+=new m.UserRequest(this.ShowMessage); //注意这种写法是错误的，因为委托是静态的 } }
三、进一步研究C#中的预定义事件处理机制
可能大家发现在C#中有些事件和前面的似乎不太一样。例如
private void textBox1_KeyPress(object sender, System.Windows.Forms.KeyPressEventArgs e)
{

   }
   this.textBox1.KeyPress+=newSystem.Windows.Forms.KeyPressEventHandler(this.textBox1_KeyPress);
 这里使用了KeyPressEventArgs而不是EventArgs作为参数。这里使用了KeyEventHandler委托，而不是EventHandler委托。
KeyPressEventArgs是EventArgs的派生类，而KeyEventHandler的声明如下
   public delegate void KeyEventHandler( object sender , KeyEventArgs e );
是参数为KeyEventArgs的委托。那为什么KeyPress事件要这么做呢，我们可以从两个类的构造函数来找答案。
   public EventArgs();
   public KeyPressEventArgs(char keyChar);
 这里的keyData是什么，是用来传递我们按下了哪个键的，哈。
 我在KeyEventArgs中又发现了属性
    public char KeyChar { get; }
 进一步证明了我的理论。下面我们来做一个类似的例子来帮助理解。

四、简单的自定义事件(2)
拿我们上面做的例子来改。
我们也定义一个EventArgs（类似KeyEventArgs）取名MyEventArgs,定义一个构造函数public MyEventArgs(char keyChar),同样我们也设置相应的属性。代码如下
using System; class MyMyEventArgs:EventArgs { private char keyChar; public MyMyEventArgs(char keyChar) { this.keychar=keychar; } public char KeyChar { get { return keyChar; } } }
因为现在要监听多个键了，我们得改写监听器的类中的do…while部分。改写委托，改写客户端传递的参数。好了最终代码如下，好累
using System; class MyEventArgs:EventArgs { private char keyChar; public MyEventArgs(char keyChar) { this.keyChar=keyChar; } public char KeyChar { get { return keyChar; } } }
class UserInputMonitor { public delegate void UserRequest(object sender,MyEventArgs e); //定义委托 public event UserRequest OnUserRequest; //此委托类型类型的事件 public void Run() { bool finished=false; do { string inputString= Console.ReadLine(); if (inputString!=”“) OnUserRequest(this,new MyEventArgs(inputString[0])); }while(!finished); } }
public class Client { public static void Main() { UserInputMonitor monitor=new UserInputMonitor(); new Client(monitor); monitor.Run(); } private void ShowMessage(object sender,MyEventArgs e) { Console.WriteLine(“捕捉到：{0}”,e.KeyChar); } Client(UserInputMonitor m) { m.OnUserRequest+=new UserInputMonitor.UserRequest(this.ShowMessage); //m.OnUserRequest+=new m.UserRequest(this.ShowMessage); //注意这种写法是错误的，因为委托是静态的 } }