Tài liệu Module 8: Delegates and Events docx

Using Delegates In this demonstration, you will use MicrosoftVisual Studio® .NET to run code in which a delegate to a light object’s method is passed to a switch object.. Multicast Dele

Trang 2

domain names, e-mail addresses, logos, people, places and events depicted herein are fictitious, and no association with any real company, organization, product, domain name, e-mail address, logo, person, place or event is intended or should be inferred Complying with all applicable copyright laws is the responsibility of the user Without limiting the rights under copyright, no part of this document may be reproduced, stored in or introduced into a retrieval system, or transmitted in any form or by any means (electronic, mechanical, photocopying, recording, or otherwise), or for any purpose, without the express written permission of Microsoft Corporation Microsoft may have patents, patent applications, trademarks, copyrights, or other intellectual property rights covering subject matter in this document Except as expressly provided in any written license agreement from Microsoft, the furnishing of this document does not give you any license to these patents, trademarks, copyrights, or other intellectual property

Microsoft, ActiveX, BizTalk, IntelliMirror, Jscript, MSDN, MS-DOS, MSN, PowerPoint, Visual Basic, Visual C++, Visual C#, Visual Studio, Win32, Windows, Windows Media, and Window NT are either registered trademarks or trademarks of Microsoft Corporation in the U.S.A and/or other countries

The names of actual companies and products mentioned herein may be the trademarks of their respective owners

Trang 3

Instructor Notes

After completing this module, students will be able to:

! Use the delegate class to create type-safe callback functions and handling methods

event-! Use the event keyword to simplify and improve the implementation of a

class that raises events

! Implement events that conform to the Microsoft® NET Framework guidelines

Materials and Preparation

This section provides the materials and preparation tasks that you need to teach this module

Required Materials

To teach this module, you need the Microsoft PowerPoint® file 2349B_08.ppt

Preparation Tasks

To prepare for this module, you should:

! Read all of the materials for this module

! Practice the demonstrations

! Complete the lab

Presentation:

75 Minutes

Lab:

75 Minutes

Trang 4

Demonstrations

This section provides demonstration procedures that will not fit in the margin notes or are not appropriate for the student notes

Using Delegates

In this demonstration, you will use MicrosoftVisual Studio® NET to run code

in which a delegate to a light object’s method is passed to a switch object When the switch object’s state changes, the switch object calls the light

object’s method and passes its new state

The code for this demonstration is provided in the student notes The

demonstration files are located in <install folder>\Democode\Mod08\

Demo08.1\Using Delegates

Multicast Delegates

In this demonstration, you will show students how to add and remove methods

from the invocation list of multicast delegates by using the plus operator (+) and the minus operator (-)

The code for this demonstration is provided in the student notes The

demonstration files are located in <install folder>\Democode\Mod08\

Demo08.2\MULTICAST DELEGATES

Module Strategy

Use the following strategy to present this module:

! Delegates Use the Delegate Scenario to help students to visualize and comprehend the concept of delegates Some students may question the validity of this scenario In the real world, a house would never be rewired dynamically, but you can explain that software programs often need to rebind dynamically

! Multicast Delegates Contrast typical multicast delegate use with that of the single delegate example by using the common scenario of a switch that controls two light bulbs Explain how to create and invoke multicast delegates and show how

to use the + and – operators in C# to add and remove methods from the

invocation list of multicast delegates

! Events Use the Event Scenario to help students to visualize and comprehend the concept of events Emphasize that events are an important building block for creating classes that can be reused in many different programs, and that delegates are particularly suited for event handling Explain how to declare, connect to, and raise an event

Introduce the NET Framework guidelines for delegates and events

! When to Use Delegates, Events, and Interfaces Contrast and compare the specific usage characteristics of delegates, interfaces, and events for providing callback functionality in particular situations

Trang 5

Overview

! Delegates

! Multicast Delegates

! Events

! When to Use Delegates, Events, and Interfaces

***************************** ILLEGAL FOR NON - TRAINER USE ******************************

In the Microsoft® NET Framework, delegates are the object-oriented equivalents of function pointers However, unlike function pointers, delegates are type-safe and secure The common language runtime supports the use of delegates in callback and event-handling scenarios

An event is raised by an object or event source in response to an action performed by a user or some sort of program logic The event receiver must

then respond to the raised event and perform an action The event keyword lets

you specify delegates that will be called upon the occurrence of an event After completing this module, you will be able to:

! Use the delegate class to create type-safe callback functions and handling methods

event-! Use the event keyword to simplify and improve the implementation of a

class that raises events

! Implement events that conform to the NET Framework guidelines

