[转]C#自定义控件属性与行为

原文链接:http://blog.csdn.net/a237428367/article/details/5926445

控件应该定义属性而不是公共字段，因为可视化设计器在属性浏览器中显示属性，而不显示字段。属性就像智能字段。属性通常具有带访问函数的专用数据成员，在语法上属性被作为类的字段进行访问。（虽然属性可以具有不同的访问级别，但此处的讨论将重点放在公共访问这种更加常见的情况上。

属性定义通常由以下两部分组成：

1、专用数据成员的定义。

1. private int number = 0;

private int number = 0;

2、使用属性声明语法对公共属性进行的定义。

1. //该语法通过 get 和 set 访问函数将专用数据成员和公共属性关联起来。
2. public int MyNumber
3. {
4. get
5. {
6. return number;
7. }
8. set
9. {
10. number = value;
11. }
12. }

//该语法通过 get 和 set 访问函数将专用数据成员和公共属性关联起来。
public int MyNumber
{
get
{
return number;
}
set
{
number = value;
}
}

虽然属性定义中通常包含专用数据成员，但这不是必需的。get 访问器不用访问私有数据成员就可以返回值。get 方法返回系统时间的属性就属于这种情况。属性启用数据隐藏，访问器方法隐藏属性的实现。

定义属性时需考虑以下重要的注意事项：

1、   必须将属性应用于定义的属性。属性用来指定设计器显示属性的方式。

2、   如果改变属性将影响控件的外观显示，请从 set 访问器中调用 Invalidate 方法（从 Control 继承该方法）。Invalidate 随后调用 OnPaint 方法，该方法将重新绘制控件。为提高效率起见，对 Invalidate 的多次调用将产生对 OnPaint 的一次调用。

3、   .NET Framework 类库为常见数据类型（如整数、小数、布尔值和其他数据）提供了类型转换器。类型转换器的目的通常是用来提供字符串到数值的转换（从字符串数据转换为其他数据类型）。常见数据类型与默认类型转换器（将数值转换为字符串，并将字符串转换为相应数据类型）相关联。如果定义了自定义（即，非标准）数据类型的属性，则应用的属性必须将类型转换器指定为与该属性相关联。还可以使用属性使自定义 UI 类型编辑器与某个属性相关联。UI 类型编辑器提供了一个用来编辑属性或数据类型的用户界面。颜色选择器是 UI 类型编辑器的一个示例。

例：首先创建一个名为 DrawingMode 的简单枚举。

1. public enum DrawingMode
2. {
3. Happy = 0,
4. Sad = 1,
5. Angry = 2
6. }

public enum DrawingMode
{
Happy = 0,
Sad = 1,
Angry = 2
}

接着，向该控件添加 MyDrawingMode 属性

1. private DrawingMode myDrawingMode;
2. [Browsable(true), Category("Appearance")]
3. public DrawingMode MyDrawingMode
4. {
5. get
6. {
7. return myDrawingMode;
8. }
9. set
10. {
11. myDrawingMode = value;
12. SetColors();
13. }
14. }

private DrawingMode myDrawingMode;
[Browsable(true), Category("Appearance")]
public DrawingMode MyDrawingMode
{
get
{
return myDrawingMode;
}
set
{
myDrawingMode = value;
SetColors();
}
}

对 SetColors 方法的调用只是根据 myDrawingMode 的值设置控件的 BackColor 和 ForeColor。向控件添加下面的代码。

1. private void SetColors()
2. {
3. switch (myDrawingMode)
4. {
5. case DrawingMode.Happy:
6. this.BackColor = Color.Yellow;
7. this.ForeColor = Color.Green;
8. break;
9. case DrawingMode.Sad:
10. this.BackColor = Color.LightSlateGray;
11. this.ForeColor = Color.White;
12. break;
13. case DrawingMode.Angry:
14. this.BackColor = Color.Red;
15. this.ForeColor = Color.Teal;
16. break;
17. default:
18. this.BackColor = Color.Black;
19. this.ForeColor = Color.White;
20. break;
21. }
22. }

