asp net core 2.0 mvc pdf : Add two pdf files together control SDK utility azure wpf web page visual studio McGraw.Hill.CSharp.4.0.The.Complete.Reference.Apr.201061-part1223

584
Part I: The C# Language
// Create a query that groups websites by top-level domain name,
// but select only those groups that have more than two members.
// Here, ws is the range variable over the set of groups
// returned when the first half of the query is executed.
var webAddrs = from addr in websites
where addr.LastIndexOf('.') != -1
into ws
where ws.Count() > 2
select ws;
// Execute the query and display the results.
foreach(var sites in webAddrs) {
Console.WriteLine("Contents of " + sites.Key + " domain:");
foreach(var site in sites)
Console.WriteLine("  " + site);
Console.WriteLine();
}
}
}
The following output is produced:
Top-level domains with more than 2 members.
Contents of .net domain:
hsNameB.net
hsNameC.net
hsNameH.net
As the output shows, only the .net group is returned because it is the only group that has 
more than two elements.
In the program, pay special attention to this sequence of clauses in the query:
group addr by addr.Substring(addr.LastIndexOf('.'))
into ws
where ws.Count() > 2
select ws;
First, the results of the group clause are stored (creating a temporary result) and the where
clause operates on the stored results. At this point,ws will range over each group obtained 
bygroup. Next, the where clause filters the query so the final result contains only those 
groups that contain more than two members. This determination is made by calling Count( ),
which is an extensionmethod that is implemented for all IEnumerable objects. It returns the 
number of elements in a sequence. (You’ll learn more about extension methods later in this 
chapter.) The resulting sequence of groups is returned by the select clause.
Add two pdf files together - Merge, append PDF files in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Provide C# Demo Codes for Merging and Appending PDF Document
acrobat reader merge pdf files; acrobat merge pdf
Add two pdf files together - 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 merger online; add pdf files together reader
P
A
R
T
I
Chapter 19: LINQ 
585
P
A
R
T
I
P
A
R
T
I
Use let to Create a Variable in a Query
In a query, you will sometimes want to retain a value temporarily. For example, you might 
want to create an enumerable variable that can, itself, be queried. Or, you might want to 
store a value that will be used later on in a where clause. Whatever the purpose, these types 
of actions can be accomplished through the use of let.
Thelet clause has this general form:
letname = expression
Here, name is an identifier that is assigned the value of expression. The type of name is 
inferred from the type of the expression.
Here is an example that shows how let can be used to create another enumerable data 
sour
char
arrays. This is accomplished by use of another string method called ToCharArray( ), which 
returns an array containing the characters in the string. The result is assigned to a variable 
calledchrArray, which is then used by a nested from clause to obtain the individual characters 
in the array. The query then sorts the characters and returns the resulting sequence.
// Use a let clause and a nested from clause.
using System;
using System.Linq;
class LetDemo {
static void Main() {
string[] strs = { "alpha", "beta", "gamma" };
// Create a query that obtains the characters in the
// strings, returned in sorted order. Notice the use
// of a nested from clause.
var chrs = from str in strs
let chrArray = str.ToCharArray()
from ch in chrArray
orderby ch
select ch;
Console.WriteLine("The individual characters in sorted order:");
// Execute the query and display the results.
foreach(char c in chrs) Console.Write(c + " ");
Console.WriteLine();
}
}
The output is shown here:
The individual characters in sorted order:
a a a a a b e g h l m m p t
C# Word - Merge Word Documents in C#.NET
SDK empowers C# programmers to easily merge and append Word files with mature To be more specific, two or more input Word documents can be merged Add references
how to combine pdf files; batch pdf merger
C# PowerPoint - Merge PowerPoint Documents in C#.NET
To be more specific, two or more input PowerPoint documents C# DLLs: Merge PowerPoint Files. Add necessary XDoc.PowerPoint DLL libraries into your created C#
break pdf into multiple files; split pdf into multiple files
586
Part I: The C# Language
In the program, notice how the let clause assigns to chrArray a reference to the array 
returned by str.ToCharArray( ):
let chrArray = str.ToCharArray()
After the let clause, other clauses can make use of chrArray. Furthermore, because all arrays 
in C# are convertible to IEnumerable<T>,chrArray can be used as a data source for a second, 
nestedfrom clause. This is what happens in the example. It uses the nested from to enumerate 
the individual characters in the array, sorting them into ascending sequence and returning 
the result.
You can also use a let clause to hold a non-enumerable value. For example, the following 
is a more efficient way to write the query used in the IntoDemo program shown in the 
preceding section.
var webAddrs = from addr in websites
let idx = addr.LastIndexOf('.')
where idx != -1
group addr by addr.Substring(idx)
into ws
where ws.Count() > 2
select ws;
In this version, the index of the last occurrence of a period is assigned to idx. This value 
is then used by Substring( ). This prevents the search for the period from having to be 
conducted twice.
Join Two Sequences with join
When working with databases, it is common to want to create a sequence that correlates 
data from two different data sources. For example, an online store might have one database 
that associates the name of an item with its item number, and a second database that 
You can do this by correlating the data in the two databases. Such an action is easy to 
accomplish in LINQ through the use of the join clause.
The general form of join is shown here (in context with the from):
from range-varA indata-sourceA
join range-varB in data-sourceB
on range-varA.property equals range-varB.property
The key to using join is to understand that each data source must contain data in common, 
and that the data can be compared for equality. Thus, in the general form, data-sourceA and 
data-sourceB must have something in common that can be compared. The items being 
compared are specified by the on section. Thus, when range-varA.property is equal to range-
varB.property, the correlation succeeds. In essence, join acts like a filter, allowing only those 
elements that share a common value to pass through.
When using join, often the sequence returned is a composite of portions of the two data 
sources. Therefore, join lets you generate a new list that contains elements from two different 
data sources. This enables you to organize data in a new way.
VB.NET Word: How to Process MS Word in VB.NET Library in .NET
corresponding online tutorial on how to add & insert application in VB.NET to merge two or a imaging controls, PDF document, image to pdf files and components
pdf mail merge plug in; break pdf file into multiple files
C# PowerPoint: C# Codes to Combine & Split PowerPoint Documents
String doc in dirs) { docList.Add(doc); } PPTXDocument can split a PowerPoint document into two sub-documents & profession imaging controls, PDF document, tiff
merge pdf; acrobat combine pdf
P
A
R
T
I
Chapter 19: LINQ 
587
P
A
R
T
I
P
A
R
T
I
The following program creates a class called Item, which encapsulates an item’s name 
with its number. It creates another class called InStockStatus, which links an item number 
with a Boolean property that indicates whether or not the item is in stock. It also creates a 
class called Temp, which has two fields: one string and one bool. Objects of this class will 
hold the result of the query. The query uses join to produce a list in which an item’s name 
is associated with its in-stock status.
// Demonstrate join.
using System;
using System.Linq;
// A class that links an item name with its number.
class Item {
public string Name { get; set; }
public int ItemNumber { get; set; }
public Item(string n, int inum) {
Name = n;
ItemNumber = inum;
}
}
// A class that links an item number with its in-stock status.
class InStockStatus {
public int ItemNumber { get; set; }
public bool InStock { get; set; }
public InStockStatus(int n, bool b) {
ItemNumber = n;
InStock = b;
}
}
// A class that encapsulates a name with its status.
class Temp {
public string Name { get; set; }
public bool InStock { get; set; }
public Temp(string n, bool b) {
Name = n;
InStock  = b;
}
}
class JoinDemo {
static void Main() {
Item[] items = {
new Item("Pliers", 1424),
new Item("Hammer", 7892),
new Item("Wrench", 8534),
new Item("Saw", 6411)
};
VB.NET Word: .NET Project for Merging Two or More Microsoft Word
Support to add or delete pages from a Word dll and RasterEdge.Imaging.MSWordDocx. dll two dlls are controls, PDF document, image to pdf files and components for
batch pdf merger online; merge pdf files
C# Excel - Merge Excel Documents in C#.NET
To be more specific, two or more input Excel documents can be merged and appended together according to its C# DLLs: Merge Excel Files. Add necessary references
c# merge pdf files into one; batch combine pdf
588
Part I: The C# Language
InStockStatus[] statusList = {
new InStockStatus(1424, true),
new InStockStatus(7892, false),
new InStockStatus(8534, true),
new InStockStatus(6411, true)
};
// Create a query that joins Item with InStockStatus to
// produce a list of item names and availability. Notice
// that a sequence of Temp objects is produced.
var inStockList = from item in items
join entry in statusList
on item.ItemNumber equals entry.ItemNumber
select new Temp(item.Name, entry.InStock);
Console.WriteLine("Item\tAvailable\n");
// Execute the query and display the results.
foreach(Temp t in inStockList)
Console.WriteLine("{0}\t{1}", t.Name, t.InStock);
}
}
The output is shown here:
Item    Available
Pliers  True
Hammer  False
Wrench  True
Saw     True
To understand how join works, let’s walk through each line in the query. The query 
begins in the normal fashion with this from clause:
var inStockList = from item in items
This clause specifies that item is the range variable for the data source specified by items.
Theitems array contains objects of type Item, which encapsulate a name and a number for 
an inventory item.
Next comes the join clause shown here:
join entry in statusList
on item.ItemNumber equals entry.ItemNumber
This clause specifies that entry is the range variable for the statusList data source. The 
statusList array contains objects of type InStockStatus, which link an item number with 
its status. Thus, items and statusList have a property in common: the item number. This 
is used by the on/equals portion of the join clause to describe the correlation. Thus, join
matches items from the two data sources when their item numbers are equal.
Finally, the select clause returns a Temp object that contains an item’s name along with 
its in-stock status:
C# TIFF: How to Convert TIFF to GIF Using Sample C# Code
Imaging Converting Library, conversions from TIFF to PDF & vector with other add-on DLLs, like TIFF add-on. Please refer to following two sets of APIs for TIFF
apple merge pdf; break a pdf into multiple files
VB.NET TIFF: .NET TIFF Printer Control; Print TIFF Using VB.NET
Actually, the combination of those two VB.NET TIFF this VB.NET TIFF file printer control add-on does controls, PDF document, image to pdf files and components
pdf combine two pages into one; combine pdf files
P
A
R
T
I
Chapter 19: LINQ 
589
P
A
R
T
I
P
A
R
T
I
select new Temp(item.Name, entry.InStock);
Therefore, the sequence obtained by the query consists of Temp objects.
Although the preceding example is fairly straightforward, join supports substantially 
more sophisticated operations. For example, you can use into with join to create a group
join, which creates a result that consists of an element from the first sequence and a group of 
all matching elements from the second sequence. (You’ll see an example of this a bit later in 
this chapter.) In general, the time and effort needed to fully master join is well worth the 
investment because it gives you the ability to reorganize data at runtime. This is a powerful 
capability. This capability is made even more powerful by the use of anonymous types, 
described in the next section.
Anonymous Types
C# provides a feature called the anonymous type that directly relates to LINQ. As the name 
implies, an anonymous type is a class that has no name. Its primary use is to create an object 
returned by the select clause. Often, the outcome of a query is a sequence of objects that are 
either a composite of two (or more) data sources (such as in the case of join) or include a 
subset of the members of one data source. In either case, often the type of the object being 
returned is needed only because of the query and is not used elsewhere in the program. In 
this case, using an anonymous type eliminates the need to declare a class that will be used 
simply to hold the outcome of the query.
An anonymous type is created through the use of this general form:
new { nameA = valueA,nameB = valueB, ... }
Here, the names specify identifiers that translate into read-only properties that are 
initialized by the values. For example,
new { Count = 10, Max = 100, Min = 0 }
This creates a class type that has three public read-only properties: Count,Max, and Min.
These are given the values 10, 100, and 0, respectively. These properties can be referred to by 
properties. As explained in Chapter 8, object initializers provide a way to initialize an object 
without explicitly invoking a constructor. This is necessary in the case of anonymous types 
because there is no way to explicitly call a constructor. (Recall that constructors have the 
same name as their class. In the case of an anonymous class, there is no name. So, how 
would you invoke the constructor?)
refer to it. This lets the compiler infer the proper type. For example,
var myOb = new { Count = 10, Max = 100, Min = 0 }
creates a variable called myOb that is assigned a reference to the object created by the 
anonymous type expression. This means that the following statements are legal:
Console.WriteLine("Count is " + myOb.Count);
if(i <= myOb.Max && i >= myOb.Min) // ...
590
Part I: The C# Language
Remember, when an anonymous type is created, the identifiers that you specify become 
read-only public properties. Thus, they can be used by other parts of your code.
Although the term anonymoustype is used, it’s not quite completely true! The type is 
anonymous relative to you, the programmer. However, the compiler does give it an internal 
name. Thus, anonymous types do not violate C#‘s strong type checking rules.
To fully understand the value of anonymous types, consider this rewrite of the previous 
program that demonstrated join. Recall that in the previous version, a class called Temp
was needed to encapsulate the result of the join. Through the use of an anonymous type, 
ce code to the 
program. The output from the program is unchanged from before.
// Use an anonymous type to improve the join demo program.
using System;
using System.Linq;
// A class that links an item name with its number.
class Item {
public string Name { get; set; }
public int ItemNumber { get; set; }
public Item(string n, int inum) {
Name = n;
ItemNumber = inum;
}
}
// A class that links an item number with its in-stock status.
class InStockStatus {
public int ItemNumber { get; set; }
public bool InStock { get; set; }
public InStockStatus(int n, bool b) {
ItemNumber = n;
InStock = b;
}
}
class AnonTypeDemo {
static void Main() {
Item[] items = {
new Item("Pliers", 1424),
new Item("Hammer", 7892),
new Item("Wrench", 8534),
new Item("Saw", 6411)
};
InStockStatus[] statusList = {
new InStockStatus(1424, true),
new InStockStatus(7892, false),
new InStockStatus(8534, true),
new InStockStatus(6411, true)
};
P
A
R
T
I
Chapter 19: LINQ 
591
P
A
R
T
I
P
A
R
T
I
// Create a query that joins Item with InStockStatus to
// produce a list of item names and availability.
// Now, an anonymous type is used.
var inStockList = from item in items
join entry in statusList
on item.ItemNumber equals entry.ItemNumber
select new { Name = item.Name,
InStock =  entry.InStock };
Console.WriteLine("Item\tAvailable\n");
// Execute the query and display the results.
foreach(var t in inStockList)
Console.WriteLine("{0}\t{1}", t.Name, t.InStock);
}
}
Pay special attention to the select clause:
select new { Name = item.Name,
InStock =  entry.InStock };
It returns an object of an anonymous type that has two read-only properties, Name and 
InStock. These are given the values specified by the item’s name and availability. Because 
of the anonymous type, there is no longer any need for the Temp class.
One other point. Notice the foreach loop that executes the query. It now uses var to 
declar
inStockList has no name. This situation is one of the reasons that C# includes implicitly 
typed variables. They are needed to support anonymous types.
Before moving on, there is one more aspect of anonymous types that warrants a mention. 
type through the use of a projection initializer. In this case, you simply specify the name of 
operty. For 
example, here is another way to code the select clause used by the preceding program:
select new { item.Name, entry.InStock };
Here, the property names are still Name and InStock, just as before. The compiler 
automatically “projects” the identifiers Name and InStock, making them the property 
names of the anonymous type. Also as before, the properties are given the values specified 
byitem.Nameandentry.InStock.
Create a Group Join
As mentioned earlier, you can use into with join to create a groupjoin, which creates a 
sequence in which each entry in the result consists of an entry from the first sequence and 
a group of all matching elements from the second sequence. No example was presented 
then because often a group join makes use of an anonymous type. Now that anonymous 
types have been covered, an example of a simple group join can be given.
The following example uses a group join to create a list in which various transports, such 
as cars, boats, and planes, are organized by their general transportation category, which is 
592
Part I: The C# Language
land, sea, or air. The program first creates a class called Transport that links a transport type 
with its classification. Inside Main( ), it creates two input sequences. The first is an array of 
e land, 
sea, and air. The second is an array of Transport, which encapsulates various means of 
transportation. It then uses a group join to produce a list of transports that are organized 
by their category.
// Demonstrate a simple group join.
using System;
using System.Linq;
// This class links the name of a transport, such as Train,
// with its general classification, such as land, sea, or air.
class Transport {
public string Name { get; set; }
public string How { get; set; }
public Transport(string n, string h) {
Name = n;
How = h;
}
}
class GroupJoinDemo {
static void Main() {
// An array of transport classifications.
string[] travelTypes = {
"Air",
"Sea",
"Land"
};
// An array of transports.
Transport[] transports = {
new Transport("Bicycle", "Land"),
new Transport("Balloon", "Air"),
new Transport("Boat", "Sea"),
new Transport("Jet", "Air"),
new Transport("Canoe", "Sea"),
new Transport("Biplane", "Air"),
new Transport("Car", "Land"),
new Transport("Cargo Ship", "Sea"),
new Transport("Train", "Land")
};
// Create a query that uses a group join to produce
// a list of item names and IDs organized by category.
var byHow = from how in travelTypes
join trans in transports
on how equals trans.How
into lst
select new { How = how, Tlist = lst };
P
A
R
T
I
Chapter 19: LINQ 
593
P
A
R
T
I
P
A
R
T
I
// Execute the query and display the results.
foreach(var t in byHow) {
Console.WriteLine("{0} transportation includes:", t.How);
foreach(var m in t.Tlist)
Console.WriteLine("  " + m.Name);
Console.WriteLine();
}
}
}
The output is shown here:
Air transportation includes:
Balloon
Jet
Biplane
Sea transportation includes:
Boat
Canoe
Cargo Ship
Land transportation includes:
Bicycle
Car
Train
The key part of the program is, of course, the query, which is shown here:
var byHow = from how in travelTypes
join trans in transports
on how equals trans.How
into lst
select new { How = how, Tlist = lst };
Here is how it works. The from statement uses how to range over the travelTypes array. 
Recall that travelTypes contains an array of the general travel classifications: air, land, and 
sea. The join
example, the type Land is joined with Bicycle, Car, and Train. However, because of the into
clause, for each travel type, the join produces a list of the transports that use that travel 
type. This list is represented by lst. Finally, select returns an anonymous type that encapsulates 
each value of how (the travel type) with a list of transports. This is why the two foreach
loops shown here are needed to display the results of the query:
foreach(var t in byHow) {
Console.WriteLine("{0} transportation includes:", t.How);
foreach(var m in t.Tlist)
Console.WriteLine("  " + m.Name);
Console.WriteLine();
}
Documents you may be interested
Documents you may be interested