Trang 6

You can use delegates to encapsulate a reference to a method inside a delegate object Because delegates are type-safe, secure, managed objects, they offer all

of the advantages of pointers without any of the disadvantages of pointers For example, delegates will always point to a valid object and cannot corrupt the memory of other objects

Topic Objective

To provide an overview of

the topics in this section

Lead-in

In this section, you will learn

about how delegates are

used in the NET

Framework

Trang 7

Delegate Scenario

1 - Change in switch position invokes switch’s OnFlip method

2 - OnFlip Method invokes delegate

3 - Delegate invokes light’s OnFlipCallback method

4 - OnFlipCallback method changes light’s state

OnFlip method

Switch Object

OnFlipCallback method

Light Object

Delegate object

OnFlip method

Switch Object

This scenario of a switch that controls a light illustrates one use of delegates

The switch object models an electric switch, and the light object models an electric light The delegate object encapsulates a reference to a light object’s OnFlipCallback method

The switch object code could be written without a delegate by referring directly

to the specific light object’s method However, this approach does not offer the flexibility to dynamically connect, disconnect, and reconnect various light object methods to the switch object You can use a delegate object that connects the switch object and the light object to achieve this flexibility

In real life, the preceding scenario would probably not occur as described While a house would never be rewired dynamically, software programs often need to dynamically rebind

When the switch is flipped in the light switch scenario shown in the slide:

1 The switch object’s OnFlip method is invoked

2 The OnFlip method invokes the delegate object

3 The delegate object invokes the light object’s OnFlipCallback method

4 The OnFlipCallback method changes the state of the light

Topic Objective

To illustrate one use of

delegates through the

scenario of a switch and a

light bulb

Lead-in

This scenario of a switch

that controls a light

illustrates one use of

delegates

To run the build slide, click

through the lower-left button

on the slide

For Your Information

Stress that this scenario

reflects a common scenario

to which everyone can

relate While you may not

use the same light switch to

turn different lights on and

off at different times, this

scenario helps you to

visualize and comprehend

the concepts behind

delegates

Delivery Tip

You should briefly preview

the Demonstration: Using

Delegates to provide

students with an overview of

the code that can be used to

implement this scenario

Defer discussion of delegate

specific code until after the

following topics are covered

Trang 8

Declaring a Delegate

! A Delegate Declaration Defines a Type That Encapsulates a Method with a Particular Set of Arguments and Return Type

// declares a delegate for a method that takes a single// argument of type string and has a void return typedelegate void MyDelegate1(string s);

A delegate declaration defines a type that encapsulates a method with a particular set of arguments and return type The delegate declaration is sufficient to define a delegate class whose actual implementation is provided by the common language runtime

The following example shows how to declare a delegate for a method that takes

a single argument of type string and has a void return type:

delegate void MyDelegate1(string s);

defines a type that

encapsulates a method with

a particular set of arguments

and return type

The details of how the

common language runtime

creates delegates are

presented later in this

module

Trang 9

Instantiating a Delegate

! A Delegate Object Is Created with the new Operator

! Delegate Objects Are Immutable

// instantiating a delegate to a static method Hello// in the class MyClass

MyDelegate1 a = new MyDelegate1(MyClass.Hello);

// instantiating a delegate to an instance method// AMethod in object p

MyClass p = new MyClass();

MyDelegate1 b = new MyDelegate1(p.AMethod);

// instantiating a delegate to a static method Hello// in the class MyClass

MyDelegate1 a = new MyDelegate1(MyClass.Hello);

// instantiating a delegate to an instance method// AMethod in object p

MyClass p = new MyClass();

After you have declared a delegate type, you can create a delegate object and associate it with a particular method This topic explains the code used to instantiate delegates

Creating a New Delegate Object Like all objects, a new delegate object is created with the new operator When creating a delegate, however, the argument passed to the new operator is

special: it is written like a method call, but without the arguments to the method After a delegate is created, the method to which it is associated never changes: delegate objects are immutable

When referencing an object, an interesting and useful feature of a delegate is that the delegate does not know or care about the class of the object that it references It can reference any object as long as the method’s signature matches the delegate’s signature

A delegate can reference static or instance methods When referencing instance methods, the delegate stores not only a reference to the method’s entry point, but also a reference to the object instance on which the method is invoked

Topic Objective

To explain how to instantiate

delegates

Lead-in

After you have declared a

delegate type, you can

create a delegate object and

associate it with a particular

method

Delivery Tip

To place the delegate

instantiation code in a fuller

context, refer to the

following code example

Trang 10

The following example shows how to declare a delegate named MyDelegate1