private void SetColors()
{
switch (myDrawingMode)
{
case DrawingMode.Happy:
this.BackColor = Color.Yellow;
this.ForeColor = Color.Green;
break;
case DrawingMode.Sad:
this.BackColor = Color.LightSlateGray;
this.ForeColor = Color.White;
break;
case DrawingMode.Angry:
this.BackColor = Color.Red;
this.ForeColor = Color.Teal;
break;
default:
this.BackColor = Color.Black;
this.ForeColor = Color.White;
break;
}
}

现在可以向控件的paint方法添加代码，来绘制控件的样式，也可以添加现有的控件来组合实现想要的功能（例子里面有）。

1. private void UserControl1_Paint(object sender, PaintEventArgs e)
2. {
3. Graphics curG = e.Graphics;
4. Pen curPen = new Pen(Color.Black);
5. Rectangle curRect = new Rectangle(0, 0, Width - 2, Height - 3);
6. curG.DrawRectangle(curPen, curRect);
7. curG.DrawEllipse(curPen, curRect);
8. }

private void UserControl1_Paint(object sender, PaintEventArgs e)
{
Graphics curG = e.Graphics;
Pen curPen = new Pen(Color.Black);
Rectangle curRect = new Rectangle(0, 0, Width - 2, Height - 3);
curG.DrawRectangle(curPen, curRect);
curG.DrawEllipse(curPen, curRect);
}

---

事件（Event）

事件是对象发送的消息，以发信号通知操作的发生。操作可能是由用户交互（例如鼠标单击）引起的，也可能是由某些其他的程序逻辑触发的。引发事件的对象称为事件发送方。捕获事件并对其作出响应的对象叫做事件接收方。

在事件通信中，事件发送方类不知道哪个对象或方法将接收到（处理）它引发的事件。所需要的是在源和接收方之间存在一个媒介（或类似指针的机制）。.NET Framework 定义了一个特殊的类型（Delegate），该类型提供函数指针的功能。

代理（delegate）

delegate是C#中的一种类型，它实际上是一个能够持有对某个方法的引用的类。与其它的类不同，delegate类能够拥有一个签名（signature），并且它只能持有与它的签名相匹配的方法的引用。这样，代理就等效于一个类型安全函数指针或一个回调。它允许你传递一个类A的方法m给另一个类B的对象，使得类B的对象能够调用这个方法m。但与函数指针相比，delegate有许多函数指针不具备的优点。首先，函数指针只能指向静态函数，而delegate既可以引用静态函数，又可以引用非静态成员函数。在引用非静态成员函数时，delegate不但保存了对此函数入口指针的引用，而且还保存了调用此函数的类实例的引用。其次，与函数指针相比，delegate是面向对象、类型安全、可靠的受控（managed）对象。也就是说，runtime能够保证delegate指向一个有效的方法，你无须担心delegate会指向无效地址或者越界地址。

实现一个delegate是很简单的，通过以下3个步骤即可实现一个delegate：

1． 声明一个delegate对象，它应当与你想要传递的方法具有相同的参数和返回值类型。

2． 创建delegate对象，并将你想要传递的函数作为参数传入。

3． 在要实现异步调用的地方，通过上一步创建的对象来调用方法。

1. public class MyDelegateTest
2. {
3. // 步骤1，声明delegate对象
4. public delegate void MyDelegate(string name);
5. // 这是我们欲传递的方法，它与MyDelegate具有相同的参数和返回值类型
6. public static void MyDelegateFunc(string name)
7. {
8. Console.WriteLine("Hello, {0}", name);
9. }
10. public static void Main ()
11. {
12. // 步骤2，创建delegate对象
13. MyDelegate md = new MyDelegate(MyDelegateTest.MyDelegateFunc);
14. // 步骤3，调用delegate
15. md("sam1111");
16. }
17. }

