using Delegates to Call Back Instance Methods in C#

Creation PDF-417 2d barcode in C# using Delegates to Call Back Instance Methods

I just explained how delegates can be used to call static methods, but they can also be used to call instance methods for a specific object . To understand how calling back an instance method works, look at the InstanceDelegateDemo method that appears in the code shown at the beginning of this chapter . Notice that a Program object named p is constructed in the InstanceDelegateDemo method . This Program object doesn t have any instance fields or properties associated with it; I created it merely for demonstration purposes . When the new Feedback delegate object is constructed in the call to the Counter method, its constructor is passed p.FeedbackToFile . This causes the delegate to wrap a reference to the FeedbackToFile method, which is an instance method (not a static method) . When Counter calls the callback method identified by its fb argument, the FeedbackToFile instance method is called, and the address of the

recently constructed object p will be passed as the implicit this argument to the instance method . The FeedbackToFile method works as the FeedbackToConsole and FeedbackToMsgBox methods, except that it opens a file and appends the string to the end of the file . (The Status file that the method creates can be found in the application s AppBase directory .) Again, the purpose of this example is to demonstrate that delegates can wrap calls to instance methods as well as static methods . For instance methods, the delegate needs to know the instance of the object the method is going to operate on . Wrapping an instance method is useful because code inside the object can access the object s instance members . This means that the object can have some state that can be used while the callback method is doing its processing .

On the surface, delegates seem easy to use: you define them by using C# s delegate keyword, you construct instances of them by using the familiar new operator, and you invoke the callback by using the familiar method-call syntax (except instead of a method name, you use the variable that refers to the delegate object) . However, what s really going on is quite a bit more complex than what the earlier examples illustrate . The compilers and the CLR do a lot of behind-the-scenes processing to hide the complexity . In this section, I ll focus on how the compiler and the CLR work together to implement delegates . Having this knowledge will improve your understanding of delegates and will teach you how to use them efficiently and effectively . I ll also touch on some additional features delegates make available . Let s start by reexamining this line of code:

internal delegate void Feedback(Int32 value);

When it sees this line, the compiler actually defines a complete class that looks something like this:

internal class Feedback : System.MulticastDelegate { // Constructor public Feedback(Object object, IntPtr method); // Method with same prototype as specified by the source code public virtual void Invoke(Int32 value); // Methods allowing the callback to be called asynchronously public virtual IAsyncResult BeginInvoke(Int32 value, AsyncCallback callback, Object object); public virtual void EndInvoke(IAsyncResult result); }

The class defined by the compiler has four methods: a constructor, Invoke, BeginInvoke, and EndInvoke . In this chapter, I ll concentrate on the constructor and Invoke methods . I ll address the BeginInvoke and EndInvoke methods in 27, I/O-Bound Asynchronous Operations, in the The APM and Compute-Bound Operations section . In fact, you can verify that the compiler did indeed generate this class automatically by examining the resulting assembly with ILDasm .exe, as shown in Figure 17-1 .