The code illustrates how this delegate can be instantiated to a static or an

instance method The signature of the method and MyDelegate1 must match; the method must have a void return and take a single argument of type string

} }

// instantiating a delegate to a static method MyDelegate1 a = new MyDelegate1(MyClass.Hello);

// instantiating a delegate to object p's AMethod method MyClass p = new MyClass();

Trang 11

Calling a Delegate

! Use a Statement Containing:

to the delegate

// given the previous delegate declaration and// instantiation, the following invokes MyClass'// static method Hello with the parameter "World"

a("World");

// given the previous delegate declaration and// instantiation, the following invokes MyClass'// static method Hello with the parameter "World"

a("World");

After a delegate object is created, it can be passed to other code that will call the

delegate For example, a server object may provide a method that a client

object calls to register a callback method for a specific event The server will

invoke this callback method when that event occurs Typically, the client

instantiates a delegate that refers to its callback method The client passes the callback delegate object as a parameter

You can call a delegate object by using the name of the delegate, followed by the parenthesized arguments to be passed to the delegate For example, using

the declaration and instantiations of delegates a and b shown in the previous slide, the following lines invoke the static Hello method of the class MyClass and the AMethod of the MyClass object p with the argument "World": a("World");

After a delegate is created,

it can be passed to other

code that will call the

delegate

Refer to the previous slide

on delegate declaration and

instantiations

Trang 12

Demonstration: Using Delegates

In this demonstration, you will use MicrosoftVisual Studio® NET to run code

in which a delegate to a light object’s method is passed to a switch object When the switch object’s state changes, the switch object calls the light

object’s method and passes its new state

Topic Objective

To demonstrate using a

callback delegate

Lead-in

In this demonstration, you

will use MicrosoftVisual

Studio NET to run code in

which a delegate to a light

object’s method is passed to

a switch object When the

switch object’s state

changes, the switch object

calls the light object’s

method and passes its new

state

Delivery Tip

Use Visual Studio NET to

run the following code Set

breakpoints or single step to

illustrate the sequence of

events

Trang 13

using System;

namespace SwitchAndLight {

public enum SwitchPosition {Up, Down};

delegate void SwitchFlipped(SwitchPosition switchState); class Light

{ private string name;

public Light(string s) {

} public void OnFlipCallback(SwitchPosition switchState) {

private SwitchPosition switchState = SwitchPosition.Down;

private SwitchFlipped switchFlippedHandler = null;

public void ConnectToLight(SwitchFlipped lightHandler) {

switchFlippedHandler = lightHandler;

} public SwitchPosition SwitchState {

get {return switchState;}

}

(Code continued on the following page.)

As noted in C#

Language-Specific Syntax in this

module, delegate types with

a void return value in C#

cause the compiler to derive

the delegate class from the

Trang 14

public void OnFlip() {

static void OnFlip(Switch aSwitch) {

Switch s = new Switch();

Light light1 = new Light("bathroom");

Light light2 = new Light("bedroom");

// connect switch and bathroom light by passing a // delegate to the bathroom light's

// OnFlipCallback method to s s.ConnectToLight(new

SwitchFlipped(light1.OnFlipCallback)); OnFlip(s);

OnFlip(s);

// connect switch and bedroom light by passing a // delegate to the bedroom's light's

// OnFlipCallback method to s s.ConnectToLight(new

SwitchFlipped(light2.OnFlipCallback)); OnFlip(s);

OnFlip(s);

} } }

Trang 15

This code generates the following output:

Before flipping, the switch is: Down Flipping switch

bathroom light is on After flipping, the switch is: Up

Before flipping, the switch is: Up Flipping switch

bathroom light is off After flipping, the switch is: Down

Before flipping, the switch is: Down Flipping switch

bedroom light is on After flipping, the switch is: Up

Before flipping, the switch is: Up Flipping switch

bedroom light is off After flipping, the switch is: Down

Trang 16

" Multicast Delegates

! Multicast Delegate Scenario

! Single vs Multicast Delegates

! Creating and Invoking Multicast Delegates

! C# Language-Specific Syntax

! Delegate Details

If you change the state in one object, you may need to broadcast that change to multiple objects You can use multicast delegate objects to provide this functionality; they can be composed together so that a single invocation invokes all of their methods, just as a single light switch can turn on or off all lights connected to that switch

Topic Objective

To provide an overview of

the topics in this section

Lead-in

If you change the state in

one object, you may need to

broadcast that change to

multiple objects

As noted in the C#

Language-Specific Syntax in

this module, delegate types

with a void return value in

C# cause the compiler to

derive the delegate class