public class MyDelegateTest
{
// 步骤1，声明delegate对象
public delegate void MyDelegate(string name);
// 这是我们欲传递的方法，它与MyDelegate具有相同的参数和返回值类型
public static void MyDelegateFunc(string name)
{
Console.WriteLine("Hello, {0}", name);
}
public static void Main ()
{
// 步骤2，创建delegate对象
MyDelegate md = new MyDelegate(MyDelegateTest.MyDelegateFunc);
// 步骤3，调用delegate
md("sam1111");
}
}

C#中的事件处理实际上是一种具有特殊签名的delegate，象下面这个样子：

1. public delegate void MyEventHandler(object sender, MyEventArgs e);

public delegate void MyEventHandler(object sender, MyEventArgs e);

其中的两个参数，sender代表事件发送者，e是事件参数类。MyEventArgs类用来包含与事件相关的数据，所有的事件参数类都必须从System.EventArgs类派生。当然，如果你的事件不含特别的参数，那么可以直接用System.EventArgs类作为参数。

结合delegate的实现，我们可以将自定义事件的实现归结为以下几步：

1：定义delegate对象类型，它有两个参数，第一个参数是事件发送者对象，第二个参数是事件参数类对象。

2：定义事件参数类，此类应当从System.EventArgs类派生。如果事件不带参数，这一步可以省略。

3：定义事件处理方法，它应当与delegate对象具有相同的参数和返回值类型。

4：用event关键字定义事件对象，它同时也是一个delegate对象。

5：用+=操作符添加事件到事件队列中（-=操作符能够将事件从队列中删除）。

6：在需要触发事件的地方用调用delegate的方式写事件触发方法。一般来说，此方法应为protected访问限制，既不能以public方式调用，但可以被子类继承。名字是可以是OnEventName。

7：在适当的地方调用事件触发方法触发事件。

下面是一个例子，例子模仿容器和控件的模式，由控件触发一个事件，在容器中捕捉并且进行处理。

1. /// <summary>
2. /// 事件的触发者
3. /// </summary>
4. public class Control
5. {
6. public delegate void SomeHandler(object sender, System.EventArgs e);
7. public event SomeHandler SomeEvent;
8. public Control()
9. {
10. //这里使用的delegate必须与事件中声名的一致
11. this.SomeEvent += new SomeHandler(this.ProcessSomeEvent);
12. }
13. public void RaiseSomeEvent()
14. {
15. EventArgs e = new EventArgs();
16. Console.Write("Please input 'a':");
17. string s = Console.ReadLine();
18. //在用户输入一个小a的情况下触发事件，否则不触发
19. if (s == "a")
20. {
21. SomeEvent(this, e);
22. }
23. }
24. //事件的触发者自己对事件进行处理，这个方法的参数必须和代理中声名的一致
25. private void ProcessSomeEvent(object sender, EventArgs e)
26. {
27. Console.WriteLine("hello");
28. }
29. }

/// <summary>
/// 事件的触发者
/// </summary>
public class Control
{
public delegate void SomeHandler(object sender, System.EventArgs e);
public event SomeHandler SomeEvent;
public Control()
{
//这里使用的delegate必须与事件中声名的一致
this.SomeEvent += new SomeHandler(this.ProcessSomeEvent);
}
public void RaiseSomeEvent()
{
EventArgs e = new EventArgs();
Console.Write("Please input 'a':");
string s = Console.ReadLine();
//在用户输入一个小a的情况下触发事件，否则不触发
if (s == "a")
{
SomeEvent(this, e);
}
}
//事件的触发者自己对事件进行处理，这个方法的参数必须和代理中声名的一致
private void ProcessSomeEvent(object sender, EventArgs e)
{
Console.WriteLine("hello");
}
}

1. /// <summary>
2. /// 事件的接收和处理者
3. /// </summary>
4. class Container
5. {
6. private Control ctrl = new Control();
7. 　  public Container()
8. {
9. //这里使用的delegate必须与事件中声名的一致
10. ctrl.SomeEvent += new Control.SomeHandler(this.ResponseSomeEvent);
11. ctrl.RaiseSomeEvent();
12. }
13. public static void Main()
14. {
15. Container pane = new Container();
16. Console.ReadLine();
17. }
18. //这是事件的接受者对事件的响应
19. private void ResponseSomeEvent(object sender, EventArgs e)
20. {
21. Console.WriteLine("Some event occur!");
22. }
23. }

