asp net core 2.0 mvc pdf : Acrobat split pdf into multiple files application SDK tool html .net wpf online McGraw.Hill.CSharp.4.0.The.Complete.Reference.Apr.201050-part1211

474
Part I: The C# Language
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");
}
}
Here is the output, which is the same as before:
The cast in b = (B) a is NOT allowed.
In this version, the as statement checks the validity of the cast and then, if valid, performs 
the cast, all in one statement.
Using typeof
Although useful in their own ways, the as and is operators simply test the compatibility of 
two types. Often, you will need to obtain information about a type. To do this, C# supplies 
thetypeof operator. It retrieves a System.Type object for a given type. Using this object, you 
can determine the type’s characteristics.
Thetypeof operator has this general form:
typeof(type)
Here, type is the type being obtained. The Type object returned encapsulates the information 
associated with type.
Once you have obtained a Type object for a given type, you can obtain information about 
it through the use of various properties, fields, and methods defined by Type.Type is a large 
class with many members, and a discussion is deferred until the next section, where reflection 
is examined. However, to briefly demonstrate Type, the following program uses three of 
its properties: FullName,IsClass, and IsAbstract. To obtain the full name of the type, use 
FullName.IsClass returns true if the type is a class. IsAbstract returns true if a class is abstract.
// Demonstrate typeof.
using System;
using System.IO;
class UseTypeof {
static void Main() {
Type t = typeof(StreamReader);
Console.WriteLine(t.FullName);
if(t.IsClass) Console.WriteLine("Is a class.");
if(t.IsAbstract) Console.WriteLine("Is abstract.");
else Console.WriteLine("Is concrete.");
}
}
This program outputs the following:
System.IO.StreamReader
Is a class.
Is concrete.
Acrobat split pdf into multiple files - Merge, append PDF files in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Provide C# Demo Codes for Merging and Appending PDF Document
break pdf file into multiple files; append pdf
Acrobat split pdf into multiple 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
merge pdf files; pdf merger online
P
A
R
T
I
Chapter 17: Runtime Type ID, Reflection, and Attributes 
475
P
A
R
T
I
P
A
R
T
I
This program obtains a Type object that describes StreamReader. It then displays the full 
name, and determines if it is a class and whether it is abstract.
Reflection
Reflection is the feature that enables you to obtain information about a type. The term 
reflection comes from the way the process works: A Type object mirrors the underlying type 
that it represents. To obtain information, you ask the Type object questions, and it returns 
(r
e known 
only at runtime.
Many of the classes that support reflection are part of the .NET Reflection API, which 
is in the System.Reflection namespace. Thus, you will normally include the following in 
programs that use reflection:
using System.Reflection;
The Reflection Core: System.Type
System.Type is at the core of the reflection subsystem because it encapsulates a type. It 
contains many pr
at runtime. Type is derived from an abstract class called System.Reflection.MemberInfo.
MemberInfo defines the following read-only properties:
Property
Description
Type DeclaringType
Obtains the type of the class or interface in which the member is 
declared.
MemberTypes MemberType
Obtains the kind of the member. This value indicates if the 
member is a field, method, property, event, or constructor, 
among others.
int MetadataToken
Obtains a value associated with a specific metadata.
Module Module
Obtains a Module object that represents the module (an 
executable file) in which the reflected type resides.
string Name
The name of the member.
Type ReflectedType
The type of the object being reflected.
Notice that the return type of MemberType is MemberTypes.MemberTypes is an 
enumeration that defines values that indicate the various member types. Among others, 
these include
MemberTypes.Constructor
MemberTypes.Method
MemberTypes.Field
MemberTypes.Event
MemberTypes.Property
Thus, the type of a member can be determined by checking MemberType. For example, if 
MemberType equals MemberTypes.Method, then that member is a method.
.NET PDF Document Viewing, Annotation, Conversion & Processing
Merge, split PDF files. Insert, delete PDF pages. Edit, update, delete PDF annotations from PDF file. Print. Support for all the print modes in Acrobat PDF.
attach pdf to mail merge; pdf merge comments
C# PDF Converter Library SDK to convert PDF to other file formats
without using other external third-party dependencies like Adobe Acrobat. It's easy to be integrated into your C# program and convert PDF to .txt file with
pdf merge files; c# merge pdf files into one
476
Part I: The C# Language
MemberInfo includes two abstract methods: GetCustomAttributes( ) and IsDefined( ).
These both r
The .NET Framework Version 4.0 adds a method called GetCustomAttributesData( ), which 
returns information about custom attributes. (Attributes are described later in this chapter.)
To the methods and properties defined by MemberInfo,Type adds a great many of its 
own. For example, here are several commonly used methods defined by Type:
Method
Purpose
ConstructorInfo[ ] GetConstructors( )
Obtains a list of the constructors for the specified type.
EventInfo[ ] GetEvents( )
Obtains a list of events for the specified type.
FieldInfo[ ] GetFields( )
Obtains a list of the fields for the specified type.
Type[ ] GetGenericArguments( )
Obtains a list of the type arguments bound to 
a closed constructed generic type or the type 
parameters if the specified type is a generic type 
definition. For an open constructed type, the list may 
contain both type arguments and type parameters. 
(See Chapter 18 for a discussion of generics.)
MemberInfo[ ] GetMembers( )
Obtains a list of the members for the specified type.
MethodInfo[ ] GetMethods( )
Obtains a list of methods for the specified type.
PropertyInfo[ ] GetProperties( )
Obtains a list of properties for the specified type.
Here are several commonly used, read-only properties defined by Type:
Property
Purpose
Assembly Assembly
Obtains the assembly for the specified type. 
TypeAttributes Attributes
Obtains the attributes for the specified type.
Type BaseType
Obtains the immediate base type for the specified type.
string FullName
Obtains the complete name of the specified type.
bool IsAbstract
Is true if the specified type is abstract.
bool isArray
Is true if the specified type is an array.
bool IsClass
Is true if the specified type is a class.
bool IsEnum
Is true if the specified type is an enumeration.
bool IsGenericParameter
Is true if the specified type is a generic type parameter. 
(See Chapter 18 for a discussion of generics.)
bool IsGenericType
Is true if the specified type is a generic type. (See 
Chapter 18 for a discussion of generics.)
string Namespace
Obtains the namespace of the specified type.
VB.NET PDF: How to Create Watermark on PDF Document within
need no external application plugin, like Adobe Acrobat. creating same watermarks on multiple PDF pages at the PDF document, image to pdf files and components
reader combine pdf; pdf mail merge
P
A
R
T
I
Chapter 17: Runtime Type ID, Reflection, and Attributes 
477
P
A
R
T
I
P
A
R
T
I
Using Reflection
UsingType’s methods and properties, it is possible to obtain detailed information about a 
type at runtime. This is an extremely powerful feature, because once you have obtained 
information about a type, you can invoke its constructors, call its methods, and use its 
properties. Thus, r
The Reflection API is quite large, and it is not possible to cover the entire topic here. 
(Complete coverage of reflection could easily fill an entire book!) However, because the 
Reflection est 
just falls into place. With this thought in mind, the following sections demonstrate four key 
ructing 
objects, and loading types from assemblies.
Obtaining Information About Methods
Once you have a Type object, you can obtain a list of the public methods supported by the 
type by using GetMethods( ). One form is shown here:
MethodInfo[ ] GetMethods( )
It returns an array of MethodInfo objects that describe the methods supported by the 
invoking type. MethodInfo is in the System.Reflection namespace.
MethodInfo is derived from the abstract class MethodBase, which inherits MemberInfo.
Thus, the properties and methods defined by all three of these classes are available for your 
use. For example, to obtain the name of a method, use the Name property. Two members that 
are of particular interest at this time are ReturnType and GetParameters( ).
The return type of a method is found in the read-only ReturnType property, which is an 
object of Type.
The method GetParameters( ) returns a list of the parameters associated with a method. 
It has this general form:
ParameterInfo[ ] GetParameters( );
The parameter information is held in a ParameterInfo object. ParameterInfo defines 
properties and methods that describe the parameter. Two properties that are of particular 
value are Name, which is a string that contains the name of the parameter, and ParameterType,
which describes the parameter’s type. The parameter’s type is encapsulated within a Type
object.
Here is a program that uses reflection to obtain the methods supported by a class called 
MyClass. For each method, it displays the return type and name of the method, and the 
name and type of any parameters that each method may have.
// Analyze methods using reflection.
using System;
using System.Reflection;
class MyClass {
int x;
int y;
478
Part I: The C# Language
public MyClass(int i, int j) {
x = i;
y = j;
}
public int Sum() {
return x+y;
}
public bool IsBetween(int i) {
if(x < i && i < y) return true;
else return false;
}
public void Set(int a, int b) {
x = a;
y = b;
}
public void Set(double a, double b) {
x = (int) a;
y = (int) b;
}
public void Show() {
Console.WriteLine(" x: {0}, y: {1}", x, y);
}
}
class ReflectDemo {
static void Main() {
Console.WriteLine("Analyzing methods in " + t.Name);
Console.WriteLine();
Console.WriteLine("Methods supported: ");
MethodInfo[] mi = t.GetMethods();
// Display methods supported by MyClass.
foreach(MethodInfo m in mi) {
// Display return type and name.
Console.Write("   " + m.ReturnType.Name +
" " + m.Name + "(");
// Display parameters.
ParameterInfo[] pi = m.GetParameters();
for(int i=0; i < pi.Length; i++) {
Console.Write(pi[i].ParameterType.Name +
" " + pi[i].Name);
if(i+1 < pi.Length) Console.Write(", ");
}
P
A
R
T
I
Chapter 17: Runtime Type ID, Reflection, and Attributes 
479
P
A
R
T
I
P
A
R
T
I
Console.WriteLine(")");
Console.WriteLine();
}
}
}
The output is shown here:
Analyzing methods in MyClass
Methods supported:
Int32 Sum()
Boolean IsBetween(Int32 i)
Void Set(Int32 a, Int32 b)
Void Set(Double a, Double b)
Void Show()
Type GetType()
String ToString()
Boolean Equals(Object obj)
Int32 GetHashCode()
Notice that in addition to the methods defined by MyClass, the public, non-static methods 
defined by object are also displayed. This is because all types in C# inherit object. Also 
notice that the .NET structure names are used for the type names. Observe that Set( ) is 
displayed twice. This is because Set( ) is overloaded. One version takes int arguments. The 
other takes double arguments.
Let’s look at this program closely. First, notice that MyClass defines a public constructor 
and a number of public methods, including the overloaded Set( ) method.
InsideMain( ), a Type object representing MyClass is obtained using this line of code:
Type t = typeof(MyClass); // get a Type object representing MyClass
Recall that typeof returns a Type object that represents the specified type, which in this case 
isMyClass.
Usingt and the Reflection API, the program then displays information about the methods 
supported by MyClass. First, a list of the methods is obtained by the following statement:
MethodInfo[] mi = t.GetMethods();
Next, a foreach loop is established that cycles through mi. With each pass, the return 
type, name, and parameters for each method are displayed by the following code:
// Display return type and name.
Console.Write("   " + m.ReturnType.Name +
" " + m.Name + "(");
480
Part I: The C# Language
// Display parameters.
ParameterInfo[] pi = m.GetParameters();
for(int i=0; i < pi.Length; i++) {
Console.Write(pi[i].ParameterType.Name +
" " + pi[i].Name);
if(i+1 < pi.Length) Console.Write(", ");
}
In this sequence, the parameters associated with each method are obtained by calling 
GetParameters( ) and stored in the pi array. Then a for loop cycles through the pi array, 
displaying the type and name of each parameter. The key point is that this information 
is obtained dynamically at runtime without relying on prior knowledge of MyClass.
A Second Form of GetMethods( )
A second form of GetMethods( ) lets you specify various flags that filter the methods that 
are retrieved. It has this general form:
MethodInfo[ ] GetMethods(BindingFlags bindingAttr)
BindingFlags is 
an enumeration. Here are several commonly used values:
Value
Meaning
DeclaredOnly
Retrieves only those methods defined by the specified class. Inherited 
methods are not included.
Instance
Retrieves instance methods.
NonPublic
Retrieves nonpublic methods.
Public
Retrieves public methods.
Static
Retrieves static methods.
You can OR together two or more flags. In fact, minimally you must include either Instance
orStatic with Public or NonPublic. Failure to do so will result in no methods being retrieved.
One of the main uses of the BindingFlags form of GetMethods( ) is to enable you to 
obtain a list of the methods defined by a class without also retrieving the inherited methods. 
This is especially useful for preventing the methods defined by object from being obtained. 
For example, try substituting this call to GetMethods( ) into the preceding program:
// Now, only methods declared by MyClass are obtained.
MethodInfo[] mi = t.GetMethods(BindingFlags.DeclaredOnly |
BindingFlags.Instance |
BindingFlags.Public) ;
After making this change, the program produces the following output:
Analyzing methods in MyClass
Methods supported:
Int32 Sum()
P
A
R
T
I
Chapter 17: Runtime Type ID, Reflection, and Attributes 
481
P
A
R
T
I
P
A
R
T
I
Boolean IsBetween(Int32 i)
Void Set(Int32 a, Int32 b)
Void Set(Double a, Double b)
Void Show()
As you can see, only those methods explicitly defined by MyClass are displayed.
Calling Methods Using Reflection
Once you know what methods a type supports, you can call one or more of them. To do 
this, you will use the Invoke( ) method that is contained in MethodInfo. One of its forms 
is shown here:
object Invoke(object obj, object[ ] parameters)
Here, obj is a reference to the object on which the method is invoked. (For static methods, you 
can pass null to obj.) Any arguments that need to be passed to the method are specified in the 
arrayparameters. If no arguments are needed, parameters must be null. Also, parameters must 
contain exactly the same number of elements as there are arguments. Therefore, if two 
arguments are needed, then parameters must be two elements long. It can’t, for example, be three 
or four elements long. The value returned by the invoked method is returned by Invoke( ).
To call a method, simply call Invoke( ) on an instance of MethodInfo that was obtained 
by calling GetMethods( ). The following program demonstrates the procedure:
// Invoke methods using reflection.
using System;
using System.Reflection;
class MyClass {
int x;
int y;
public MyClass(int i, int j) {
x = i;
y = j;
}
public int Sum() {
return x+y;
}
public bool IsBetween(int i) {
if((x < i) && (i < y)) return true;
else return false;
}
public void Set(int a, int b) {
Console.Write("Inside Set(int, int). ");
x = a;
482
Part I: The C# Language
y = b;
Show();
}
// Overload set.
public void Set(double a, double b) {
Console.Write("Inside Set(double, double). ");
x = (int) a;
y = (int) b;
Show();
}
public void Show() {
Console.WriteLine("Values are x: {0}, y: {1}", x, y);
}
}
class InvokeMethDemo {
static void Main() {
Type t = typeof(MyClass);
MyClass reflectOb = new MyClass(10, 20);
int val;
Console.WriteLine("Invoking methods in " + t.Name);
Console.WriteLine();
MethodInfo[] mi = t.GetMethods();
// Invoke each method.
foreach(MethodInfo m in mi) {
// Get the parameters.
ParameterInfo[] pi = m.GetParameters();
if(m.Name.Equals("Set", StringComparison.Ordinal) &&
pi[0].ParameterType == typeof(int)) {
object[] args = new object[2];
args[0] = 9;
args[1] = 18;
m.Invoke(reflectOb, args);
}
else if(m.Name.Equals("Set", StringComparison.Ordinal) &&
pi[0].ParameterType == typeof(double)) {
object[] args = new object[2];
args[0] = 1.12;
args[1] = 23.4;
m.Invoke(reflectOb, args);
}
else if(m.Name.Equals("Sum", StringComparison.Ordinal)) {
val = (int) m.Invoke(reflectOb, null);
Console.WriteLine("sum is " + val);
}
object[] args = new object[1];
args[0] = 14;
if((bool) m.Invoke(reflectOb, args))
P
A
R
T
I
Chapter 17: Runtime Type ID, Reflection, and Attributes 
483
P
A
R
T
I
P
A
R
T
I
Console.WriteLine("14 is between x and y");
}
else if(m.Name.Equals("Show", StringComparison.Ordinal)) {
m.Invoke(reflectOb, null);
}
}
}
}
The output is shown here:
Invoking methods in MyClass
sum is 30
14 is between x and y
Inside Set(int, int). Values are x: 9, y: 18
Inside Set(double, double). Values are x: 1, y: 23
Values are x: 1, y: 23
Look closely at how the methods are invoked. First, a list of methods is obtained. Then, 
inside the foreach loop, parameter information is retrieved. Next, using a series of if/else 
statements, each method is executed with the proper type and number of arguments. Pay 
special attention to the way that the overloaded Set( ) method is executed by the following 
code:
if(m.Name.Equals("Set", StringComparison.Ordinal) &&
pi[0].ParameterType == typeof(int)) {
object[] args = new object[2];
args[0] = 9;
args[1] = 18;
m.Invoke(reflectOb, args);
}
else if(m.Name.Equals("Set", StringComparison.Ordinal) &&
pi[0].ParameterType == typeof(double)) {
object[] args = new object[2];
args[0] = 1.12;
args[1] = 23.4;
m.Invoke(reflectOb, args);
}
If the name of the method is Set, then the type of the first parameter is tested to determine 
which version of the method was found. If it was Set(int, int), then int arguments are 
loaded into args. Otherwise, double arguments are used.
Obtaining a Type’s Constructors
In the previous example, there is no advantage to using reflection to invoke methods on 
MyClass since an object of type MyClass was explicitly created. It would be easier to just 
call its methods normally. However, the power of reflection starts to become apparent when 
an object is created dynamically at runtime. To do this, you will need to first obtain a list 
of the constructors. Then, you will create an instance of the type by invoking one of the 
constructors. This mechanism allows you to instantiate an object at runtime without naming 
it in a declaration statement.
Documents you may be interested
Documents you may be interested