зеркало из https://github.com/mono/old-code.git
47 строки
2.9 KiB
XML
47 строки
2.9 KiB
XML
<?xml version="1.0"?>
|
|
<clause number="8.7.5" title="Events" informative="true">
|
|
<paragraph>An event is a member that enables an object or class to provide notifications. A class defines an event by providing an event declaration (which resembles a field declaration, though with an added event keyword) and an optional set of event accessors. The type of this declaration must be a delegate type. </paragraph>
|
|
<paragraph>An instance of a delegate type encapsulates one or more callable entities. For instance methods, a callable entity consists of an instance and a method on that instance. For static methods, a callable entity consists of just a method. Given a delegate instance and an appropriate set of arguments, one can invoke all of that delegate instance's methods with that set of arguments. </paragraph>
|
|
<paragraph>In the example <code_example><![CDATA[
|
|
public delegate void EventHandler(object sender, System.EventArgs e);
|
|
public class Button
|
|
{
|
|
public event EventHandler Click;
|
|
public void Reset() {
|
|
Click = null;
|
|
}
|
|
}
|
|
]]></code_example>the Button class defines a Click event of type EventHandler. Inside the Button class, the Click member is exactly like a private field of type EventHandler. However, outside the Button class, the Click member can only be used on the left-hand side of the += and -= operators. The += operator adds a handler for the event, and the -= operator removes a handler for the event. The example <code_example><![CDATA[
|
|
using System;
|
|
public class Form1
|
|
{
|
|
public Form1() {
|
|
// Add Button1_Click as an event handler for Button1's Click event
|
|
Button1.Click += new EventHandler(Button1_Click);
|
|
}
|
|
Button Button1 = new Button();
|
|
void Button1_Click(object sender, EventArgs e) {
|
|
Console.WriteLine("Button1 was clicked!");
|
|
}
|
|
public void Disconnect() {
|
|
Button1.Click -= new EventHandler(Button1_Click);
|
|
}
|
|
}
|
|
]]></code_example>shows a Form1 class that adds Button1_Click as an event handler for Button1's Click event. In the Disconnect method, that event handler is removed. </paragraph>
|
|
<paragraph>For a simple event declaration such as <code_example><![CDATA[
|
|
public event EventHandler Click;
|
|
]]></code_example>the compiler automatically provides the implementation underlying the += and -= operators. </paragraph>
|
|
<paragraph>An implementer who wants more control can get it by explicitly providing add and remove accessors. For example, the Button class could be rewritten as follows: <code_example><![CDATA[
|
|
public class Button
|
|
{
|
|
private EventHandler handler;
|
|
public event EventHandler Click {
|
|
add { handler += value; }
|
|
|
|
remove { handler -= value; }
|
|
}
|
|
}
|
|
]]></code_example></paragraph>
|
|
<paragraph>This change has no effect on client code, but allows the Button class more implementation flexibility. For example, the event handler for Click need not be represented by a field. </paragraph>
|
|
</clause>
|