/// <summary>
/// 事件的接收和处理者
/// </summary>
class Container
{
private Control ctrl = new Control();
　 public Container()
{
//这里使用的delegate必须与事件中声名的一致
ctrl.SomeEvent += new Control.SomeHandler(this.ResponseSomeEvent);
ctrl.RaiseSomeEvent();
}
public static void Main()
{
Container pane = new Container();
Console.ReadLine();
}
//这是事件的接受者对事件的响应
private void ResponseSomeEvent(object sender, EventArgs e)
{
Console.WriteLine("Some event occur!");
}
}

1. //程序运行的结果如下：
2. please input 'a':a
3. hello
4. Some event occur!

//程序运行的结果如下：
please input 'a':a
hello
Some event occur!

---

而我们看到的工具箱上的每个控件都有自己的图标，我们可以通过下面语句为自己制作的控件添加图标。

1. [ToolboxBitmap(@"D:/Program Files/qq/AirDLIcon/1381love.ico")]
2. public partial class UserControl1 : UserControl
3. {………….}

[ToolboxBitmap(@"D:/Program Files/qq/AirDLIcon/1381love.ico")]
public partial class UserControl1 : UserControl
{………….}

即在控件类前面加上ToolboxBitmap属性，属性参数指向一个图片的地址就可以了。

再比如，我自己定义了一个属性，如果不进行设置，是不会在属性窗口显示的，也就是我们在用控件的时候不能够通过可视化的界面对其进行设置，想让它在属性窗口显示，就要用Browsable属性了，如下面的例子。

1. public enum DrawingMode{Happy = 0,Sad = 1,Angry = 2}
2. private DrawingMode myDrawingMode;
3. [Browsable(true)]
4. public DrawingMode MyDrawingMode
5. {
6. get
7. {
8. return myDrawingMode;
9. }
10. set
11. {
12. myDrawingMode = value;
13. }
14. }

public enum DrawingMode{Happy = 0,Sad = 1,Angry = 2}
private DrawingMode myDrawingMode;
[Browsable(true)]
public DrawingMode MyDrawingMode
{
get
{
return myDrawingMode;
}
set
{
myDrawingMode = value;
}
}

像这样的属性还可以组合使用，例如上面的例子，我在Browsable属性后面再加上一个Category属性，让它的参数等于Appearance，这时我们自己定义的属性就从属性框中的杂项转到了外观项里面了。

1. [Browsable(true), Category("Appearance")]

[Browsable(true), Category("Appearance")]

像这样的属性有很多，我主要罗列下面这些，在使用的时候大家可以参照。

Browsable

适用于属性和事件，指定属性或事件是否应该显示在属性浏览器中。

Category

适用于属性和事件，指定类别的名称，在该类别中将对属性或事件进行分组。当使用了类别时，组件属性和事件可以按逻辑分组显示在属性浏览器中。

Description

适用于属性和事件，定义一小块文本，该文本将在用户选择属性或事件时显示在属性浏览器底部。

Bindable

适用于属性 指定是否要绑定到该属性。

DefaultProperty

适用于属性，（将此特性插入类声明前。）指定组件的默认属性。当用户单击控件时，将在属性浏览器中选定该属性。

DefaultValue

适用于属性，为属性设置一个简单的默认值。

Editor

适用于属性，指定在可视设计器中编辑（更改）属性时要使用的编辑器。

Localizable

适用于属性，指定属性可本地化。当用户要本地化某个窗体时，任何具有该特性的属性都将自动永久驻留到资源文件中。

DesignerSerializationVisibility

适用于属性，指定显示在属性浏览器中的属性是否应该（以及如何）永久驻留在代码中。

TypeConverter

适用于属性，指定将属性的类型转换为另一个数据类型时要使用的类型转换器。

DefaultEvent

适用于事件，（将此特性插入类声明前。）指定组件的默认事件。这是当用户单击组件时在属性浏览器中选定的事件。