asp net core 2.0 mvc pdf : C# merge pdf files software Library project winforms asp.net azure UWP McGraw.Hill.CSharp.4.0.The.Complete.Reference.Apr.201049-part1209

464
Part I: The C# Language
All preprocessor directives begin with a # sign. In addition, each preprocessor directive 
must be on its own line.
Given C#’s modern, object-oriented architecture, there is not as much need for the 
preprocessor directives as there is in older languages. Nevertheless, they can be of value 
from time to time, especially for conditional compilation. Each directive is examined in turn.
#define
The#define directive defines a character sequence called a symbol. The existence or 
nonexistence of a symbol can be determined by #if or #elif and is used to control 
compilation. Here is the general form for #define:
#defi ne symbol
Notice that there is no semicolon in this statement. There may be any number of spaces 
between the #define and the symbol, but once the symbol begins, it is terminated only by 
a newline. For example, to define the symbol EXPERIMENTAL, use this directive:
#define EXPERIMENTAL
N
OTE
N
OTE
In C/C++ you can use #define to perform textual substitutions, such as defining a name for 
a value, and to create function-like macros. C# does not support these uses of #define. In C#, 
#define is used only to define a symbol.
#if and #endif
The#if and #endif directives enable conditional compilation of a sequence of code based 
upon whether an expression involving one or more symbols evaluates to true. A symbol is 
tr
#define directive, it will evaluate as true.
The general form of #if is
#ifsymbol-expression
statement sequence
#endif
If the expression following #if is true, the code that is between it and #endif is compiled. 
Otherwise, the intervening code is skipped. The #endif directive marks the end of an #if block.
A symbol expression can be as simple as just the name of a symbol. You can also use 
these operators in a symbol expression: !,= =,!=,&&, and ||. Parentheses are also allowed.
Here’s an example:
// Demonstrate #if, #endif, and #define.
#define EXPERIMENTAL
using System;
class Test {
static void Main() {
#if EXPERIMENTAL
Console.WriteLine("Compiled for experimental version.");
C# merge pdf files - 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; pdf split and merge
C# merge pdf files - 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
batch pdf merger; apple merge pdf
P
A
R
T
I
Chapter 16:  Namespaces, the Preprocessor, and Assemblies 
465
P
A
R
T
I
P
A
R
T
I
#endif
Console.WriteLine("This is in all versions.");
}
}
This program displays the following:
Compiled for experimental version.
This is in all versions.
The program defines the symbol EXPERIMENTAL. Thus, when the #if is encountered, 
the symbol expression evaluates to true, and the first WriteLine( ) statement is compiled. 
If you remove the definition of EXPERIMENTAL and recompile the program, the first 
WriteLine( ) statement will not be compiled, because the #if will evaluate to false. In all 
cases, the second WriteLine( ) statement is compiled because it is not part of the #if block.
As explained, you can use operators in a symbol expression in an #if. For example,
// Use an operator in a symbol expression.
#define EXPERIMENTAL
#define TRIAL
using System;
class Test {
static void Main() {
#if EXPERIMENTAL
Console.WriteLine("Compiled for experimental version.");
#endif
#if EXPERIMENTAL && TRIAL
Console.Error.WriteLine("Testing experimental trial version.");
#endif
Console.WriteLine("This is in all versions.");
}
}
The output from this program is shown here:
Compiled for experimental version.
Testing experimental trial version.
This is in all versions.
In this example, two symbols are defined, EXPERIMENTAL and TRIAL. The second 
WriteLine( ) statement is compiled only if both are defined.
Y
#if !EXPERIMENTAL
Console.WriteLine("Code is not experimental!");
#endif
The call to WriteLine( ) will be compiled only if EXPERIMENTALhasnot been defined.
Online Merge PDF files. Best free online merge PDF tool.
Thus, C#.NET PDF document merge library control can be counted as an efficient .NET doc solution for keeping PDF document files organized. Download Free Trial.
attach pdf to mail merge; pdf combine files online
C# PDF File Split Library: Split, seperate PDF into multiple files
outputFiles); Split PDF Document into Multiple PDF Files in C#. You can use the following C# demo to split PDF document to four files.
add multiple pdf files into one online; add pdf files together
466
Part I: The C# Language
#else and #elif
The#else directive works much like the else that is part of the C# language: It establishes an 
alternative if #if fails. The previous example can be expanded as shown here:
// Demonstrate #else.
#define EXPERIMENTAL
using System;
class Test {
static void Main() {
#if EXPERIMENTAL
Console.WriteLine("Compiled for experimental version.");
#else
Console.WriteLine("Compiled for release.");
#endif
#if EXPERIMENTAL && TRIAL
Console.Error.WriteLine("Testing experimental trial version.");
#else
Console.Error.WriteLine("Not experimental trial version.");
#endif
Console.WriteLine("This is in all versions.");
}
}
The output is shown here:
Compiled for experimental version.
Not experimental trial version.
This is in all versions.
SinceTRIAL is not defined, the #else portion of the second conditional code sequence is 
used.
Notice that #else marks both the end of the #if block and the beginning of the #else
block. This is necessary because there can only be one #endif associated with any #if.
Furthermore, there can be only one #else associated with any #if.
The#elif dir
compilation options. #elif is followed by a symbol expression. If the expression is true, that 
block of code is compiled and no other #elif expressions are tested. Otherwise, the next 
block in the series is checked. If no #elifsucceeds, then if there is a #else, the code sequence 
associated with the #elseis compiled. Otherwise, no code in the entire #ifis compiled.
The general form for #elif is
#ifsymbol-expression
statement sequence
#elifsymbol-expression
statement sequence
#elifsymbol-expression
C# PDF Convert to HTML SDK: Convert PDF to html files in C#.net
How to Use C#.NET Demo Code to Convert PDF Document to HTML5 Files in C#.NET Class. Add necessary references: RasterEdge.Imaging.Basic.dll.
add two pdf files together; best pdf combiner
C# PDF Convert to Jpeg SDK: Convert PDF to JPEG images in C#.net
toolkit, C# developers can easily and quickly convert a large-size multi-page PDF document to a group of high-quality separate JPEG image files within .NET
pdf combine two pages into one; pdf merge comments
P
A
R
T
I
Chapter 16:  Namespaces, the Preprocessor, and Assemblies 
467
P
A
R
T
I
P
A
R
T
I
statement sequence
// . . .
#endif
Here’s an example:
// Demonstrate #elif.
#define RELEASE
using System;
class Test {
static void Main() {
#if EXPERIMENTAL
Console.WriteLine("Compiled for experimental version.");
#elif RELEASE
Console.WriteLine("Compiled for release.");
#else
Console.WriteLine("Compiled for internal testing.");
#endif
#if TRIAL && !RELEASE
Console.WriteLine("Trial version.");
#endif
Console.WriteLine("This is in all versions.");
}
}
The output is shown here:
Compiled for release.
This is in all versions.
#undef
The#undef directive removes a previously defined symbol. That is, it “undefines” a 
symbol. The general form for #undef is
#undefsymbol
Here’s an example:
#define SMALL
#if SMALL
// ...
#undef SMALL
// at this point SMALL is undefined.
After the #undef directive, SMALL is no longer defined.
#undef
code that need them.
C# PDF Convert to SVG SDK: Convert PDF to SVG files in C#.net, ASP
file using C#. Instantly convert all PDF document pages to SVG image files in C#.NET class application. Perform high-fidelity PDF
acrobat combine pdf files; merge pdf
C# PDF Convert to Text SDK: Convert PDF to txt files in C#.net
content of target PDF document can be copied and pasted to .txt files by keeping original layout. C#.NET class source code for converting each PDF document page
pdf mail merge plug in; append pdf files reader
468
Part I: The C# Language
#error
The#error directive forces the compiler to stop compilation. It is used for debugging. The 
general form of the #error directive is
#error error-message
When the #error directive is encountered, the error message is displayed. For example, 
when the compiler encounters this line:
#error This is a test error!
compilation stops and the error message “This is a test error!” is displayed.
#warning
The#warning directive is similar to #error, except that a warning rather than an error is 
produced. Thus, compilation is not stopped. The general form of the #warning directive is
#warningwarning-message
#line
The#line directive sets the line number and filename for the file that contains the #line
directive. The number and the name are used when errors or warnings are output during 
compilation. The general form for #line is
#line number fi lename
where number is any positive integer, which becomes the new line number, and the optional 
filename is any valid file identifier, which becomes the new filename. #line is primarily used 
for debugging and special applications.
#lineallows two options. The first is default, which returns the line numbering to its 
original condition. It is used like this:
#line default
The second is hidden. When stepping through a program, the hidden option allows a 
debugger to bypass lines between a
#line hidden
directive and the next #line directive that does not include the hidden option.
#region and #endregion
The#region and #endregion directives let you define a region that will be expanded or 
collapsed when using outlining in the Visual Studio IDE. The general form is shown here:
#region text
//  code sequence
#endregion text
Here, text is an optional string.
C# PDF Image Extract Library: Select, copy, paste PDF images in C#
C#.NET extract image from multiple page adobe PDF file Extract various types of image from PDF file, like JPG, JPEG and other high quality image files from PDF
attach pdf to mail merge in word; pdf merge files
C# PDF Text Extract Library: extract text content from PDF file in
image files. Enable extracting PDF text to another PDF file, TXT and SVG formats. Support extracting OCR text from PDF by working with XImage.OCR SDK. Best C#.NET
asp.net merge pdf files; c# merge pdf files into one
P
A
R
T
I
Chapter 16:  Namespaces, the Preprocessor, and Assemblies 
469
P
A
R
T
I
P
A
R
T
I
#pragma
The#pragma directive gives instructions, such as specifying an option, to the compiler. It 
has this general form:
#pragmaoption
Here, option is the instruction passed to the compiler.
There are currently two options supported by #pragma. The first is warning, which is 
#pragma warning disable warnings
#pragma warning restore warnings
Here, warnings is a comma-separated list of warning numbers. To disable a warning, use 
thedisable option. To enable a warning, use the restore option. If no warnings are specified, 
then all warnings are affected.
For example, this #pragmastatement disables warning 168, which indicates when a 
variable is declared but not used:
#pragma warning disable 168
The second #pragmaoption is checksum. It is used to generate checksums for ASP.NET 
projects. It has this general form.
#pragma checksum “fi lename” “{GUID}” “check-sum
Here, filename is the name of the file, GUID is the globally unique identifier associated with 
filename, and check-sum is a hexadecimal number that contains the checksum. This string 
must contain an even number of digits.
Assemblies and the internal Access Modifier
An integral part of C# programming is the assembly. An assembly is a file (or files) that 
contains all deployment and version information for a program. Assemblies are fundamental 
to the .NET environment. They provide mechanisms that support safe component interaction, 
cross-language interoperability, and versioning. An assembly also defines a scope.
An assembly is composed of four sections. The first is the assembly manifest. The manifest 
contains information about the assembly, itself. This data includes such things as the name of 
the assembly, its version number, type mapping information, and cultural settings. The second 
section is type metadata, which is information about the data types used by the program. 
Among other benefits, type metadata aids in cross-language interoperability. The third part 
of an assembly is the program code, which is stored in Microsoft Intermediate Language 
(MSIL)format. The fourth constituent of an assembly is the resources used by the program.
Fortunately, when using C#, assemblies are produced automatically, with little or no 
extra effort on your part. The reason for this is that the exe file created when you compile 
a C# program is actually an assembly that contains your program’s executable code as 
well as other types of information. Thus, when you compile a C# program, an assembly 
is automatically produced.
There are many other features and topics that relate to assemblies, but a discussion of 
these is outside the scope of this book. (Assemblies are an integral part of .NET development,
470
Part I: The C# Language
but are not technically a feature of the C# language.) However, there is one part of C# that 
relates directly to the assembly: the internal access modifier, which is examined next.
The internal Access Modifier
In addition to the access modifiers public,private, and protected, which you have been 
using throughout this book, C# also defines internal. The internal modifier declares that a 
member is known throughout all files in an assembly, but unknown outside that assembly. 
Thus, in simplified terms, a member marked as internal is known throughout a program, 
but not elsewhere. The internal access modifier is particularly useful when creating 
software components.
Theinternal modifier can be applied to classes and members of classes and to structures 
and members of structures. The internal modifier can also be applied to interface and 
enumeration declarations.
You can use protected in conjunction with internal to produce the protectedinternal
access modifier pair. The protectedinternal access level can be given only to class members. 
A member declared with protectedinternal access is accessible within its own assembly or 
to derived types.
Here is an example that uses internal:
// Use internal.
using System;
class InternalTest {
internal int x;
}
class InternalDemo {
static void Main() {
InternalTest ob = new InternalTest();
ob.x = 10; // can access -- in same file
Console.WriteLine("Here is ob.x: " + ob.x);
}
}
InsideInternalTest, the field x is declared internal. This means that it is accessible within 
the program, as its use in InternalDemo shows, but unavailable outside the program.
17
Runtime Type ID, Reflection, 
and Attributes
T
his chapter discusses three interrelated and powerful features: runtime type 
identification, reflection, and attributes. Runtime type ID is the mechanism that lets 
you identify a type during the execution of a program. Reflection is the feature that 
uct 
and use objects at runtime. This feature is very powerful because it lets a program add 
functionality dynamically, during execution. An attribute describes a characteristic of some 
element of a C# pr
fields, among others. Attributes can be interrogated at runtime, and the attribute information 
obtained. Attributes use both runtime type identification and reflection.
Runtime Type Identification
Runtime type identification (RTTI) allows the type of an object to be determined during 
program execution. RTTI is useful for many reasons. For example, you can discover 
precisely what type of object is being referred to by a base-class reference. Another use of 
RTTI is to test in advance whether a cast will succeed, preventing an invalid cast exception. 
Runtime type identification is also a key component of reflection.
C# includes three keywords that support runtime type identification: is,as, and typeof.
Each is examined in turn.
Testing a Type with is
You can determine if an object is of a certain type by using the is operator. Its general form 
is shown here:
expr is type
Here, expr is an expression that describes an object whose type is being tested against type. If 
the type of expr is the same as, or compatible with, type, then the outcome of this operation 
is true. Otherwise, it is false. Thus, if the outcome is true, expr is some form of type. As it 
applies to is, one type is compatible with another if both are the same type, or if a reference, 
boxing, or unboxing conversion exists.
471
CHAPTER
472
Part I: The C# Language
Here is an example that uses is:
// Demonstrate is.
using System;
class A {}
class B : A {}
class UseIs {
static void Main() {
A a = new A();
B b = new B();
if(a is A) Console.WriteLine("a is an A");
if(b is A)
Console.WriteLine("b is an A because it is derived from A");
if(a is B)
if(b is B) Console.WriteLine("b is a B");
if(a is object) Console.WriteLine("a is an object");
}
}
The output is shown here:
a is an A
b is an A because it is derived from A
b is a B
a is an object
Most of the is expressions are self-explanatory, but two may need a little discussion. 
First, notice this statement:
if(b is A)
Console.WriteLine("b is an A because it is derived from A");
Theif succeeds because b is an object of type B, which is derived from type A. Thus, bis an 
A. However, the reverse is not true. When this line is executed,
if(a is B)
Console.WriteLine("This won’t display -- a not derived from B");
theif does not succeed, because a is of type A, which is not derived from B. Thus, aisnot a B.
Using as
Sometimes you will want to try a conversion at runtime, but not throw an exception if the 
conversion fails (which is the case when a cast is used). To do this, use the as operator, 
which has this general form:
expr as type
P
A
R
T
I
Chapter 17: Runtime Type ID, Reflection, and Attributes 
473
P
A
R
T
I
P
A
R
T
I
Here, expr is the expression being converted to type. If the conversion succeeds, then a 
reference to type is returned. Otherwise, a null reference is returned. The as operator can 
be used to perform only reference, boxing, unboxing, or identity conversions.
Theas operator offers a streamlined alternative to is in some cases. For example, 
consider the following program that uses is to prevent an invalid cast from occurring:
// Use is to avoid an invalid cast.
using System;
class A {}
class B : A {}
class CheckCast {
static void Main() {
A a = new A();
B b = new B();
// Check to see if a can be cast to B.
if(a is B)  // if so, do the cast
b = (B) a;
else // if not, skip the cast
b = null;
if(b==null)
Console.WriteLine("The cast in b = (B) a is NOT allowed.");
else
Console.WriteLine("The cast in b = (B) a is allowed");
}
}
This program displays the following output:
The cast in b = (B) a is NOT allowed.
As the output shows, since a is not a B, the cast of a to B is invalid and is prevented by the if
statement. However, this approach requires two steps. First, the validity of the cast must be 
ough 
the use of as, as the following program shows:
// Demonstrate as.
using System;
class A {}
class B : A {}
class CheckCast {
static void Main() {
A a = new A();
B b = new B();
b = a as B; // cast, if possible
Documents you may be interested
Documents you may be interested