from the MulticastDelegate

class

Trang 17

Multicast Delegate Scenario

2 - OnFlip method invokes multicast delegate1

4 - OnFlipCallback method changes light1’s state

3 - delegate1 invokes light1’s OnFlipCallback

7 - OnFlipCallback method changes light2’s state

6 - delegate2 invokes light2’s OnFlipCallback

OnFlip method

Switch Object

OnFlipCallback method Light1 Object

OnFlipCallback method Light2 Object

Multicast delegate1 object Multicast delegate2 object

Invocation list

5 - delegate2

is invoked

1 - Change in switch position invokes switch’s OnFlip method

OnFlip method

Switch Object

In the light scenario, multicast delegate1 refers to the light1 object’s OnFlipCallback method, and multicast delegate2 refers to the light2 object’s

OnFlipCallback method Their composition logically represents an invocation

list, a list of methods that are executed when the delegate is invoked In this

case, the invocation list consists of these two methods

In the light switch scenario shown in the slide, the multicast delegate objects encapsulate references to two objects and two methods When the switch is flipped:

1 The switch object’s OnFlip method is invoked

2 The OnFlip method invokes the multicast delegate1 object

3 The multicast delegate1 object first invokes the light1 object’s OnFlipCallback method

4 The light1 object’s OnFlipCallback method changes the state of the light1

To illustrate the typical

multicast delegate use by

using the common scenario

of a switch that controls two

light bulbs

Lead-in

The following scenario of a

switch that controls two

lights illustrates the use of

multicast delegates

To run the build slide, click

through the lower-left button

on the slide

The following scenario of a

switch that controls two

lights illustrates the use of

multicast delegates The

switch object models the

light switch, and the two

light objects model the two

electric lights To provide

the capability to dynamically

connect, disconnect, and

reconnect light object

methods to the switch

object, the switch object is

dynamically connected to

the light objects by

instantiating and composing

two multicast delegate

objects

Trang 18

Single vs Multicast Delegates

! All Delegates Have an Invocation List of Methods That Are Executed When Their Invoke Method is Called

! Single-Cast Delegates: Derived Directly From System.MulticastDelegate

# Invocation list contains only one method

! Multicast Delegates: Derived from System.MulticastDelegate

# Invocation list may contain multiple methods

# Multicast delegates contain two static methods to add and remove

references from invocation list: Combine and Remove

! Use GetInvocationList to Obtain an Invocation List as an Array of Delegate References

! Use a Delegate’s Target and Method Properties to Determine:

# Which object will receive the callback

# Which method will be called

When delegate declarations are compiled, the compiler, in effect, generates a

new class The new delegate class derives from the System.MulticastDelegate

class that is provided by the NET Framework

All delegates have an invocation list, or linked list of delegates that are

executed when the invoke method is called A delegate that derives from the MulticastDelegate class may contain an invocation list with multiple delegates The MulticastDelegate class contains two static methods to add and remove method references from an invocation list: Combine and Remove

Combine is declared as follows:

public static Delegate Combine(

Delegate a, Delegate b);

The method returns a new multicast Delegate object with an invocation list that concatenates the invocation lists of a and b in that order

Remove is declared as follows:

public static Delegate Remove(

Delegate source, Delegate value);

The method returns a new Delegate object with an invocation list formed by taking the invocation list of source and removing the last occurrence of value,

if value is found in the invocation list of source If value is null or if value is not found, then source is returned

You can use the method GetInvocationList to obtain the invocation list as an array of delegate references You can also use the delegate’s Target and Method properties to determine which object is to receive the callback and which method is to be called In the case of a static method, Target is null

Topic Objective

To explain the difference

between single-cast and

multicast delegates

Lead-in

When delegate declarations

are compiled, the compiler

generates a new class,

which derives from two

delegate classes provided

by the NET Framework

Trang 19

Creating and Invoking Multicast Delegates

// assign to c the composition of delegates a and b

for (int i = 0; i < DelegateList.Length; i++) {

if (DelegateList[i].Target != aFoo1) {

((MyDelegate2) DelegateList[i])();

}}

// assign to c the composition of delegates a and b

if (DelegateList[i].Target != aFoo1) {

((MyDelegate2) DelegateList[i])();

}}

The following sample code shows:

! How to create multicast delegate objects

! How to write code to invoke delegates’ Combine and Remove methods

! How to write code to iterate through an invocation list invoking all delegates, except those delegates whose target is a specific object

Topic Objective

To provide specific

examples of how to create

and invoke multicast

delegates, and how to

iterate though an invocation

list to invoke specific

delegates

Lead-in

This sample code shows

