asp net core 2.0 mvc pdf : Add pdf files together online application software utility html windows .net visual studio McGraw.Hill.CSharp.4.0.The.Complete.Reference.Apr.201045-part1204

424
Part I: The C# Language
Use Outer Variables with Anonymous Methods
A
outervariable. 
captured. A 
captured it is subject 
that variable will stay in existence at least until the delegate referring to that method is 
destroyed.
The capturing of a local variable can lead to unexpected results. For example, consider 
this version of the counting program. As in the previous version, the summation of the 
count is computed. However, in this version, a CountIt object is constructed and returned 
by a static method called Counter( ). This object uses the variable sum, which is declared in 
the enclosing scope provided by Counter( ), rather than in the anonymous method, itself. 
Thus,sum is captured by the anonymous method. Inside Main( ),Counter( ) is called to 
obtain a CountIt object. Thus, sum will not be destroyed until the program finishes.
// Demonstrate a captured variable.
using System;
// This delegate returns int and takes an int argument.
delegate int CountIt(int end);
class VarCapture {
static CountIt Counter() {
int sum = 0;
// Here, a summation of the count is stored
// in the captured variable sum.
CountIt ctObj = delegate (int end) {
for(int i=0; i <= end; i++) {
Console.WriteLine(i);
sum += i;
}
return sum;
};
return ctObj;
}
static void Main() {
// Get a counter.
CountIt count = Counter();
int result;
result = count(3);
Console.WriteLine("Summation of 3 is " + result);
Console.WriteLine();
Add pdf files together online - Merge, append PDF files in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Provide C# Demo Codes for Merging and Appending PDF Document
acrobat merge pdf files; append pdf
Add pdf files together 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
adding pdf pages together; pdf merger online
P
A
R
T
I
Chapter 15: Delegates, Events, and Lambda Expressions 
425
P
A
R
T
I
P
A
R
T
I
result = count(5);
Console.WriteLine("Summation of 5 is " + result);
}
}
The output is shown here. Pay special attention to the summation value.
0
1
2
3
Summation of 3 is 6
0
1
2
3
4
5
Summation of 5 is 21
As you can see, the count still proceeds normally. However, notice the summation value for 
5. It shows 21 instead of 15! The reason for this is that sum is captured by ctObj when it is 
created by the Counter( ) method. This means it remains in existence until count is subject 
to garbage collection at the end of the program. Thus, its value is not destroyed when 
Counter( ) returns or with each call to the anonymous method when count is called in Main( ).
Although captured variables can result in rather counterintuitive situations, such as the 
anonymous method captures a variable, that variable cannot go out of existence until the 
delegate that captures it is no longer being used. If this were not the case, then the captured 
variable could be undefined when it is needed by the delegate.
Lambda Expressions
Although anonymous methods are still part of C#, they have been largely superceded 
by a better approach: the lambdaexpression. It is not an overstatement to say that the lambda 
expression is one of the most important features added to C# since its original 1.0 release. 
Based on a distinctive syntactic element, the lambda expression provides a powerful 
alternative to the anonymous method. Although a principal use of lambda expressions is 
found when working with LINQ (see Chapter 19), they are also applicable to (and commonly 
used with) delegates and events. This use of lambda expressions is described here.
A lambda expression is the second way that an anonymous function can be created. 
preceding section.) Thus, a lambda expression can be assigned to a delegate. Because a 
lambda expression is more streamlined than the equivalent anonymous method, lambda 
expressions are now the recommended approach in almost all cases.
The Lambda Operator
All lambda expressions use the lambda operator, which is =>. This operator divides 
a lambda expr
specified. On the right is the lambda body. The => operator is sometimes verbalized as 
“goes to” or “becomes.”
C# Word - Merge Word Documents in C#.NET
empowers C# programmers to easily merge and append Word files with mature input Word documents can be merged and appended together according to Add references:
batch pdf merger online; acrobat combine pdf files
C# PowerPoint - Merge PowerPoint Documents in C#.NET
together according to its loading sequence, and then saved and output as a single PowerPoint with user-defined location. C# DLLs: Merge PowerPoint Files. Add
merge pdf; pdf split and merge
426
Part I: The C# Language
C# supports two types of lambda expressions, and it is the lambda body that determines 
what type is being created. If the lambda body consists of a single expression, then an 
expression lambda is being created. In this case, the body is free-standing—it is not enclosed 
then a statement lambda is being created. A statement lambda can contain multiple statements 
and include such things as loops, method calls, and if statements. The following sections 
describe both kinds of lambdas.
Expression Lambdas
In an expression lambda, the expression on the right side of the => acts on the parameter (or 
parameters) specified by the left side. The result of the expression becomes the result of the 
lambda operator and is returned.
Here is the general form of an expression lambda that takes only one parameter:
param => expr
When more than one parameter is required, then the following form is used:
(param-list) => expr
Therefore, when two or more parameters are needed, they must be enclosed by parentheses. 
If no parameters are needed, then empty parentheses must be used.
Here is a simple expression lambda:
count => count + 2
Here count is the parameter that is acted on by the expression count + 2. Thus, the result is 
the value of count increased by two. Here is another example:
n => n % 2 == 0
In this case, this expression returns true if n is even and false if it is odd.
To use a lambda expression involves two steps. First, declare a delegate type that 
is compatible with the lambda expression. Second, declare an instance of the delegate, 
assigning to it the lambda expression. Once this has been done, the lambda expression can 
be executed by calling the delegate instance. The result of the lambda expression becomes 
the return value.
The following program shows how to put the two expression lambdas just shown into 
action. It declares two delegate types. The first, called Incr, takes an int argument and 
returns an int result. The second, called IsEven, takes an int argument and returns a bool
result. It then assigns the lambda expressions to instances of those delegates. Finally, it 
executes the lambda expressions through the delegate instances.
// Use two simple lambda expressions.
using System;
// Declare a delegate that takes an int argument
// and returns an int result.
delegate int Incr(int v);
// Declare a delegate that takes an int argument
// and returns a bool result.
C# PDF Convert to Text SDK: Convert PDF to txt files in C#.net
can be copied and pasted to .txt files by keeping text by a method loses the original PDF document layout and all the paragraphs are joining together, our C#
pdf combine files online; break pdf into multiple files
VB.NET Word: How to Process MS Word in VB.NET Library in .NET
Imaging.MSWordDocx.dll", which, when used together with other online tutorial on how to add & insert controls, PDF document, image to pdf files and components
attach pdf to mail merge; combine pdf
P
A
R
T
I
Chapter 15: Delegates, Events, and Lambda Expressions 
427
P
A
R
T
I
P
A
R
T
I
delegate bool IsEven(int v);
class SimpleLambdaDemo {
static void Main() {
// Create an Incr delegate instance that refers to
// a lambda expression that increases its parameter by 2.
Incr incr = count => count + 2;
// Now, use the incr lambda expression.
Console.WriteLine("Use incr lambda expression: ");
int x = -10;
while(x <= 0) {
Console.Write(x + " ");
x = incr(x); // increase x by 2
}
Console.WriteLine("\n");
// Create an IsEven delegate instance that refers to
// a lambda expression that returns true if its parameter
// is even and false otherwise.
IsEven isEven = n => n % 2 == 0;
// Now, use the isEven lambda expression.
Console.WriteLine("Use isEven lambda expression: ");
for(int i=1; i <= 10; i++)
if(isEven(i)) Console.WriteLine(i + " is even.");
}
}
The output is shown here:
Use incr lambda expression:
-10 -8 -6 -4 -2 0
Use isEven lambda expression:
2 is even.
4 is even.
6 is even.
8 is even.
10 is even.
In the program, pay special attention to these declarations:
Incr incr = count => count + 2;
IsEven isEven = n => n % 2 == 0;
The first assigns to incr a lambda expression that returns the result of increasing the value 
passed to count by 2. This expression can be assigned to an Incr delegate because it is 
compatible with Incr’s declaration. The argument used in the call to incr is passed to count.
The result is returned. The second declaration assigns to isEven an expression that returns 
C# TIFF: TIFF Editor SDK to Read & Manipulate TIFF File Using C#.
2. How to add and implement Tiff imaging functions in your C# project. 2. Word/Excel/PPT/PDF/Jpeg to Tiff conversion. 2. Merge and append Tiff files using
attach pdf to mail merge in word; c# combine pdf
C# Excel - Merge Excel Documents in C#.NET
and appended together according to its loading sequence, and then saved and output as a single Excel with user-defined location. C# DLLs: Merge Excel Files. Add
reader combine pdf; build pdf from multiple files
428
Part I: The C# Language
true if the argument is even and false otherwise. Thus, it is compatible with the IsEven
delegate declaration.
used in a lambda expression. For example, in the lambda expression assigned to incr, how 
does the compiler know that count is an int? The answer is that the compiler infers the type 
of the parameter and the expression’s result type from the delegate type. Thus, the lambda 
parameters and return value must be compatible with the parameter type(s) and return type 
of the delegate.
Although type inference is quite useful, in some cases, you might need to explicitly 
specify the type of a lambda parameter. To do so, simply include the type name. For 
example, here is another way to declare the incr delegate instance:
Incr incr = (int count) => count + 2;
Notice now that count is explicitly declared as an int. Also notice the use of parentheses. 
They are now necessary. (Parentheses can be omitted only when exactly one parameter is 
specified and no type specifier is used.)
Although the preceding two lambda expressions each used one parameter, lambda 
expressions can use any number, including zero. When using more than one parameter you 
must enclose them within parentheses. Here is an example that uses a lambda expression to 
determine if a value is within a specified range:
(low, high, val) => val >= low && val <= high;
Here is a delegate type that is compatible with this lambda expression:
delegate bool InRange(int lower, int upper, int v);
Thus, you could create an InRange delegate instance like this:
InRange rangeOK = (low, high, val) => val >= low && val <= high;
After doing so, the lambda expression can be executed as shown here:
if(rangeOK(1, 5, 3)) Console.WriteLine("3 is within 1 to 5.");
One other point: Lambda expressions can use outer variables in the same way as 
anonymous methods, and they are captured in the same way.
Statement Lambdas
As mentioned, there are two basic flavors of the lambda expression. The first is the expression 
lambda, which was discussed in the preceding section. As explained, the body of an 
expression lambda consists solely of a single expression. The second type of lambda 
expression is the statementlambda. A statement lambda expands the types of operations that 
can be handled within a lambda expression because it allows the body of lambda to contain 
if statements, 
declare variables, and so on. A statement lambda is easy to create. Simply enclose the body 
within braces. Aside from allowing multiple statements, it works much like the expression 
lambdas just discussed.
C# Image: C# Code to Encode & Decode JBIG2 Images in RasterEdge .
Easy to add C# JBIG2 codec controls to your image and codec into PDF documents for a better PDF compression; text to the new project folder, together with .NET
add pdf files together; c# merge pdf pages
VB.NET PDF Text Search Library: search text inside PDF file in vb.
and find text content in multiple page adobe PDF files in .NET Our VB.NET PDF Document Add-On enables you to search for text in target PDF document by using
combine pdf online; acrobat combine pdf
P
A
R
T
I
Chapter 15: Delegates, Events, and Lambda Expressions 
429
P
A
R
T
I
P
A
R
T
I
Here is an example that uses a statement lambda to compute and return the factorial of 
anint value:
// Demonstrate a statement lambda.
using System;
// IntOp takes one int argument and returns an int result.
delegate int IntOp(int end);
class StatementLambdaDemo {
static void Main() {
// A statement lambda that returns the factorial
// of the value it is passed.
IntOp fact = n => {
int r = 1;
for(int i=1; i <= n; i++)
r = i * r;
return r;
};
Console.WriteLine("The factorial of 3 is " + fact(3));
Console.WriteLine("The factorial of 5 is " + fact(5));
}
}
The output is shown here:
The factorial of 3 is 6
The factorial of 5 is 120
In the program, notice that the statement lambda declares a variable called r, uses a for
loop, and has a return statement. These are legal inside a statement lambda. In essence, a 
statement lambda closely parallels an anonymous method. Therefore, many anonymous 
methods will be converted to statement lambdas when updating legacy code.One other 
point: When a return statement occurs within a lambda expression, it simply causes a 
return from the lambda. It does not cause the enclosing method to return.
Befor
lambda in action. The following program reworks the first delegate example in this chapter 
modifications:
// The first delegate example rewritten to use
// statement lambdas.
using System;
// Declare a delegate type.
delegate string StrMod(string s);
430
Part I: The C# Language
class UseStatementLambdas {
static void Main() {
// Create delegates that refer to lambda expressions
// that perform various string modifications.
// Replaces spaces with hyphens.
StrMod ReplaceSpaces = s => {
Console.WriteLine("Replacing spaces with hyphens.");
return s.Replace(' ', '-');
};
// Remove spaces.
StrMod RemoveSpaces = 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.
StrMod Reverse = 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;
};
string str;
// Call methods through the delegate.
StrMod strOp = ReplaceSpaces;
str = strOp("This is a test.");
Console.WriteLine("Resulting string: " + str);
Console.WriteLine();
strOp = RemoveSpaces;
str = strOp("This is a test.");
Console.WriteLine("Resulting string: " + str);
Console.WriteLine();
strOp = Reverse;
str = strOp("This is a test.");
P
A
R
T
I
Chapter 15: Delegates, Events, and Lambda Expressions 
431
P
A
R
T
I
P
A
R
T
I
Console.WriteLine("Resulting string: " + str);
}
}
The output, which is the same as the original version, is shown here:
Replacing spaces with hyphens.
Resulting string: This-is-a-test.
Removing spaces.
Resulting string: Thisisatest.
Reversing string.
Resulting string: .tset a si sihT
Events
Another important C# feature is built upon the foundation of delegates: the event. An event 
is, essentially, an automatic notification that some action has occurred. Events work like this: 
An object that has an interest in an event registers an event handler for that event. When the 
event occurs, all registered handlers are called. Event handlers are represented by delegates.
Events are members of a class and are declared using the event keyword. Its most 
commonly used form is shown here:
eventevent-delegate event-name;
Here, event-delegate is the name of the delegate used to support the event, and event-name is 
the name of the specific event object being declared.
Let’s begin with a very simple example:
// A very simple event demonstration.
using System;
// Declare a delegate type for an event.
delegate void MyEventHandler();
// Declare a class that contains an event.
class MyEvent {
public event MyEventHandler SomeEvent;
// This is called to raise the event.
public void OnSomeEvent() {
if(SomeEvent != null)
SomeEvent();
}
}
class EventDemo {
// An event handler.
static void Handler() {
Console.WriteLine("Event occurred");
}
432
Part I: The C# Language
static void Main() {
MyEvent evt = new MyEvent();
// Add Handler() to the event list.
evt.SomeEvent += Handler;
// Raise the event.
evt.OnSomeEvent();
}
}
This program displays the following output:
Event occurred
Although simple, this program contains all the elements essential to proper event 
handling. Let’s look at it carefully. The program begins by declaring a delegate type for 
the event handler, as shown here:
delegate void MyEventHandler();
All events are activated through a delegate. Thus, the event delegate type defines the return 
type and signature for the event. In this case, there are no parameters, but event parameters 
are allowed.
Next, an event class, called MyEvent, is created. Inside the class, an event called 
SomeEvent is declared, using this line:
public event MyEventHandler SomeEvent;
Notice the syntax. The keyword event tells the compiler that an event is being declared.
Also declared inside MyEvent is the method OnSomeEvent( ), which is the method a 
program will call to raise (or “fire”) an event. (That is, this is the method called when the 
event occurs.) It calls an event handler through the SomeEvent delegate, as shown here:
if(SomeEvent != null)
SomeEvent();
Notice that a handler is called if and only if SomeEvent is not null. Since other parts of your 
program must register an interest in an event in order to receive event notifications, it is 
possible that OnSomeEvent( ) could be called before any event handler has been registered. 
To prevent calling on a null reference, the event delegate must be tested to ensure that it is 
notnull.
InsideEventDemo, an event handler called Handler( ) is created. In this simple example, 
meaningful actions. In Main( ), a MyEvent object is created, and Handler( ) is registered 
as a handler for this event, by adding it as shown here:
MyEvent evt = new MyEvent();
// Add Handler() to the event list.
evt.SomeEvent += Handler;
P
A
R
T
I
Chapter 15: Delegates, Events, and Lambda Expressions 
433
P
A
R
T
I
P
A
R
T
I
Notice that the handler is added using the += operator. Events support only += and – =. In 
this case, Handler( ) is a static method, but event handlers can also be instance methods.
Finally, the event is raised as shown here:
// Raise the event.
evt.OnSomeEvent();
CallingOnSomeEvent( ) causes all registered event handlers to be called. In this case, there 
is only one registered handler, but there could be more, as the next section explains.
A Multicast Event Example
espond to an event 
notification. Here is an event multicast example:
// An event multicast demonstration.
using System;
// Declare a delegate type for an event.
delegate void MyEventHandler();
// Declare a class that contains an event.
class MyEvent {
public event MyEventHandler SomeEvent;
// This is called to raise the event.
public void OnSomeEvent() {
if(SomeEvent != null)
SomeEvent();
}
}
class X {
public void Xhandler() {
Console.WriteLine("Event received by X object");
}
}
class Y {
public void Yhandler() {
Console.WriteLine("Event received by Y object");
}
}
class EventDemo2 {
static void Handler() {
Console.WriteLine("Event received by EventDemo");
}
static void Main() {
MyEvent evt = new MyEvent();
X xOb = new X();
Y yOb = new Y();
Documents you may be interested
Documents you may be interested