C# ПІДРУЧНИКИ / c# / MS Press - Msdn Training Programming Net Framework With C#

Overview

Topic Objective

To provide an overview of the module topics and objectives.

Lead-in

Delegates are the objectoriented equivalents of function pointers.

!Delegates

!Multicast Delegates

!Events

!When to Use Delegates, Events, and Interfaces

" Delegates

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.

!Delegate Scenario

!Declaring a Delegate

!Instantiating a Delegate

!Calling a Delegate

Delegate Scenario

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.

OnFlip method

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.

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 explain how to declare a delegate.

Lead-in

A delegate declaration defines a type that encapsulates a method with a particular set of arguments and return type.

! 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 // declares a delegate for a method that takes a single // argument of type string and has a void return type // argument of type string and has a void return type delegate void MyDelegate1(string s);

delegate void MyDelegate1(string s);

For Your Information

The details of how the common language runtime creates delegates are presented later in this module.

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);

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.

! A Delegate Object Is Created with the new Operator ! Delegate Objects Are Immutable

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

// in the class MyClass

MyDelegate1 a = new MyDelegate1(MyClass.Hello); MyDelegate1 a = new MyDelegate1(MyClass.Hello);

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

// AMethod in object p MyClass p = new MyClass(); MyClass p = new MyClass();

MyDelegate1 b = new MyDelegate1(p.AMethod); MyDelegate1 b = new MyDelegate1(p.AMethod);

Delivery Tip

To place the delegate instantiation code in a fuller context, refer to the following code example.

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 call delegates.

Lead-in

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

!Use a Statement Containing:

#The name of the delegate object

#Followed by the parenthesized arguments to be passed to the delegate

//given the previous delegate declaration and

//given the previous delegate declaration and

//instantiation, the following invokes MyClass'

//instantiation, the following invokes MyClass'

//static method Hello with the parameter "World"

//static method Hello with the parameter "World"

a("World");

a("World");

For Your Information

Refer to the previous slide on delegate declaration and instantiations.

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"); b("World");

Delivery Tip

Use Visual Studio .NET to run the following code. Set breakpoints or single step to illustrate the sequence of events.

In this demonstration, you will use Microsoft Visual 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.

For Your Information

As noted in C# LanguageSpecific 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. Therefore, the IL for this delegate demonstration code will show the

SwitchFlipped delegate inheriting from the

System.MulticastDelegate

class.

using System;

namespace SwitchAndLight

{

public enum SwitchPosition {Up, Down};

delegate void SwitchFlipped(SwitchPosition switchState);

class Light

{

private string name;

public Light(string s)

{

name = s;

}

public void OnFlipCallback(SwitchPosition switchState)

{

if (switchState == SwitchPosition.Up)

{

Console.WriteLine("... {0} light is on",name);

}

else

{

Console.WriteLine("... {0} light is off",name);

}

}

}

class Switch

{

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.)