414
Part I: The C# Language
Next,strOp is assigned a reference to RemoveSpaces( ), and then strOp is called again. 
This time, RemoveSpaces( ) is invoked.
Finally, strOp is assigned a reference to Reverse( ) and strOp is called. This results in 
Reverse( ) being called.
The key point of the example is that the invocation of strOp results in a call to the method 
referred to by strOp
resolved at runtime, not compile time.
Delegate Method Group Conversion
assigns a method to a delegate. This feature is called method group conversion, and it allows 
you to simply assign the name of a method to a delegate, without using new or explicitly 
invoking the delegate’s constructor.
For example, here is the Main( ) method of the preceding program rewritten to use 
method group conversions:
static void Main() {
// Construct a delegate using method group conversion.
StrMod strOp = ReplaceSpaces; // use method group conversion
string str;
// Call methods through the delegate.
str = strOp("This is a test.");
Console.WriteLine("Resulting string: " + str);
Console.WriteLine();
strOp = RemoveSpaces; // use method group conversion
str = strOp("This is a test.");
Console.WriteLine("Resulting string: " + str);
Console.WriteLine();
strOp = Reverse; // use method group conversion
str = strOp("This is a test.");
Console.WriteLine("Resulting string: " + str);
}
Pay special attention to the way that strOp is created and assigned the method 
ReplaceSpaces( ) in this line:
StrMod strOp = ReplaceSpaces; // use method group conversion
The name of the method is assigned directly to strOp. C# automatically provides a 
conversion from the method to the delegate type. This syntax can be generalized to 
Because the method group conversion syntax is simpler than the old approach, it is 
used throughout the remainder of this book.
Using Instance Methods as Delegates
Although the preceding example used static methods, a delegate can also refer to instance 
methods. It must do so, however, through an object reference. For example, here is a rewrite 
of the pr
Pdf merger online - Merge, append PDF files in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Provide C# Demo Codes for Merging and Appending PDF Document
apple merge pdf; pdf merge files
Pdf merger online - VB.NET PDF File Merge Library: Merge, append PDF files in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
VB.NET Guide and Sample Codes to Merge PDF Documents in .NET Project
pdf merge documents; add pdf files together
P
A
R
T
I
Chapter 15: Delegates, Events, and Lambda Expressions 
415
P
A
R
T
I
P
A
R
T
I
StringOps. Notice that the method group conversion syntax can also be applied in this 
situation.
// Delegates can refer to instance methods, too.
using System;
// Declare a delegate type.
delegate string StrMod(string str);
class StringOps {
// Replaces spaces with hyphens.
public string ReplaceSpaces(string s) {
Console.WriteLine("Replacing spaces with hyphens.");
return s.Replace(' ', '-');
}
// Remove spaces.
public string RemoveSpaces(string s) {
string temp = "";
int i;
Console.WriteLine("Removing spaces.");
for(i=0; i < s.Length; i++)
if(s[i] != ' ') temp += s[i];
return temp;
}
// Reverse a string.
public string Reverse(string s) {
string temp = "";
int i, j;
Console.WriteLine("Reversing string.");
for(j=0, i=s.Length-1; i >= 0; i--, j++)
temp += s[i];
return temp;
}
}
class DelegateTest {
static void Main() {
StringOps so = new StringOps(); // create an instance of StringOps
// Initialize a delegate.
StrMod strOp = so.ReplaceSpaces;
string str;
// Call methods through delegates.
str = strOp("This is a test.");
Console.WriteLine("Resulting string: " + str);
Console.WriteLine();
C# PDF: C#.NET PDF Document Merging & Splitting Control SDK
SDK > C# > Merge and Split Document(s). "This online guide content ". C# PDF Merging & Splitting Application. This C#.NET PDF document merger & splitter
best pdf combiner; c# merge pdf pages
C# Word: .NET Merger & Splitter Control to Merge & Split MS Word
From this online article, you will know C#.NET MS Word document merging and RasterEdge C#.NET MS Word (DOCX) document merger & splitter control add-on. C#
pdf combine; append pdf files reader
416
Part I: The C# Language
strOp = so.RemoveSpaces;
str = strOp("This is a test.");
Console.WriteLine("Resulting string: " + str);
Console.WriteLine();
strOp = so.Reverse;
str = strOp("This is a test.");
Console.WriteLine("Resulting string: " + str);
}
}
This program produces the same output as the first, but in this case, the delegate refers 
to methods on an instance of StringOps.
Multicasting
One of the most exciting features of a delegate is its support for multicasting. In simple 
terms, multicasting is the ability to create an invocation list, or chain, of methods that will be 
eate. Simply 
instantiate a delegate, and then use the + or += operator to add methods to the chain. To 
remove a method, use  or – =. If the delegate returns a value, then the value returned by 
the last method in the list becomes the return value of the entire delegate invocation. Thus, 
a delegate that makes use of multicasting will often have a void return type.
Here is an example of multicasting. Notice that it reworks the preceding examples by 
changing the string manipulation method’s return type to void and using a ref parameter to 
return the altered string to the caller. This makes the methods more appropriate for multicasting.
// Demonstrate multicasting.
using System;
// Declare a delegate type.
delegate void StrMod(ref string str);
class MultiCastDemo {
// Replaces spaces with hyphens.
static void ReplaceSpaces(ref string s) {
Console.WriteLine("Replacing spaces with hyphens.");
s = s.Replace(' ', '-');
}
// Remove spaces.
static void RemoveSpaces(ref string s) {
string temp = "";
int i;
Console.WriteLine("Removing spaces.");
for(i=0; i < s.Length; i++)
if(s[i] != ' ') temp += s[i];
s = temp;
}
VB.NET TIFF: .NET TIFF Merger SDK to Combine TIFF Files
This online guide content is A 2: Yes, this VB.NET TIFF merger SDK allows developers to to provide powerful & profession imaging controls, PDF document, image
attach pdf to mail merge; add multiple pdf files into one online
VB.NET Word: Merge Multiple Word Files & Split Word Document
Word processing and editing controls, this VB.NET Word merger and splitter are dedicated to provide powerful & profession imaging controls, PDF document, image
reader merge pdf; pdf merge comments
P
A
R
T
I
Chapter 15: Delegates, Events, and Lambda Expressions 
417
P
A
R
T
I
P
A
R
T
I
// Reverse a string.
static void Reverse(ref string s) {
string temp = "";
int i, j;
Console.WriteLine("Reversing string.");
for(j=0, i=s.Length-1; i >= 0; i--, j++)
temp += s[i];
s = temp;
}
static void Main() {
// Construct delegates.
StrMod strOp;
StrMod replaceSp = ReplaceSpaces;
StrMod removeSp = RemoveSpaces;
StrMod reverseStr = Reverse;
string str = "This is a test";
// Set up multicast.
strOp = replaceSp;
strOp += reverseStr;
// Call multicast.
strOp(ref str);
Console.WriteLine("Resulting string: " + str);
Console.WriteLine();
// Remove replace and add remove.
strOp -= replaceSp;
strOp += removeSp;
str = "This is a test."; // reset string
// Call multicast.
strOp(ref str);
Console.WriteLine("Resulting string: " + str);
Console.WriteLine();
}
}
Here is the output:
Replacing spaces with hyphens.
Reversing string.
Resulting string: tset-a-si-sihT
Reversing string.
Removing spaces.
Resulting string: .tsetasisihT
C# PDF: C# Code to Process PDF Document Page Using C#.NET PDF
C# PDF Page Processing: Sort PDF Pages - online C#.NET tutorial page for C# PDF Page Processing: Merge PDF Files - C#.NET PDF document merger APIs for
combine pdfs online; batch combine pdf
C# PowerPoint: C# Codes to Combine & Split PowerPoint Documents
SDK is some like PowerPoint file merger in its PowerPoint files with the aid of online C# sample code powerful & profession imaging controls, PDF document, tiff
add pdf files together online; pdf merge documents
418
Part I: The C# Language
InMain( ), four delegate instances are created. One, strOp, is null. The other three refer to 
specific string modification methods. Next, a multicast is created that calls RemoveSpaces( )
andReverse( ). This is accomplished via the following lines:
strOp = replaceSp;
strOp += reverseStr;
First,strOp is assigned replaceSp. Next, using +=,reverseStr is added. When strOp
is invoked, both methods are invoked, replacing spaces with hyphens and reversing the 
string, as the output illustrates.
Next,replaceSp is removed from the chain, using this line:
strOp -= replaceSp;
andremoveSP is added using this line:
strOp += removeSp;
Then,strOp is again invoked. This time, spaces are removed and the string is reversed.
Delegate chains are a powerful mechanism because they allow you to define a set of 
methods that can be executed as a unit. This can increase the structure of some types of 
code. 
Covariance and Contravariance
There are two features that add flexibility to delegates: covarianceandcontravariance.Normally, 
the method that you pass to a delegate must have the same return type and signature as the 
delegate. However, covariance and contravariance relax this rule slightly, as it pertains to 
return type is a class derived from the class specified by the return type of the delegate. 
Here is an example that illustrates both covariance and contravariance:
// Demonstrate covariance and contravariance.
using System;
class X {
public int Val;
}
// Y is derived from X.
class Y : X { }
// This delegate returns X and takes a Y argument.
delegate X ChangeIt(Y obj);
class CoContraVariance {
// This method returns X and has an X parameter.
VB.NET TIFF: Merge and Split TIFF Documents with RasterEdge .NET
Besides TIFF document merger and splitter, RasterEdge still In our online VB.NET tutorial, users can powerful & profession imaging controls, PDF document, tiff
reader combine pdf pages; add pdf pages together
VB.NET PowerPoint: Merge and Split PowerPoint Document(s) with PPT
here is what you are looking for - RasterEdge VB.NET PPT Document Merger and Splitter Note: If you want to see more PDF processing functions in VB.NET, please
break pdf file into multiple files; acrobat reader merge pdf files
P
A
R
T
I
Chapter 15: Delegates, Events, and Lambda Expressions 
419
P
A
R
T
I
P
A
R
T
I
static X IncrA(X obj) {
X temp = new X();
temp.Val = obj.Val + 1;
return temp;
}
// This method returns Y and has a Y parameter.
static Y IncrB(Y obj) {
Y temp = new Y();
temp.Val = obj.Val + 1;
return temp;
}
static void Main() {
Y Yob = new Y();
// In this case, the parameter to IncrA
// is X and the parameter to ChangeIt is Y.
// Because of contravariance, the following
// line is OK.
ChangeIt change = IncrA;
X Xob = change(Yob);
Console.WriteLine("Xob: " + Xob.Val);
// In the next case, the return type of
// IncrB is Y and the return type of
// ChangeIt is X. Because of covariance,
// the following line is OK.
change = IncrB;
Yob = (Y) change(Yob);
Console.WriteLine("Yob: " + Yob.Val);
}
}
The output from the program is shown here:
Xob: 1
Yob: 1
In the program, notice that class Y is derived from class X. Next, notice that the delegate 
ChangeIt is declared like this:
delegate X ChangeIt(Y obj);
ChangeIt returns X and has a Y parameter. Next, notice that the methods IncrA( ) and 
IncrB( ) are declared as shown here:
static X IncrA(X obj)
static Y IncrB(Y obj)
420
Part I: The C# Language
TheIncrA( ) method has an X parameter and returns X. The IncrB( ) method has a Y
parameter and returns Y. Given covariance and contravariance, either of these methods 
can be passed to ChangeIt, as the program illustrates.
Therefore, this line
ChangeIt change = IncrA;
uses contravariance to enable IncrA( ) to be passed to the delegate because IncrA( ) has an X
parameter, but the delegate has a Y parameter. This works because, with contravariance, if 
used by the delegate, then the method and the delegate are compatible.
The next line is also legal, but this time it is because of covariance:
change = IncrB;
In this case, the return type of IncrB( ) is Y, but the return type of ChangeIt is X. However, 
because the return type of the method is a class derived from the return type of the delegate, 
the two are compatible.
System.Delegate
All delegates are classes that are implicitly derived from System.Delegate. You don’t normally 
need to use its members directly, and this book makes no explicit use of System.Delegate.
However, its members may be useful in certain specialized situations.
Why Delegates
Although the preceding examples show the “how” behind delegates, they don’t really 
illustrate the “why.” In general, delegates are useful for two main reasons. First, as shown 
later in this chapter, delegates support events. Second, delegates give your program a way 
to execute methods at runtime without having to know precisely what those methods are at 
compile time. This ability is quite useful when you want to create a framework that allows 
components to be plugged in. For example, imagine a drawing program (a bit like the 
standard W
special color filters or image analyzers. Furthermore, the user could create a sequence of 
Anonymous Functions
You will often find that the method referred to by a delegate is used only for that purpose. 
In other words, the only reason for the method is so it can be invoked via a delegate. The 
eate a 
separate method by using an anonymous function. An anonymous function is, essentially, an 
unnamed block of code that is passed to a delegate constructor. One advantage to using an 
anonymous function is simplicity. There is no need to declare a separate method whose only 
purpose is to be passed to a delegate.
anonymous
methodsandlambda expressions. The anonymous method was added by C# 2.0. The lambda 
expression was added by C# 3.0. In general, the lambda expression improves on the concept 
P
A
R
T
I
Chapter 15: Delegates, Events, and Lambda Expressions 
421
P
A
R
T
I
P
A
R
T
I
of the anonymous method and is now the preferred approach to creating an anonymous 
function. However, anonymous methods are still used in legacy C# code. Therefore, it is 
important to know how they work. Furthermore, anonymous methods are the precursor to 
lambda expr
understand aspects of the lambda expression. Also, there is a narrow set of cases in which 
an anonymous method can be used, but a lambda expression cannot. Therefore, both 
anonymous methods and lambda expressions are described in this chapter.
Anonymous Methods
An anonymous method is one way to create an unnamed block of code that is associated 
with a specific delegate instance. An anonymous method is created by following the 
keyword delegate with a block of code. To see how this is done, let’s begin with a simple 
example. The following program uses an anonymous method that counts from 0 to 5.
// Demonstrate an anonymous method.
using System;
// Declare a delegate type.
delegate void CountIt();
class AnonMethDemo {
static void Main() {
// Here, the code for counting is passed
// as an anonymous method.
CountIt count = delegate {
// This is the block of code passed to the delegate.
for(int i=0; i <= 5; i++)
Console.WriteLine(i);
}; // notice the semicolon
count();
}
}
This program first declares a delegate type called CountIt that has no parameters and 
returns void. Inside Main( ), a CountIt instance called count is created, and it is passed the 
block of code that follows the delegate keyword. This block of code is the anonymous 
method that will be executed when count is called. Notice that the block of code is followed 
om the program is 
shown here:
0
1
2
3
4
5
422
Part I: The C# Language
Pass Arguments to an Anonymous Method
It is possible to pass one or more arguments to an anonymous method. To do so, follow the 
delegate keyword with a parenthesized parameter list. Then, pass the argument(s) to the 
delegate instance when it is called. For example, here is the preceding program rewritten 
so that the ending value for the count is passed:
// Demonstrate an anonymous method that takes an argument.
using System;
// Notice that CountIt now has a parameter.
delegate void CountIt(int end);
class AnonMethDemo2 {
static void Main() {
// Here, the ending value for the count
// is passed to the anonymous method.
CountIt count = delegate (int end) {
for(int i=0; i <= end; i++)
Console.WriteLine(i);
};
count(3);
Console.WriteLine();
count(5);
}
}
In this version, CountIt now takes an integer argument. Notice how the parameter list 
is specified after the delegate keyword when the anonymous method is created. The code 
inside the anonymous method has access to the parameter end in just the same way it would 
if a named method were being created. The output from this program is shown next:
0
1
2
3
0
1
2
3
4
5
Return a Value from an Anonymous Method
An anonymous method can return a value. The value is returned by use of the return
As you would expect, the type of the return value must be compatible with the return type 
P
A
R
T
I
Chapter 15: Delegates, Events, and Lambda Expressions 
423
P
A
R
T
I
P
A
R
T
I
specified by the delegate. For example, here the code that performs the count also computes 
the summation of the count and returns the result:
// Demonstrate an anonymous method that returns a value.
using System;
// This delegate returns a value.
delegate int CountIt(int end);
class AnonMethDemo3 {
static void Main() {
int result;
// Here, the ending value for the count
// is passed to the anonymous method.
// A summation of the count is returned.
CountIt count = delegate (int end) {
int sum = 0;
for(int i=0; i <= end; i++) {
Console.WriteLine(i);
sum += i;
}
return sum; // return a value from an anonymous method
};
result = count(3);
Console.WriteLine("Summation of 3 is " + result);
Console.WriteLine();
result = count(5);
Console.WriteLine("Summation of 5 is " + result);
}
}
In this version, the value of sum is returned by the code block that is associated with the 
count delegate instance. Notice that the return statement is used in an anonymous method 
e:
0
1
2
3
Summation of 3 is 6
0
1
2
3
4
5
Summation of 5 is 15
Documents you may be interested
Documents you may be interested