how to create and invoke

multicast delegates, and

how to iterate through an

invocation list to invoke

specific delegates

Trang 20

using System;

public delegate void MyDelegate2();

public class Foo {

public void Bar() { Console.WriteLine("Bar invoked");

} } class Application { public static void Main() { Foo aFoo1 = new Foo();

Foo aFoo2 = new Foo();

if (DelegateList[i].Target != aFoo1) { ((MyDelegate2) DelegateList[i])();

} } }

The preceding code invokes the delegate that invokes object aFoo2’s Bar

method and outputs:

Bar invoked

Trang 21

C# Language-Specific Syntax

! C# Delegates That Return Void Are Multicast Delegates

! In C#, Use the + and - Operators to Add and Remove Invocation List Entries

MyDelegate a, b, c, d;

a = new MyDelegate(Foo);

b = new MyDelegate(Bar);

c = a + b; // Compose two delegates to make another

d = c - a; // Remove a from the composed delegate

a += b; // Add delegate b to a's invocation list

a -= b; // Remove delegate b from a's list

MyDelegate a, b, c, d;

a = new MyDelegate(Foo);

b = new MyDelegate(Bar);

d = c - a; // Remove a from the composed delegate

Delegate types with a void return value in C# cause the compiler to derive the delegate class from the MulticastDelegate class You can also use these delegates’ addition operator (+) and the subtraction operator (-) to invoke the Combine and Remove methods for delegate composition and decomposition

Topic Objective

To present helpful

alternative C# syntax

Lead-in

Delegate types with a void

return value in C# cause the

compiler to derive the

delegate class from the

MulticastDelegate class

Trang 22

Demonstration: Multicast Delegates

In this demonstration, you will learn how to add and remove methods from the

invocation list of multicast delegates by using the + and – operators

using System;

namespace Multicast_Delegates {

class MyClass {

public static void Hello(string s) { Console.WriteLine(" Hello, {0}!", s);

} public static void Goodbye(string s) { Console.WriteLine(" Goodbye, {0}!", s);

}

(Code continued on the following page.)

Topic Objective

To demonstrate how to use

the + and – operators to add

and remove methods

Lead-in

You can add and remove

methods from the invocation

list of multicast delegates by

using the + and – operators

Delivery Tip

Use Visual Studio NET to

run this code Set

breakpoints or single-step to

illustrate the sequence of

events

Trang 23

public static void Main() { MyDelegate3 a, b, c, d;

a = new MyDelegate3(MyClass.Hello);

b = new MyDelegate3(MyClass.Goodbye);

d = c - a; // Remove a from c to make another Console.WriteLine("Invoking delegate a:");

Console.WriteLine("Adding b to a and invoking:");

a += b; // Add the b delegate to a a("E");

Console.WriteLine("Removing b from a and invoking:");

a -= b; // Remove the b delegate from a a("F");

} } } This code generates the following output:

Trang 24

Delegate Details

! A Delegate Declaration Causes the Compiler to Generate a New Class

// delegate void MyDelegate3(string val);

class MyDelegate3 : System.MulticastDelegate { public MyDelegate3(object obj, methodref mref): base (obj, mref) { //

} public void virtual Invoke(string val) { // }

};

class MyDelegate3 : System.MulticastDelegate { public MyDelegate3(object obj, methodref mref): base (obj, mref) { //

} public void virtual Invoke(string val) { // }

};

As previously noted in this module, when delegate declarations are compiled, the compiler, in effect, generates a new class that derives from

System.Delegate The new delegate class has two members: a constructor and

an Invoke method The following class declaration resembles what the

compiler actually does:

class MyDelegate3 : System.MulticastDelegate { public MyDelegate3(object obj, methodref mref) : base (obj, mref) {//

} public void virtual Invoke(string val) {//

} } The first member is a constructor: its first parameter is the delegate’s target object, and its second parameter is a reference to a method When a delegate

refers to a static method, the target object is null

The Invoke method for the class MyDelegate3 indicates that delegate instances

of this class encapsulate methods that have a void return and a single string parameter When a delegate is invoked, the Invoke method is called with the

When delegate declarations

are compiled, the compiler

generates a new class that

derives from

System.Delegate

There is no actual type

named methodref, but

having an instance of a type

that encapsulates a

reference to a class method

resembles what the

compiler actually does

Tiêu đề	Delegates and Events
Trường học	Microsoft Corporation
Chuyên ngành	Computer Science
Thể loại	Tài liệu Module 8: Delegates and Events
Năm xuất bản	2001-2002

Định dạng
Số trang	48
Dung lượng	0,95 MB