asp net core 2.0 mvc pdf : Add pdf files together reader SDK Library service wpf asp.net web page dnn McGraw.Hill.CSharp.4.0.The.Complete.Reference.Apr.201059-part1220

564
Part I: The C# Language
Some Generic Restrictions
Here are a few restrictions that you need to keep in mind when using generics:
• Properties, operators, and indexers cannot be generic. However, these items can be 
• The extern modifier cannot be applied to a generic method.
• Pointer types cannot be used as type arguments.
• If a generic class contains a static field, then each constructed type has its own copy of
that field. This means that each instance of the same constructed type shares the same 
static field. However, a different constructed type shares a different copy of that 
field. Thus, a static field is not shared by all constructed types.
Final Thoughts on Generics
Generics are a powerful element of C# because they streamline the creation of type-safe, 
reusable code. 
become second nature. Likewise, learning how and when to use constraints takes a bit of 
practice, but becomes easier over time. Generics are now an integral part of C# programming. 
It’s worth the effort it takes to master this important feature.
Add pdf files together reader - Merge, append PDF files in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Provide C# Demo Codes for Merging and Appending PDF Document
asp.net merge pdf files; pdf merge files
Add pdf files together reader - 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
combine pdf files; combine pdfs online
19
LINQ
L
INQ is without question one of the most exciting features in C#. It was added by 
C# 3.0, and it represented a major addition to the language. Not only did it add 
an entirely new syntactic element, several new keywords, and a powerful new 
capability, but also it significantly increased the scope of the language, expanding the range 
in the evolution of C#.
LINQ stands for Language-Integrated Query. It encompasses a set of features that 
lets you retrieve information from a data source. As you may know, the retrieval of data 
constitutes an important part of many programs. For example, a program might obtain 
information from a customer list, look up product information in a catalog, or access an 
employee’s record. In many cases, such data is stored in a database that is separate from 
the application. For example, a product catalog might be stored in a relational database. 
(Structured Query Language). Other sources of data, such as XML, required their own 
approaches. Therefore, prior to C# 3.0, support for such queries was not built into C#. 
The addition of LINQ changed this.
ce. 
Furthermore, the syntax used for the query is the same—no matter what data source is 
used. This means the syntax used to query data in a relational database is the same as 
that used to query data stored in an array, for example. It is not necessary to use SQL 
language.
In addition to using LINQ with SQL, LINQ can be used with XML files and ADO.NET 
Datasets. Per
(described in Chapter 25). Therefore, LINQ gives you a uniform way to access data in 
not stop there. LINQ also offers a different way to think about and approach many types of 
programming tasks—not just traditional database access. As a result, many solutions can be 
crafted in terms of LINQ.
565
CHAPTER
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:
merge pdf; pdf combine files online
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
asp.net merge pdf files; acrobat combine pdf files
566
Part I: The C# Language
LINQ is supported by a set of interrelated features, including the query syntax added to 
the C# language, lambda expressions, anonymous types, and extension methods. Lambda 
expressions are described in Chapter 15. The others are examined here.
N
OTE
N
OTE
LINQ in C# is essentially a language within a language. As a result, the subject of LINQ is 
quite large, involving many features, options, and alternatives. Although this chapter describes 
LINQ in significant detail, it is not possible to explore all facets, nuances, and applications of this 
powerful feature. To do so would require an entire book of its own. Instead, this chapter focuses 
on the core elements of LINQ and presents numerous examples. Going forward, LINQ is 
definitely a subsystem that you will want to study in greater detail.
LINQ Fundamentals
At LINQ’s core is the query. A query specifies what data will be obtained from a data source. 
For example, a query on a customer mailing list might request the addresses of all customers 
that reside in a specific city, such as Chicago or Tokyo. A query on an inventory database 
might request a list of out-of-stock items. A query on a log of Internet usage could ask for a 
list of the websites with the highest hit counts. Although these queries differ in their specifics, 
all can be expressed using the same LINQ syntactic elements.
After a query has been created, it can be executed. One way this is done is by using the 
query in a foreach loop. Executing a query causes its results to be obtained. Thus, using a 
query involves two key steps. First, the form of the query is created. Second, the query is 
executed. Therefore, the query defines what to retrieve from a data source. Executing the 
query actually obtains the results.
In order for a source of data to be used by LINQ, it must implement the IEnumerable
interface. There ar
if the data source implements the generic version, IEnumerable<T>, where T specifies the 
type of data being enumerated. The rest of the chapter assumes that a data source implements 
IEnumerable<T>. This interface is declared in System.Collections.Generic. A class that 
implementsIEnumerable<T> supports enumeration, which means that its contents can 
be obtained one at a time, in sequence. All C# arrays implicitly support IEnumerable<T>.
that LINQ is not limited to arrays.
A Simple Query
At this point, it will be helpful to work through a simple LINQ example. The following 
pr
// Create a simple LINQ query.
using System;
using System.Linq;
class SimpQuery {
static void Main() {
int[] nums =  { 1, -2, 3, 0, -4, 5 };
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#
c# merge pdf files into one; pdf split and merge
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
batch combine pdf; batch pdf merger
P
A
R
T
I
Chapter 19: LINQ 
567
P
A
R
T
I
P
A
R
T
I
// Create a query that obtains only positive numbers.
var posNums = from n in nums
where n > 0
select n;
Console.Write("The positive values in nums: ");
// Execute the query and display the results.
foreach(int i in posNums) Console.Write(i + " ");
Console.WriteLine();
}
}
This program produces the following output:
The positive values in nums: 1 3 5
As you can see, only the positive values in the nums array are displayed. Although quite 
simple, this program demonstrates the key features of LINQ. Let’s examine it closely.
The first thing to notice in the program is the using directive:
using System.Linq;
To use the LINQ features, you must include the System.Linq namespace.
Next, an array of int called nums is declared. All arrays in C# are implicitly convertible 
toIEnumerable<T>. This makes any C# array usable as a LINQ data source.
Next, a query is declared that retrieves those elements in nums that are positive. It is 
shown here:
var posNums = from n in nums
where n > 0
select n;
The variable posNums is called the query variable. It refers to the set of rules defined by the 
query. Notice it uses var to implicitly declare posNums. As you know, this makes posNums
variables, although you can also explicitly declare the type (which must be some form 
ofIEnumerable<T>). The variable posNums is then assigned the query expression.
All queries begin with from. This clause specifies two items. The first is the range
variable, which will receive elements obtained from the data source. In this case, the range 
variable is n. The second item is the data source, which in this case is the nums array. The 
type of the range variable is inferred from the data source. In this case, the type of n is int.
Generalizing, here is the syntax of the from clause:
from range-variable in data-source
The next clause in the query is where. It specifies a condition that an element in the data 
source must meet in order to be obtained by the query. Its general form is shown here:
where boolean-expression
C# TIFF: TIFF Editor SDK to Read & Manipulate TIFF File Using C#.
Support converting other files to Tiff, like Word, Excel, PowerPoint, PDF, and images. Enable to add XImage.OCR for .NET into C# Tiff imaging application
add pdf files together reader; reader combine pdf pages
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
acrobat split pdf into multiple files; batch pdf merger online
568
Part I: The C# Language
Theboolean-expression must produce a bool result. (This expression is also called a predicate.)
There can be more than one where clause in a query. In the program, this where clause is used:
where n > 0
It will be true only for an element whose value is greater than zero. This expression will be 
evaluated for every n in nums when the query executes. Only those values that satisfy this 
condition will be obtained. In other words, a where clause acts as a filter on the data source, 
allowing only certain items through.
All queries end with either a select clause or a group clause. This example employs the 
select clause. It specifies precisely what is obtained by the query. For simple queries, such as 
the one in this example, the range value is selected. Therefore, it returns those integers from 
nums that satisfy the where clause. In more sophisticated situations, it is possible to finely 
eturn just the 
last name of each recipient, rather than the entire address. Notice that the select clause ends 
with a semicolon. Because select ends a query, it ends the statement and requires a semicolon. 
Notice, however, that the other clauses in the query do not end with a semicolon.
At this point, a query variable called posNums has been created, but no results have 
ules. It is 
not until the query is executed that results are obtained. Furthermore, the same query can 
be executed two or more times, with the possibility of differing results if the underlying 
data source changes between executions. Therefore, simply declaring the query posNums
does not mean that it contains the results of the query.
To execute the query, the program uses the foreach loop shown here:
foreach(int i in posNums) Console.WriteLine(i + " ");
Notice that posNums is specified as the collection being iterated over. When the foreach
executes, the rules defined by the query specified by posNums are executed. With each pass 
through the loop, the next element returned by the query is obtained. The process ends when 
there are no more elements to retrieve. In this case, the type of the iteration variable i is 
explicitly specified as int because this is the type of the elements retrieved by the query. 
to know the type of the value selected by the query. However, in more complicated situations, 
variable by using var.
A Query Can Be Executed More Than Once
Because a query defines a set of rules that are used to retrieve data, but does not, itself, 
produce results, the same query can be run multiple times. If the data source changes 
between runs, then the results of the query may differ. Therefore, once you define a query, 
executing it will always produce the most current results. Here is an example. In the 
following version of the preceding program, the contents of the nums array are changed 
between two executions of posNums:
// Create a simple query.
using System;
using System.Linq;
using System.Collections.Generic;
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
how to combine pdf files; add pdf files together
VB.NET Image: VB.NET ISSN Barcode Reader & Scanner; Decode Barcode
and recognize ISSN barcode from document files, like PDF from source PDF file, RasterEdge.Imaging.PDF.dll will And all those .NET add-ons can be integrated and
batch merge pdf; attach pdf to mail merge
P
A
R
T
I
Chapter 19: LINQ 
569
P
A
R
T
I
P
A
R
T
I
class SimpQuery {
static void Main() {
int[] nums =  { 1, -2, 3, 0, -4, 5 };
// Create a query that obtains only positive numbers.
var posNums = from n in nums
where n > 0
select n;
Console.Write("The positive values in nums: ");
// Execute the query and display the results.
foreach(int i in posNums) Console.Write(i + " ");
Console.WriteLine();
// Change nums.
Console.WriteLine("\nSetting nums[1] to 99.");
nums[1] = 99;
Console.Write("The positive values in nums after change: ");
// Execute the query a second time.
foreach(int i in posNums) Console.Write(i + " ");
Console.WriteLine();
}
}
The following output is produced:
The positive values in nums: 1 3 5
Setting nums[1] to 99.
The positive values in nums after change: 1 99 3 5
As the output confirms, after the value in nums[1]was changed from –2 to 99, the result 
of rerunning the query reflects the change. This is a key point that must be emphasized. 
Each execution of a query produces its own results, which are obtained by enumerating the 
current contents of the data source. Therefore, if the data source changes, so, too, might the 
results of executing a query. The benefits of this approach are quite significant. For example, 
if you are obtaining a list of pending orders for an online store, then you want each execution 
of your query to produce all orders, including those just entered.
How the Data Types in a Query Relate
As the preceding examples have shown, a query involves variables whose types relate to 
one another. These are the query variable, the range variable, and the data source. Because 
the corr
merit a closer look.
The type of the range variable must agree with the type of the elements stored in the 
data sour
source. In many cases, C# can infer the type of the range variable. As long as the data source 
implementsIEnumerable<T>, the type inference can be made because T describes the type 
570
Part I: The C# Language
of the elements in the data source. However, if the data source implements the non-generic 
version of IEnumerable, then you will need to explicitly specify the type of the range 
variable. This is done by specifying its type in the from clause. For example, assuming 
the preceding examples, this shows how to explicitly declare n to be an int:
var posNums = from int n in nums
// ...
Of course, the explicit type specification is not needed here because all arrays are implicitly 
convertible to IEnumerable<T>, which enables the type of the range variable to be inferred.
The type of object returned by a query is an instance of IEnumerable<T>, where T is 
IEnumerable<T>. The value of T is determined by the type of the value specified by the 
select clause. In the case of the preceding examples, T is int because n is an int. (As explained, 
n is an int because int is the type of elements stored in nums.) Therefore, the query could 
have been written like this, with the type explicitly specified as IEnumerable <int>:
IEnumerable<int> posNums = from n in nums
where n > 0
select n;
The key point is that the type of the item selected by select must agree with the type 
argument passed to IEnumerable<T> used to declare the query variable. Often query 
variables use var
infer the proper type from the select clause. As you will see, this approach is particularly 
useful when select returns something other than an individual element from the data source.
When a query is executed by the foreach loop, the type of the iteration variable must 
be the same as the type specified by the select clause. In the preceding examples, this type 
was explicitly specified as int, but you can let the compiler infer the type by declaring this 
variable as var. As you will see, there are also some cases in which var must be used because 
the data type has no name.
The General Form of a Query
All queries share a general form, which is based on a set of contextual keywords, shown here:
ascending
by
descending
equals
from
group
in
into
join
let
on
orderby
select
where
Of these, the following begin query clauses:
from
group
join
let
orderby
select
where
A query must begin with the keyword from and end with either a select or group clause. 
Theselect clause determines what type of value is enumerated by the query. The group
P
A
R
T
I
Chapter 19: LINQ 
571
P
A
R
T
I
P
A
R
T
I
clause returns the data by groups, with each group being able to be enumerated individually. 
As the preceding examples have shown, the where clause specifies criteria that an item 
must meet in order for it to be returned. The remaining clauses help you fine-tune a query. 
The follows sections examine each query clause.
Filter Values with where
As explained, where is used to filter the data returned by a query. The preceding examples 
have shown only its simplest form, in which a single condition is used. A key point to 
understand is that you can use where to filter data based on more than one condition. One 
way to do this is through the use of multiple where clauses. For example, consider the 
following program that displays only those values in the array that are both positive and 
less than 10:
// Use multiple where clauses.
using System;
using System.Linq;
class TwoWheres {
static void Main() {
int[] nums =  { 1, -2, 3, -3, 0, -8, 12, 19, 6, 9, 10 };
// Create a query that obtains positive values less than 10.
var posNums = from n in nums
where n > 0
where n < 10
select n;
Console.Write("The positive values less than 10: ");
// Execute the query and display the results.
foreach(int i in posNums) Console.Write (i + " ");
Console.WriteLine();
}
}
The output is shown here:
The positive values less than 10: 1 3 6 9
As you can see, only positive values less than 10 are retrieved. This outcome is achieved by 
the use of the following two where clauses:
where n > 0
where n < 10
The first where requires that an element be greater than zero. The second requires the 
both clauses.
572
Part I: The C# Language
Although it is not wrong to use two where clauses as just shown, the same effect can be 
achieved in a more compact manner by using a single where in which both tests are combined 
into a single expression. Here is the query rewritten to use this approach:
var posNums = from n in nums
where n > 0 && n < 10
select n;
In general, a where condition can use any valid C# expression that evaluates to a 
Boolean result. For example, the following program defines an array of strings. Several of 
the strings define Internet addresses. The query netAddrs retrieves only those strings that 
have mor
contain Internet addresses that use the .net top-level domain name.
// Demonstrate another where clause.
using System;
using System.Linq;
class WhereDemo2 {
static void Main() {
string[] strs = { ".com", ".net", "hsNameA.com", "hsNameB.net",
"test", ".network", "hsNameC.net", "hsNameD.com" };
// Create a query that obtains Internet addresses that
// end with .net.
var netAddrs = from addr in strs
where addr.Length > 4 && addr.EndsWith(".net", 
StringComparison.Ordinal)
select addr;
// Execute the query and display the results.
foreach(var str in netAddrs) Console.WriteLine(str);
}
}
The output is shown here:
hsNameB.net
hsNameC.net
Notice that the program makes use of one of string’s methods called EndsWith( ) within the 
where clause. It returns true if the invoking string ends with the character sequence specified 
as an argument.
Sort Results with orderby
Often you will want the results of a query to be sorted. For example, you might want to 
obtain a list of past-due accounts, in order of the remaining balance, from greatest to least. 
Or
LINQ gives you an easy way to produce sorted results: the orderby clause.
P
A
R
T
I
Chapter 19: LINQ 
573
P
A
R
T
I
P
A
R
T
I
You can use orderby to sort on one or more criteria. We will begin with the simplest 
case: sorting on a single item. The general form of orderby that sorts based on a single 
criterion is shown here:
orderby sort-on how
The item on which to sort is specified by sort-on. This can be as inclusive as the entire element 
stored in the data source or as restricted as a portion of a single field within the element. 
The value of how
ascending or descending. The default direction is ascending, so you won’t normally specify 
ascending.
Here is an example that uses orderby to retrieve the values in an int array in ascending 
order:
// Demonstrate orderby.
using System;
using System.Linq;
class OrderbyDemo {
static void Main() {
int[] nums =  { 10, -19, 4, 7, 2, -5, 0 };
// Create a query that obtains the values in sorted order.
var posNums = from n in nums
orderby n
select n;
Console.Write("Values in ascending order: ");
// Execute the query and display the results.
foreach(int i in posNums) Console.Write(i + " ");
Console.WriteLine();
}
}
The output is shown here:
Values in ascending order: -19 -5 0 2 4 7 10
To change the order to descending, simply specify the descending option, as shown here:
var posNums = from n in nums
orderby n descending
select n;
If you try this, you will see that the order of the values is reversed.
orderby to 
sort on multiple items by using this form:
orderby sort-onAdirection,sort-onB direction,sort-onC direction, …
Documents you may be interested
Documents you may be interested